mirror of
https://gcc.gnu.org/git/gcc.git
synced 2024-12-14 14:33:40 +08:00
profiler_container_size.h: Fix include guard, formatting fixes.
2009-12-09 Benjamin Kosnik <bkoz@redhat.com> * include/profile/impl/profiler_container_size.h: Fix include guard, formatting fixes. * include/profile/impl/profiler_vector_size.h: Same. * include/profile/impl/profiler_hash_func.h: Same. * include/profile/impl/profiler_trace.h: Same. * include/profile/impl/profiler_vector_to_list.h: Same. * include/profile/impl/profiler.h: Same. * include/profile/impl/profiler_state.h: Same. * include/profile/impl/profiler_map_to_unordered_map.h: Same. * include/profile/impl/profiler_hashtable_size.h: Same. * include/profile/impl/profiler_node.h: Same. From-SVN: r155123
This commit is contained in:
Benjamin Kosnik
Benjamin Kosnik
parent
14aa63526a
commit
6b22319107
@ -1,3 +1,17 @@
|
||||
2009-12-09 Benjamin Kosnik <bkoz@redhat.com>
|
||||
|
||||
* include/profile/impl/profiler_container_size.h: Fix include
|
||||
guard, formatting fixes.
|
||||
* include/profile/impl/profiler_vector_size.h: Same.
|
||||
* include/profile/impl/profiler_hash_func.h: Same.
|
||||
* include/profile/impl/profiler_trace.h: Same.
|
||||
* include/profile/impl/profiler_vector_to_list.h: Same.
|
||||
* include/profile/impl/profiler.h: Same.
|
||||
* include/profile/impl/profiler_state.h: Same.
|
||||
* include/profile/impl/profiler_map_to_unordered_map.h: Same.
|
||||
* include/profile/impl/profiler_hashtable_size.h: Same.
|
||||
* include/profile/impl/profiler_node.h: Same.
|
||||
|
||||
2009-12-09 Roman Odaisky <to.roma.from.bugcc@qwertty.com>
|
||||
|
||||
PR libstdc++/42273
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_H__
|
||||
#define PROFCXX_PROFILER_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstddef>
|
||||
@ -311,4 +311,4 @@ namespace __gnu_profile
|
||||
#include "profile/impl/profiler_vector_size.h"
|
||||
#include "profile/impl/profiler_vector_to_list.h"
|
||||
|
||||
#endif // PROFCXX_PROFILER_H__
|
||||
#endif // _GLIBCXX_PROFILE_PROFILER_H
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_CONTAINER_SIZE_H__
|
||||
#define PROFCXX_PROFILER_CONTAINER_SIZE_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdlib>
|
||||
@ -53,7 +53,6 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
/** @brief A container size instrumentation line in the object table. */
|
||||
class __container_size_info: public __object_info_base
|
||||
{
|
||||
@ -68,19 +67,22 @@ class __container_size_info: public __object_info_base
|
||||
const char* __advice() const;
|
||||
|
||||
void __merge(const __container_size_info& __o);
|
||||
|
||||
// Call if a container is destructed or cleaned.
|
||||
void __destruct(size_t __num, size_t __inum);
|
||||
|
||||
// Estimate the cost of resize/rehash.
|
||||
float __resize_cost(size_t __from, size_t __to) { return __from; }
|
||||
|
||||
// Call if container is resized.
|
||||
void __resize(size_t __from, size_t __to);
|
||||
|
||||
private:
|
||||
size_t _M_init;
|
||||
size_t _M_max; // range of # buckets
|
||||
size_t _M_max; // Range of # buckets.
|
||||
size_t _M_min;
|
||||
size_t _M_total;
|
||||
size_t _M_item_min; // range of # items
|
||||
size_t _M_item_min; // Range of # items.
|
||||
size_t _M_item_max;
|
||||
size_t _M_item_total;
|
||||
size_t _M_count;
|
||||
@ -88,7 +90,8 @@ class __container_size_info: public __object_info_base
|
||||
size_t _M_cost;
|
||||
};
|
||||
|
||||
inline const char* __container_size_info::__advice() const
|
||||
inline const char*
|
||||
__container_size_info::__advice() const
|
||||
{
|
||||
const size_t __max_chars_size_t_printed = 20;
|
||||
const char* __message_pattern =
|
||||
@ -108,14 +111,18 @@ inline const char* __container_size_info::__advice() const
|
||||
return __message;
|
||||
}
|
||||
|
||||
inline void __container_size_info::__destruct(size_t __num, size_t __inum)
|
||||
inline void
|
||||
__container_size_info::__destruct(size_t __num, size_t __inum)
|
||||
{
|
||||
_M_max = __max(_M_max, __num);
|
||||
_M_item_max = __max(_M_item_max, __inum);
|
||||
if (_M_min == 0) {
|
||||
if (_M_min == 0)
|
||||
{
|
||||
_M_min = __num;
|
||||
_M_item_min = __inum;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
_M_min = __min(_M_min, __num);
|
||||
_M_item_min = __min(_M_item_min, __inum);
|
||||
}
|
||||
@ -124,27 +131,16 @@ inline void __container_size_info::__destruct(size_t __num, size_t __inum)
|
||||
_M_count += 1;
|
||||
}
|
||||
|
||||
inline void __container_size_info::__resize(size_t __from, size_t __to)
|
||||
inline void
|
||||
__container_size_info::__resize(size_t __from, size_t __to)
|
||||
{
|
||||
_M_cost += this->__resize_cost(__from, __to);
|
||||
_M_resize += 1;
|
||||
_M_max = __max(_M_max, __to);
|
||||
}
|
||||
|
||||
inline __container_size_info::__container_size_info(__stack_t __stack,
|
||||
size_t __num)
|
||||
: __object_info_base(__stack), _M_init(0), _M_max(0), _M_item_max(0),
|
||||
_M_min(0), _M_item_min(0), _M_total(0), _M_item_total(0), _M_cost(0),
|
||||
_M_count(0), _M_resize(0)
|
||||
{
|
||||
_M_init = _M_max = __num;
|
||||
_M_item_min = _M_item_max = _M_item_total = _M_total = 0;
|
||||
_M_min = 0;
|
||||
_M_count = 0;
|
||||
_M_resize = 0;
|
||||
}
|
||||
|
||||
inline void __container_size_info::__merge(const __container_size_info& __o)
|
||||
inline void
|
||||
__container_size_info::__merge(const __container_size_info& __o)
|
||||
{
|
||||
_M_init = __max(_M_init, __o._M_init);
|
||||
_M_max = __max(_M_max, __o._M_max);
|
||||
@ -161,11 +157,22 @@ inline void __container_size_info::__merge(const __container_size_info& __o)
|
||||
inline __container_size_info::__container_size_info()
|
||||
: _M_init(0), _M_max(0), _M_item_max(0), _M_min(0), _M_item_min(0),
|
||||
_M_total(0), _M_item_total(0), _M_cost(0), _M_count(0), _M_resize(0)
|
||||
{ }
|
||||
|
||||
inline __container_size_info::__container_size_info(__stack_t __stack,
|
||||
size_t __num)
|
||||
: __object_info_base(__stack), _M_init(0), _M_max(0), _M_item_max(0),
|
||||
_M_min(0), _M_item_min(0), _M_total(0), _M_item_total(0), _M_cost(0),
|
||||
_M_count(0), _M_resize(0)
|
||||
{
|
||||
_M_init = _M_max = __num;
|
||||
_M_item_min = _M_item_max = _M_item_total = _M_total = 0;
|
||||
_M_min = 0;
|
||||
_M_count = 0;
|
||||
_M_resize = 0;
|
||||
}
|
||||
|
||||
inline __container_size_info::__container_size_info(
|
||||
const __container_size_info& __o)
|
||||
inline __container_size_info::__container_size_info(const __container_size_info& __o)
|
||||
: __object_info_base(__o)
|
||||
{
|
||||
_M_init = __o._M_init;
|
||||
@ -193,34 +200,38 @@ class __trace_container_size
|
||||
: public __trace_base<__container_size_info, __container_size_stack_info>
|
||||
{
|
||||
public:
|
||||
~__trace_container_size() {}
|
||||
__trace_container_size()
|
||||
: __trace_base<__container_size_info, __container_size_stack_info>() { };
|
||||
|
||||
~__trace_container_size() { }
|
||||
|
||||
// Insert a new node at construct with object, callstack and initial size.
|
||||
void __insert(const __object_t __obj, __stack_t __stack, size_t __num);
|
||||
|
||||
// Call at destruction/clean to set container final size.
|
||||
void __destruct(const void* __obj, size_t __num, size_t __inum);
|
||||
void __construct(const void* __obj, size_t __inum);
|
||||
|
||||
// Call at resize to set resize/cost information.
|
||||
void __resize(const void* __obj, int __from, int __to);
|
||||
};
|
||||
|
||||
inline void __trace_container_size::__insert(const __object_t __obj,
|
||||
inline void
|
||||
__trace_container_size::__insert(const __object_t __obj,
|
||||
__stack_t __stack, size_t __num)
|
||||
{
|
||||
__add_object(__obj, __container_size_info(__stack, __num));
|
||||
}
|
||||
{ __add_object(__obj, __container_size_info(__stack, __num)); }
|
||||
|
||||
inline void __container_size_info::__write(FILE* __f) const
|
||||
inline void
|
||||
__container_size_info::__write(FILE* __f) const
|
||||
{
|
||||
fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n",
|
||||
_M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max, _M_total,
|
||||
_M_item_min, _M_item_max, _M_item_total);
|
||||
}
|
||||
|
||||
inline void __trace_container_size::__destruct(const void* __obj,
|
||||
size_t __num, size_t __inum)
|
||||
inline void
|
||||
__trace_container_size::__destruct(const void* __obj, size_t __num,
|
||||
size_t __inum)
|
||||
{
|
||||
if (!__is_on()) return;
|
||||
|
||||
@ -234,8 +245,8 @@ inline void __trace_container_size::__destruct(const void* __obj,
|
||||
__retire_object(__obj_handle);
|
||||
}
|
||||
|
||||
inline void __trace_container_size::__resize(const void* __obj, int __from,
|
||||
int __to)
|
||||
inline void
|
||||
__trace_container_size::__resize(const void* __obj, int __from, int __to)
|
||||
{
|
||||
if (!__is_on()) return;
|
||||
|
||||
@ -245,6 +256,5 @@ inline void __trace_container_size::__resize(const void* __obj, int __from,
|
||||
|
||||
__object_info->__resize(__from, __to);
|
||||
}
|
||||
|
||||
} // namespace __gnu_profile
|
||||
#endif /* PROFCXX_PROFILER_CONTAINER_SIZE_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_HASH_FUNC_H__
|
||||
#define PROFCXX_PROFILER_HASH_FUNC_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdlib>
|
||||
@ -52,17 +52,18 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
/** @brief A hash performance instrumentation line in the object table. */
|
||||
class __hashfunc_info: public __object_info_base
|
||||
{
|
||||
public:
|
||||
__hashfunc_info()
|
||||
:_M_longest_chain(0), _M_accesses(0), _M_hops(0) {}
|
||||
__hashfunc_info() :_M_longest_chain(0), _M_accesses(0), _M_hops(0) { }
|
||||
|
||||
__hashfunc_info(const __hashfunc_info& o);
|
||||
|
||||
__hashfunc_info(__stack_t __stack)
|
||||
: __object_info_base(__stack),
|
||||
_M_longest_chain(0), _M_accesses(0), _M_hops(0){}
|
||||
: __object_info_base(__stack), _M_longest_chain(0),
|
||||
_M_accesses(0), _M_hops(0) { }
|
||||
|
||||
virtual ~__hashfunc_info() { }
|
||||
|
||||
void __merge(const __hashfunc_info& __o);
|
||||
@ -85,15 +86,16 @@ inline __hashfunc_info::__hashfunc_info(const __hashfunc_info& __o)
|
||||
_M_hops = __o._M_hops;
|
||||
}
|
||||
|
||||
inline void __hashfunc_info::__merge(const __hashfunc_info& __o)
|
||||
inline void
|
||||
__hashfunc_info::__merge(const __hashfunc_info& __o)
|
||||
{
|
||||
_M_longest_chain = __max(_M_longest_chain, __o._M_longest_chain);
|
||||
_M_accesses += __o._M_accesses;
|
||||
_M_hops += __o._M_hops;
|
||||
}
|
||||
|
||||
inline void __hashfunc_info::__destruct(size_t __chain, size_t __accesses,
|
||||
size_t __hops)
|
||||
inline void
|
||||
__hashfunc_info::__destruct(size_t __chain, size_t __accesses, size_t __hops)
|
||||
{
|
||||
_M_longest_chain = __max(_M_longest_chain, __chain);
|
||||
_M_accesses += __accesses;
|
||||
@ -101,7 +103,8 @@ inline void __hashfunc_info::__destruct(size_t __chain, size_t __accesses,
|
||||
}
|
||||
|
||||
/** @brief A hash performance instrumentation line in the stack table. */
|
||||
class __hashfunc_stack_info: public __hashfunc_info {
|
||||
class __hashfunc_stack_info: public __hashfunc_info
|
||||
{
|
||||
public:
|
||||
__hashfunc_stack_info(const __hashfunc_info& __o) : __hashfunc_info(__o) { }
|
||||
};
|
||||
@ -116,31 +119,30 @@ class __trace_hash_func
|
||||
|
||||
// Insert a new node at construct with object, callstack and initial size.
|
||||
void __insert(__object_t __obj, __stack_t __stack);
|
||||
|
||||
// Call at destruction/clean to set container final size.
|
||||
void __destruct(const void* __obj, size_t __chain,
|
||||
size_t __accesses, size_t __hops);
|
||||
void __destruct(const void* __obj, size_t __chain, size_t __accesses,
|
||||
size_t __hops);
|
||||
};
|
||||
|
||||
inline __trace_hash_func::__trace_hash_func()
|
||||
: __trace_base<__hashfunc_info, __hashfunc_stack_info>()
|
||||
{
|
||||
__id = "hash-distr";
|
||||
}
|
||||
{ __id = "hash-distr"; }
|
||||
|
||||
inline void __trace_hash_func::__insert(__object_t __obj, __stack_t __stack)
|
||||
{
|
||||
__add_object(__obj, __hashfunc_info(__stack));
|
||||
}
|
||||
inline void
|
||||
__trace_hash_func::__insert(__object_t __obj, __stack_t __stack)
|
||||
{ __add_object(__obj, __hashfunc_info(__stack)); }
|
||||
|
||||
inline void __hashfunc_info::__write(FILE* __f) const
|
||||
{
|
||||
fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, _M_accesses, _M_longest_chain);
|
||||
}
|
||||
inline void
|
||||
__hashfunc_info::__write(FILE* __f) const
|
||||
{ fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, _M_accesses, _M_longest_chain); }
|
||||
|
||||
inline void __trace_hash_func::__destruct(const void* __obj, size_t __chain,
|
||||
inline void
|
||||
__trace_hash_func::__destruct(const void* __obj, size_t __chain,
|
||||
size_t __accesses, size_t __hops)
|
||||
{
|
||||
if (!__is_on()) return;
|
||||
if (!__is_on())
|
||||
return;
|
||||
|
||||
// First find the item from the live objects and update the informations.
|
||||
__hashfunc_info* __objs = __get_object_info(__obj);
|
||||
@ -151,42 +153,42 @@ inline void __trace_hash_func::__destruct(const void* __obj, size_t __chain,
|
||||
__retire_object(__obj);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Initialization and report.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
inline void
|
||||
__trace_hash_func_init()
|
||||
{ __tables<0>::_S_hash_func = new __trace_hash_func(); }
|
||||
|
||||
inline void __trace_hash_func_init()
|
||||
inline void
|
||||
__trace_hash_func_report(FILE* __f, __warning_vector_t& __warnings)
|
||||
{
|
||||
__tables<0>::_S_hash_func = new __trace_hash_func();
|
||||
}
|
||||
|
||||
inline void __trace_hash_func_report(FILE* __f,
|
||||
__warning_vector_t& __warnings)
|
||||
if (__tables<0>::_S_hash_func)
|
||||
{
|
||||
if (__tables<0>::_S_hash_func) {
|
||||
__tables<0>::_S_hash_func->__collect_warnings(__warnings);
|
||||
__tables<0>::_S_hash_func->__write(__f);
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Implementations of instrumentation hooks.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
inline void __trace_hash_func_construct(const void* __obj)
|
||||
// Implementations of instrumentation hooks.
|
||||
inline void
|
||||
__trace_hash_func_construct(const void* __obj)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__tables<0>::_S_hash_func->__insert(__obj, __get_stack());
|
||||
}
|
||||
|
||||
inline void __trace_hash_func_destruct(const void* __obj, size_t __chain,
|
||||
inline void
|
||||
__trace_hash_func_destruct(const void* __obj, size_t __chain,
|
||||
size_t __accesses, size_t __hops)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__tables<0>::_S_hash_func->__destruct(__obj, __chain, __accesses, __hops);
|
||||
}
|
||||
|
||||
} // namespace __gnu_profile
|
||||
#endif /* PROFCXX_PROFILER_HASH_FUNC_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_HASHTABLE_SIZE_H__
|
||||
#define PROFCXX_PROFILER_HASHTABLE_SIZE_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdlib>
|
||||
@ -54,62 +54,58 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
/** @brief Hashtable size instrumentation trace producer. */
|
||||
class __trace_hashtable_size : public __trace_container_size
|
||||
{
|
||||
public:
|
||||
__trace_hashtable_size() : __trace_container_size()
|
||||
{
|
||||
__id = "hashtable-size";
|
||||
}
|
||||
{ __id = "hashtable-size"; }
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization and report.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
inline void
|
||||
__trace_hashtable_size_init()
|
||||
{ __tables<0>::_S_hashtable_size = new __trace_hashtable_size(); }
|
||||
|
||||
inline void __trace_hashtable_size_init()
|
||||
inline void
|
||||
__trace_hashtable_size_report(FILE* __f, __warning_vector_t& __warnings)
|
||||
{
|
||||
__tables<0>::_S_hashtable_size = new __trace_hashtable_size();
|
||||
}
|
||||
|
||||
inline void __trace_hashtable_size_report(FILE* __f,
|
||||
__warning_vector_t& __warnings)
|
||||
if (__tables<0>::_S_hashtable_size)
|
||||
{
|
||||
if (__tables<0>::_S_hashtable_size) {
|
||||
__tables<0>::_S_hashtable_size->__collect_warnings(__warnings);
|
||||
__tables<0>::_S_hashtable_size->__write(__f);
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Implementations of instrumentation hooks.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
inline void __trace_hashtable_size_construct(const void* __obj, size_t __num)
|
||||
inline void
|
||||
__trace_hashtable_size_construct(const void* __obj, size_t __num)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__tables<0>::_S_hashtable_size->__insert(__obj, __get_stack(), __num);
|
||||
}
|
||||
|
||||
inline void __trace_hashtable_size_destruct(const void* __obj, size_t __num,
|
||||
inline void
|
||||
__trace_hashtable_size_destruct(const void* __obj, size_t __num,
|
||||
size_t __inum)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__tables<0>::_S_hashtable_size->__destruct(__obj, __num, __inum);
|
||||
}
|
||||
|
||||
inline void __trace_hashtable_size_resize(const void* __obj, size_t __from,
|
||||
size_t __to)
|
||||
inline void
|
||||
__trace_hashtable_size_resize(const void* __obj, size_t __from, size_t __to)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__tables<0>::_S_hashtable_size->__resize(__obj, __from, __to);
|
||||
}
|
||||
|
||||
} // namespace __gnu_profile
|
||||
|
||||
#endif /* PROFCXX_PROFILER_HASHTABLE_SIZE_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_MAP_TO_UNORDERED_MAP_H__
|
||||
#define PROFCXX_PROFILER_MAP_TO_UNORDERED_MAP_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdlib>
|
||||
@ -52,8 +52,7 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
// Cost model. XXX: this must be taken from the machine model instead.
|
||||
// Cost model.
|
||||
// Map operations:
|
||||
// - insert: 1.5 * log(size)
|
||||
// - erase: 1.5 * log(size)
|
||||
@ -64,7 +63,7 @@ namespace __gnu_profile
|
||||
// - erase: 12
|
||||
// - find: 10
|
||||
// - iterate: 1.7
|
||||
|
||||
// XXX: this must be taken from the machine model instead.
|
||||
const float __map_insert_cost_factor = 1.5;
|
||||
const float __map_erase_cost_factor = 1.5;
|
||||
const float __map_find_cost_factor = 1;
|
||||
@ -75,30 +74,29 @@ const float __umap_erase_cost = 12.0;
|
||||
const float __umap_find_cost = 10.0;
|
||||
const float __umap_iterate_cost = 1.7;
|
||||
|
||||
inline int __log2(size_t __size)
|
||||
inline int
|
||||
__log2(size_t __size)
|
||||
{
|
||||
for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0; --__bit_count) {
|
||||
if ((2 << __bit_count) & __size) {
|
||||
int __bit_count = sizeof(size_t) - 1;
|
||||
for (; __bit_count >= 0; --__bit_count)
|
||||
{
|
||||
if ((2 << __bit_count) & __size)
|
||||
return __bit_count;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline float __map_insert_cost(size_t __size)
|
||||
{
|
||||
return __map_insert_cost_factor * static_cast<float>(__log2(__size));
|
||||
}
|
||||
inline float
|
||||
__map_insert_cost(size_t __size)
|
||||
{ return __map_insert_cost_factor * static_cast<float>(__log2(__size)); }
|
||||
|
||||
inline float __map_erase_cost(size_t __size)
|
||||
{
|
||||
return __map_erase_cost_factor * static_cast<float>(__log2(__size));
|
||||
}
|
||||
inline float
|
||||
__map_erase_cost(size_t __size)
|
||||
{ return __map_erase_cost_factor * static_cast<float>(__log2(__size)); }
|
||||
|
||||
inline float __map_find_cost(size_t __size)
|
||||
{
|
||||
return __map_find_cost_factor * static_cast<float>(__log2(__size));
|
||||
}
|
||||
inline float
|
||||
__map_find_cost(size_t __size)
|
||||
{ return __map_find_cost_factor * static_cast<float>(__log2(__size)); }
|
||||
|
||||
/** @brief A map-to-unordered_map instrumentation line in the object table. */
|
||||
class __map2umap_info: public __object_info_base
|
||||
@ -107,11 +105,15 @@ class __map2umap_info: public __object_info_base
|
||||
__map2umap_info()
|
||||
: _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0),
|
||||
_M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) { }
|
||||
|
||||
__map2umap_info(__stack_t __stack)
|
||||
: __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0),
|
||||
_M_iterate(0), _M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) { }
|
||||
|
||||
virtual ~__map2umap_info() { }
|
||||
|
||||
__map2umap_info(const __map2umap_info& o);
|
||||
|
||||
void __merge(const __map2umap_info& o);
|
||||
void __write(FILE* __f) const;
|
||||
float __magnitude() const { return _M_map_cost - _M_umap_cost; }
|
||||
@ -133,11 +135,6 @@ class __map2umap_info: public __object_info_base
|
||||
bool _M_valid;
|
||||
};
|
||||
|
||||
inline const char* __map2umap_info::__advice() const
|
||||
{
|
||||
return "change std::map to std::unordered_map";
|
||||
}
|
||||
|
||||
inline __map2umap_info::__map2umap_info(const __map2umap_info& __o)
|
||||
: __object_info_base(__o),
|
||||
_M_insert(__o._M_insert),
|
||||
@ -149,7 +146,12 @@ inline __map2umap_info::__map2umap_info(const __map2umap_info& __o)
|
||||
_M_valid(__o._M_valid)
|
||||
{ }
|
||||
|
||||
inline void __map2umap_info::__merge(const __map2umap_info& __o)
|
||||
inline const char*
|
||||
__map2umap_info::__advice() const
|
||||
{ return "change std::map to std::unordered_map"; }
|
||||
|
||||
inline void
|
||||
__map2umap_info::__merge(const __map2umap_info& __o)
|
||||
{
|
||||
_M_insert += __o._M_insert;
|
||||
_M_erase += __o._M_erase;
|
||||
@ -159,40 +161,46 @@ inline void __map2umap_info::__merge(const __map2umap_info& __o)
|
||||
_M_valid &= __o._M_valid;
|
||||
}
|
||||
|
||||
inline void __map2umap_info:: __record_insert(size_t __size, size_t __count)
|
||||
inline void
|
||||
__map2umap_info:: __record_insert(size_t __size, size_t __count)
|
||||
{
|
||||
_M_insert += __count;
|
||||
_M_map_cost += __count * __map_insert_cost(__size);
|
||||
_M_umap_cost += __count * __umap_insert_cost;
|
||||
}
|
||||
|
||||
inline void __map2umap_info:: __record_erase(size_t __size, size_t __count)
|
||||
inline void
|
||||
__map2umap_info:: __record_erase(size_t __size, size_t __count)
|
||||
{
|
||||
_M_erase += __count;
|
||||
_M_map_cost += __count * __map_erase_cost(__size);
|
||||
_M_umap_cost += __count * __umap_erase_cost;
|
||||
}
|
||||
|
||||
inline void __map2umap_info:: __record_find(size_t __size)
|
||||
inline void
|
||||
__map2umap_info:: __record_find(size_t __size)
|
||||
{
|
||||
_M_find += 1;
|
||||
_M_map_cost += __map_find_cost(__size);
|
||||
_M_umap_cost += __umap_find_cost;
|
||||
}
|
||||
|
||||
inline void __map2umap_info:: __record_iterate(size_t __count)
|
||||
inline void
|
||||
__map2umap_info:: __record_iterate(size_t __count)
|
||||
{
|
||||
_M_iterate += __count;
|
||||
_M_map_cost += __count * __map_iterate_cost;
|
||||
_M_umap_cost += __count * __umap_iterate_cost;
|
||||
}
|
||||
|
||||
inline void __map2umap_info:: __record_invalidate()
|
||||
inline void
|
||||
__map2umap_info:: __record_invalidate()
|
||||
{
|
||||
_M_valid = false;
|
||||
}
|
||||
|
||||
inline void __map2umap_info::__write(FILE* __f) const
|
||||
inline void
|
||||
__map2umap_info::__write(FILE* __f) const
|
||||
{
|
||||
fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f %s\n",
|
||||
_M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost, _M_umap_cost,
|
||||
@ -216,90 +224,103 @@ class __trace_map2umap
|
||||
|
||||
inline __trace_map2umap::__trace_map2umap()
|
||||
: __trace_base<__map2umap_info, __map2umap_stack_info>()
|
||||
{
|
||||
__id = "map-to-unordered-map";
|
||||
}
|
||||
{ __id = "map-to-unordered-map"; }
|
||||
|
||||
inline void __trace_map_to_unordered_map_init()
|
||||
{
|
||||
__tables<0>::_S_map2umap = new __trace_map2umap();
|
||||
}
|
||||
inline void
|
||||
__trace_map_to_unordered_map_init()
|
||||
{ __tables<0>::_S_map2umap = new __trace_map2umap(); }
|
||||
|
||||
inline void __trace_map_to_unordered_map_report(
|
||||
FILE* __f, __warning_vector_t& __warnings)
|
||||
inline void
|
||||
__trace_map_to_unordered_map_report(FILE* __f, __warning_vector_t& __warnings)
|
||||
{
|
||||
if (__tables<0>::_S_map2umap)
|
||||
{
|
||||
if (__tables<0>::_S_map2umap) {
|
||||
__tables<0>::_S_map2umap->__collect_warnings(__warnings);
|
||||
__tables<0>::_S_map2umap->__write(__f);
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Implementations of instrumentation hooks.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
inline void __trace_map_to_unordered_map_construct(const void* __obj)
|
||||
inline void
|
||||
__trace_map_to_unordered_map_construct(const void* __obj)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__tables<0>::_S_map2umap->__add_object(__obj,
|
||||
__map2umap_info(__get_stack()));
|
||||
}
|
||||
|
||||
inline void __trace_map_to_unordered_map_destruct(const void* __obj)
|
||||
inline void
|
||||
__trace_map_to_unordered_map_destruct(const void* __obj)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__tables<0>::_S_map2umap->__retire_object(__obj);
|
||||
}
|
||||
|
||||
inline void __trace_map_to_unordered_map_insert(const void* __obj,
|
||||
size_t __size, size_t __count)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info) __info->__record_insert(__size, __count);
|
||||
}
|
||||
|
||||
inline void __trace_map_to_unordered_map_erase(const void* __obj,
|
||||
size_t __size, size_t __count)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info) __info->__record_erase(__size, __count);
|
||||
}
|
||||
|
||||
inline void __trace_map_to_unordered_map_find(const void* __obj, size_t __size)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info) __info->__record_find(__size);
|
||||
}
|
||||
|
||||
inline void __trace_map_to_unordered_map_iterate(const void* __obj,
|
||||
inline void
|
||||
__trace_map_to_unordered_map_insert(const void* __obj, size_t __size,
|
||||
size_t __count)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info) __info->__record_iterate(__count);
|
||||
if (__info)
|
||||
__info->__record_insert(__size, __count);
|
||||
}
|
||||
|
||||
inline void __trace_map_to_unordered_map_invalidate(const void* __obj)
|
||||
inline void
|
||||
__trace_map_to_unordered_map_erase(const void* __obj, size_t __size,
|
||||
size_t __count)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info) __info->__record_invalidate();
|
||||
if (__info)
|
||||
__info->__record_erase(__size, __count);
|
||||
}
|
||||
|
||||
inline void
|
||||
__trace_map_to_unordered_map_find(const void* __obj, size_t __size)
|
||||
{
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info)
|
||||
__info->__record_find(__size);
|
||||
}
|
||||
|
||||
inline void
|
||||
__trace_map_to_unordered_map_iterate(const void* __obj, size_t __count)
|
||||
{
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info)
|
||||
__info->__record_iterate(__count);
|
||||
}
|
||||
|
||||
inline void
|
||||
__trace_map_to_unordered_map_invalidate(const void* __obj)
|
||||
{
|
||||
if (!__profcxx_init())
|
||||
return;
|
||||
|
||||
__map2umap_info* __info = __tables<0>::_S_map2umap->__get_object_info(__obj);
|
||||
|
||||
if (__info)
|
||||
__info->__record_invalidate();
|
||||
}
|
||||
|
||||
} // namespace __gnu_profile
|
||||
#endif /* PROFCXX_PROFILER_MAP_TO_UNORDERED_MAP_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_NODE_H__
|
||||
#define PROFCXX_PROFILER_NODE_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_NODE_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_NODE_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdio>
|
||||
@ -78,24 +78,21 @@ inline __stack_t __get_stack()
|
||||
|
||||
inline __size(const __stack_t& __stack)
|
||||
{
|
||||
if (!__stack) {
|
||||
if (!__stack)
|
||||
return 0;
|
||||
} else {
|
||||
else
|
||||
return __stack->size();
|
||||
}
|
||||
}
|
||||
|
||||
inline void __write(FILE* __f, const __stack_t __stack)
|
||||
{
|
||||
if (!__stack) {
|
||||
if (!__stack)
|
||||
return;
|
||||
}
|
||||
|
||||
__stack_npt::const_iterator __it;
|
||||
for (__it = __stack->begin(); __it != __stack->end(); ++__it) {
|
||||
for (__it = __stack->begin(); __it != __stack->end(); ++__it)
|
||||
fprintf(__f, "%p ", *__it);
|
||||
}
|
||||
}
|
||||
|
||||
/** @brief Hash function for summary trace using call stack as index. */
|
||||
class __stack_hash
|
||||
@ -103,13 +100,13 @@ class __stack_hash
|
||||
public:
|
||||
size_t operator()(const __stack_t __s) const
|
||||
{
|
||||
if (!__s) {
|
||||
if (!__s)
|
||||
return 0;
|
||||
}
|
||||
|
||||
uintptr_t __index = 0;
|
||||
__stack_npt::const_iterator __it;
|
||||
for (__it = __s->begin(); __it != __s->end(); ++__it) {
|
||||
for (__it = __s->begin(); __it != __s->end(); ++__it)
|
||||
{
|
||||
__index += reinterpret_cast<uintptr_t>(*__it);
|
||||
}
|
||||
return __index;
|
||||
@ -167,6 +164,5 @@ class __stack_info_base
|
||||
virtual float __magnitude() const = 0;
|
||||
virtual const char* __get_id() const = 0;
|
||||
};
|
||||
|
||||
} // namespace __gnu_profile
|
||||
#endif /* PROFCXX_PROFILER_NODE_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_NODE_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_STATE_H__
|
||||
#define PROFCXX_PROFILER_STATE_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_STATE_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_STATE_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdio>
|
||||
@ -45,13 +45,16 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
/** @brief Profiling mode on/off state. */
|
||||
template<int _Unused=0>
|
||||
class __state
|
||||
{
|
||||
public:
|
||||
private:
|
||||
enum __state_type { __ON, __OFF, __INVALID };
|
||||
|
||||
__state_type _M_state;
|
||||
|
||||
public:
|
||||
static __state<_Unused>* _S_diag_state;
|
||||
|
||||
__state() : _M_state(__INVALID) { }
|
||||
@ -62,46 +65,44 @@ class __state
|
||||
bool __is_invalid() { return _M_state == __INVALID; }
|
||||
void __turn_on() { _M_state = __ON; }
|
||||
void __turn_off() { _M_state = __OFF; }
|
||||
|
||||
private:
|
||||
enum __state_type { __ON, __OFF, __INVALID };
|
||||
__state_type _M_state;
|
||||
};
|
||||
|
||||
template<int _Unused>
|
||||
__state<_Unused>* __state<_Unused>::_S_diag_state = NULL;
|
||||
|
||||
inline bool __is_on()
|
||||
inline bool
|
||||
__is_on()
|
||||
{
|
||||
return __state<0>::_S_diag_state && __state<0>::_S_diag_state->__is_on();
|
||||
}
|
||||
|
||||
inline bool __is_off()
|
||||
inline bool
|
||||
__is_off()
|
||||
{
|
||||
return __state<0>::_S_diag_state && __state<0>::_S_diag_state->__is_off();
|
||||
}
|
||||
|
||||
inline bool __is_invalid()
|
||||
inline bool
|
||||
__is_invalid()
|
||||
{
|
||||
return (!__state<0>::_S_diag_state
|
||||
|| __state<0>::_S_diag_state->__is_invalid());
|
||||
return (!__state<0>::_S_diag_state || __state<0>::_S_diag_state->__is_invalid());
|
||||
}
|
||||
|
||||
inline void __turn_on()
|
||||
inline void
|
||||
__turn_on()
|
||||
{
|
||||
if (!__state<0>::_S_diag_state) {
|
||||
if (!__state<0>::_S_diag_state)
|
||||
__state<0>::_S_diag_state = new __state<0>();
|
||||
}
|
||||
__state<0>::_S_diag_state->__turn_on();
|
||||
}
|
||||
|
||||
inline void __turn_off()
|
||||
inline void
|
||||
__turn_off()
|
||||
{
|
||||
if (!__state<0>::_S_diag_state) {
|
||||
if (!__state<0>::_S_diag_state)
|
||||
__state<0>::_S_diag_state = new __state<0>();
|
||||
}
|
||||
__state<0>::_S_diag_state->__turn_off();
|
||||
}
|
||||
|
||||
} // end namespace __gnu_profile
|
||||
#endif /* PROFCXX_PROFILER_STATE_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_STATE_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_TRACE_H__
|
||||
#define PROFCXX_PROFILER_TRACE_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_TRACE_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_TRACE_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cerrno>
|
||||
@ -65,13 +65,14 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
#if defined _GLIBCXX_PROFILE_THREADS && defined HAVE_TLS
|
||||
#define _GLIBCXX_IMPL_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
|
||||
typedef pthread_mutex_t __mutex_t;
|
||||
|
||||
/** @brief Pthread mutex wrapper. */
|
||||
template<int _Unused=0>
|
||||
class __mutex {
|
||||
class __mutex
|
||||
{
|
||||
public:
|
||||
static __mutex_t __global_lock;
|
||||
static void __lock(__mutex_t& __m) { pthread_mutex_lock(&__m); }
|
||||
@ -80,9 +81,11 @@ class __mutex {
|
||||
#else
|
||||
#define _GLIBCXX_IMPL_MUTEX_INITIALIZER 0
|
||||
typedef int __mutex_t;
|
||||
|
||||
/** @brief Mock mutex interface. */
|
||||
template<int _Unused=0>
|
||||
class __mutex {
|
||||
class __mutex
|
||||
{
|
||||
public:
|
||||
static __mutex_t __global_lock;
|
||||
static void __lock(__mutex_t& __m) { }
|
||||
@ -109,20 +112,17 @@ struct __warning_data
|
||||
inline __warning_data::__warning_data()
|
||||
: __magnitude(0.0), __context(NULL), __warning_id(NULL),
|
||||
__warning_message(NULL)
|
||||
{
|
||||
}
|
||||
{ }
|
||||
|
||||
inline __warning_data::__warning_data(float __m, __stack_t __c,
|
||||
const char* __id, const char* __msg)
|
||||
: __magnitude(__m), __context(__c), __warning_id(__id),
|
||||
__warning_message(__msg)
|
||||
{
|
||||
}
|
||||
{ }
|
||||
|
||||
inline bool __warning_data::operator>(const struct __warning_data& other) const
|
||||
{
|
||||
return __magnitude > other.__magnitude;
|
||||
}
|
||||
inline bool
|
||||
__warning_data::operator>(const struct __warning_data& other) const
|
||||
{ return __magnitude > other.__magnitude; }
|
||||
|
||||
typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t;
|
||||
|
||||
@ -144,15 +144,11 @@ void __trace_vector_to_list_report(FILE*, __warning_vector_t&);
|
||||
void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&);
|
||||
|
||||
// Utility functions.
|
||||
inline size_t __max(size_t __a, size_t __b)
|
||||
{
|
||||
return __a >= __b ? __a : __b;
|
||||
}
|
||||
inline size_t
|
||||
__max(size_t __a, size_t __b) { return __a >= __b ? __a : __b; }
|
||||
|
||||
inline size_t __min(size_t __a, size_t __b)
|
||||
{
|
||||
return __a <= __b ? __a : __b;
|
||||
}
|
||||
inline size_t
|
||||
__min(size_t __a, size_t __b) { return __a <= __b ? __a : __b; }
|
||||
|
||||
/** @brief Storage for diagnostic table entries. Has only static fields. */
|
||||
template<int _Unused=0>
|
||||
@ -168,18 +164,23 @@ class __tables
|
||||
|
||||
template<int _Unused>
|
||||
__trace_hash_func* __tables<_Unused>::_S_hash_func = NULL;
|
||||
|
||||
template<int _Unused>
|
||||
__trace_hashtable_size* __tables<_Unused>::_S_hashtable_size = NULL;
|
||||
|
||||
template<int _Unused>
|
||||
__trace_map2umap* __tables<_Unused>::_S_map2umap = NULL;
|
||||
|
||||
template<int _Unused>
|
||||
__trace_vector_size* __tables<_Unused>::_S_vector_size = NULL;
|
||||
|
||||
template<int _Unused>
|
||||
__trace_vector_to_list* __tables<_Unused>::_S_vector_to_list = NULL;
|
||||
|
||||
/** @brief Storage for user defined parameters. Has only static fields. */
|
||||
template<int _Unused=0>
|
||||
class __settings {
|
||||
class __settings
|
||||
{
|
||||
public:
|
||||
static const char* _S_trace_file_name;
|
||||
static size_t _S_max_warn_count;
|
||||
@ -190,25 +191,24 @@ class __settings {
|
||||
template<int _Unused>
|
||||
const char* __settings<_Unused>::_S_trace_file_name =
|
||||
_GLIBCXX_PROFILE_TRACE_PATH_ROOT;
|
||||
|
||||
template<int _Unused>
|
||||
size_t __settings<_Unused>::_S_max_warn_count =
|
||||
_GLIBCXX_PROFILE_MAX_WARN_COUNT;
|
||||
|
||||
template<int _Unused>
|
||||
size_t __settings<_Unused>::_S_max_stack_depth =
|
||||
_GLIBCXX_PROFILE_MAX_STACK_DEPTH;
|
||||
|
||||
template<int _Unused>
|
||||
size_t __settings<_Unused>::_S_max_mem =
|
||||
_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC;
|
||||
|
||||
inline size_t __stack_max_depth()
|
||||
{
|
||||
return __settings<0>::_S_max_stack_depth;
|
||||
}
|
||||
inline size_t
|
||||
__stack_max_depth() { return __settings<0>::_S_max_stack_depth; }
|
||||
|
||||
inline size_t __max_mem()
|
||||
{
|
||||
return __settings<0>::_S_max_mem;
|
||||
}
|
||||
inline size_t
|
||||
__max_mem() { return __settings<0>::_S_max_mem; }
|
||||
|
||||
/** @brief Base class for all trace producers. */
|
||||
template<typename __object_info, typename __stack_info>
|
||||
@ -245,8 +245,8 @@ class __trace_base
|
||||
};
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__collect_warnings(
|
||||
__warning_vector_t& warnings)
|
||||
void
|
||||
__trace_base<__object_info, __stack_info>::__collect_warnings(__warning_vector_t& warnings)
|
||||
{
|
||||
typename __stack_table_t::iterator __i = __stack_table.begin();
|
||||
for ( ; __i != __stack_table.end(); ++__i)
|
||||
@ -259,57 +259,53 @@ void __trace_base<__object_info, __stack_info>::__collect_warnings(
|
||||
}
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__lock_object_table()
|
||||
{
|
||||
__mutex<0>::__lock(this->__object_table_lock);
|
||||
}
|
||||
void
|
||||
__trace_base<__object_info, __stack_info>::__lock_object_table()
|
||||
{ __mutex<0>::__lock(this->__object_table_lock); }
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__lock_stack_table()
|
||||
{
|
||||
__mutex<0>::__lock(this->__stack_table_lock);
|
||||
}
|
||||
void
|
||||
__trace_base<__object_info, __stack_info>::__lock_stack_table()
|
||||
{ __mutex<0>::__lock(this->__stack_table_lock); }
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__unlock_object_table()
|
||||
{
|
||||
__mutex<0>::__unlock(this->__object_table_lock);
|
||||
}
|
||||
{ __mutex<0>::__unlock(this->__object_table_lock); }
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__unlock_stack_table()
|
||||
{
|
||||
__mutex<0>::__unlock(this->__stack_table_lock);
|
||||
}
|
||||
{ __mutex<0>::__unlock(this->__stack_table_lock); }
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
__trace_base<__object_info, __stack_info>::__trace_base()
|
||||
{
|
||||
// Do not pick the initial size too large, as we don't know which diagnostics
|
||||
// are more active.
|
||||
// Do not pick the initial size too large, as we don't know which
|
||||
// diagnostics are more active.
|
||||
__object_table.rehash(10000);
|
||||
__stack_table.rehash(10000);
|
||||
__stack_table_byte_size = 0;
|
||||
__id = NULL;
|
||||
__object_table_lock = __stack_table_lock = _GLIBCXX_IMPL_MUTEX_INITIALIZER;
|
||||
__stack_table_lock = _GLIBCXX_IMPL_MUTEX_INITIALIZER;
|
||||
__object_table_lock = __stack_table_lock;
|
||||
}
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__add_object(
|
||||
__object_t __object, __object_info __info)
|
||||
void
|
||||
__trace_base<__object_info, __stack_info>::__add_object(__object_t __object, __object_info __info)
|
||||
{
|
||||
typedef typename __object_table_t::value_type value_type;
|
||||
if (__max_mem() == 0
|
||||
|| __object_table.size() * sizeof(__object_info) <= __max_mem()) {
|
||||
|| __object_table.size() * sizeof(__object_info) <= __max_mem())
|
||||
{
|
||||
__lock_object_table();
|
||||
__object_table.insert(
|
||||
typename __object_table_t::value_type(__object, __info));
|
||||
__object_table.insert(value_type(__object, __info));
|
||||
__unlock_object_table();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
__object_info* __trace_base<__object_info, __stack_info>::__get_object_info(
|
||||
__object_t __object)
|
||||
__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
|
||||
@ -317,37 +313,48 @@ __object_info* __trace_base<__object_info, __stack_info>::__get_object_info(
|
||||
__lock_object_table();
|
||||
typename __object_table_t::iterator __object_it =
|
||||
__object_table.find(__object);
|
||||
if (__object_it == __object_table.end()){
|
||||
|
||||
if (__object_it == __object_table.end())
|
||||
{
|
||||
__unlock_object_table();
|
||||
return NULL;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
__unlock_object_table();
|
||||
return &__object_it->second;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__retire_object(
|
||||
__object_t __object)
|
||||
void
|
||||
__trace_base<__object_info, __stack_info>::__retire_object(__object_t __object)
|
||||
{
|
||||
__lock_object_table();
|
||||
__lock_stack_table();
|
||||
typename __object_table_t::iterator __object_it =
|
||||
__object_table.find(__object);
|
||||
if (__object_it != __object_table.end()){
|
||||
|
||||
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()) {
|
||||
|
||||
if (__stack_it == __stack_table.end())
|
||||
{
|
||||
// First occurence of this call context.
|
||||
if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) {
|
||||
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 {
|
||||
}
|
||||
else
|
||||
{
|
||||
// Merge object info into info summary for this call context.
|
||||
__stack_it->second.__merge(__info);
|
||||
delete __stack;
|
||||
@ -359,12 +366,15 @@ void __trace_base<__object_info, __stack_info>::__retire_object(
|
||||
}
|
||||
|
||||
template<typename __object_info, typename __stack_info>
|
||||
void __trace_base<__object_info, __stack_info>::__write(FILE* __f)
|
||||
void
|
||||
__trace_base<__object_info, __stack_info>::__write(FILE* __f)
|
||||
{
|
||||
typename __stack_table_t::iterator __it;
|
||||
|
||||
for (__it = __stack_table.begin(); __it != __stack_table.end(); __it++) {
|
||||
if (__it->second.__is_valid()) {
|
||||
for (__it = __stack_table.begin(); __it != __stack_table.end(); __it++)
|
||||
{
|
||||
if (__it->second.__is_valid())
|
||||
{
|
||||
fprintf(__f, __id);
|
||||
fprintf(__f, "|");
|
||||
__gnu_profile::__write(__f, __it->first);
|
||||
@ -374,45 +384,55 @@ void __trace_base<__object_info, __stack_info>::__write(FILE* __f)
|
||||
}
|
||||
}
|
||||
|
||||
inline size_t __env_to_size_t(const char* __env_var, size_t __default_value)
|
||||
inline size_t
|
||||
__env_to_size_t(const char* __env_var, size_t __default_value)
|
||||
{
|
||||
char* __env_value = getenv(__env_var);
|
||||
if (__env_value) {
|
||||
if (__env_value)
|
||||
{
|
||||
long int __converted_value = strtol(__env_value, NULL, 10);
|
||||
if (errno || __converted_value < 0) {
|
||||
fprintf(stderr, "Bad value for environment variable '%s'.", __env_var);
|
||||
if (errno || __converted_value < 0)
|
||||
{
|
||||
fprintf(stderr, "Bad value for environment variable '%s'.",
|
||||
__env_var);
|
||||
abort();
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
return static_cast<size_t>(__converted_value);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
return __default_value;
|
||||
}
|
||||
}
|
||||
|
||||
inline void __set_max_stack_trace_depth()
|
||||
inline void
|
||||
__set_max_stack_trace_depth()
|
||||
{
|
||||
__settings<0>::_S_max_stack_depth = __env_to_size_t(
|
||||
_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR,
|
||||
__settings<0>::_S_max_stack_depth);
|
||||
__settings<0>::_S_max_stack_depth = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR, __settings<0>::_S_max_stack_depth);
|
||||
}
|
||||
|
||||
inline void __set_max_mem()
|
||||
inline void
|
||||
__set_max_mem()
|
||||
{
|
||||
__settings<0>::_S_max_mem = __env_to_size_t(
|
||||
_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, __settings<0>::_S_max_mem);
|
||||
__settings<0>::_S_max_mem = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, __settings<0>::_S_max_mem);
|
||||
}
|
||||
|
||||
inline int __log_magnitude(float f)
|
||||
inline int
|
||||
__log_magnitude(float f)
|
||||
{
|
||||
const float log_base = 10.0;
|
||||
int result = 0;
|
||||
int sign = 1;
|
||||
if (f < 0) {
|
||||
if (f < 0)
|
||||
{
|
||||
f = -f;
|
||||
sign = -1;
|
||||
}
|
||||
while (f > log_base) {
|
||||
while (f > log_base)
|
||||
{
|
||||
++result;
|
||||
f /= 10.0;
|
||||
}
|
||||
@ -422,18 +442,22 @@ inline int __log_magnitude(float f)
|
||||
struct __warn
|
||||
{
|
||||
FILE* __file;
|
||||
|
||||
__warn(FILE* __f) { __file = __f; }
|
||||
|
||||
void operator() (const __warning_data& __info)
|
||||
{
|
||||
fprintf(__file, __info.__warning_id);
|
||||
fprintf(__file, ": improvement = %d", __log_magnitude(__info.__magnitude));
|
||||
fprintf(__file, ": improvement = %d",
|
||||
__log_magnitude(__info.__magnitude));
|
||||
fprintf(__file, ": call stack = ");
|
||||
__gnu_profile::__write(__file, __info.__context);
|
||||
fprintf(__file, ": advice = %s\n", __info.__warning_message);
|
||||
}
|
||||
};
|
||||
|
||||
inline FILE* __open_output_file(const char* extension)
|
||||
inline FILE*
|
||||
__open_output_file(const char* extension)
|
||||
{
|
||||
// The path is made of _S_trace_file_name + "." + extension.
|
||||
size_t root_len = strlen(__settings<0>::_S_trace_file_name);
|
||||
@ -444,9 +468,10 @@ inline FILE* __open_output_file(const char* extension)
|
||||
*(file_name + root_len) = '.';
|
||||
memcpy(file_name + root_len + 1, extension, ext_len + 1);
|
||||
FILE* out_file = fopen(file_name, "w");
|
||||
if (out_file) {
|
||||
if (out_file)
|
||||
return out_file;
|
||||
} else {
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "Could not open trace file '%s'.", file_name);
|
||||
abort();
|
||||
}
|
||||
@ -459,7 +484,8 @@ inline FILE* __open_output_file(const char* extension)
|
||||
* 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)
|
||||
inline void
|
||||
__report(void)
|
||||
{
|
||||
__mutex<0>::__lock(__mutex<0>::__global_lock);
|
||||
|
||||
@ -474,7 +500,9 @@ inline void __report(void)
|
||||
fclose(__raw_file);
|
||||
|
||||
// Sort data by magnitude.
|
||||
// XXX: instead of sorting, should collect only top N for better performance.
|
||||
|
||||
// XXX: instead of sorting, should collect only top N for better
|
||||
// performance.
|
||||
size_t __cutoff = __min(__settings<0>::_S_max_warn_count,
|
||||
__warnings.size());
|
||||
|
||||
@ -489,43 +517,45 @@ inline void __report(void)
|
||||
__mutex<0>::__unlock(__mutex<0>::__global_lock);
|
||||
}
|
||||
|
||||
inline void __set_trace_path()
|
||||
inline void
|
||||
__set_trace_path()
|
||||
{
|
||||
char* __env_trace_file_name = getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR);
|
||||
|
||||
if (__env_trace_file_name) {
|
||||
if (__env_trace_file_name)
|
||||
__settings<0>::_S_trace_file_name = __env_trace_file_name;
|
||||
}
|
||||
|
||||
// Make sure early that we can create the trace file.
|
||||
fclose(__open_output_file("txt"));
|
||||
}
|
||||
|
||||
inline void __set_max_warn_count()
|
||||
inline void
|
||||
__set_max_warn_count()
|
||||
{
|
||||
char* __env_max_warn_count_str = getenv(
|
||||
_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR);
|
||||
char* __env_max_warn_count_str = getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR);
|
||||
|
||||
if (__env_max_warn_count_str) {
|
||||
__settings<0>::_S_max_warn_count = static_cast<size_t>(
|
||||
atoi(__env_max_warn_count_str));
|
||||
if (__env_max_warn_count_str)
|
||||
{
|
||||
int i = atoi(__env_max_warn_count_str);
|
||||
__settings<0>::_S_max_warn_count = static_cast<size_t>(i);
|
||||
}
|
||||
}
|
||||
|
||||
inline void __profcxx_init_unconditional()
|
||||
inline void
|
||||
__profcxx_init_unconditional()
|
||||
{
|
||||
__mutex<0>::__lock(__mutex<0>::__global_lock);
|
||||
|
||||
__set_max_warn_count();
|
||||
|
||||
if (__is_invalid()) {
|
||||
|
||||
if (__settings<0>::_S_max_warn_count == 0) {
|
||||
|
||||
if (__is_invalid())
|
||||
{
|
||||
if (__settings<0>::_S_max_warn_count == 0)
|
||||
{
|
||||
__turn_off();
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
__set_max_stack_trace_depth();
|
||||
__set_max_mem();
|
||||
__set_trace_path();
|
||||
@ -539,7 +569,6 @@ inline void __profcxx_init_unconditional()
|
||||
atexit(__report);
|
||||
|
||||
__turn_on();
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -550,15 +579,14 @@ inline void __profcxx_init_unconditional()
|
||||
*
|
||||
* The common path is inlined fully.
|
||||
*/
|
||||
inline bool __profcxx_init(void)
|
||||
inline bool
|
||||
__profcxx_init(void)
|
||||
{
|
||||
if (__is_invalid()) {
|
||||
if (__is_invalid())
|
||||
__profcxx_init_unconditional();
|
||||
}
|
||||
|
||||
return __is_on();
|
||||
}
|
||||
|
||||
} // namespace __gnu_profile
|
||||
|
||||
#endif /* PROFCXX_PROFILER_TRACE_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_VECTOR_SIZE_H__
|
||||
#define PROFCXX_PROFILER_VECTOR_SIZE_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdlib>
|
||||
@ -54,7 +54,6 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
/** @brief Hashtable size instrumentation trace producer. */
|
||||
class __trace_vector_size : public __trace_container_size
|
||||
{
|
||||
@ -62,51 +61,42 @@ class __trace_vector_size : public __trace_container_size
|
||||
__trace_vector_size() : __trace_container_size() { __id = "vector-size"; }
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization and report.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
inline void
|
||||
__trace_vector_size_init()
|
||||
{ __tables<0>::_S_vector_size = new __trace_vector_size(); }
|
||||
|
||||
inline void __trace_vector_size_init()
|
||||
inline void
|
||||
__trace_vector_size_report(FILE* __f, __warning_vector_t& __warnings)
|
||||
{
|
||||
__tables<0>::_S_vector_size = new __trace_vector_size();
|
||||
}
|
||||
|
||||
inline void __trace_vector_size_report(FILE* __f,
|
||||
__warning_vector_t& __warnings)
|
||||
if (__tables<0>::_S_vector_size)
|
||||
{
|
||||
if (__tables<0>::_S_vector_size) {
|
||||
__tables<0>::_S_vector_size->__collect_warnings(__warnings);
|
||||
__tables<0>::_S_vector_size->__write(__f);
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Implementations of instrumentation hooks.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
inline void __trace_vector_size_construct(const void* __obj, size_t __num)
|
||||
inline void
|
||||
__trace_vector_size_construct(const void* __obj, size_t __num)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_size->__insert(__obj, __get_stack(), __num);
|
||||
}
|
||||
|
||||
inline void __trace_vector_size_destruct(const void* __obj, size_t __num,
|
||||
size_t __inum)
|
||||
inline void
|
||||
__trace_vector_size_destruct(const void* __obj, size_t __num, size_t __inum)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_size->__destruct(__obj, __num, __inum);
|
||||
}
|
||||
|
||||
inline void __trace_vector_size_resize(const void* __obj, size_t __from,
|
||||
size_t __to)
|
||||
inline void
|
||||
__trace_vector_size_resize(const void* __obj, size_t __from, size_t __to)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_size->__resize(__obj, __from, __to);
|
||||
}
|
||||
|
||||
} // namespace __gnu_profile
|
||||
|
||||
#endif /* PROFCXX_PROFILER_VECTOR_SIZE_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H */
|
||||
|
||||
@ -34,8 +34,8 @@
|
||||
|
||||
// Written by Lixia Liu and Silvius Rus.
|
||||
|
||||
#ifndef PROFCXX_PROFILER_VECTOR_TO_LIST_H__
|
||||
#define PROFCXX_PROFILER_VECTOR_TO_LIST_H__ 1
|
||||
#ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H
|
||||
#define _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H 1
|
||||
|
||||
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
||||
#include <cstdio>
|
||||
@ -52,7 +52,6 @@
|
||||
|
||||
namespace __gnu_profile
|
||||
{
|
||||
|
||||
/** @brief A vector-to-list instrumentation line in the object table. */
|
||||
class __vector2list_info: public __object_info_base
|
||||
{
|
||||
@ -60,11 +59,14 @@ class __vector2list_info: public __object_info_base
|
||||
__vector2list_info()
|
||||
:_M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0),
|
||||
_M_vector_cost(0), _M_valid(true) { }
|
||||
|
||||
__vector2list_info(__stack_t __stack)
|
||||
: __object_info_base(__stack), _M_shift_count(0), _M_iterate(0),
|
||||
_M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true) { }
|
||||
|
||||
virtual ~__vector2list_info() { }
|
||||
__vector2list_info(const __vector2list_info& __o);
|
||||
|
||||
void __merge(const __vector2list_info& __o);
|
||||
void __write(FILE* __f) const;
|
||||
float __magnitude() const { return _M_vector_cost - _M_list_cost; }
|
||||
@ -103,7 +105,8 @@ inline __vector2list_info::__vector2list_info(const __vector2list_info& __o)
|
||||
_M_resize = __o._M_resize;
|
||||
}
|
||||
|
||||
inline void __vector2list_info::__merge(const __vector2list_info& __o)
|
||||
inline void
|
||||
__vector2list_info::__merge(const __vector2list_info& __o)
|
||||
{
|
||||
_M_shift_count += __o._M_shift_count;
|
||||
_M_iterate += __o._M_iterate;
|
||||
@ -113,18 +116,17 @@ inline void __vector2list_info::__merge(const __vector2list_info& __o)
|
||||
_M_resize += __o._M_resize;
|
||||
}
|
||||
|
||||
inline void __vector2list_info::__opr_insert(size_t __pos, size_t __num)
|
||||
{
|
||||
_M_shift_count += __num - __pos;
|
||||
}
|
||||
inline void
|
||||
__vector2list_info::__opr_insert(size_t __pos, size_t __num)
|
||||
{ _M_shift_count += __num - __pos; }
|
||||
|
||||
inline void __vector2list_info::__resize(size_t __from, size_t __to)
|
||||
{
|
||||
_M_resize += __from;
|
||||
}
|
||||
inline void
|
||||
__vector2list_info::__resize(size_t __from, size_t __to)
|
||||
{ _M_resize += __from; }
|
||||
|
||||
/** @brief A vector-to-list instrumentation line in the stack table. */
|
||||
class __vector2list_stack_info: public __vector2list_info {
|
||||
class __vector2list_stack_info: public __vector2list_info
|
||||
{
|
||||
public:
|
||||
__vector2list_stack_info(const __vector2list_info& __o)
|
||||
: __vector2list_info(__o) { }
|
||||
@ -140,6 +142,7 @@ class __trace_vector_to_list
|
||||
|
||||
// Insert a new node at construct with object, callstack and initial size.
|
||||
void __insert(__object_t __obj, __stack_t __stack);
|
||||
|
||||
// Call at destruction/clean to set container final size.
|
||||
void __destruct(const void* __obj);
|
||||
|
||||
@ -157,23 +160,20 @@ class __trace_vector_to_list
|
||||
|
||||
inline __trace_vector_to_list::__trace_vector_to_list()
|
||||
: __trace_base<__vector2list_info, __vector2list_stack_info>()
|
||||
{ __id = "vector-to-list"; }
|
||||
|
||||
inline void
|
||||
__trace_vector_to_list::__insert(__object_t __obj, __stack_t __stack)
|
||||
{ __add_object(__obj, __vector2list_info(__stack)); }
|
||||
|
||||
inline void
|
||||
__vector2list_info::__write(FILE* __f) const
|
||||
{
|
||||
__id = "vector-to-list";
|
||||
fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count, _M_resize,
|
||||
_M_iterate, _M_vector_cost, _M_list_cost);
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list::__insert(__object_t __obj,
|
||||
__stack_t __stack)
|
||||
{
|
||||
__add_object(__obj, __vector2list_info(__stack));
|
||||
}
|
||||
|
||||
inline void __vector2list_info::__write(FILE* __f) const
|
||||
{
|
||||
fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n",
|
||||
_M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost);
|
||||
}
|
||||
|
||||
// Cost model. XXX: get this from the cost model database instead.
|
||||
// Cost model.
|
||||
// Vector operation cost:
|
||||
// - Cost per shift: 1
|
||||
// - Cost per access: 1
|
||||
@ -182,22 +182,19 @@ inline void __vector2list_info::__write(FILE* __f) const
|
||||
// - Cost per shift: 0
|
||||
// - Cost per access: 10
|
||||
// - Cost per resize: 0
|
||||
|
||||
inline float __trace_vector_to_list::__vector_cost(size_t __shift,
|
||||
size_t __iterate,
|
||||
// XXX: get this from the cost model database instead.
|
||||
inline float
|
||||
__trace_vector_to_list::__vector_cost(size_t __shift, size_t __iterate,
|
||||
size_t __resize)
|
||||
{
|
||||
return __shift * 1 + __iterate * 1 + __resize * 1;
|
||||
}
|
||||
{ return __shift * 1 + __iterate * 1 + __resize * 1; }
|
||||
|
||||
inline float __trace_vector_to_list::__list_cost(size_t __shift,
|
||||
size_t __iterate,
|
||||
inline float
|
||||
__trace_vector_to_list::__list_cost(size_t __shift, size_t __iterate,
|
||||
size_t __resize)
|
||||
{
|
||||
return __shift * 0 + __iterate * 10 + __resize * 0;
|
||||
}
|
||||
{ return __shift * 0 + __iterate * 10 + __resize * 0; }
|
||||
|
||||
inline void __trace_vector_to_list::__destruct(const void* __obj)
|
||||
inline void
|
||||
__trace_vector_to_list::__destruct(const void* __obj)
|
||||
{
|
||||
if (!__is_on())
|
||||
return;
|
||||
@ -216,30 +213,33 @@ inline void __trace_vector_to_list::__destruct(const void* __obj)
|
||||
__retire_object(__obj);
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list::__opr_insert(const void* __obj,
|
||||
size_t __pos, size_t __num)
|
||||
inline void
|
||||
__trace_vector_to_list::__opr_insert(const void* __obj, size_t __pos,
|
||||
size_t __num)
|
||||
{
|
||||
__vector2list_info* __res = __get_object_info(__obj);
|
||||
if (__res)
|
||||
__res->__opr_insert(__pos, __num);
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list::__opr_iterate(const void* __obj,
|
||||
size_t __num)
|
||||
inline void
|
||||
__trace_vector_to_list::__opr_iterate(const void* __obj, size_t __num)
|
||||
{
|
||||
__vector2list_info* __res = __get_object_info(__obj);
|
||||
if (__res)
|
||||
__res->__opr_iterate(__num);
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list::__invalid_operator(const void* __obj)
|
||||
inline void
|
||||
__trace_vector_to_list::__invalid_operator(const void* __obj)
|
||||
{
|
||||
__vector2list_info* __res = __get_object_info(__obj);
|
||||
if (__res)
|
||||
__res->__set_invalid();
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list::__resize(const void* __obj, size_t __from,
|
||||
inline void
|
||||
__trace_vector_to_list::__resize(const void* __obj, size_t __from,
|
||||
size_t __to)
|
||||
{
|
||||
__vector2list_info* __res = __get_object_info(__obj);
|
||||
@ -247,72 +247,63 @@ inline void __trace_vector_to_list::__resize(const void* __obj, size_t __from,
|
||||
__res->__resize(__from, __to);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Initialization and report.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
inline void
|
||||
__trace_vector_to_list_init()
|
||||
{ __tables<0>::_S_vector_to_list = new __trace_vector_to_list(); }
|
||||
|
||||
inline void __trace_vector_to_list_init()
|
||||
inline void
|
||||
__trace_vector_to_list_report(FILE* __f, __warning_vector_t& __warnings)
|
||||
{
|
||||
__tables<0>::_S_vector_to_list = new __trace_vector_to_list();
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list_report(FILE* __f,
|
||||
__warning_vector_t& __warnings)
|
||||
if (__tables<0>::_S_vector_to_list)
|
||||
{
|
||||
if (__tables<0>::_S_vector_to_list) {
|
||||
__tables<0>::_S_vector_to_list->__collect_warnings(__warnings);
|
||||
__tables<0>::_S_vector_to_list->__write(__f);
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Implementations of instrumentation hooks.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
inline void __trace_vector_to_list_construct(const void* __obj)
|
||||
inline void
|
||||
__trace_vector_to_list_construct(const void* __obj)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_to_list->__insert(__obj, __get_stack());
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list_destruct(const void* __obj)
|
||||
inline void
|
||||
__trace_vector_to_list_destruct(const void* __obj)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_to_list->__destruct(__obj);
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list_insert(const void* __obj,
|
||||
size_t __pos, size_t __num)
|
||||
inline void
|
||||
__trace_vector_to_list_insert(const void* __obj, size_t __pos, size_t __num)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_to_list->__opr_insert(__obj, __pos, __num);
|
||||
}
|
||||
|
||||
|
||||
inline void __trace_vector_to_list_iterate(const void* __obj, size_t __num)
|
||||
inline void
|
||||
__trace_vector_to_list_iterate(const void* __obj, size_t __num)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_to_list->__opr_iterate(__obj, __num);
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list_invalid_operator(const void* __obj)
|
||||
inline void
|
||||
__trace_vector_to_list_invalid_operator(const void* __obj)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_to_list->__invalid_operator(__obj);
|
||||
}
|
||||
|
||||
inline void __trace_vector_to_list_resize(const void* __obj,
|
||||
size_t __from, size_t __to)
|
||||
inline void
|
||||
__trace_vector_to_list_resize(const void* __obj, size_t __from, size_t __to)
|
||||
{
|
||||
if (!__profcxx_init()) return;
|
||||
|
||||
__tables<0>::_S_vector_to_list->__resize(__obj, __from, __to);
|
||||
}
|
||||
|
||||
} // namespace __gnu_profile
|
||||
#endif /* PROFCXX_PROFILER_VECTOR_TO_LIST_H__ */
|
||||
#endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user