__gnu_profile Namespace Reference

GNU profile code for public use. More...

Classes
struct	__reentrance_guard
	Reentrance guard. More...
class	__container_size_info
	A container size instrumentation line in the object table. More...
class	__container_size_stack_info
	A container size instrumentation line in the stack table. More...
class	__trace_container_size
	Container size instrumentation trace producer. More...
class	__hashfunc_info
	A hash performance instrumentation line in the object table. More...
class	__hashfunc_stack_info
	A hash performance instrumentation line in the stack table. More...
class	__trace_hash_func
	Hash performance instrumentation producer. More...
class	__trace_hashtable_size
	Hashtable size instrumentation trace producer. More...
class	__list2slist_info
class	__list2slist_stack_info
class	__trace_list_to_slist
class	__list2vector_info
	A list-to-vector instrumentation line in the object table. More...
class	__list2vector_stack_info
class	__trace_list_to_vector
class	__map2umap_info
	A map-to-unordered_map instrumentation line in the object table. More...
class	__map2umap_stack_info
	A map-to-unordered_map instrumentation line in the stack table. More...
class	__trace_map2umap
	Map-to-unordered_map instrumentation producer. More...
class	__stack_hash
	Hash function for summary trace using call stack as index. More...
class	__object_info_base
	Base class for a line in the object table. More...
class	__stack_info_base
	Base class for a line in the stack table. More...
struct	__warning_data
	Representation of a warning. More...
struct	__cost_factor
class	__trace_base
	Base class for all trace producers. More...
struct	__warn
struct	__cost_factor_writer
struct	__cost_factor_setter
class	__trace_vector_size
	Hashtable size instrumentation trace producer. More...
class	__vector2list_info
	A vector-to-list instrumentation line in the object table. More...
class	__vector2list_stack_info
	A vector-to-list instrumentation line in the stack table. More...
class	__trace_vector_to_list
	Vector-to-list instrumentation producer. More...

Typedefs
typedef const void *	__object_t
typedef void *	__instruction_address_t
typedef std::_GLIBCXX_STD_C::vector < __instruction_address_t >	__stack_npt
typedef __stack_npt *	__stack_t
typedef _GLIBCXX_IMPL_UNORDERED_MAP < std::string, std::string >	__env_t
	Internal environment. Values can be set one of two ways: More...
typedef std::_GLIBCXX_STD_C::vector < __warning_data >	__warning_vector_t
typedef std::_GLIBCXX_STD_C::vector < __cost_factor * >	__cost_factor_vector

Enumerations
enum	__state_type { __ON, __OFF, __INVALID }

Functions
bool	__turn_on ()
bool	__turn_off ()
bool	__is_invalid ()
bool	__is_on ()
bool	__is_off ()
void	__report (void)
	Final report method, registered with atexit. More...
void	__trace_hashtable_size_resize (const void *, std::size_t, std::size_t)
void	__trace_hashtable_size_destruct (const void *, std::size_t, std::size_t)
void	__trace_hashtable_size_construct (const void *, std::size_t)
void	__trace_vector_size_resize (const void *, std::size_t, std::size_t)
void	__trace_vector_size_destruct (const void *, std::size_t, std::size_t)
void	__trace_vector_size_construct (const void *, std::size_t)
void	__trace_hash_func_destruct (const void *, std::size_t, std::size_t, std::size_t)
void	__trace_hash_func_construct (const void *)
void	__trace_vector_to_list_destruct (const void *)
void	__trace_vector_to_list_construct (const void *)
void	__trace_vector_to_list_insert (const void *, std::size_t, std::size_t)
void	__trace_vector_to_list_iterate (const void *, std::size_t)
void	__trace_vector_to_list_invalid_operator (const void *)
void	__trace_vector_to_list_resize (const void *, std::size_t, std::size_t)
void	__trace_vector_to_list_find (const void *, std::size_t)
void	__trace_list_to_slist_destruct (const void *)
void	__trace_list_to_slist_construct (const void *)
void	__trace_list_to_slist_rewind (const void *)
void	__trace_list_to_slist_operation (const void *)
void	__trace_list_to_vector_destruct (const void *)
void	__trace_list_to_vector_construct (const void *)
void	__trace_list_to_vector_insert (const void *, std::size_t, std::size_t)
void	__trace_list_to_vector_iterate (const void *, std::size_t)
void	__trace_list_to_vector_invalid_operator (const void *)
void	__trace_list_to_vector_resize (const void *, std::size_t, std::size_t)
void	__trace_list_to_set_destruct (const void *)
void	__trace_list_to_set_construct (const void *)
void	__trace_list_to_set_insert (const void *, std::size_t, std::size_t)
void	__trace_list_to_set_iterate (const void *, std::size_t)
void	__trace_list_to_set_invalid_operator (const void *)
void	__trace_list_to_set_find (const void *, std::size_t)
void	__trace_map_to_unordered_map_construct (const void *)
void	__trace_map_to_unordered_map_invalidate (const void *)
void	__trace_map_to_unordered_map_insert (const void *, std::size_t, std::size_t)
void	__trace_map_to_unordered_map_erase (const void *, std::size_t, std::size_t)
void	__trace_map_to_unordered_map_iterate (const void *, std::size_t)
void	__trace_map_to_unordered_map_find (const void *, std::size_t)
void	__trace_map_to_unordered_map_destruct (const void *)
template<typename _Container >
void	__insert_top_n (_Container &__output, const typename _Container::value_type &__value, typename _Container::size_type __n)
template<typename _Container >
void	__top_n (const _Container &__input, _Container &__output, typename _Container::size_type __n)
template<typename _InputIterator , typename _Function >
_Function	__for_each (_InputIterator __first, _InputIterator __last, _Function __f)
template<typename _ForwardIterator , typename _Tp >
_ForwardIterator	__remove (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value)
void	__trace_hash_func_init ()
void	__trace_hash_func_report (FILE *__f, __warning_vector_t &__warnings)
void	__trace_hashtable_size_init ()
void	__trace_hashtable_size_report (FILE *__f, __warning_vector_t &__warnings)
void	__trace_list_to_slist_init ()
void	__trace_list_to_slist_report (FILE *__f, __warning_vector_t &__warnings)
void	__trace_list_to_vector_init ()
void	__trace_list_to_vector_report (FILE *__f, __warning_vector_t &__warnings)
int	__log2 (std::size_t __size)
float	__map_insert_cost (std::size_t __size)
float	__map_erase_cost (std::size_t __size)
float	__map_find_cost (std::size_t __size)
void	__trace_map_to_unordered_map_init ()
void	__trace_map_to_unordered_map_report (FILE *__f, __warning_vector_t &__warnings)
std::size_t	__stack_max_depth ()
__stack_t	__get_stack ()
std::size_t	__size (__stack_t __stack)
void	__write (FILE *__f, __stack_t __stack)
	_GLIBCXX_PROFILE_DEFINE_DATA (__state_type, __state, __INVALID)
bool	__turn (__state_type __s)
	_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA (__env_t, __env)
	_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA (__gnu_cxx::__mutex, __global_lock)
	Master lock. More...
void	__trace_vector_size_init ()
void	__trace_vector_to_list_init ()
void	__trace_vector_size_report (FILE *, __warning_vector_t &)
void	__trace_vector_to_list_report (FILE *, __warning_vector_t &)
	_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)
std::size_t	__max_mem ()
std::size_t	__env_to_size_t (const char *__env_var, std::size_t __default_value)
void	__set_max_stack_trace_depth ()
void	__set_max_mem ()
int	__log_magnitude (float __f)
FILE *	__open_output_file (const char *__extension)
void	__set_trace_path ()
void	__set_max_warn_count ()
void	__read_cost_factors ()
void	__write_cost_factors ()
void	__set_cost_factors ()
void	__profcxx_init_unconditional ()
bool	__profcxx_init ()
	This function must be called by each instrumentation point. More...

Detailed Description

GNU profile code for public use.

Typedef Documentation

typedef std::_GLIBCXX_STD_C::vector<__cost_factor*> __gnu_profile::__cost_factor_vector

typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __gnu_profile::__env_t

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 void* __gnu_profile::__instruction_address_t

typedef const void* __gnu_profile::__object_t

typedef std::_GLIBCXX_STD_C::vector<__instruction_address_t> __gnu_profile::__stack_npt

typedef __stack_npt* __gnu_profile::__stack_t

typedef std::_GLIBCXX_STD_C::vector<__warning_data> __gnu_profile::__warning_vector_t

Enumeration Type Documentation

enum __gnu_profile::__state_type

Enumerator
__ON
__OFF
__INVALID

{ __ON, __OFF, __INVALID };

Function Documentation

std::size_t __gnu_profile::__env_to_size_t ( const char *  __env_var, std::size_t  __default_value  )

inline

  {
    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;
  }

template<typename _InputIterator , typename _Function >

_Function __gnu_profile::__for_each	(	_InputIterator	__first,
		_InputIterator	__last,
		_Function	__f
	)

    {
      for (; __first != __last; ++__first)
    __f(*__first);
      return __f;
    }

__stack_t __gnu_profile::__get_stack ( )

inline

  {
#if defined _GLIBCXX_HAVE_EXECINFO_H
    std::size_t __max_depth = __stack_max_depth();
    if (__max_depth == 0)
      return 0;
    __stack_npt __buffer(__max_depth);
    int __depth = backtrace(&__buffer[0], __max_depth);
    __stack_t __stack = new __stack_npt(__depth);
    __builtin_memcpy(&(*__stack)[0], &__buffer[0],
             __depth * sizeof(__object_t));
    return __stack;
#else
    return 0;
#endif
  }

template<typename _Container >

void __gnu_profile::__insert_top_n	(	_Container &	__output,
		const typename _Container::value_type &	__value,
		typename _Container::size_type	__n
	)

    {
      typename _Container::iterator __it = __output.begin();
      typename _Container::size_type __count = 0;

      // Skip up to N - 1 elements larger than VALUE.
      // XXX: Could do binary search for random iterators.
      while (true)
    {
      if (__count >= __n)
        // VALUE is not in top N.
        return;

      if (__it == __output.end())
        break;

      if (*__it < __value)
        break;

      ++__it;
      ++__count;
    }

      __output.insert(__it, __value);
    }

bool __gnu_profile::__is_invalid ( )

inline

  { return _GLIBCXX_PROFILE_DATA(__state) == __INVALID; }

bool __gnu_profile::__is_off ( )

inline

  { return _GLIBCXX_PROFILE_DATA(__state) == __OFF; }

bool __gnu_profile::__is_on ( )

inline

  { return _GLIBCXX_PROFILE_DATA(__state) == __ON; }

int __gnu_profile::__log2 ( std::size_t  __size )

inline

  {
    for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0;
     -- __bit_count) 
      if ((2 << __bit_count) & __size)
    return __bit_count;
    return 0;
  }

int __gnu_profile::__log_magnitude ( float  __f )

inline

  {
    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;
  }

float __gnu_profile::__map_erase_cost ( std::size_t  __size )

inline

  { return (_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor).__value
        * static_cast<float>(__log2(__size))); }

float __gnu_profile::__map_find_cost ( std::size_t  __size )

inline

  { return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value
        * static_cast<float>(__log2(__size))); }

float __gnu_profile::__map_insert_cost ( std::size_t  __size )

inline

  { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value 
        * static_cast<float>(__log2(__size))); }

std::size_t __gnu_profile::__max_mem ( )

inline

  { return _GLIBCXX_PROFILE_DATA(_S_max_mem); }

FILE* __gnu_profile::__open_output_file ( const char *  __extension )

inline

  {
    // 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;
  }

bool __gnu_profile::__profcxx_init ( )

inline

This function must be called by each instrumentation point.

The common path is inlined fully.

  {
    if (__is_invalid())
      __profcxx_init_unconditional();

    return __is_on();
  }

void __gnu_profile::__profcxx_init_unconditional ( )

inline

  {
    _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();
  }

void __gnu_profile::__read_cost_factors ( )

inline

  {
    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;
      }
  }

template<typename _ForwardIterator , typename _Tp >

_ForwardIterator __gnu_profile::__remove	(	_ForwardIterator	__first,
		_ForwardIterator	__last,
		const _Tp &	__value
	)

    {
      if(__first == __last)
    return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for(; __first != __last; ++__first)
    if(!(*__first == __value))
      {
        *__result = *__first;
        ++__result;
      }
      return __result;
    }

void __gnu_profile::__report ( void  )

inline

Final report method, registered with 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.

  {
    _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();
  }

void __gnu_profile::__set_cost_factors ( )

inline

  {
    _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());
  }

void __gnu_profile::__set_max_mem ( )

inline

  {
    _GLIBCXX_PROFILE_DATA(_S_max_mem) 
      = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR,
            _GLIBCXX_PROFILE_DATA(_S_max_mem));
  }

void __gnu_profile::__set_max_stack_trace_depth ( )

inline

  {
    _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));
  }

void __gnu_profile::__set_max_warn_count ( )

inline

  {
    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));
  }

void __gnu_profile::__set_trace_path ( )

inline

  {
    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"));
  }

std::size_t __gnu_profile::__size ( __stack_t  __stack )

inline

  {
    if (!__stack)
      return 0;
    else
      return __stack->size();
  }

std::size_t __gnu_profile::__stack_max_depth ( )

inline

  { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); }

template<typename _Container >

void __gnu_profile::__top_n	(	const _Container &	__input,
		_Container &	__output,
		typename _Container::size_type	__n
	)

    {
      __output.clear();
      typename _Container::const_iterator __it;
      for (__it = __input.begin(); __it != __input.end(); ++__it)
    __insert_top_n(__output, *__it, __n);
    }

void __gnu_profile::__trace_hash_func_construct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_hash_func)->__insert(__obj, __get_stack());
  }

void __gnu_profile::__trace_hash_func_destruct ( const void *  __obj, std::size_t  __chain, std::size_t  __accesses, std::size_t  __hops  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_hash_func)->__destruct(__obj, __chain,
                            __accesses, __hops);
  }

void __gnu_profile::__trace_hash_func_init ( )

inline

  { _GLIBCXX_PROFILE_DATA(_S_hash_func) = new __trace_hash_func(); }

void __gnu_profile::__trace_hash_func_report ( FILE *  __f, __warning_vector_t &  __warnings  )

inline

  {
    if (_GLIBCXX_PROFILE_DATA(_S_hash_func))
      {
    _GLIBCXX_PROFILE_DATA(_S_hash_func)->__collect_warnings(__warnings);
    _GLIBCXX_PROFILE_DATA(_S_hash_func)->__write(__f);
      }
  }

void __gnu_profile::__trace_hashtable_size_construct ( const void *  __obj, std::size_t  __num  )

inline

  {
    if (!__profcxx_init())
      return;
  
    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__insert(__obj, __get_stack(),
                               __num);
  }

void __gnu_profile::__trace_hashtable_size_destruct ( const void *  __obj, std::size_t  __num, std::size_t  __inum  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__destruct(__obj, __num, __inum);
  }

void __gnu_profile::__trace_hashtable_size_init ( )

inline

  { _GLIBCXX_PROFILE_DATA(_S_hashtable_size) = new __trace_hashtable_size(); }

void __gnu_profile::__trace_hashtable_size_report ( FILE *  __f, __warning_vector_t &  __warnings  )

inline

  {
    if (_GLIBCXX_PROFILE_DATA(_S_hashtable_size))
      {
    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->
      __collect_warnings(__warnings);
    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__write(__f);
      }
  }

void __gnu_profile::__trace_hashtable_size_resize ( const void *  __obj, std::size_t  __from, std::size_t  __to  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__resize(__obj, __from, __to);
  }

void __gnu_profile::__trace_list_to_set_construct

(

const void *

)

void __gnu_profile::__trace_list_to_set_destruct

(

const void *

)

void __gnu_profile::__trace_list_to_set_find	(	const void *	,
		std::size_t
	)

void __gnu_profile::__trace_list_to_set_insert	(	const void *	,
		std::size_t	,
		std::size_t
	)

void __gnu_profile::__trace_list_to_set_invalid_operator

(

const void *

)

void __gnu_profile::__trace_list_to_set_iterate	(	const void *	,
		std::size_t
	)

void __gnu_profile::__trace_list_to_slist_construct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__insert(__obj, __get_stack());
  }

void __gnu_profile::__trace_list_to_slist_destruct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__destruct(__obj);
  }

void __gnu_profile::__trace_list_to_slist_init ( )

inline

  { _GLIBCXX_PROFILE_DATA(_S_list_to_slist) = new __trace_list_to_slist(); }

void __gnu_profile::__trace_list_to_slist_operation ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__record_operation(__obj);
  }

void __gnu_profile::__trace_list_to_slist_report ( FILE *  __f, __warning_vector_t &  __warnings  )

inline

  {
    if (_GLIBCXX_PROFILE_DATA(_S_list_to_slist))
      {
    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->
      __collect_warnings(__warnings);
    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__write(__f);
      }
  }

void __gnu_profile::__trace_list_to_slist_rewind ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__opr_rewind(__obj);
  }

void __gnu_profile::__trace_list_to_vector_construct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__insert(__obj, __get_stack());
  }

void __gnu_profile::__trace_list_to_vector_destruct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__destruct(__obj);
  }

void __gnu_profile::__trace_list_to_vector_init ( )

inline

  { _GLIBCXX_PROFILE_DATA(_S_list_to_vector) = new __trace_list_to_vector(); }

void __gnu_profile::__trace_list_to_vector_insert ( const void *  __obj, std::size_t  __shift, std::size_t  __size  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_insert(__obj, __shift, 
                               __size);
  }

void __gnu_profile::__trace_list_to_vector_invalid_operator ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__invalid_operator(__obj);
  }

void __gnu_profile::__trace_list_to_vector_iterate ( const void *  __obj, std::size_t  __num = 1  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_iterate(__obj, __num);
  }

void __gnu_profile::__trace_list_to_vector_report ( FILE *  __f, __warning_vector_t &  __warnings  )

inline

  {
    if (_GLIBCXX_PROFILE_DATA(_S_list_to_vector))
      {
    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->
      __collect_warnings(__warnings);
    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__write(__f);
      }
  }

void __gnu_profile::__trace_list_to_vector_resize ( const void *  __obj, std::size_t  __from, std::size_t  __to  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__resize(__obj, __from, __to);
  }

void __gnu_profile::__trace_map_to_unordered_map_construct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_map2umap)->
      __add_object(__obj, __map2umap_info(__get_stack()));
  }

void __gnu_profile::__trace_map_to_unordered_map_destruct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_map2umap)->__retire_object(__obj);
  }

void __gnu_profile::__trace_map_to_unordered_map_erase ( const void *  __obj, std::size_t  __size, std::size_t  __count  )

inline

  {
    if (!__profcxx_init()) 
      return;

    __map2umap_info* __info 
      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);

    if (__info)
      __info->__record_erase(__size, __count);
  }

void __gnu_profile::__trace_map_to_unordered_map_find ( const void *  __obj, std::size_t  __size  )

inline

  {
    if (!__profcxx_init())
      return;

    __map2umap_info* __info
      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);

    if (__info)
      __info->__record_find(__size);
  }

void __gnu_profile::__trace_map_to_unordered_map_init ( )

inline

  { _GLIBCXX_PROFILE_DATA(_S_map2umap) = new __trace_map2umap(); }

void __gnu_profile::__trace_map_to_unordered_map_insert ( const void *  __obj, std::size_t  __size, std::size_t  __count  )

inline

  {
    if (!__profcxx_init())
      return;

    __map2umap_info* __info
      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);

    if (__info)
      __info->__record_insert(__size, __count);
  }

void __gnu_profile::__trace_map_to_unordered_map_invalidate ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    __map2umap_info* __info
      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);

    if (__info)
      __info->__record_invalidate();
  }

void __gnu_profile::__trace_map_to_unordered_map_iterate ( const void *  __obj, std::size_t  __count  )

inline

  {
    if (!__profcxx_init())
      return;

    __map2umap_info* __info
      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
    
    if (__info)
      __info->__record_iterate(__count);
  }

void __gnu_profile::__trace_map_to_unordered_map_report ( FILE *  __f, __warning_vector_t &  __warnings  )

inline

  {
    if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) 
      {
    _GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings);
    _GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f);
      }
  }

void __gnu_profile::__trace_vector_size_construct ( const void *  __obj, std::size_t  __num  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__insert(__obj, __get_stack(),
                            __num);
  }

void __gnu_profile::__trace_vector_size_destruct ( const void *  __obj, std::size_t  __num, std::size_t  __inum  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__destruct(__obj, __num, __inum);
  }

void __gnu_profile::__trace_vector_size_init ( )

inline

  { _GLIBCXX_PROFILE_DATA(_S_vector_size) = new __trace_vector_size(); }

void __gnu_profile::__trace_vector_size_report ( FILE *  __f, __warning_vector_t &  __warnings  )

inline

  {
    if (_GLIBCXX_PROFILE_DATA(_S_vector_size))
      {
    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__collect_warnings(__warnings);
    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__write(__f);
      }
  }

void __gnu_profile::__trace_vector_size_resize ( const void *  __obj, std::size_t  __from, std::size_t  __to  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__resize(__obj, __from, __to);
  }

void __gnu_profile::__trace_vector_to_list_construct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__insert(__obj, __get_stack());
  }

void __gnu_profile::__trace_vector_to_list_destruct ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__destruct(__obj);
  }

void __gnu_profile::__trace_vector_to_list_find ( const void *  __obj, std::size_t  __size  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_find(__obj, __size);
  }

void __gnu_profile::__trace_vector_to_list_init ( )

inline

  { _GLIBCXX_PROFILE_DATA(_S_vector_to_list) = new __trace_vector_to_list(); }

void __gnu_profile::__trace_vector_to_list_insert ( const void *  __obj, std::size_t  __pos, std::size_t  __num  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_insert(__obj, __pos,
                               __num);
  }

void __gnu_profile::__trace_vector_to_list_invalid_operator ( const void *  __obj )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__invalid_operator(__obj);
  }

void __gnu_profile::__trace_vector_to_list_iterate ( const void *  __obj, std::size_t  __num = 1  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_iterate(__obj, __num);
  }

void __gnu_profile::__trace_vector_to_list_report ( FILE *  __f, __warning_vector_t &  __warnings  )

inline

  {
    if (_GLIBCXX_PROFILE_DATA(_S_vector_to_list))
      {
    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->
      __collect_warnings(__warnings);
    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__write(__f);
      }
  }

void __gnu_profile::__trace_vector_to_list_resize ( const void *  __obj, std::size_t  __from, std::size_t  __to  )

inline

  {
    if (!__profcxx_init())
      return;

    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__resize(__obj, __from, __to);
  }

bool __gnu_profile::__turn ( __state_type  __s )

inline

  { 
    __state_type inv(__INVALID);
    return __atomic_compare_exchange_n(&_GLIBCXX_PROFILE_DATA(__state),
                       &inv, __s, false, __ATOMIC_ACQ_REL, 
                       __ATOMIC_RELAXED);
  }

bool __gnu_profile::__turn_off ( )

inline

  { return __turn(__OFF); }

bool __gnu_profile::__turn_on ( )

inline

  { return __turn(__ON); }

void __gnu_profile::__write ( FILE *  __f, __stack_t  __stack  )

inline

  {
    if (!__stack)
      return;
  
    __stack_npt::const_iterator __it;
    for (__it = __stack->begin(); __it != __stack->end(); ++__it)
      std::fprintf(__f, "%p ", *__it);
  }

void __gnu_profile::__write_cost_factors ( )

inline

  {
    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);
  }

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__state_type	,
		__state	,
		__INVALID
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__trace_hash_func *	,
		_S_hash_func	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__trace_hashtable_size *	,
		_S_hashtable_size	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__trace_map2umap *	,
		_S_map2umap	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__trace_vector_size *	,
		_S_vector_size	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__trace_vector_to_list *	,
		_S_vector_to_list	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__trace_list_to_slist *	,
		_S_list_to_slist	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__trace_list_to_vector *	,
		_S_list_to_vector	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__vector_shift_cost_factor	,
		{"__vector_shift_cost_factor", 1.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__vector_iterate_cost_factor	,
		{"__vector_iterate_cost_factor", 1.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__vector_resize_cost_factor	,
		{"__vector_resize_cost_factor", 1.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__list_shift_cost_factor	,
		{"__list_shift_cost_factor", 0.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__list_iterate_cost_factor	,
		{"__list_iterate_cost_factor", 10.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__list_resize_cost_factor	,
		{"__list_resize_cost_factor", 0.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__map_insert_cost_factor	,
		{"__map_insert_cost_factor", 1.5}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__map_erase_cost_factor	,
		{"__map_erase_cost_factor", 1.5}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__map_find_cost_factor	,
		{"__map_find_cost_factor", 1}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__map_iterate_cost_factor	,
		{"__map_iterate_cost_factor", 2.3}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__umap_insert_cost_factor	,
		{"__umap_insert_cost_factor", 12.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__umap_erase_cost_factor	,
		{"__umap_erase_cost_factor", 12.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__umap_find_cost_factor	,
		{"__umap_find_cost_factor", 10.0}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor	,
		__umap_iterate_cost_factor	,
		{"__umap_iterate_cost_factor", 1.7}
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	__cost_factor_vector *	,
		__cost_factors	,
		0
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	const char *	,
		_S_trace_file_name	,
		_GLIBCXX_PROFILE_TRACE_PATH_ROOT
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	std::size_t	,
		_S_max_warn_count	,
		_GLIBCXX_PROFILE_MAX_WARN_COUNT
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	std::size_t	,
		_S_max_stack_depth	,
		_GLIBCXX_PROFILE_MAX_STACK_DEPTH
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_DATA	(	std::size_t	,
		_S_max_mem	,
		_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA	(	__env_t	,
		__env
	)

__gnu_profile::_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA	(	__gnu_cxx::__mutex	,
		__global_lock
	)

Master lock.