Merge multiple histogram snapshots into single one for reporting.

base/metrics/histogram.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Histogram is an object that aggregates statistics, and can summarize them in
 // various forms, including ASCII graphical, HTML, and numerically (as a
 // vector of numbers corresponding to each of the aggregating buckets).
 // See header file for details and examples.
 
 #include "base/metrics/histogram.h"
@@ skipping 254 matching lines @@
                                          int32_t flags) {
   return FactoryTimeGet(std::string(name), minimum, maximum, bucket_count,
                         flags);
 }
 
 HistogramBase* Histogram::PersistentGet(const std::string& name,
                                         Sample minimum,
                                         Sample maximum,
                                         const BucketRanges* ranges,
                                         HistogramBase::AtomicCount* counts,
+                                        HistogramBase::AtomicCount* logged,
                                         uint32_t counts_size,
                                         HistogramSamples::Metadata* meta) {
-  return new Histogram(name, minimum, maximum, ranges, counts, counts_size,
-                       meta);
+  return new Histogram(name, minimum, maximum, ranges, counts, logged,
+                       counts_size, meta);
 }
 
 // Calculate what range of values are held in each bucket.
 // We have to be careful that we don't pick a ratio between starting points in
 // consecutive buckets that is sooo small, that the integer bounds are the same
 // (effectively making one bucket get no values).  We need to avoid:
 //   ranges(i) == ranges(i + 1)
 // To avoid that, we just do a fine-grained bucket width as far as we need to
 // until we get a ratio that moves us along at least 2 units at a time.  From
 // that bucket onward we do use the exponential growth of buckets.
@@ skipping 134 matching lines @@
   }
   samples_->Accumulate(value, count);
 
   FindAndRunCallback(value);
 }
 
 scoped_ptr<HistogramSamples> Histogram::SnapshotSamples() const {
   return SnapshotSampleVector();
 }
 
+scoped_ptr<HistogramSamples> Histogram::SnapshotDelta() {
+  scoped_ptr<HistogramSamples> snapshot = SnapshotSampleVector();
+  if (!logged_) {
+    // If nothing has been previously logged, save this one as logged and

[Alexei Svitkine (slow), 2016/02/09 19:46:51]

Nit: save this one as |logged_counts_| and

[bcwhite, 2016/02/11 16:42:38]

Done.

+    // gather another snapshot to return.
+    logged_.swap(snapshot);
+    return SnapshotSampleVector();
+  }
+
+  // Subtract what was previously logged and update that information.
+  snapshot->Subtract(*logged_);
+  logged_->Add(*snapshot);
+  return snapshot;
+}
+
 void Histogram::AddSamples(const HistogramSamples& samples) {
   samples_->Add(samples);
 }
 
 bool Histogram::AddSamplesFromPickle(PickleIterator* iter) {
   return samples_->AddFromPickle(iter);
 }
 
 // The following methods provide a graphical histogram display.
 void Histogram::WriteHTMLGraph(std::string* output) const {
@@ skipping 27 matching lines @@
     declared_max_(maximum) {
   if (ranges)
     samples_.reset(new SampleVector(HashMetricName(name), ranges));
 }
 
 Histogram::Histogram(const std::string& name,
                      Sample minimum,
                      Sample maximum,
                      const BucketRanges* ranges,
                      HistogramBase::AtomicCount* counts,
+                     HistogramBase::AtomicCount* logged,
                      uint32_t counts_size,
                      HistogramSamples::Metadata* meta)
   : HistogramBase(name),
     bucket_ranges_(ranges),
     declared_min_(minimum),
     declared_max_(maximum) {
   if (ranges) {
     samples_.reset(new SampleVector(HashMetricName(name),
                                     counts, counts_size, meta, ranges));
+    logged_.reset(new SampleVector(samples_->id(),
+                                   logged, counts_size, meta, ranges));
   }
 }
 
 Histogram::~Histogram() {
 }
 
 bool Histogram::PrintEmptyBucket(uint32_t index) const {
   return true;
 }
 
@@ skipping 270 matching lines @@
   return FactoryTimeGet(std::string(name),  minimum, maximum, bucket_count,
                         flags);
 }
 
 HistogramBase* LinearHistogram::PersistentGet(
     const std::string& name,
     Sample minimum,
     Sample maximum,
     const BucketRanges* ranges,
     HistogramBase::AtomicCount* counts,
+    HistogramBase::AtomicCount* logged,
     uint32_t counts_size,
     HistogramSamples::Metadata* meta) {
-  return new LinearHistogram(name, minimum, maximum, ranges, counts,
+  return new LinearHistogram(name, minimum, maximum, ranges, counts, logged,
                              counts_size, meta);
 }
 
 HistogramBase* LinearHistogram::FactoryGetWithRangeDescription(
     const std::string& name,
     Sample minimum,
     Sample maximum,
     uint32_t bucket_count,
     int32_t flags,
     const DescriptionPair descriptions[]) {
@@ skipping 14 matching lines @@
                                  Sample maximum,
                                  const BucketRanges* ranges)
     : Histogram(name, minimum, maximum, ranges) {
 }
 
 LinearHistogram::LinearHistogram(const std::string& name,
                                  Sample minimum,
                                  Sample maximum,
                                  const BucketRanges* ranges,
                                  HistogramBase::AtomicCount* counts,
+                                 HistogramBase::AtomicCount* logged,
                                  uint32_t counts_size,
                                  HistogramSamples::Metadata* meta)
     : Histogram(name,
                 minimum,
                 maximum,
                 ranges,
                 counts,
+                logged,
                 counts_size,
                 meta) {}
 
 double LinearHistogram::GetBucketSize(Count current, uint32_t i) const {
   DCHECK_GT(ranges(i + 1), ranges(i));
   // Adjacent buckets with different widths would have "surprisingly" many (few)
   // samples in a histogram if we didn't normalize this way.
   double denominator = ranges(i + 1) - ranges(i);
   return current/denominator;
 }
@@ skipping 79 matching lines @@
 }
 
 HistogramBase* BooleanHistogram::FactoryGet(const char* name, int32_t flags) {
   return FactoryGet(std::string(name), flags);
 }
 
 HistogramBase* BooleanHistogram::PersistentGet(
     const std::string& name,
     const BucketRanges* ranges,
     HistogramBase::AtomicCount* counts,
+    HistogramBase::AtomicCount* logged,
     HistogramSamples::Metadata* meta) {
-  return new BooleanHistogram(name, ranges, counts, meta);
+  return new BooleanHistogram(name, ranges, counts, logged, meta);
 }
 
 HistogramType BooleanHistogram::GetHistogramType() const {
   return BOOLEAN_HISTOGRAM;
 }
 
 BooleanHistogram::BooleanHistogram(const std::string& name,
                                    const BucketRanges* ranges)
     : LinearHistogram(name, 1, 2, ranges) {}
 
 BooleanHistogram::BooleanHistogram(const std::string& name,
                                    const BucketRanges* ranges,
                                    HistogramBase::AtomicCount* counts,
+                                   HistogramBase::AtomicCount* logged,
                                    HistogramSamples::Metadata* meta)
-    : LinearHistogram(name, 1, 2, ranges, counts, 2, meta) {}
+    : LinearHistogram(name, 1, 2, ranges, counts, logged, 2, meta) {}
 
 HistogramBase* BooleanHistogram::DeserializeInfoImpl(PickleIterator* iter) {
   std::string histogram_name;
   int flags;
   int declared_min;
   int declared_max;
   uint32_t bucket_count;
   uint32_t range_checksum;
 
   if (!ReadHistogramArguments(iter, &histogram_name, &flags, &declared_min,
@@ skipping 63 matching lines @@
     const char* name,
     const std::vector<Sample>& custom_ranges,
     int32_t flags) {
   return FactoryGet(std::string(name), custom_ranges, flags);
 }
 
 HistogramBase* CustomHistogram::PersistentGet(
     const std::string& name,
     const BucketRanges* ranges,
     HistogramBase::AtomicCount* counts,
+    HistogramBase::AtomicCount* logged,
     uint32_t counts_size,
     HistogramSamples::Metadata* meta) {
-  return new CustomHistogram(name, ranges, counts, counts_size, meta);
+  return new CustomHistogram(name, ranges, counts, logged, counts_size, meta);
 }
 
 HistogramType CustomHistogram::GetHistogramType() const {
   return CUSTOM_HISTOGRAM;
 }
 
 // static
 std::vector<Sample> CustomHistogram::ArrayToCustomRanges(
     const Sample* values, uint32_t num_values) {
   std::vector<Sample> all_values;
@@ skipping 11 matching lines @@
 CustomHistogram::CustomHistogram(const std::string& name,
                                  const BucketRanges* ranges)
     : Histogram(name,
                 ranges->range(1),
                 ranges->range(ranges->bucket_count() - 1),
                 ranges) {}
 
 CustomHistogram::CustomHistogram(const std::string& name,
                                  const BucketRanges* ranges,
                                  HistogramBase::AtomicCount* counts,
+                                 HistogramBase::AtomicCount* logged,
                                  uint32_t counts_size,
                                  HistogramSamples::Metadata* meta)
     : Histogram(name,
                 ranges->range(1),
                 ranges->range(ranges->bucket_count() - 1),
                 ranges,
                 counts,
+                logged,
                 counts_size,
                 meta) {}
 
 bool CustomHistogram::SerializeInfoImpl(Pickle* pickle) const {
   if (!Histogram::SerializeInfoImpl(pickle))
     return false;
 
   // Serialize ranges. First and last ranges are alwasy 0 and INT_MAX, so don't
   // write them.
   for (uint32_t i = 1; i < bucket_ranges()->bucket_count(); ++i) {
@@ skipping 46 matching lines @@
     Sample sample = custom_ranges[i];
     if (sample < 0 || sample > HistogramBase::kSampleType_MAX - 1)
       return false;
     if (sample != 0)
       has_valid_range = true;
   }
   return has_valid_range;
 }
 
 }  // namespace base