src/metrics.cc

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "metrics.h"
  16
  17 #include <errno.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20
  21 #ifndef WIN32
  22 #include <sys/time.h>
  23 #else
  24 #include <windows.h>
  25 #endif
  26
  27 #include "util.h"
  28
  29 Metrics* g_metrics = NULL;
  30
  31 namespace {
  32
  33 #ifndef WIN32
  34 /// Compute a platform-specific high-res timer value that fits into an int64.
  35 int64_t HighResTimer() {
  36   timeval tv;
  37   if (gettimeofday(&tv, NULL) < 0)
  38     Fatal("gettimeofday: %s", strerror(errno));
  39   return (int64_t)tv.tv_sec * 1000*1000 + tv.tv_usec;
  40 }
  41
  42 /// Convert a delta of HighResTimer() values to microseconds.
  43 int64_t TimerToMicros(int64_t dt) {
  44   // No conversion necessary.
  45   return dt;
  46 }
  47 #else
  48 int64_t LargeIntegerToInt64(const LARGE_INTEGER& i) {
  49   return ((int64_t)i.HighPart) << 32 | i.LowPart;
  50 }
  51
  52 int64_t HighResTimer() {
  53   LARGE_INTEGER counter;
  54   if (!QueryPerformanceCounter(&counter))
  55     Fatal("QueryPerformanceCounter: %s", GetLastErrorString().c_str());
  56   return LargeIntegerToInt64(counter);
  57 }
  58
  59 int64_t TimerToMicros(int64_t dt) {
  60   static int64_t ticks_per_sec = 0;
  61   if (!ticks_per_sec) {
  62     LARGE_INTEGER freq;
  63     if (!QueryPerformanceFrequency(&freq))
  64       Fatal("QueryPerformanceFrequency: %s", GetLastErrorString().c_str());
  65     ticks_per_sec = LargeIntegerToInt64(freq);
  66   }
  67
  68   // dt is in ticks.  We want microseconds.
  69   return (dt * 1000000) / ticks_per_sec;
  70 }
  71 #endif
  72
  73 }  // anonymous namespace
  74
  75 ScopedMetric::ScopedMetric(Metric* metric) {
  76   metric_ = metric;
  77   if (!metric_)
  78     return;
  79   start_ = HighResTimer();
  80 }
  81 ScopedMetric::~ScopedMetric() {
  82   if (!metric_)
  83     return;
  84   metric_->count++;
  85   int64_t dt = TimerToMicros(HighResTimer() - start_);
  86   metric_->sum += dt;
  87 }
  88
  89 Metric* Metrics::NewMetric(const string& name) {
  90   Metric* metric = new Metric;
  91   metric->name = name;
  92   metric->count = 0;
  93   metric->sum = 0;
  94   metrics_.push_back(metric);
  95   return metric;
  96 }
  97
  98 void Metrics::Report() {
  99   int width = 0;
 100   for (vector<Metric*>::iterator i = metrics_.begin();
 101        i != metrics_.end(); ++i) {
 102     width = max((int)(*i)->name.size(), width);
 103   }
 104
 105   printf("%-*s\t%-6s\t%9s\t%s\n", width,
 106          "metric", "count", "total (ms)" , "avg (us)");
 107   for (vector<Metric*>::iterator i = metrics_.begin();
 108        i != metrics_.end(); ++i) {
 109     Metric* metric = *i;
 110     double total = metric->sum / (double)1000;
 111     double avg = metric->sum / (double)metric->count;
 112     printf("%-*s\t%-6d\t%-8.1f\t%.1f\n", width, metric->name.c_str(),
 113            metric->count, total, avg);
 114   }
 115 }