1 // -*- C++ -*- 2 // 3 // Copyright (C) 2009-2018 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 #include <unordered_map> 39 #define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_C::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_mutex); 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 void __trace_vector_size_free(); 118 void __trace_hashtable_size_free(); 119 void __trace_hash_func_free(); 120 void __trace_vector_to_list_free(); 121 void __trace_list_to_slist_free(); 122 void __trace_list_to_vector_free(); 123 void __trace_map_to_unordered_map_free(); 124 125 struct __cost_factor 126 { 127 const char* __env_var; 128 float __value; 129 }; 130 131 typedef std::_GLIBCXX_STD_C::vector<__cost_factor*> __cost_factor_vector; 132 133 _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0); 134 _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0); 135 _GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0); 136 _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0); 137 _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0); 138 _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); 139 _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0); 140 141 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, 142 {"__vector_shift_cost_factor", 1.0}); 143 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor, 144 {"__vector_iterate_cost_factor", 1.0}); 145 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor, 146 {"__vector_resize_cost_factor", 1.0}); 147 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor, 148 {"__list_shift_cost_factor", 0.0}); 149 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor, 150 {"__list_iterate_cost_factor", 10.0}); 151 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor, 152 {"__list_resize_cost_factor", 0.0}); 153 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor, 154 {"__map_insert_cost_factor", 1.5}); 155 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor, 156 {"__map_erase_cost_factor", 1.5}); 157 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor, 158 {"__map_find_cost_factor", 1}); 159 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor, 160 {"__map_iterate_cost_factor", 2.3}); 161 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor, 162 {"__umap_insert_cost_factor", 12.0}); 163 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor, 164 {"__umap_erase_cost_factor", 12.0}); 165 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor, 166 {"__umap_find_cost_factor", 10.0}); 167 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor, 168 {"__umap_iterate_cost_factor", 1.7}); 169 _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0); 170 171 _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name, 172 _GLIBCXX_PROFILE_TRACE_PATH_ROOT); 173 _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_warn_count, 174 _GLIBCXX_PROFILE_MAX_WARN_COUNT); 175 _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_stack_depth, 176 _GLIBCXX_PROFILE_MAX_STACK_DEPTH); 177 _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_mem, 178 _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC); 179 180 inline std::size_t 181 __stack_max_depth() 182 { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); } 183 184 inline std::size_t 185 __max_mem() 186 { return _GLIBCXX_PROFILE_DATA(_S_max_mem); } 187 188 /** @brief Base class for all trace producers. */ 189 template<typename __object_info, typename __stack_info> 190 class __trace_base 191 { 192 public: 193 // Do not pick the initial size too large, as we don't know which 194 // diagnostics are more active. 195 __trace_base() 196 : __objects_byte_size(0), __stack_table(10000), 197 __stack_table_byte_size(0), __id(0) { } 198 199 ~__trace_base() 200 { 201 for (typename __stack_table_t::iterator __it 202 = __stack_table.begin(); __it != __stack_table.end(); ++__it) 203 delete __it->first; 204 } 205 206 __object_info* __add_object(__stack_t __stack); 207 void __retire_object(__object_info* __info); 208 void __write(FILE* __f); 209 void __collect_warnings(__warning_vector_t& __warnings); 210 void __free(); 211 212 private: 213 __gnu_cxx::__mutex __trace_mutex; 214 typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, 215 __stack_hash, 216 __stack_hash> __stack_table_t; 217 std::size_t __objects_byte_size; 218 __stack_table_t __stack_table; 219 std::size_t __stack_table_byte_size; 220 221 protected: 222 const char* __id; 223 }; 224 225 template<typename __object_info, typename __stack_info> 226 __object_info* 227 __trace_base<__object_info, __stack_info>:: 228 __add_object(__stack_t __stack) 229 { 230 // If we have no backtrace information no need to collect data. 231 if (!__stack) 232 return 0; 233 234 __gnu_cxx::__scoped_lock __lock(this->__trace_mutex); 235 236 if (__max_mem() != 0 && __objects_byte_size >= __max_mem()) 237 { 238 delete __stack; 239 return 0; 240 } 241 242 __object_info* __ret = new(std::nothrow) __object_info(__stack); 243 if (!__ret) 244 { 245 delete __stack; 246 return 0; 247 } 248 249 __objects_byte_size += sizeof(__object_info); 250 return __ret; 251 } 252 253 template<typename __object_info, typename __stack_info> 254 void 255 __trace_base<__object_info, __stack_info>:: 256 __retire_object(__object_info* __obj_info) 257 { 258 if (!__obj_info) 259 return; 260 261 __gnu_cxx::__scoped_lock __lock(this->__trace_mutex); 262 263 const __object_info& __info = *__obj_info; 264 __stack_t __stack = __info.__stack(); 265 typename __stack_table_t::iterator __stack_it 266 = __stack_table.find(__stack); 267 268 if (__stack_it == __stack_table.end()) 269 { 270 // First occurrence of this call context. 271 if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) 272 { 273 __stack_table_byte_size 274 += (sizeof(__instruction_address_t) * __size(__stack) 275 + sizeof(__stack) + sizeof(__stack_info)); 276 __stack_table.insert(make_pair(__stack, 277 __stack_info(__info))); 278 } 279 else 280 delete __stack; 281 } 282 else 283 { 284 // Merge object info into info summary for this call context. 285 __stack_it->second.__merge(__info); 286 delete __stack; 287 } 288 289 delete __obj_info; 290 __objects_byte_size -= sizeof(__object_info); 291 } 292 293 template<typename __object_info, typename __stack_info> 294 void 295 __trace_base<__object_info, __stack_info>:: 296 __write(FILE* __f) 297 { 298 for (typename __stack_table_t::iterator __it 299 = __stack_table.begin(); __it != __stack_table.end(); ++__it) 300 if (__it->second.__is_valid()) 301 { 302 std::fprintf(__f, __id); 303 std::fprintf(__f, "|"); 304 __gnu_profile::__write(__f, __it->first); 305 std::fprintf(__f, "|"); 306 __it->second.__write(__f); 307 } 308 } 309 310 template<typename __object_info, typename __stack_info> 311 void 312 __trace_base<__object_info, __stack_info>:: 313 __collect_warnings(__warning_vector_t& __warnings) 314 { 315 for (typename __stack_table_t::iterator __it 316 = __stack_table.begin(); __it != __stack_table.end(); ++__it) 317 __warnings.push_back(__warning_data(__it->second.__magnitude(), 318 __it->first, __id, 319 __it->second.__advice())); 320 } 321 322 template<typename __object_info, typename __stack_info> 323 inline void 324 __trace_report(__trace_base<__object_info, __stack_info>* __cont, 325 FILE* __f, __warning_vector_t& __warnings) 326 { 327 if (__cont) 328 { 329 __cont->__collect_warnings(__warnings); 330 __cont->__write(__f); 331 } 332 } 333 334 inline std::size_t 335 __env_to_size_t(const char* __env_var, std::size_t __default_value) 336 { 337 char* __env_value = std::getenv(__env_var); 338 if (__env_value) 339 { 340 errno = 0; 341 long __converted_value = std::strtol(__env_value, 0, 10); 342 if (errno || __converted_value < 0) 343 { 344 std::fprintf(stderr, 345 "Bad value for environment variable '%s'.\n", 346 __env_var); 347 std::abort(); 348 } 349 else 350 return static_cast<std::size_t>(__converted_value); 351 } 352 else 353 return __default_value; 354 } 355 356 inline void 357 __set_max_stack_trace_depth() 358 { 359 _GLIBCXX_PROFILE_DATA(_S_max_stack_depth) 360 = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR, 361 _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)); 362 } 363 364 inline void 365 __set_max_mem() 366 { 367 _GLIBCXX_PROFILE_DATA(_S_max_mem) 368 = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, 369 _GLIBCXX_PROFILE_DATA(_S_max_mem)); 370 } 371 372 inline int 373 __log_magnitude(float __f) 374 { 375 const float __log_base = 10.0; 376 int __result = 0; 377 int __sign = 1; 378 379 if (__f < 0) 380 { 381 __f = -__f; 382 __sign = -1; 383 } 384 385 while (__f > __log_base) 386 { 387 ++__result; 388 __f /= 10.0; 389 } 390 return __sign * __result; 391 } 392 393 inline FILE* 394 __open_output_file(const char* __extension) 395 { 396 // The path is made of _S_trace_file_name + "." + extension. 397 std::size_t __root_len 398 = __builtin_strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); 399 std::size_t __ext_len = __builtin_strlen(__extension); 400 char* __file_name = new char[__root_len + 1 + __ext_len + 1]; 401 __builtin_memcpy(__file_name, 402 _GLIBCXX_PROFILE_DATA(_S_trace_file_name), 403 __root_len); 404 *(__file_name + __root_len) = '.'; 405 __builtin_memcpy(__file_name + __root_len + 1, 406 __extension, __ext_len + 1); 407 408 FILE* __out_file = std::fopen(__file_name, "w"); 409 if (!__out_file) 410 { 411 std::fprintf(stderr, "Could not open trace file '%s'.\n", 412 __file_name); 413 std::abort(); 414 } 415 416 delete[] __file_name; 417 return __out_file; 418 } 419 420 struct __warn 421 { 422 FILE* __file; 423 424 __warn(FILE* __f) 425 { __file = __f; } 426 427 void 428 operator()(const __warning_data& __info) 429 { 430 std::fprintf(__file, __info.__warning_id); 431 std::fprintf(__file, ": improvement = %d", 432 __log_magnitude(__info.__magnitude)); 433 std::fprintf(__file, ": call stack = "); 434 __gnu_profile::__write(__file, __info.__context); 435 std::fprintf(__file, ": advice = %s\n", 436 __info.__warning_message.c_str()); 437 } 438 }; 439 440 /** @brief Final report method, registered with @b atexit. 441 * 442 * This can also be called directly by user code, including signal handlers. 443 * It is protected against deadlocks by the reentrance guard in profiler.h. 444 * However, when called from a signal handler that triggers while within 445 * __gnu_profile (under the guarded zone), no output will be produced. 446 */ 447 inline void 448 __report() 449 { 450 __gnu_cxx::__scoped_lock __lock(_GLIBCXX_PROFILE_DATA(__global_mutex)); 451 452 __warning_vector_t __warnings, __top_warnings; 453 454 FILE* __raw_file = __open_output_file("raw"); 455 __trace_vector_size_report(__raw_file, __warnings); 456 __trace_hashtable_size_report(__raw_file, __warnings); 457 __trace_hash_func_report(__raw_file, __warnings); 458 __trace_vector_to_list_report(__raw_file, __warnings); 459 __trace_list_to_slist_report(__raw_file, __warnings); 460 __trace_list_to_vector_report(__raw_file, __warnings); 461 __trace_map_to_unordered_map_report(__raw_file, __warnings); 462 std::fclose(__raw_file); 463 464 // Sort data by magnitude, keeping just top N. 465 std::size_t __cutoff = std::min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count), 466 __warnings.size()); 467 __top_n(__warnings, __top_warnings, __cutoff); 468 469 FILE* __warn_file = __open_output_file("txt"); 470 __for_each(__top_warnings.begin(), __top_warnings.end(), 471 __warn(__warn_file)); 472 std::fclose(__warn_file); 473 } 474 475 inline void 476 __report_and_free() 477 { 478 __report(); 479 480 __trace_map_to_unordered_map_free(); 481 __trace_list_to_vector_free(); 482 __trace_list_to_slist_free(); 483 __trace_vector_to_list_free(); 484 __trace_hash_func_free(); 485 __trace_hashtable_size_free(); 486 __trace_vector_size_free(); 487 delete _GLIBCXX_PROFILE_DATA(__cost_factors); 488 } 489 490 inline void 491 __set_trace_path() 492 { 493 char* __env_trace_file_name = std::getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR); 494 495 if (__env_trace_file_name) 496 _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name; 497 498 // Make sure early that we can create the trace file. 499 std::fclose(__open_output_file("txt")); 500 } 501 502 inline void 503 __set_max_warn_count() 504 { 505 char* __env_max_warn_count_str 506 = std::getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR); 507 508 if (__env_max_warn_count_str) 509 _GLIBCXX_PROFILE_DATA(_S_max_warn_count) 510 = static_cast<std::size_t>(std::atoi(__env_max_warn_count_str)); 511 } 512 513 inline void 514 __read_cost_factors() 515 { 516 std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); 517 __conf_file_name += ".conf"; 518 519 std::ifstream __conf_file(__conf_file_name.c_str()); 520 521 if (__conf_file.is_open()) 522 { 523 std::string __line; 524 525 while (std::getline(__conf_file, __line)) 526 { 527 std::string::size_type __i = __line.find_first_not_of(" \t\n\v"); 528 529 if (__line.length() <= 0 || __line[__i] == '#') 530 // Skip empty lines or comments. 531 continue; 532 } 533 534 // Trim. 535 __line.erase(__remove(__line.begin(), __line.end(), ' '), 536 __line.end()); 537 std::string::size_type __pos = __line.find("="); 538 std::string __factor_name = __line.substr(0, __pos); 539 std::string::size_type __end = __line.find_first_of(";\n"); 540 std::string __factor_value = __line.substr(__pos + 1, __end - __pos); 541 542 _GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value; 543 } 544 } 545 546 struct __cost_factor_writer 547 { 548 FILE* __file; 549 550 __cost_factor_writer(FILE* __f) 551 : __file(__f) { } 552 553 void 554 operator() (const __cost_factor* __factor) 555 { std::fprintf(__file, "%s = %f\n", __factor->__env_var, 556 __factor->__value); } 557 }; 558 559 inline void 560 __write_cost_factors() 561 { 562 FILE* __file = __open_output_file("conf.out"); 563 __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), 564 _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), 565 __cost_factor_writer(__file)); 566 std::fclose(__file); 567 } 568 569 struct __cost_factor_setter 570 { 571 void 572 operator()(__cost_factor* __factor) 573 { 574 // Look it up in the process environment first. 575 const char* __env_value = std::getenv(__factor->__env_var); 576 577 if (!__env_value) 578 { 579 // Look it up in the config file. 580 __env_t::iterator __it 581 = _GLIBCXX_PROFILE_DATA(__env).find(__factor->__env_var); 582 if (__it != _GLIBCXX_PROFILE_DATA(__env).end()) 583 __env_value = __it->second.c_str(); 584 } 585 586 if (__env_value) 587 __factor->__value = std::atof(__env_value); 588 } 589 }; 590 591 inline void 592 __set_cost_factors() 593 { 594 __cost_factor_vector* __factors = new __cost_factor_vector; 595 _GLIBCXX_PROFILE_DATA(__cost_factors) = __factors; 596 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor)); 597 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor)); 598 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor)); 599 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor)); 600 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor)); 601 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor)); 602 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor)); 603 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor)); 604 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_find_cost_factor)); 605 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor)); 606 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor)); 607 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor)); 608 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor)); 609 __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor)); 610 __for_each(__factors->begin(), __factors->end(), __cost_factor_setter()); 611 } 612 613 inline void 614 __profcxx_init_unconditional() 615 { 616 __gnu_cxx::__scoped_lock __lock(_GLIBCXX_PROFILE_DATA(__global_mutex)); 617 618 if (__is_invalid()) 619 { 620 __set_max_warn_count(); 621 622 if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0) 623 __turn_off(); 624 else 625 { 626 __set_max_stack_trace_depth(); 627 __set_max_mem(); 628 __set_trace_path(); 629 __read_cost_factors(); 630 __set_cost_factors(); 631 __write_cost_factors(); 632 633 __trace_vector_size_init(); 634 __trace_hashtable_size_init(); 635 __trace_hash_func_init(); 636 __trace_vector_to_list_init(); 637 __trace_list_to_slist_init(); 638 __trace_list_to_vector_init(); 639 __trace_map_to_unordered_map_init(); 640 641 std::atexit(__report_and_free); 642 643 __turn_on(); 644 } 645 } 646 } 647 648 /** @brief This function must be called by each instrumentation point. 649 * 650 * The common path is inlined fully. 651 */ 652 inline bool 653 __profcxx_init() 654 { 655 if (__is_invalid()) 656 __profcxx_init_unconditional(); 657 658 return __is_on(); 659 } 660 661 } // namespace __gnu_profile 662 663 #endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */ 664