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::__gnu_profile
  48  * @brief Implementation of profile extension.
  49  */
  50 namespace __gnu_profile
  51 {
  52   /** @brief Reentrance guard.
  53    *
  54    * Mechanism to protect all __gnu_profile operations against recursion,
  55    * multithreaded and exception reentrance.
  56    */
  57   struct __reentrance_guard
  58   {
  59     static bool
  60     _S_set_in()
  61     {
  62       if (_S_get_in())
  63         return false;
  64       else
  65         {
  66           _S_get_in() = true;
  67           return true;
  68         }
  69     }
  70
  71     static bool&
  72     _S_get_in()
  73     {
  74       static __thread bool _S_inside(false);
  75       return _S_inside;
  76     }
  77
  78     __reentrance_guard() { }
  79     ~__reentrance_guard() { _S_get_in() = false; }
  80   };
  81
  82 #define _GLIBCXX_PROFILE_REENTRANCE_GUARD(__x...)               \
  83   {                                                             \
  84     if (__gnu_profile::__reentrance_guard::_S_get_in())         \
  85     {                                                           \
  86       __gnu_profile::__reentrance_guard __get_out;              \
  87       __x;                                                      \
  88     }                                                           \
  89   }
  90
  91
  92   // Forward declarations of implementation functions.
  93   // Don't use any __gnu_profile:: in user code.
  94   // Instead, use the __profcxx... macros, which offer guarded access.
  95   void __turn_on();
  96   void __turn_off();
  97   bool __is_invalid();
  98   bool __is_on();
  99   bool __is_off();
 100   void __report(void);
 101   void __trace_hashtable_size_resize(const void*, size_t, size_t);
 102   void __trace_hashtable_size_destruct(const void*, size_t, size_t);
 103   void __trace_hashtable_size_construct(const void*, size_t);
 104   void __trace_vector_size_resize(const void*, size_t, size_t);
 105   void __trace_vector_size_destruct(const void*, size_t, size_t);
 106   void __trace_vector_size_construct(const void*, size_t);
 107   void __trace_hash_func_destruct(const void*, size_t, size_t, size_t);
 108   void __trace_hash_func_construct(const void*);
 109   void __trace_vector_to_list_destruct(const void*);
 110   void __trace_vector_to_list_construct(const void*);
 111   void __trace_vector_to_list_insert(const void*, size_t, size_t);
 112   void __trace_vector_to_list_iterate(const void*, size_t);
 113   void __trace_vector_to_list_invalid_operator(const void*);
 114   void __trace_vector_to_list_resize(const void*, size_t, size_t);
 115   void __trace_map_to_unordered_map_construct(const void*);
 116   void __trace_map_to_unordered_map_invalidate(const void*);
 117   void __trace_map_to_unordered_map_insert(const void*, size_t, size_t);
 118   void __trace_map_to_unordered_map_erase(const void*, size_t, size_t);
 119   void __trace_map_to_unordered_map_iterate(const void*, size_t);
 120   void __trace_map_to_unordered_map_find(const void*, size_t);
 121   void __trace_map_to_unordered_map_destruct(const void*);
 122 } // namespace __gnu_profile
 123
 124 // Master switch turns on all diagnostics.
 125 #ifdef _GLIBCXX_PROFILE
 126 #define _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL
 127 #define _GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE
 128 #define _GLIBCXX_PROFILE_VECTOR_TOO_SMALL
 129 #define _GLIBCXX_PROFILE_VECTOR_TOO_LARGE
 130 #define _GLIBCXX_PROFILE_INEFFICIENT_HASH
 131 #define _GLIBCXX_PROFILE_VECTOR_TO_LIST
 132 #define _GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP
 133 #endif
 134
 135 // Expose global management routines to user code.
 136 #ifdef _GLIBCXX_PROFILE
 137 #define __profcxx_report() \
 138   _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__report())
 139 #define __profcxx_turn_on() \
 140   _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__turn_on())
 141 #define __profcxx_turn_off() \
 142   _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__turn_off())
 143 #define __profcxx_is_invalid() \
 144   _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_invalid())
 145 #define __profcxx_is_on() \
 146   _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_on())
 147 #define __profcxx__is_off() \
 148   _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_off())
 149 #else
 150 #define __profcxx_report()
 151 #define __profcxx_turn_on()
 152 #define __profcxx_turn_off()
 153 #define __profcxx_is_invalid()
 154 #define __profcxx_is_on()
 155 #define __profcxx_is_off()
 156 #endif
 157
 158 // Turn on/off instrumentation for HASHTABLE_TOO_SMALL and HASHTABLE_TOO_LARGE.
 159 #if ((defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \
 160       && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL)) \
 161      || (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE) \
 162          && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE)))
 163 #define __profcxx_hashtable_resize(__x...) \
 164   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 165       __gnu_profile::__trace_hashtable_size_resize(__x))
 166 #define __profcxx_hashtable_destruct(__x...) \
 167   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 168       __gnu_profile::__trace_hashtable_size_destruct(__x))
 169 #define __profcxx_hashtable_construct(__x...) \
 170   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 171       __gnu_profile::__trace_hashtable_size_construct(__x))
 172 #else
 173 #define __profcxx_hashtable_resize(__x...)
 174 #define __profcxx_hashtable_destruct(__x...)
 175 #define __profcxx_hashtable_construct(__x...)
 176 #endif
 177
 178 // Turn on/off instrumentation for VECTOR_TOO_SMALL and VECTOR_TOO_LARGE.
 179 #if ((defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \
 180       && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_SMALL)) \
 181      || (defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE) \
 182          && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_LARGE)))
 183 #define __profcxx_vector_resize(__x...) \
 184   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 185       __gnu_profile::__trace_vector_size_resize(__x))
 186 #define __profcxx_vector_destruct(__x...) \
 187   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 188       __gnu_profile::__trace_vector_size_destruct(__x))
 189 #define __profcxx_vector_construct(__x...) \
 190   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 191       __gnu_profile::__trace_vector_size_construct(__x))
 192 #else
 193 #define __profcxx_vector_resize(__x...)
 194 #define __profcxx_vector_destruct(__x...)
 195 #define __profcxx_vector_construct(__x...)
 196 #endif
 197
 198 // Turn on/off instrumentation for INEFFICIENT_HASH.
 199 #if (defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH) \
 200      && !defined(_NO_GLIBCXX_PROFILE_INEFFICIENT_HASH))
 201 #define __profcxx_hashtable_construct2(__x...) \
 202   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 203       __gnu_profile::__trace_hash_func_construct(__x))
 204 #define __profcxx_hashtable_destruct2(__x...) \
 205   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 206       __gnu_profile::__trace_hash_func_destruct(__x))
 207 #else
 208 #define __profcxx_hashtable_destruct2(__x...)
 209 #define __profcxx_hashtable_construct2(__x...)
 210 #endif
 211
 212 // Turn on/off instrumentation for VECTOR_TO_LIST.
 213 #if (defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST) \
 214      && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TO_LIST))
 215 #define __profcxx_vector_construct2(__x...) \
 216   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 217       __gnu_profile::__trace_vector_to_list_construct(__x))
 218 #define __profcxx_vector_destruct2(__x...) \
 219   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 220       __gnu_profile::__trace_vector_to_list_destruct(__x))
 221 #define __profcxx_vector_insert(__x...) \
 222   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 223       __gnu_profile::__trace_vector_to_list_insert(__x))
 224 #define __profcxx_vector_iterate(__x...) \
 225   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 226       __gnu_profile::__trace_vector_to_list_iterate(__x))
 227 #define __profcxx_vector_invalid_operator(__x...) \
 228   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 229       __gnu_profile::__trace_vector_to_list_invalid_operator(__x))
 230 #define __profcxx_vector_resize2(__x...) \
 231   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 232       __gnu_profile::__trace_vector_to_list_resize(__x))
 233 #else
 234 #define __profcxx_vector_destruct2(__x...)
 235 #define __profcxx_vector_construct2(__x...)
 236 #define __profcxx_vector_insert(__x...)
 237 #define __profcxx_vector_iterate(__x...)
 238 #define __profcxx_vector_invalid_operator(__x...)
 239 #define __profcxx_vector_resize2(__x...)
 240 #endif
 241
 242 // Turn on/off instrumentation for MAP_TO_UNORDERED_MAP.
 243 #if (defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP) \
 244      && !defined(_NO_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP))
 245 #define __profcxx_map_to_unordered_map_construct(__x...) \
 246   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 247       __gnu_profile::__trace_map_to_unordered_map_construct(__x))
 248 #define __profcxx_map_to_unordered_map_destruct(__x...) \
 249   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 250       __gnu_profile::__trace_map_to_unordered_map_destruct(__x))
 251 #define __profcxx_map_to_unordered_map_insert(__x...) \
 252   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 253       __gnu_profile::__trace_map_to_unordered_map_insert(__x))
 254 #define __profcxx_map_to_unordered_map_erase(__x...) \
 255   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 256       __gnu_profile::__trace_map_to_unordered_map_erase(__x))
 257 #define __profcxx_map_to_unordered_map_iterate(__x...) \
 258   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 259       __gnu_profile::__trace_map_to_unordered_map_iterate(__x))
 260 #define __profcxx_map_to_unordered_map_invalidate(__x...) \
 261   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 262       __gnu_profile::__trace_map_to_unordered_map_invalidate(__x))
 263 #define __profcxx_map_to_unordered_map_find(__x...) \
 264   _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
 265       __gnu_profile::__trace_map_to_unordered_map_find(__x))
 266 #else
 267 #define __profcxx_map_to_unordered_map_construct(__x...) \
 268
 269 #define __profcxx_map_to_unordered_map_destruct(__x...)
 270 #define __profcxx_map_to_unordered_map_insert(__x...)
 271 #define __profcxx_map_to_unordered_map_erase(__x...)
 272 #define __profcxx_map_to_unordered_map_iterate(__x...)
 273 #define __profcxx_map_to_unordered_map_invalidate(__x...)
 274 #define __profcxx_map_to_unordered_map_find(__x...)
 275 #endif
 276
 277 // Run multithreaded unless instructed not to do so.
 278 #ifndef _GLIBCXX_PROFILE_NOTHREADS
 279 #define _GLIBCXX_PROFILE_THREADS
 280 #endif
 281
 282 // Set default values for compile-time customizable variables.
 283 #ifndef _GLIBCXX_PROFILE_TRACE_PATH_ROOT
 284 #define _GLIBCXX_PROFILE_TRACE_PATH_ROOT "libstdcxx-profile"
 285 #endif
 286 #ifndef _GLIBCXX_PROFILE_TRACE_ENV_VAR
 287 #define _GLIBCXX_PROFILE_TRACE_ENV_VAR "GLIBCXX_PROFILE_TRACE_PATH_ROOT"
 288 #endif
 289 #ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR
 290 #define _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR \
 291   "GLIBCXX_PROFILE_MAX_WARN_COUNT"
 292 #endif
 293 #ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT
 294 #define _GLIBCXX_PROFILE_MAX_WARN_COUNT 10
 295 #endif
 296 #ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH
 297 #define _GLIBCXX_PROFILE_MAX_STACK_DEPTH 32
 298 #endif
 299 #ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR
 300 #define _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR \
 301   "GLIBCXX_PROFILE_MAX_STACK_DEPTH"
 302 #endif
 303 #ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC
 304 #define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC 2 << 27
 305 #endif
 306 #ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR
 307 #define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR \
 308   "GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC"
 309 #endif
 310
 311 // Instrumentation hook implementations.
 312 #include "profile/impl/profiler_hash_func.h"
 313 #include "profile/impl/profiler_hashtable_size.h"
 314 #include "profile/impl/profiler_map_to_unordered_map.h"
 315 #include "profile/impl/profiler_vector_size.h"
 316 #include "profile/impl/profiler_vector_to_list.h"
 317
 318 #endif // PROFCXX_PROFILER_H__