release/src-rt-6.x.4708/toolchains/hndtools-arm-linux-2.6.36-uclibc-4.5.3/arm-brcm-linux-uclibcgnueabi/include/c++/4.5.3/profile/impl/profiler_trace.h

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