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 249 matching lines @@
 
 HistogramBase* Histogram::FactoryTimeGet(const char* name,
                                          TimeDelta minimum,
                                          TimeDelta maximum,
                                          uint32_t bucket_count,
                                          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,
-                                        uint32_t counts_size,
-                                        HistogramSamples::Metadata* meta) {
-  return new Histogram(name, minimum, maximum, ranges, counts, counts_size,
-                       meta);
+HistogramBase* Histogram::PersistentGet(
+    const std::string& name,
+    Sample minimum,
+    Sample maximum,
+    const BucketRanges* ranges,
+    HistogramBase::AtomicCount* counts,
+    HistogramBase::AtomicCount* logged_counts,
+    uint32_t counts_size,
+    HistogramSamples::Metadata* meta,
+    HistogramSamples::Metadata* logged_meta) {
+  return new Histogram(name, minimum, maximum, ranges, counts, logged_counts,
+                       counts_size, meta, logged_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 24 matching lines @@
       ++current;  // Just do a narrow bucket, and keep trying.
     ranges->set_range(bucket_index, current);
   }
   ranges->set_range(ranges->bucket_count(), HistogramBase::kSampleType_MAX);
   ranges->ResetChecksum();
 }
 
 // static
 const int Histogram::kCommonRaceBasedCountMismatch = 5;
 
-int Histogram::FindCorruption(const HistogramSamples& samples) const {
+uint32_t Histogram::FindCorruption(const HistogramSamples& samples) const {
   int inconsistencies = NO_INCONSISTENCIES;
   Sample previous_range = -1;  // Bottom range is always 0.
   for (uint32_t index = 0; index < bucket_count(); ++index) {
     int new_range = ranges(index);
     if (previous_range >= new_range)
       inconsistencies |= BUCKET_ORDER_ERROR;
     previous_range = new_range;
   }
 
   if (!bucket_ranges()->HasValidChecksum())
@@ skipping 89 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_samples_) {
+    // If nothing has been previously logged, save this one as
+    // |logged_samples_| and gather another snapshot to return.
+    logged_samples_.swap(snapshot);
+    return SnapshotSampleVector();
+  }
+
+  // Subtract what was previously logged and update that information.
+  snapshot->Subtract(*logged_samples_);
+  logged_samples_->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_counts,
                      uint32_t counts_size,
-                     HistogramSamples::Metadata* meta)
+                     HistogramSamples::Metadata* meta,
+                     HistogramSamples::Metadata* logged_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_samples_.reset(new SampleVector(samples_->id(), logged_counts,
+                                           counts_size, logged_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_counts,
     uint32_t counts_size,
-    HistogramSamples::Metadata* meta) {
+    HistogramSamples::Metadata* meta,
+    HistogramSamples::Metadata* logged_meta) {
   return new LinearHistogram(name, minimum, maximum, ranges, counts,
-                             counts_size, meta);
+                             logged_counts, counts_size, meta, logged_meta);
 }
 
 HistogramBase* LinearHistogram::FactoryGetWithRangeDescription(
     const std::string& name,
     Sample minimum,
     Sample maximum,
     uint32_t bucket_count,
     int32_t flags,
     const DescriptionPair descriptions[]) {
   bool valid_arguments = Histogram::InspectConstructionArguments(
@@ skipping 13 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_counts,
                                  uint32_t counts_size,
-                                 HistogramSamples::Metadata* meta)
-    : Histogram(name,
-                minimum,
-                maximum,
-                ranges,
-                counts,
-                counts_size,
-                meta) {}
+                                 HistogramSamples::Metadata* meta,
+                                 HistogramSamples::Metadata* logged_meta)
+    : Histogram(name, minimum, maximum, ranges, counts, logged_counts,
+                counts_size, meta, logged_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;
 }
 
 const std::string LinearHistogram::GetAsciiBucketRange(uint32_t i) const {
@@ skipping 77 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,
-    HistogramSamples::Metadata* meta) {
-  return new BooleanHistogram(name, ranges, counts, meta);
+    HistogramBase::AtomicCount* logged_counts,
+    HistogramSamples::Metadata* meta,
+    HistogramSamples::Metadata* logged_meta) {
+  return new BooleanHistogram(name, ranges, counts, logged_counts, meta,
+                              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,
-                                   HistogramSamples::Metadata* meta)
-    : LinearHistogram(name, 1, 2, ranges, counts, 2, meta) {}
+                                   HistogramBase::AtomicCount* logged_counts,
+                                   HistogramSamples::Metadata* meta,
+                                   HistogramSamples::Metadata* logged_meta)
+    : LinearHistogram(name, 1, 2, ranges, counts, logged_counts, 2, meta,
+                      logged_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_counts,
     uint32_t counts_size,
-    HistogramSamples::Metadata* meta) {
-  return new CustomHistogram(name, ranges, counts, counts_size, meta);
+    HistogramSamples::Metadata* meta,
+    HistogramSamples::Metadata* logged_meta) {
+  return new CustomHistogram(name, ranges, counts, logged_counts, counts_size,
+                             meta, logged_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_counts,
                                  uint32_t counts_size,
-                                 HistogramSamples::Metadata* meta)
+                                 HistogramSamples::Metadata* meta,
+                                 HistogramSamples::Metadata* logged_meta)
     : Histogram(name,
                 ranges->range(1),
                 ranges->range(ranges->bucket_count() - 1),
                 ranges,
                 counts,
+                logged_counts,
                 counts_size,
-                meta) {}
+                meta,
+                logged_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) {
     if (!pickle->WriteInt(bucket_ranges()->range(i)))
       return false;
@@ skipping 44 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