Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // -*- C++ -*-
  2. //
  3. // Copyright (C) 2009-2013 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library.  This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 3, or (at your option)
  9. // any later version.
  10. //
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU General Public License for more details.
  15.  
  16. // Under Section 7 of GPL version 3, you are granted additional
  17. // permissions described in the GCC Runtime Library Exception, version
  18. // 3.1, as published by the Free Software Foundation.
  19.  
  20. // You should have received a copy of the GNU General Public License along
  21. // with this library; see the file COPYING3.  If not see
  22. // <http://www.gnu.org/licenses/>.
  23.  
  24. /** @file profile/impl/profiler_trace.h
  25.  *  @brief Data structures to represent profiling traces.
  26.  */
  27.  
  28. // Written by Lixia Liu and Silvius Rus.
  29.  
  30. #ifndef _GLIBCXX_PROFILE_PROFILER_TRACE_H
  31. #define _GLIBCXX_PROFILE_PROFILER_TRACE_H 1
  32.  
  33. #include <cstdio>  // fopen, fclose, fprintf, FILE
  34. #include <cerrno>
  35. #include <cstdlib> // atof, atoi, strtol, getenv, atexit, abort
  36.  
  37. #if __cplusplus >= 201103L
  38. #define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_C::unordered_map
  39. #include <unordered_map>
  40. #else
  41. #include <tr1/unordered_map>
  42. #define _GLIBCXX_IMPL_UNORDERED_MAP std::tr1::unordered_map
  43. #endif
  44.  
  45. #include <ext/concurrence.h>
  46. #include <fstream>
  47. #include <string>
  48. #include <utility>
  49. #include <vector>
  50.  
  51. #include "profile/impl/profiler_algos.h"
  52. #include "profile/impl/profiler_state.h"
  53. #include "profile/impl/profiler_node.h"
  54.  
  55. namespace __gnu_profile
  56. {
  57.   /** @brief Internal environment.  Values can be set one of two ways:
  58.       1. In config file "var = value".  The default config file path is
  59.          libstdcxx-profile.conf.
  60.       2. By setting process environment variables.  For instance, in a Bash
  61.          shell you can set the unit cost of iterating through a map like this:
  62.          export __map_iterate_cost_factor=5.0.
  63.          If a value is set both in the input file and through an environment
  64.          variable, the environment value takes precedence.  */
  65.   typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t;
  66.  
  67.   _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env);
  68.  
  69.   /** @brief Master lock.  */
  70.   _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock);
  71.  
  72.   /** @brief Representation of a warning.  */
  73.   struct __warning_data
  74.   {
  75.     float __magnitude;
  76.     __stack_t __context;
  77.     const char* __warning_id;
  78.     std::string __warning_message;
  79.  
  80.     __warning_data()
  81.     : __magnitude(0.0), __context(0), __warning_id(0) { }
  82.  
  83.     __warning_data(float __m, __stack_t __c, const char* __id,
  84.                    const std::string& __msg)
  85.     : __magnitude(__m), __context(__c), __warning_id(__id),
  86.       __warning_message(__msg) { }
  87.  
  88.     bool
  89.     operator<(const __warning_data& __other) const
  90.     { return __magnitude < __other.__magnitude; }
  91.   };
  92.  
  93.   typedef std::_GLIBCXX_STD_C::vector<__warning_data> __warning_vector_t;
  94.  
  95.   // Defined in profiler_<diagnostic name>.h.
  96.   class __trace_hash_func;
  97.   class __trace_hashtable_size;
  98.   class __trace_map2umap;
  99.   class __trace_vector_size;
  100.   class __trace_vector_to_list;
  101.   class __trace_list_to_slist;
  102.   class __trace_list_to_vector;
  103.   void __trace_vector_size_init();
  104.   void __trace_hashtable_size_init();
  105.   void __trace_hash_func_init();
  106.   void __trace_vector_to_list_init();
  107.   void __trace_list_to_slist_init();  
  108.   void __trace_list_to_vector_init();  
  109.   void __trace_map_to_unordered_map_init();
  110.   void __trace_vector_size_report(FILE*, __warning_vector_t&);
  111.   void __trace_hashtable_size_report(FILE*, __warning_vector_t&);
  112.   void __trace_hash_func_report(FILE*, __warning_vector_t&);
  113.   void __trace_vector_to_list_report(FILE*, __warning_vector_t&);
  114.   void __trace_list_to_slist_report(FILE*, __warning_vector_t&);
  115.   void __trace_list_to_vector_report(FILE*, __warning_vector_t&);
  116.   void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&);
  117.  
  118.   struct __cost_factor
  119.   {
  120.     const char* __env_var;
  121.     float __value;
  122.   };
  123.  
  124.   typedef std::_GLIBCXX_STD_C::vector<__cost_factor*> __cost_factor_vector;
  125.  
  126.   _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0);
  127.   _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0);
  128.   _GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0);
  129.   _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0);
  130.   _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0);
  131.   _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0);
  132.   _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0);
  133.  
  134.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor,
  135.                                {"__vector_shift_cost_factor", 1.0});
  136.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor,
  137.                                {"__vector_iterate_cost_factor", 1.0});
  138.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor,
  139.                                {"__vector_resize_cost_factor", 1.0});
  140.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor,
  141.                                {"__list_shift_cost_factor", 0.0});
  142.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor,
  143.                                {"__list_iterate_cost_factor", 10.0});
  144.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor,
  145.                                {"__list_resize_cost_factor", 0.0});
  146.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor,
  147.                                {"__map_insert_cost_factor", 1.5});
  148.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor,
  149.                                {"__map_erase_cost_factor", 1.5});
  150.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor,
  151.                                {"__map_find_cost_factor", 1});
  152.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor,
  153.                                {"__map_iterate_cost_factor", 2.3});
  154.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor,
  155.                                {"__umap_insert_cost_factor", 12.0});
  156.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor,
  157.                                {"__umap_erase_cost_factor", 12.0});
  158.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor,
  159.                                {"__umap_find_cost_factor", 10.0});
  160.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor,
  161.                                {"__umap_iterate_cost_factor", 1.7});
  162.   _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0);
  163.  
  164.   _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name,
  165.                                _GLIBCXX_PROFILE_TRACE_PATH_ROOT);
  166.   _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_warn_count,
  167.                                _GLIBCXX_PROFILE_MAX_WARN_COUNT);
  168.   _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_stack_depth,
  169.                                _GLIBCXX_PROFILE_MAX_STACK_DEPTH);
  170.   _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_mem,
  171.                                _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC);
  172.  
  173.   inline std::size_t
  174.   __stack_max_depth()
  175.   { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); }
  176.  
  177.   inline std::size_t
  178.   __max_mem()
  179.   { return _GLIBCXX_PROFILE_DATA(_S_max_mem); }
  180.  
  181.   /** @brief Base class for all trace producers.  */
  182.   template<typename __object_info, typename __stack_info>
  183.     class __trace_base
  184.     {
  185.     public:
  186.       // Do not pick the initial size too large, as we don't know which
  187.       // diagnostics are more active.
  188.       __trace_base()
  189.       : __object_table(10000), __stack_table(10000),
  190.         __stack_table_byte_size(0), __id(0) { }
  191.  
  192.       virtual ~__trace_base() { }
  193.  
  194.       void __add_object(__object_t object, __object_info __info);
  195.       __object_info* __get_object_info(__object_t __object);
  196.       void __retire_object(__object_t __object);
  197.       void __write(FILE* __f);
  198.       void __collect_warnings(__warning_vector_t& __warnings);
  199.  
  200.     private:
  201.       __gnu_cxx::__mutex __object_table_lock;
  202.       __gnu_cxx::__mutex __stack_table_lock;
  203.       typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t,
  204.                                           __object_info> __object_table_t;
  205.       typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info,
  206.                                           __stack_hash,
  207.                                           __stack_hash> __stack_table_t;
  208.       __object_table_t __object_table;
  209.       __stack_table_t __stack_table;
  210.       std::size_t __stack_table_byte_size;
  211.  
  212.     protected:
  213.       const char* __id;
  214.     };
  215.  
  216.   template<typename __object_info, typename __stack_info>
  217.     void
  218.     __trace_base<__object_info, __stack_info>::
  219.     __collect_warnings(__warning_vector_t& __warnings)
  220.     {
  221.       for (typename __stack_table_t::iterator __it
  222.              = __stack_table.begin(); __it != __stack_table.end(); ++__it)
  223.         __warnings.push_back(__warning_data((*__it).second.__magnitude(),
  224.                                             (*__it).first, __id,
  225.                                             (*__it).second.__advice()));
  226.     }
  227.  
  228.   template<typename __object_info, typename __stack_info>
  229.     void
  230.     __trace_base<__object_info, __stack_info>::
  231.     __add_object(__object_t __object, __object_info __info)
  232.     {
  233.       if (__max_mem() == 0
  234.           || __object_table.size() * sizeof(__object_info) <= __max_mem())
  235.         {
  236.           this->__object_table_lock.lock();
  237.           __object_table.insert(typename __object_table_t::
  238.                                 value_type(__object, __info));
  239.           this->__object_table_lock.unlock();
  240.         }
  241.     }
  242.  
  243.   template<typename __object_info, typename __stack_info>
  244.     __object_info*
  245.     __trace_base<__object_info, __stack_info>::
  246.     __get_object_info(__object_t __object)
  247.     {
  248.       // XXX: Revisit this to see if we can decrease mutex spans.
  249.       // Without this mutex, the object table could be rehashed during an
  250.       // insertion on another thread, which could result in a segfault.
  251.       this->__object_table_lock.lock();
  252.       typename __object_table_t::iterator __object_it
  253.         =  __object_table.find(__object);
  254.  
  255.       if (__object_it == __object_table.end())
  256.         {
  257.           this->__object_table_lock.unlock();
  258.           return 0;
  259.         }
  260.       else
  261.         {
  262.           this->__object_table_lock.unlock();
  263.           return &__object_it->second;
  264.         }
  265.     }
  266.  
  267.   template<typename __object_info, typename __stack_info>
  268.     void
  269.     __trace_base<__object_info, __stack_info>::
  270.     __retire_object(__object_t __object)
  271.     {
  272.       this->__object_table_lock.lock();
  273.       this->__stack_table_lock.lock();
  274.       typename __object_table_t::iterator __object_it
  275.         = __object_table.find(__object);
  276.  
  277.       if (__object_it != __object_table.end())
  278.         {
  279.           const __object_info& __info = __object_it->second;
  280.           const __stack_t& __stack = __info.__stack();
  281.           typename __stack_table_t::iterator __stack_it
  282.             = __stack_table.find(__stack);
  283.    
  284.           if (__stack_it == __stack_table.end())
  285.             {
  286.               // First occurence of this call context.
  287.               if (__max_mem() == 0 || __stack_table_byte_size < __max_mem())
  288.                 {
  289.                   __stack_table_byte_size
  290.                     += (sizeof(__instruction_address_t) * __size(__stack)
  291.                         + sizeof(__stack) + sizeof(__stack_info));
  292.                   __stack_table.insert(make_pair(__stack,
  293.                                                  __stack_info(__info)));
  294.                 }
  295.             }
  296.           else
  297.             {
  298.               // Merge object info into info summary for this call context.
  299.               __stack_it->second.__merge(__info);
  300.               delete __stack;
  301.             }
  302.           __object_table.erase(__object);
  303.         }
  304.  
  305.       this->__object_table_lock.unlock();
  306.       this->__stack_table_lock.unlock();
  307.     }
  308.  
  309.   template<typename __object_info, typename __stack_info>
  310.     void
  311.     __trace_base<__object_info, __stack_info>::
  312.     __write(FILE* __f)
  313.     {
  314.       for (typename __stack_table_t::iterator __it
  315.              = __stack_table.begin(); __it != __stack_table.end(); ++__it)
  316.         if (__it->second.__is_valid())
  317.           {
  318.             std::fprintf(__f, __id);
  319.             std::fprintf(__f, "|");
  320.             __gnu_profile::__write(__f, __it->first);
  321.             std::fprintf(__f, "|");
  322.             __it->second.__write(__f);
  323.           }
  324.     }
  325.  
  326.   inline std::size_t
  327.   __env_to_size_t(const char* __env_var, std::size_t __default_value)
  328.   {
  329.     char* __env_value = std::getenv(__env_var);
  330.     if (__env_value)
  331.       {
  332.         errno = 0;
  333.         long __converted_value = std::strtol(__env_value, 0, 10);
  334.         if (errno || __converted_value < 0)
  335.           {
  336.             std::fprintf(stderr,
  337.                          "Bad value for environment variable '%s'.\n",
  338.                          __env_var);
  339.             std::abort();
  340.           }
  341.         else
  342.           return static_cast<std::size_t>(__converted_value);
  343.       }
  344.     else
  345.       return __default_value;
  346.   }
  347.  
  348.   inline void
  349.   __set_max_stack_trace_depth()
  350.   {
  351.     _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)
  352.       = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR,
  353.                         _GLIBCXX_PROFILE_DATA(_S_max_stack_depth));
  354.   }
  355.  
  356.   inline void
  357.   __set_max_mem()
  358.   {
  359.     _GLIBCXX_PROFILE_DATA(_S_max_mem)
  360.       = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR,
  361.                         _GLIBCXX_PROFILE_DATA(_S_max_mem));
  362.   }
  363.  
  364.   inline int
  365.   __log_magnitude(float __f)
  366.   {
  367.     const float __log_base = 10.0;
  368.     int __result = 0;
  369.     int __sign = 1;
  370.  
  371.     if (__f < 0)
  372.       {
  373.         __f = -__f;
  374.         __sign = -1;
  375.       }
  376.  
  377.     while (__f > __log_base)
  378.       {
  379.         ++__result;
  380.         __f /= 10.0;
  381.       }
  382.     return __sign * __result;
  383.   }
  384.  
  385.   inline FILE*
  386.   __open_output_file(const char* __extension)
  387.   {
  388.     // The path is made of _S_trace_file_name + "." + extension.
  389.     std::size_t __root_len
  390.       = __builtin_strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));
  391.     std::size_t __ext_len = __builtin_strlen(__extension);
  392.     char* __file_name = new char[__root_len + 1 + __ext_len + 1];
  393.     __builtin_memcpy(__file_name,
  394.                      _GLIBCXX_PROFILE_DATA(_S_trace_file_name),
  395.                      __root_len);
  396.     *(__file_name + __root_len) = '.';
  397.     __builtin_memcpy(__file_name + __root_len + 1,
  398.                      __extension, __ext_len + 1);
  399.  
  400.     FILE* __out_file = std::fopen(__file_name, "w");
  401.     if (!__out_file)
  402.       {
  403.         std::fprintf(stderr, "Could not open trace file '%s'.\n",
  404.                      __file_name);
  405.         std::abort();
  406.       }
  407.  
  408.     delete[] __file_name;
  409.     return __out_file;
  410.   }
  411.  
  412.   struct __warn
  413.   {
  414.     FILE* __file;
  415.  
  416.     __warn(FILE* __f)
  417.     { __file = __f; }
  418.  
  419.     void
  420.     operator()(const __warning_data& __info)
  421.     {
  422.       std::fprintf(__file,  __info.__warning_id);
  423.       std::fprintf(__file, ": improvement = %d",
  424.                    __log_magnitude(__info.__magnitude));
  425.       std::fprintf(__file, ": call stack = ");
  426.       __gnu_profile::__write(__file, __info.__context);
  427.       std::fprintf(__file, ": advice = %s\n",
  428.                    __info.__warning_message.c_str());
  429.     }
  430.   };
  431.  
  432.   /** @brief Final report method, registered with @b atexit.
  433.    *
  434.    * This can also be called directly by user code, including signal handlers.
  435.    * It is protected against deadlocks by the reentrance guard in profiler.h.
  436.    * However, when called from a signal handler that triggers while within
  437.    * __gnu_profile (under the guarded zone), no output will be produced.
  438.    */
  439.   inline void
  440.   __report(void)
  441.   {
  442.     _GLIBCXX_PROFILE_DATA(__global_lock).lock();
  443.  
  444.     __warning_vector_t __warnings, __top_warnings;
  445.  
  446.     FILE* __raw_file = __open_output_file("raw");
  447.     __trace_vector_size_report(__raw_file, __warnings);
  448.     __trace_hashtable_size_report(__raw_file, __warnings);
  449.     __trace_hash_func_report(__raw_file, __warnings);
  450.     __trace_vector_to_list_report(__raw_file, __warnings);
  451.     __trace_list_to_slist_report(__raw_file, __warnings);
  452.     __trace_list_to_vector_report(__raw_file, __warnings);
  453.     __trace_map_to_unordered_map_report(__raw_file, __warnings);
  454.     std::fclose(__raw_file);
  455.  
  456.     // Sort data by magnitude, keeping just top N.
  457.     std::size_t __cutoff = std::min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count),
  458.                                     __warnings.size());
  459.     __top_n(__warnings, __top_warnings, __cutoff);
  460.  
  461.     FILE* __warn_file = __open_output_file("txt");
  462.     __for_each(__top_warnings.begin(), __top_warnings.end(),
  463.                __warn(__warn_file));
  464.     std::fclose(__warn_file);
  465.  
  466.     _GLIBCXX_PROFILE_DATA(__global_lock).unlock();
  467.   }
  468.  
  469.   inline void
  470.   __set_trace_path()
  471.   {
  472.     char* __env_trace_file_name = std::getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR);
  473.  
  474.     if (__env_trace_file_name)
  475.       _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name;
  476.  
  477.     // Make sure early that we can create the trace file.
  478.     std::fclose(__open_output_file("txt"));
  479.   }
  480.  
  481.   inline void
  482.   __set_max_warn_count()
  483.   {
  484.     char* __env_max_warn_count_str
  485.       = std::getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR);
  486.  
  487.     if (__env_max_warn_count_str)
  488.       _GLIBCXX_PROFILE_DATA(_S_max_warn_count)
  489.         = static_cast<std::size_t>(std::atoi(__env_max_warn_count_str));
  490.   }
  491.  
  492.   inline void
  493.   __read_cost_factors()
  494.   {
  495.     std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));
  496.     __conf_file_name += ".conf";
  497.  
  498.     std::ifstream __conf_file(__conf_file_name.c_str());
  499.  
  500.     if (__conf_file.is_open())
  501.       {
  502.         std::string __line;
  503.  
  504.         while (std::getline(__conf_file, __line))
  505.           {
  506.             std::string::size_type __i = __line.find_first_not_of(" \t\n\v");
  507.  
  508.             if (__line.length() <= 0 || __line[__i] == '#')
  509.               // Skip empty lines or comments.
  510.               continue;
  511.           }
  512.  
  513.         // Trim.
  514.         __line.erase(__remove(__line.begin(), __line.end(), ' '),
  515.                      __line.end());
  516.         std::string::size_type __pos = __line.find("=");
  517.         std::string __factor_name = __line.substr(0, __pos);
  518.         std::string::size_type __end = __line.find_first_of(";\n");
  519.         std::string __factor_value = __line.substr(__pos + 1, __end - __pos);
  520.  
  521.         _GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value;
  522.       }
  523.   }
  524.  
  525.   struct __cost_factor_writer
  526.   {
  527.     FILE* __file;
  528.  
  529.     __cost_factor_writer(FILE* __f)
  530.     : __file(__f) { }
  531.  
  532.     void
  533.     operator() (const __cost_factor* __factor)
  534.     { std::fprintf(__file, "%s = %f\n", __factor->__env_var,
  535.                    __factor->__value); }
  536.   };
  537.  
  538.   inline void
  539.   __write_cost_factors()
  540.   {
  541.     FILE* __file = __open_output_file("conf.out");
  542.     __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(),
  543.                _GLIBCXX_PROFILE_DATA(__cost_factors)->end(),
  544.                __cost_factor_writer(__file));
  545.     std::fclose(__file);
  546.   }
  547.  
  548.   struct __cost_factor_setter
  549.   {
  550.     void
  551.     operator()(__cost_factor* __factor)
  552.     {
  553.       // Look it up in the process environment first.
  554.       const char* __env_value = std::getenv(__factor->__env_var);
  555.  
  556.       if (!__env_value)
  557.         {
  558.           // Look it up in the config file.
  559.           __env_t::iterator __it
  560.             = _GLIBCXX_PROFILE_DATA(__env).find(__factor->__env_var);
  561.           if (__it != _GLIBCXX_PROFILE_DATA(__env).end())
  562.             __env_value = (*__it).second.c_str();
  563.         }
  564.  
  565.       if (__env_value)
  566.         __factor->__value = std::atof(__env_value);
  567.     }
  568.   };
  569.  
  570.   inline void
  571.   __set_cost_factors()
  572.   {
  573.     _GLIBCXX_PROFILE_DATA(__cost_factors) = new __cost_factor_vector;
  574.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  575.       push_back(&_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor));
  576.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  577.       push_back(&_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor));
  578.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  579.       push_back(&_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor));
  580.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  581.       push_back(&_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor));
  582.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  583.       push_back(&_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor));
  584.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  585.       push_back(&_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor));
  586.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  587.       push_back(&_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor));
  588.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  589.       push_back(&_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor));
  590.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  591.       push_back(&_GLIBCXX_PROFILE_DATA(__map_find_cost_factor));
  592.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  593.       push_back(&_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor));
  594.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  595.       push_back(&_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor));
  596.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  597.       push_back(&_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor));
  598.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  599.       push_back(&_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor));
  600.     _GLIBCXX_PROFILE_DATA(__cost_factors)->
  601.       push_back(&_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor));
  602.     __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(),
  603.                _GLIBCXX_PROFILE_DATA(__cost_factors)->end(),
  604.                __cost_factor_setter());
  605.   }
  606.  
  607.   inline void
  608.   __profcxx_init_unconditional()
  609.   {
  610.     _GLIBCXX_PROFILE_DATA(__global_lock).lock();
  611.  
  612.     if (__is_invalid())
  613.       {
  614.         __set_max_warn_count();
  615.  
  616.         if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0)
  617.           __turn_off();
  618.         else
  619.           {
  620.             __set_max_stack_trace_depth();
  621.             __set_max_mem();
  622.             __set_trace_path();
  623.             __read_cost_factors();
  624.             __set_cost_factors();
  625.             __write_cost_factors();
  626.  
  627.             __trace_vector_size_init();
  628.             __trace_hashtable_size_init();
  629.             __trace_hash_func_init();
  630.             __trace_vector_to_list_init();
  631.             __trace_list_to_slist_init();
  632.             __trace_list_to_vector_init();
  633.             __trace_map_to_unordered_map_init();
  634.  
  635.             std::atexit(__report);
  636.  
  637.             __turn_on();
  638.           }
  639.       }
  640.  
  641.     _GLIBCXX_PROFILE_DATA(__global_lock).unlock();
  642.   }
  643.  
  644.   /** @brief This function must be called by each instrumentation point.
  645.    *
  646.    * The common path is inlined fully.
  647.    */
  648.   inline bool
  649.   __profcxx_init()
  650.   {
  651.     if (__is_invalid())
  652.       __profcxx_init_unconditional();
  653.  
  654.     return __is_on();
  655.   }
  656.  
  657. } // namespace __gnu_profile
  658.  
  659. #endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */
  660.