OSDN Git Service

merge branch profile-stdlib
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / profile / impl / profiler.h
1 // -*- C++ -*-
2 //
3 // Copyright (C) 2009 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the terms
7 // of the GNU General Public License as published by the Free Software
8 // Foundation; either version 2, or (at your option) any later
9 // version.
10
11 // This library is distributed in the hope that it will be useful, but
12 // WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License
17 // along with this library; see the file COPYING.  If not, write to
18 // the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
19 // MA 02111-1307, USA.
20
21 // As a special exception, you may use this file as part of a free
22 // software library without restriction.  Specifically, if other files
23 // instantiate templates or use macros or inline functions from this
24 // file, or you compile this file and link it with other files to
25 // produce an executable, this file does not by itself cause the
26 // resulting executable to be covered by the GNU General Public
27 // License.  This exception does not however invalidate any other
28 // reasons why the executable file might be covered by the GNU General
29 // Public License.
30
31 /** @file profile/impl/profiler.h
32  *  @brief Interface of the profiling runtime library.
33  */
34
35 // Written by Lixia Liu and Silvius Rus.
36
37 #ifndef PROFCXX_PROFILER_H__
38 #define PROFCXX_PROFILER_H__ 1
39
40 #ifdef __GXX_EXPERIMENTAL_CXX0X__
41 #include <cstddef>
42 #else
43 #include <stddef.h>
44 #endif
45
46 /**
47  * @namespace std::__cxxprof_guard
48  * @brief Mechanism to protect all __cxxprof_impl operations against
49  * multithreaded and exception reentrance.
50  */
51 namespace __cxxprof_guard
52 {
53
54 /** @brief Reentrance guard.
55  *
56  * Mechanism to protect all __cxxprof_impl operations against recursion,
57  * multithreaded and exception reentrance.
58  */
59 template <int _Unused=0>
60 class __reentrance_guard
61 {
62  public:
63   static __thread bool __inside_cxxprof_impl;
64   static bool __get_in();
65   __reentrance_guard() {}
66   ~__reentrance_guard() { __inside_cxxprof_impl = false; }
67 };
68
69 template <int _Unused>
70 __thread bool __reentrance_guard<_Unused>::__inside_cxxprof_impl = false;
71
72 template <int _Unused>
73 bool __reentrance_guard<_Unused>::__get_in()
74 {
75   if (__inside_cxxprof_impl) {
76     return false;
77   } else {
78     __inside_cxxprof_impl = true;
79     return true;
80   }
81 }
82
83 } // namespace __cxxprof_guard
84
85 #define _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__x...)             \
86   {                                                                \
87     if (__cxxprof_guard::__reentrance_guard<0>::__get_in())        \
88     {                                                              \
89       __cxxprof_guard::__reentrance_guard<0> __auto_get_out;       \
90       __x;                                                         \
91     }                                                              \
92   }
93
94 /**
95  * @namespace std::__cxxprof_impl
96  * @brief Implementation of profile extension.
97  */
98 namespace __cxxprof_impl
99 {
100 // Forward declarations of implementation functions.
101 // Don't use any __cxxprof_impl:: in user code.
102 // Instead, use the __profcxx... macros, which offer guarded access.
103 void __turn_on();
104 void __turn_off();
105 bool __is_invalid();
106 bool __is_on();
107 bool __is_off();
108 void __report(void);
109 void __trace_hashtable_size_resize(const void*, size_t, size_t);
110 void __trace_hashtable_size_destruct(const void*, size_t, size_t);
111 void __trace_hashtable_size_construct(const void*, size_t);
112 void __trace_vector_size_resize(const void*, size_t, size_t);
113 void __trace_vector_size_destruct(const void*, size_t, size_t);
114 void __trace_vector_size_construct(const void*, size_t);
115 void __trace_hash_func_destruct(const void*, size_t, size_t, size_t);
116 void __trace_hash_func_construct(const void*);
117 void __trace_vector_to_list_destruct(const void*);
118 void __trace_vector_to_list_construct(const void*);
119 void __trace_vector_to_list_insert(const void*, size_t, size_t);
120 void __trace_vector_to_list_iterate(const void*, size_t);
121 void __trace_vector_to_list_invalid_operator(const void*);
122 void __trace_vector_to_list_resize(const void*, size_t, size_t);
123 void __trace_map_to_unordered_map_construct(const void*);
124 void __trace_map_to_unordered_map_invalidate(const void*);
125 void __trace_map_to_unordered_map_insert(const void*, size_t, size_t);
126 void __trace_map_to_unordered_map_erase(const void*, size_t, size_t);
127 void __trace_map_to_unordered_map_iterate(const void*, size_t);
128 void __trace_map_to_unordered_map_find(const void*, size_t);
129 void __trace_map_to_unordered_map_destruct(const void*);
130 } // namespace __cxxprof_impl
131
132 // Master switch turns on all diagnostics.
133 #ifdef _GLIBCXX_PROFILE
134 #define _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL
135 #define _GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE
136 #define _GLIBCXX_PROFILE_VECTOR_TOO_SMALL
137 #define _GLIBCXX_PROFILE_VECTOR_TOO_LARGE
138 #define _GLIBCXX_PROFILE_INEFFICIENT_HASH
139 #define _GLIBCXX_PROFILE_VECTOR_TO_LIST
140 #define _GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP
141 #endif
142
143 // Expose global management routines to user code.
144 #ifdef _GLIBCXX_PROFILE
145 #define __profcxx_report() \
146   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__report())
147 #define __profcxx_turn_on() \
148   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__turn_on())
149 #define __profcxx_turn_off() \
150   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__turn_off())
151 #define __profcxx_is_invalid() \
152   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_invalid())
153 #define __profcxx_is_on() \
154   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_on())
155 #define __profcxx__is_off() \
156   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_off())
157 #else
158 #define __profcxx_report()
159 #define __profcxx_turn_on()
160 #define __profcxx_turn_off()
161 #define __profcxx_is_invalid()
162 #define __profcxx_is_on()
163 #define __profcxx_is_off()
164 #endif
165
166 // Turn on/off instrumentation for HASHTABLE_TOO_SMALL and HASHTABLE_TOO_LARGE.
167 #if ((defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \
168       && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL)) \
169      || (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE) \
170          && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE)))
171 #define __profcxx_hashtable_resize(__x...) \
172   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
173       __cxxprof_impl::__trace_hashtable_size_resize(__x))
174 #define __profcxx_hashtable_destruct(__x...) \
175   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
176       __cxxprof_impl::__trace_hashtable_size_destruct(__x))
177 #define __profcxx_hashtable_construct(__x...) \
178   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
179       __cxxprof_impl::__trace_hashtable_size_construct(__x))
180 #else
181 #define __profcxx_hashtable_resize(__x...)  
182 #define __profcxx_hashtable_destruct(__x...) 
183 #define __profcxx_hashtable_construct(__x...)  
184 #endif
185
186 // Turn on/off instrumentation for VECTOR_TOO_SMALL and VECTOR_TOO_LARGE.
187 #if ((defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \
188       && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_SMALL)) \
189      || (defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE) \
190          && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_LARGE)))
191 #define __profcxx_vector_resize(__x...) \
192   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
193       __cxxprof_impl::__trace_vector_size_resize(__x))
194 #define __profcxx_vector_destruct(__x...) \
195   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
196       __cxxprof_impl::__trace_vector_size_destruct(__x))
197 #define __profcxx_vector_construct(__x...) \
198   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
199       __cxxprof_impl::__trace_vector_size_construct(__x))
200 #else
201 #define __profcxx_vector_resize(__x...)  
202 #define __profcxx_vector_destruct(__x...) 
203 #define __profcxx_vector_construct(__x...)  
204 #endif 
205
206 // Turn on/off instrumentation for INEFFICIENT_HASH.
207 #if (defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH) \
208      && !defined(_NO_GLIBCXX_PROFILE_INEFFICIENT_HASH))
209 #define __profcxx_hashtable_construct2(__x...) \
210   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
211       __cxxprof_impl::__trace_hash_func_construct(__x))
212 #define __profcxx_hashtable_destruct2(__x...) \
213   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
214       __cxxprof_impl::__trace_hash_func_destruct(__x))
215 #else
216 #define __profcxx_hashtable_destruct2(__x...) 
217 #define __profcxx_hashtable_construct2(__x...)  
218 #endif
219
220 // Turn on/off instrumentation for VECTOR_TO_LIST.
221 #if (defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST) \
222      && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TO_LIST))
223 #define __profcxx_vector_construct2(__x...) \
224   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
225       __cxxprof_impl::__trace_vector_to_list_construct(__x))
226 #define __profcxx_vector_destruct2(__x...) \
227   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
228       __cxxprof_impl::__trace_vector_to_list_destruct(__x))
229 #define __profcxx_vector_insert(__x...) \
230   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
231       __cxxprof_impl::__trace_vector_to_list_insert(__x))
232 #define __profcxx_vector_iterate(__x...) \
233   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
234       __cxxprof_impl::__trace_vector_to_list_iterate(__x))
235 #define __profcxx_vector_invalid_operator(__x...) \
236   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
237       __cxxprof_impl::__trace_vector_to_list_invalid_operator(__x))
238 #define __profcxx_vector_resize2(__x...) \
239   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
240       __cxxprof_impl::__trace_vector_to_list_resize(__x))
241 #else
242 #define __profcxx_vector_destruct2(__x...)
243 #define __profcxx_vector_construct2(__x...)
244 #define __profcxx_vector_insert(__x...)
245 #define __profcxx_vector_iterate(__x...)
246 #define __profcxx_vector_invalid_operator(__x...)
247 #define __profcxx_vector_resize2(__x...)
248 #endif
249
250 // Turn on/off instrumentation for MAP_TO_UNORDERED_MAP.
251 #if (defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP) \
252      && !defined(_NO_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP))
253 #define __profcxx_map_to_unordered_map_construct(__x...) \
254   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
255       __cxxprof_impl::__trace_map_to_unordered_map_construct(__x))
256 #define __profcxx_map_to_unordered_map_destruct(__x...) \
257   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
258       __cxxprof_impl::__trace_map_to_unordered_map_destruct(__x))
259 #define __profcxx_map_to_unordered_map_insert(__x...) \
260   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
261       __cxxprof_impl::__trace_map_to_unordered_map_insert(__x))
262 #define __profcxx_map_to_unordered_map_erase(__x...) \
263   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
264       __cxxprof_impl::__trace_map_to_unordered_map_erase(__x))
265 #define __profcxx_map_to_unordered_map_iterate(__x...) \
266   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
267       __cxxprof_impl::__trace_map_to_unordered_map_iterate(__x))
268 #define __profcxx_map_to_unordered_map_invalidate(__x...) \
269   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
270       __cxxprof_impl::__trace_map_to_unordered_map_invalidate(__x))
271 #define __profcxx_map_to_unordered_map_find(__x...) \
272   _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
273       __cxxprof_impl::__trace_map_to_unordered_map_find(__x))
274 #else
275 #define __profcxx_map_to_unordered_map_construct(__x...) \
276   
277 #define __profcxx_map_to_unordered_map_destruct(__x...)
278 #define __profcxx_map_to_unordered_map_insert(__x...)
279 #define __profcxx_map_to_unordered_map_erase(__x...)
280 #define __profcxx_map_to_unordered_map_iterate(__x...)
281 #define __profcxx_map_to_unordered_map_invalidate(__x...)
282 #define __profcxx_map_to_unordered_map_find(__x...)
283 #endif
284
285 // Run multithreaded unless instructed not to do so.
286 #ifndef _GLIBCXX_PROFILE_NOTHREADS
287 #define _GLIBCXX_PROFILE_THREADS
288 #endif
289
290 // Set default values for compile-time customizable variables.
291 #ifndef _GLIBCXX_PROFILE_TRACE_PATH_ROOT
292 #define _GLIBCXX_PROFILE_TRACE_PATH_ROOT "libstdcxx-profile"
293 #endif
294 #ifndef _GLIBCXX_PROFILE_TRACE_ENV_VAR
295 #define _GLIBCXX_PROFILE_TRACE_ENV_VAR "GLIBCXX_PROFILE_TRACE_PATH_ROOT"
296 #endif
297 #ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR
298 #define _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR \
299   "GLIBCXX_PROFILE_MAX_WARN_COUNT"
300 #endif
301 #ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT
302 #define _GLIBCXX_PROFILE_MAX_WARN_COUNT 10
303 #endif
304 #ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH
305 #define _GLIBCXX_PROFILE_MAX_STACK_DEPTH 32
306 #endif
307 #ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR
308 #define _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR \
309   "GLIBCXX_PROFILE_MAX_STACK_DEPTH"
310 #endif
311 #ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC
312 #define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC 2 << 27
313 #endif
314 #ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR
315 #define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR \
316   "GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC"
317 #endif
318
319 // Instrumentation hook implementations.
320 #include "profile/impl/profiler_hash_func.h"
321 #include "profile/impl/profiler_hashtable_size.h"
322 #include "profile/impl/profiler_map_to_unordered_map.h"
323 #include "profile/impl/profiler_vector_size.h"
324 #include "profile/impl/profiler_vector_to_list.h"
325
326 #endif // PROFCXX_PROFILER_H__