base/metrics/sparse_histogram.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/metrics/sparse_histogram.h"
   6
   7 #include "base/metrics/sample_map.h"
   8 #include "base/metrics/statistics_recorder.h"
   9 #include "base/pickle.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/synchronization/lock.h"
  12
  13 using std::map;
  14 using std::string;
  15
  16 namespace base {
  17
  18 typedef HistogramBase::Count Count;
  19 typedef HistogramBase::Sample Sample;
  20
  21 // static
  22 HistogramBase* SparseHistogram::FactoryGet(const string& name, int32 flags) {
  23   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
  24
  25   if (!histogram) {
  26     // To avoid racy destruction at shutdown, the following will be leaked.
  27     HistogramBase* tentative_histogram = new SparseHistogram(name);
  28     tentative_histogram->SetFlags(flags);
  29     histogram =
  30         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
  31   }
  32   DCHECK_EQ(SPARSE_HISTOGRAM, histogram->GetHistogramType());
  33   return histogram;
  34 }
  35
  36 SparseHistogram::~SparseHistogram() {}
  37
  38 HistogramType SparseHistogram::GetHistogramType() const {
  39   return SPARSE_HISTOGRAM;
  40 }
  41
  42 bool SparseHistogram::HasConstructionArguments(
  43     Sample expected_minimum,
  44     Sample expected_maximum,
  45     size_t expected_bucket_count) const {
  46   // SparseHistogram never has min/max/bucket_count limit.
  47   return false;
  48 }
  49
  50 void SparseHistogram::Add(Sample value) {
  51   base::AutoLock auto_lock(lock_);
  52   samples_.Accumulate(value, 1);
  53 }
  54
  55 scoped_ptr<HistogramSamples> SparseHistogram::SnapshotSamples() const {
  56   scoped_ptr<SampleMap> snapshot(new SampleMap());
  57
  58   base::AutoLock auto_lock(lock_);
  59   snapshot->Add(samples_);
  60   return snapshot.PassAs<HistogramSamples>();
  61 }
  62
  63 void SparseHistogram::AddSamples(const HistogramSamples& samples) {
  64   base::AutoLock auto_lock(lock_);
  65   samples_.Add(samples);
  66 }
  67
  68 bool SparseHistogram::AddSamplesFromPickle(PickleIterator* iter) {
  69   base::AutoLock auto_lock(lock_);
  70   return samples_.AddFromPickle(iter);
  71 }
  72
  73 void SparseHistogram::WriteHTMLGraph(string* output) const {
  74   output->append("<PRE>");
  75   WriteAsciiImpl(true, "<br>", output);
  76   output->append("</PRE>");
  77 }
  78
  79 void SparseHistogram::WriteAscii(string* output) const {
  80   WriteAsciiImpl(true, "\n", output);
  81 }
  82
  83 bool SparseHistogram::SerializeInfoImpl(Pickle* pickle) const {
  84   return pickle->WriteString(histogram_name()) && pickle->WriteInt(flags());
  85 }
  86
  87 SparseHistogram::SparseHistogram(const string& name)
  88     : HistogramBase(name) {}
  89
  90 HistogramBase* SparseHistogram::DeserializeInfoImpl(PickleIterator* iter) {
  91   string histogram_name;
  92   int flags;
  93   if (!iter->ReadString(&histogram_name) || !iter->ReadInt(&flags)) {
  94     DLOG(ERROR) << "Pickle error decoding Histogram: " << histogram_name;
  95     return NULL;
  96   }
  97
  98   DCHECK(flags & HistogramBase::kIPCSerializationSourceFlag);
  99   flags &= ~HistogramBase::kIPCSerializationSourceFlag;
 100
 101   return SparseHistogram::FactoryGet(histogram_name, flags);
 102 }
 103
 104 void SparseHistogram::GetParameters(DictionaryValue* params) const {
 105   // TODO(kaiwang): Implement. (See HistogramBase::WriteJSON.)
 106 }
 107
 108 void SparseHistogram::GetCountAndBucketData(Count* count,
 109                                             int64* sum,
 110                                             ListValue* buckets) const {
 111   // TODO(kaiwang): Implement. (See HistogramBase::WriteJSON.)
 112 }
 113
 114 void SparseHistogram::WriteAsciiImpl(bool graph_it,
 115                                      const std::string& newline,
 116                                      std::string* output) const {
 117   // Get a local copy of the data so we are consistent.
 118   scoped_ptr<HistogramSamples> snapshot = SnapshotSamples();
 119   Count total_count = snapshot->TotalCount();
 120   double scaled_total_count = total_count / 100.0;
 121
 122   WriteAsciiHeader(total_count, output);
 123   output->append(newline);
 124
 125   // Determine how wide the largest bucket range is (how many digits to print),
 126   // so that we'll be able to right-align starts for the graphical bars.
 127   // Determine which bucket has the largest sample count so that we can
 128   // normalize the graphical bar-width relative to that sample count.
 129   Count largest_count = 0;
 130   Sample largest_sample = 0;
 131   scoped_ptr<SampleCountIterator> it = snapshot->Iterator();
 132   while (!it->Done())
 133   {
 134     Sample min;
 135     Sample max;
 136     Count count;
 137     it->Get(&min, &max, &count);
 138     if (min > largest_sample)
 139       largest_sample = min;
 140     if (count > largest_count)
 141       largest_count = count;
 142     it->Next();
 143   }
 144   size_t print_width = GetSimpleAsciiBucketRange(largest_sample).size() + 1;
 145
 146   // iterate over each item and display them
 147   it = snapshot->Iterator();
 148   while (!it->Done())
 149   {
 150     Sample min;
 151     Sample max;
 152     Count count;
 153     it->Get(&min, &max, &count);
 154
 155     // value is min, so display it
 156     string range = GetSimpleAsciiBucketRange(min);
 157     output->append(range);
 158     for (size_t j = 0; range.size() + j < print_width + 1; ++j)
 159       output->push_back(' ');
 160
 161     if (graph_it)
 162       WriteAsciiBucketGraph(count, largest_count, output);
 163     WriteAsciiBucketValue(count, scaled_total_count, output);
 164     output->append(newline);
 165     it->Next();
 166   }
 167 }
 168
 169 void SparseHistogram::WriteAsciiHeader(const Count total_count,
 170                                        std::string* output) const {
 171   StringAppendF(output,
 172                 "Histogram: %s recorded %d samples",
 173                 histogram_name().c_str(),
 174                 total_count);
 175   if (flags() & ~kHexRangePrintingFlag)
 176     StringAppendF(output, " (flags = 0x%x)", flags() & ~kHexRangePrintingFlag);
 177 }
 178
 179 }  // namespace base