diff options
Diffstat (limited to '8/sources/cxx-stl/gnu-libstdc++/4.6/include/profile/impl/profiler_trace.h')
| -rw-r--r-- | 8/sources/cxx-stl/gnu-libstdc++/4.6/include/profile/impl/profiler_trace.h | 666 |
1 files changed, 666 insertions, 0 deletions
diff --git a/8/sources/cxx-stl/gnu-libstdc++/4.6/include/profile/impl/profiler_trace.h b/8/sources/cxx-stl/gnu-libstdc++/4.6/include/profile/impl/profiler_trace.h new file mode 100644 index 0000000..1e00542 --- /dev/null +++ b/8/sources/cxx-stl/gnu-libstdc++/4.6/include/profile/impl/profiler_trace.h @@ -0,0 +1,666 @@ +// -*- C++ -*- +// +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_trace.h + * @brief Data structures to represent profiling traces. + */ + +// Written by Lixia Liu and Silvius Rus. + +#ifndef _GLIBCXX_PROFILE_PROFILER_TRACE_H +#define _GLIBCXX_PROFILE_PROFILER_TRACE_H 1 + +#include <cstdio> // fopen, fclose, fprintf, FILE +#include <cerrno> +#include <cstdlib> // atof, atoi, strtol, getenv, atexit, abort + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_C::unordered_map +#include <unordered_map> +#else +#include <tr1/unordered_map> +#define _GLIBCXX_IMPL_UNORDERED_MAP std::tr1::unordered_map +#endif + +#include <ext/concurrence.h> +#include <fstream> +#include <string> +#include <utility> +#include <vector> + +#include "profile/impl/profiler_algos.h" +#include "profile/impl/profiler_state.h" +#include "profile/impl/profiler_node.h" + +namespace __gnu_profile +{ + /** @brief Internal environment. Values can be set one of two ways: + 1. In config file "var = value". The default config file path is + libstdcxx-profile.conf. + 2. By setting process environment variables. For instance, in a Bash + shell you can set the unit cost of iterating through a map like this: + export __map_iterate_cost_factor=5.0. + If a value is set both in the input file and through an environment + variable, the environment value takes precedence. */ + typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t; + + _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env); + + /** @brief Master lock. */ + _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock); + + /** @brief Representation of a warning. */ + struct __warning_data + { + float __magnitude; + __stack_t __context; + const char* __warning_id; + std::string __warning_message; + + __warning_data() + : __magnitude(0.0), __context(0), __warning_id(0) { } + + __warning_data(float __m, __stack_t __c, const char* __id, + const std::string& __msg) + : __magnitude(__m), __context(__c), __warning_id(__id), + __warning_message(__msg) { } + + bool + operator<(const __warning_data& __other) const + { return __magnitude < __other.__magnitude; } + }; + + typedef std::_GLIBCXX_STD_C::vector<__warning_data> __warning_vector_t; + + // Defined in profiler_<diagnostic name>.h. + class __trace_hash_func; + class __trace_hashtable_size; + class __trace_map2umap; + class __trace_vector_size; + class __trace_vector_to_list; + class __trace_list_to_slist; + class __trace_list_to_vector; + void __trace_vector_size_init(); + void __trace_hashtable_size_init(); + void __trace_hash_func_init(); + void __trace_vector_to_list_init(); + void __trace_list_to_slist_init(); + void __trace_list_to_vector_init(); + void __trace_map_to_unordered_map_init(); + void __trace_vector_size_report(FILE*, __warning_vector_t&); + void __trace_hashtable_size_report(FILE*, __warning_vector_t&); + void __trace_hash_func_report(FILE*, __warning_vector_t&); + void __trace_vector_to_list_report(FILE*, __warning_vector_t&); + void __trace_list_to_slist_report(FILE*, __warning_vector_t&); + void __trace_list_to_vector_report(FILE*, __warning_vector_t&); + void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&); + + struct __cost_factor + { + const char* __env_var; + float __value; + }; + + typedef std::_GLIBCXX_STD_C::vector<__cost_factor*> __cost_factor_vector; + + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0); + + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, + {"__vector_shift_cost_factor", 1.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor, + {"__vector_iterate_cost_factor", 1.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor, + {"__vector_resize_cost_factor", 1.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor, + {"__list_shift_cost_factor", 0.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor, + {"__list_iterate_cost_factor", 10.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor, + {"__list_resize_cost_factor", 0.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor, + {"__map_insert_cost_factor", 1.5}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor, + {"__map_erase_cost_factor", 1.5}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor, + {"__map_find_cost_factor", 1}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor, + {"__map_iterate_cost_factor", 2.3}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor, + {"__umap_insert_cost_factor", 12.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor, + {"__umap_erase_cost_factor", 12.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor, + {"__umap_find_cost_factor", 10.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor, + {"__umap_iterate_cost_factor", 1.7}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0); + + _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name, + _GLIBCXX_PROFILE_TRACE_PATH_ROOT); + _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_warn_count, + _GLIBCXX_PROFILE_MAX_WARN_COUNT); + _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_stack_depth, + _GLIBCXX_PROFILE_MAX_STACK_DEPTH); + _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_mem, + _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC); + + inline std::size_t + __stack_max_depth() + { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); } + + inline std::size_t + __max_mem() + { return _GLIBCXX_PROFILE_DATA(_S_max_mem); } + + /** @brief Base class for all trace producers. */ + template<typename __object_info, typename __stack_info> + class __trace_base + { + public: + // Do not pick the initial size too large, as we don't know which + // diagnostics are more active. + __trace_base() + : __object_table(10000), __stack_table(10000), + __stack_table_byte_size(0), __id(0) { } + + virtual ~__trace_base() { } + + void __add_object(__object_t object, __object_info __info); + __object_info* __get_object_info(__object_t __object); + void __retire_object(__object_t __object); + void __write(FILE* __f); + void __collect_warnings(__warning_vector_t& __warnings); + + private: + __gnu_cxx::__mutex __object_table_lock; + __gnu_cxx::__mutex __stack_table_lock; + typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t, + __object_info> __object_table_t; + typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, + __stack_hash, + __stack_hash> __stack_table_t; + __object_table_t __object_table; + __stack_table_t __stack_table; + std::size_t __stack_table_byte_size; + + protected: + const char* __id; + }; + + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __collect_warnings(__warning_vector_t& __warnings) + { + for (typename __stack_table_t::iterator __it + = __stack_table.begin(); __it != __stack_table.end(); ++__it) + __warnings.push_back(__warning_data((*__it).second.__magnitude(), + (*__it).first, __id, + (*__it).second.__advice())); + } + + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __add_object(__object_t __object, __object_info __info) + { + if (__max_mem() == 0 + || __object_table.size() * sizeof(__object_info) <= __max_mem()) + { + this->__object_table_lock.lock(); + __object_table.insert(typename __object_table_t:: + value_type(__object, __info)); + this->__object_table_lock.unlock(); + } + } + + template<typename __object_info, typename __stack_info> + __object_info* + __trace_base<__object_info, __stack_info>:: + __get_object_info(__object_t __object) + { + // XXX: Revisit this to see if we can decrease mutex spans. + // Without this mutex, the object table could be rehashed during an + // insertion on another thread, which could result in a segfault. + this->__object_table_lock.lock(); + typename __object_table_t::iterator __object_it + = __object_table.find(__object); + + if (__object_it == __object_table.end()) + { + this->__object_table_lock.unlock(); + return 0; + } + else + { + this->__object_table_lock.unlock(); + return &__object_it->second; + } + } + + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __retire_object(__object_t __object) + { + this->__object_table_lock.lock(); + this->__stack_table_lock.lock(); + typename __object_table_t::iterator __object_it + = __object_table.find(__object); + + if (__object_it != __object_table.end()) + { + const __object_info& __info = __object_it->second; + const __stack_t& __stack = __info.__stack(); + typename __stack_table_t::iterator __stack_it + = __stack_table.find(__stack); + + if (__stack_it == __stack_table.end()) + { + // First occurence of this call context. + if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) + { + __stack_table_byte_size + += (sizeof(__instruction_address_t) * __size(__stack) + + sizeof(__stack) + sizeof(__stack_info)); + __stack_table.insert(make_pair(__stack, + __stack_info(__info))); + } + } + else + { + // Merge object info into info summary for this call context. + __stack_it->second.__merge(__info); + delete __stack; + } + __object_table.erase(__object); + } + + this->__object_table_lock.unlock(); + this->__stack_table_lock.unlock(); + } + + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __write(FILE* __f) + { + for (typename __stack_table_t::iterator __it + = __stack_table.begin(); __it != __stack_table.end(); ++__it) + if (__it->second.__is_valid()) + { + std::fprintf(__f, __id); + std::fprintf(__f, "|"); + __gnu_profile::__write(__f, __it->first); + std::fprintf(__f, "|"); + __it->second.__write(__f); + } + } + + inline std::size_t + __env_to_size_t(const char* __env_var, std::size_t __default_value) + { + char* __env_value = std::getenv(__env_var); + if (__env_value) + { + errno = 0; + long __converted_value = std::strtol(__env_value, 0, 10); + if (errno || __converted_value < 0) + { + std::fprintf(stderr, + "Bad value for environment variable '%s'.\n", + __env_var); + std::abort(); + } + else + return static_cast<std::size_t>(__converted_value); + } + else + return __default_value; + } + + inline void + __set_max_stack_trace_depth() + { + _GLIBCXX_PROFILE_DATA(_S_max_stack_depth) + = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR, + _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)); + } + + inline void + __set_max_mem() + { + _GLIBCXX_PROFILE_DATA(_S_max_mem) + = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, + _GLIBCXX_PROFILE_DATA(_S_max_mem)); + } + + inline int + __log_magnitude(float __f) + { + const float __log_base = 10.0; + int __result = 0; + int __sign = 1; + + if (__f < 0) + { + __f = -__f; + __sign = -1; + } + + while (__f > __log_base) + { + ++__result; + __f /= 10.0; + } + return __sign * __result; + } + + inline FILE* + __open_output_file(const char* __extension) + { + // The path is made of _S_trace_file_name + "." + extension. + std::size_t __root_len + = __builtin_strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); + std::size_t __ext_len = __builtin_strlen(__extension); + char* __file_name = new char[__root_len + 1 + __ext_len + 1]; + __builtin_memcpy(__file_name, + _GLIBCXX_PROFILE_DATA(_S_trace_file_name), + __root_len); + *(__file_name + __root_len) = '.'; + __builtin_memcpy(__file_name + __root_len + 1, + __extension, __ext_len + 1); + + FILE* __out_file = std::fopen(__file_name, "w"); + if (!__out_file) + { + std::fprintf(stderr, "Could not open trace file '%s'.\n", + __file_name); + std::abort(); + } + + delete[] __file_name; + return __out_file; + } + + struct __warn + { + FILE* __file; + + __warn(FILE* __f) + { __file = __f; } + + void + operator()(const __warning_data& __info) + { + std::fprintf(__file, __info.__warning_id); + std::fprintf(__file, ": improvement = %d", + __log_magnitude(__info.__magnitude)); + std::fprintf(__file, ": call stack = "); + __gnu_profile::__write(__file, __info.__context); + std::fprintf(__file, ": advice = %s\n", + __info.__warning_message.c_str()); + } + }; + + /** @brief Final report method, registered with @b atexit. + * + * This can also be called directly by user code, including signal handlers. + * It is protected against deadlocks by the reentrance guard in profiler.h. + * However, when called from a signal handler that triggers while within + * __gnu_profile (under the guarded zone), no output will be produced. + */ + inline void + __report(void) + { + _GLIBCXX_PROFILE_DATA(__global_lock).lock(); + + __warning_vector_t __warnings, __top_warnings; + + FILE* __raw_file = __open_output_file("raw"); + __trace_vector_size_report(__raw_file, __warnings); + __trace_hashtable_size_report(__raw_file, __warnings); + __trace_hash_func_report(__raw_file, __warnings); + __trace_vector_to_list_report(__raw_file, __warnings); + __trace_list_to_slist_report(__raw_file, __warnings); + __trace_list_to_vector_report(__raw_file, __warnings); + __trace_map_to_unordered_map_report(__raw_file, __warnings); + std::fclose(__raw_file); + + // Sort data by magnitude, keeping just top N. + std::size_t __cutoff = std::min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count), + __warnings.size()); + __top_n(__warnings, __top_warnings, __cutoff); + + FILE* __warn_file = __open_output_file("txt"); + __for_each(__top_warnings.begin(), __top_warnings.end(), + __warn(__warn_file)); + std::fclose(__warn_file); + + _GLIBCXX_PROFILE_DATA(__global_lock).unlock(); + } + + inline void + __set_trace_path() + { + char* __env_trace_file_name = std::getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR); + + if (__env_trace_file_name) + _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name; + + // Make sure early that we can create the trace file. + std::fclose(__open_output_file("txt")); + } + + inline void + __set_max_warn_count() + { + char* __env_max_warn_count_str + = std::getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR); + + if (__env_max_warn_count_str) + _GLIBCXX_PROFILE_DATA(_S_max_warn_count) + = static_cast<std::size_t>(std::atoi(__env_max_warn_count_str)); + } + + inline void + __read_cost_factors() + { + std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); + __conf_file_name += ".conf"; + + std::ifstream __conf_file(__conf_file_name.c_str()); + + if (__conf_file.is_open()) + { + std::string __line; + + while (std::getline(__conf_file, __line)) + { + std::string::size_type __i = __line.find_first_not_of(" \t\n\v"); + + if (__line.length() <= 0 || __line[__i] == '#') + // Skip empty lines or comments. + continue; + } + + // Trim. + __line.erase(__remove(__line.begin(), __line.end(), ' '), + __line.end()); + std::string::size_type __pos = __line.find("="); + std::string __factor_name = __line.substr(0, __pos); + std::string::size_type __end = __line.find_first_of(";\n"); + std::string __factor_value = __line.substr(__pos + 1, __end - __pos); + + _GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value; + } + } + + struct __cost_factor_writer + { + FILE* __file; + + __cost_factor_writer(FILE* __f) + : __file(__f) { } + + void + operator() (const __cost_factor* __factor) + { std::fprintf(__file, "%s = %f\n", __factor->__env_var, + __factor->__value); } + }; + + inline void + __write_cost_factors() + { + FILE* __file = __open_output_file("conf.out"); + __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), + _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), + __cost_factor_writer(__file)); + std::fclose(__file); + } + + struct __cost_factor_setter + { + void + operator()(__cost_factor* __factor) + { + // Look it up in the process environment first. + const char* __env_value = std::getenv(__factor->__env_var); + + if (!__env_value) + { + // Look it up in the config file. + __env_t::iterator __it + = _GLIBCXX_PROFILE_DATA(__env).find(__factor->__env_var); + if (__it != _GLIBCXX_PROFILE_DATA(__env).end()) + __env_value = (*__it).second.c_str(); + } + + if (__env_value) + __factor->__value = std::atof(__env_value); + } + }; + + inline void + __set_cost_factors() + { + _GLIBCXX_PROFILE_DATA(__cost_factors) = new __cost_factor_vector; + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_find_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor)); + __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), + _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), + __cost_factor_setter()); + } + + inline void + __profcxx_init_unconditional() + { + _GLIBCXX_PROFILE_DATA(__global_lock).lock(); + + if (__is_invalid()) + { + __set_max_warn_count(); + + if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0) + __turn_off(); + else + { + __set_max_stack_trace_depth(); + __set_max_mem(); + __set_trace_path(); + __read_cost_factors(); + __set_cost_factors(); + __write_cost_factors(); + + __trace_vector_size_init(); + __trace_hashtable_size_init(); + __trace_hash_func_init(); + __trace_vector_to_list_init(); + __trace_list_to_slist_init(); + __trace_list_to_vector_init(); + __trace_map_to_unordered_map_init(); + + std::atexit(__report); + + __turn_on(); + } + } + + _GLIBCXX_PROFILE_DATA(__global_lock).unlock(); + } + + /** @brief This function must be called by each instrumentation point. + * + * The common path is inlined fully. + */ + inline bool + __profcxx_init() + { + if (__is_invalid()) + __profcxx_init_unconditional(); + + return __is_on(); + } + +} // namespace __gnu_profile + +#endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */ |