contrib/llvm/tools/lldb/source/Core/Timer.cpp

   1 //===-- Timer.cpp -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 #include "lldb/Core/Timer.h"
  10
  11 #include <map>
  12 #include <vector>
  13 #include <algorithm>
  14
  15 #include "lldb/Core/Stream.h"
  16 #include "lldb/Host/Mutex.h"
  17
  18 #include <stdio.h>
  19
  20 using namespace lldb_private;
  21
  22 #define TIMER_INDENT_AMOUNT 2
  23 static bool g_quiet = true;
  24 uint32_t Timer::g_depth = 0;
  25 uint32_t Timer::g_display_depth = 0;
  26 FILE * Timer::g_file = NULL;
  27 typedef std::vector<Timer *> TimerStack;
  28 typedef std::map<const char *, uint64_t> TimerCategoryMap;
  29 static pthread_key_t g_key;
  30
  31 static Mutex &
  32 GetCategoryMutex()
  33 {
  34     static Mutex g_category_mutex(Mutex::eMutexTypeNormal);
  35     return g_category_mutex;
  36 }
  37
  38 static TimerCategoryMap &
  39 GetCategoryMap()
  40 {
  41     static TimerCategoryMap g_category_map;
  42     return g_category_map;
  43 }
  44
  45
  46 static TimerStack *
  47 GetTimerStackForCurrentThread ()
  48 {
  49     void *timer_stack = ::pthread_getspecific (g_key);
  50     if (timer_stack == NULL)
  51     {
  52         ::pthread_setspecific (g_key, new TimerStack);
  53         timer_stack = ::pthread_getspecific (g_key);
  54     }
  55     return (TimerStack *)timer_stack;
  56 }
  57
  58 void
  59 ThreadSpecificCleanup (void *p)
  60 {
  61     delete (TimerStack *)p;
  62 }
  63
  64 void
  65 Timer::SetQuiet (bool value)
  66 {
  67     g_quiet = value;
  68 }
  69
  70 void
  71 Timer::Initialize ()
  72 {
  73     Timer::g_file = stdout;
  74     ::pthread_key_create (&g_key, ThreadSpecificCleanup);
  75
  76 }
  77
  78 Timer::Timer (const char *category, const char *format, ...) :
  79     m_category (category),
  80     m_total_start (),
  81     m_timer_start (),
  82     m_total_ticks (0),
  83     m_timer_ticks (0)
  84 {
  85     if (g_depth++ < g_display_depth)
  86     {
  87         if (g_quiet == false)
  88         {
  89             // Indent
  90             ::fprintf (g_file, "%*s", g_depth * TIMER_INDENT_AMOUNT, "");
  91             // Print formatted string
  92             va_list args;
  93             va_start (args, format);
  94             ::vfprintf (g_file, format, args);
  95             va_end (args);
  96
  97             // Newline
  98             ::fprintf (g_file, "\n");
  99         }
 100         TimeValue start_time(TimeValue::Now());
 101         m_total_start = start_time;
 102         m_timer_start = start_time;
 103         TimerStack *stack = GetTimerStackForCurrentThread ();
 104         if (stack)
 105         {
 106             if (stack->empty() == false)
 107                 stack->back()->ChildStarted (start_time);
 108             stack->push_back(this);
 109         }
 110     }
 111 }
 112
 113
 114 Timer::~Timer()
 115 {
 116     if (m_total_start.IsValid())
 117     {
 118         TimeValue stop_time = TimeValue::Now();
 119         if (m_total_start.IsValid())
 120         {
 121             m_total_ticks += (stop_time - m_total_start);
 122             m_total_start.Clear();
 123         }
 124         if (m_timer_start.IsValid())
 125         {
 126             m_timer_ticks += (stop_time - m_timer_start);
 127             m_timer_start.Clear();
 128         }
 129
 130         TimerStack *stack = GetTimerStackForCurrentThread ();
 131         if (stack)
 132         {
 133             assert (stack->back() == this);
 134             stack->pop_back();
 135             if (stack->empty() == false)
 136                 stack->back()->ChildStopped(stop_time);
 137         }
 138
 139         const uint64_t total_nsec_uint = GetTotalElapsedNanoSeconds();
 140         const uint64_t timer_nsec_uint = GetTimerElapsedNanoSeconds();
 141         const double total_nsec = total_nsec_uint;
 142         const double timer_nsec = timer_nsec_uint;
 143
 144         if (g_quiet == false)
 145         {
 146
 147             ::fprintf (g_file,
 148                        "%*s%.9f sec (%.9f sec)\n",
 149                        (g_depth - 1) *TIMER_INDENT_AMOUNT, "",
 150                        total_nsec / 1000000000.0,
 151                        timer_nsec / 1000000000.0);
 152         }
 153
 154         // Keep total results for each category so we can dump results.
 155         Mutex::Locker locker (GetCategoryMutex());
 156         TimerCategoryMap &category_map = GetCategoryMap();
 157         category_map[m_category] += timer_nsec_uint;
 158     }
 159     if (g_depth > 0)
 160         --g_depth;
 161 }
 162
 163 uint64_t
 164 Timer::GetTotalElapsedNanoSeconds()
 165 {
 166     uint64_t total_ticks = m_total_ticks;
 167
 168     // If we are currently running, we need to add the current
 169     // elapsed time of the running timer...
 170     if (m_total_start.IsValid())
 171         total_ticks += (TimeValue::Now() - m_total_start);
 172
 173     return total_ticks;
 174 }
 175
 176 uint64_t
 177 Timer::GetTimerElapsedNanoSeconds()
 178 {
 179     uint64_t timer_ticks = m_timer_ticks;
 180
 181     // If we are currently running, we need to add the current
 182     // elapsed time of the running timer...
 183     if (m_timer_start.IsValid())
 184         timer_ticks += (TimeValue::Now() - m_timer_start);
 185
 186     return timer_ticks;
 187 }
 188
 189 void
 190 Timer::ChildStarted (const TimeValue& start_time)
 191 {
 192     if (m_timer_start.IsValid())
 193     {
 194         m_timer_ticks += (start_time - m_timer_start);
 195         m_timer_start.Clear();
 196     }
 197 }
 198
 199 void
 200 Timer::ChildStopped (const TimeValue& stop_time)
 201 {
 202     if (!m_timer_start.IsValid())
 203         m_timer_start = stop_time;
 204 }
 205
 206 void
 207 Timer::SetDisplayDepth (uint32_t depth)
 208 {
 209     g_display_depth = depth;
 210 }
 211
 212
 213 /* binary function predicate:
 214  * - returns whether a person is less than another person
 215  */
 216 static bool
 217 CategoryMapIteratorSortCriterion (const TimerCategoryMap::const_iterator& lhs, const TimerCategoryMap::const_iterator& rhs)
 218 {
 219     return lhs->second > rhs->second;
 220 }
 221
 222
 223 void
 224 Timer::ResetCategoryTimes ()
 225 {
 226     Mutex::Locker locker (GetCategoryMutex());
 227     TimerCategoryMap &category_map = GetCategoryMap();
 228     category_map.clear();
 229 }
 230
 231 void
 232 Timer::DumpCategoryTimes (Stream *s)
 233 {
 234     Mutex::Locker locker (GetCategoryMutex());
 235     TimerCategoryMap &category_map = GetCategoryMap();
 236     std::vector<TimerCategoryMap::const_iterator> sorted_iterators;
 237     TimerCategoryMap::const_iterator pos, end = category_map.end();
 238     for (pos = category_map.begin(); pos != end; ++pos)
 239     {
 240         sorted_iterators.push_back (pos);
 241     }
 242     std::sort (sorted_iterators.begin(), sorted_iterators.end(), CategoryMapIteratorSortCriterion);
 243
 244     const size_t count = sorted_iterators.size();
 245     for (size_t i=0; i<count; ++i)
 246     {
 247         const double timer_nsec = sorted_iterators[i]->second;
 248         s->Printf("%.9f sec for %s\n", timer_nsec / 1000000000.0, sorted_iterators[i]->first);
 249     }
 250 }