Skeleton code of SparseHistogram

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 115 matching lines @@
     count += i;
   }
   DCHECK_EQ(count, redundant_count_);
   return count == redundant_count_;
 }
 
 Histogram* Histogram::FactoryGet(const string& name,
                                  Sample minimum,
                                  Sample maximum,
                                  size_t bucket_count,
-                                 Flags flags) {
+                                 int32 flags) {
   CHECK(InspectConstructionArguments(name, &minimum, &maximum, &bucket_count));
 
   Histogram* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
     BucketRanges* ranges = new BucketRanges(bucket_count + 1);
     InitializeBucketRanges(minimum, maximum, bucket_count, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     Histogram* tentative_histogram =
         new Histogram(name, minimum, maximum, bucket_count, registered_ranges);
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   CHECK_EQ(HISTOGRAM, histogram->histogram_type());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
 Histogram* Histogram::FactoryTimeGet(const string& name,
                                      TimeDelta minimum,
                                      TimeDelta maximum,
                                      size_t bucket_count,
-                                     Flags flags) {
+                                     int32 flags) {
   return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
                     bucket_count, flags);
 }
 
 TimeTicks Histogram::DebugNow() {
 #ifndef NDEBUG
   return TimeTicks::Now();
 #else
   return TimeTicks();
 #endif
@@ skipping 259 matching lines @@
 Histogram::Histogram(const string& name,
                      Sample minimum,
                      Sample maximum,
                      size_t bucket_count,
                      const BucketRanges* ranges)
   : HistogramBase(name),
     bucket_ranges_(ranges),
     declared_min_(minimum),
     declared_max_(maximum),
     bucket_count_(bucket_count),
-    flags_(kNoFlags),
     sample_(bucket_count) {}
 
 Histogram::~Histogram() {
   if (StatisticsRecorder::dump_on_exit()) {
     string output;
     WriteAsciiImpl(true, "\n", &output);
     DLOG(INFO) << output;
   }
 }
 
 // static
 bool Histogram::InspectConstructionArguments(const string& name,
                                              Sample* minimum,
                                              Sample* maximum,
                                              size_t* bucket_count) {
   // Defensive code for backward compatibility.
   if (*minimum < 1) {
     DVLOG(1) << "Histogram: " << name << " has bad minimum: " << *minimum;
     *minimum = 1;
   }
   if (*maximum >= kSampleType_MAX) {
     DVLOG(1) << "Histogram: " << name << " has bad maximum: " << *maximum;
-    *maximum = kSampleType_MAX - 1;
+    *maximum = kSampleType_MAX;

[Ilya Sherman, 2012/08/04 01:18:35]

This doesn't seem right -- kSampleType_MAX fails the if-stmt's conditional...

[kaiwang, 2012/08/08 03:59:33]

Good catch! It's fixed in another CL

[Ilya Sherman, 2012/08/08 05:00:29]

Ok.  In that case, can you move this change into that CL as well?  It doesn't
seem relevant to refactoring code for the SparseHistogram implementation.

[kaiwang, 2012/08/08 22:17:08]

That's already submitted

[Ilya Sherman, 2012/08/08 22:49:40]

Could you rebase this CL, then?  It's still showing up as a diff, which is why
I'm still asking about it ;)

[kaiwang, 2012/08/08 23:03:37]

See patch set 4

   }
 
   if (*bucket_count < 3 || *bucket_count >= kBucketCount_MAX)
     return false;
   if (*bucket_count > static_cast<size_t>(*maximum - *minimum + 2))
     return false;
   return true;
 }
 
 bool Histogram::SerializeRanges(Pickle* pickle) const {
@@ skipping 38 matching lines @@
   DCHECK_GT(ranges(i + 1), ranges(i));
   static const double kTransitionWidth = 5;
   double denominator = ranges(i + 1) - ranges(i);
   if (denominator > kTransitionWidth)
     denominator = kTransitionWidth;  // Stop trying to normalize.
   return current/denominator;
 }
 
 const string Histogram::GetAsciiBucketRange(size_t i) const {
   string result;
-  if (kHexRangePrintingFlag & flags_)
+  if (kHexRangePrintingFlag & flags())
     StringAppendF(&result, "%#x", ranges(i));
   else
     StringAppendF(&result, "%d", ranges(i));
   return result;
 }
 
 // Update histogram data with new sample.
 void Histogram::Accumulate(Sample value, Count count, size_t index) {
   // Note locking not done in this version!!!
   sample_.Accumulate(value, count, index);
@@ skipping 84 matching lines @@
                 "Histogram: %s recorded %d samples",
                 histogram_name().c_str(),
                 sample_count);
   if (0 == sample_count) {
     DCHECK_EQ(snapshot.sum(), 0);
   } else {
     double average = static_cast<float>(snapshot.sum()) / sample_count;
 
     StringAppendF(output, ", average = %.1f", average);
   }
-  if (flags_ & ~kHexRangePrintingFlag)
-    StringAppendF(output, " (flags = 0x%x)", flags_ & ~kHexRangePrintingFlag);
+  if (flags() & ~kHexRangePrintingFlag)
+    StringAppendF(output, " (flags = 0x%x)", flags() & ~kHexRangePrintingFlag);
 }
 
 void Histogram::WriteAsciiBucketContext(const int64 past,
                                         const Count current,
                                         const int64 remaining,
                                         const size_t i,
                                         string* output) const {
   double scaled_sum = (past + current + remaining) / 100.0;
   WriteAsciiBucketValue(current, scaled_sum, output);
   if (0 < i) {
@@ skipping 27 matching lines @@
 // LinearHistogram: This histogram uses a traditional set of evenly spaced
 // buckets.
 //------------------------------------------------------------------------------
 
 LinearHistogram::~LinearHistogram() {}
 
 Histogram* LinearHistogram::FactoryGet(const string& name,
                                        Sample minimum,
                                        Sample maximum,
                                        size_t bucket_count,
-                                       Flags flags) {
+                                       int32 flags) {
   CHECK(Histogram::InspectConstructionArguments(name, &minimum, &maximum,
                                                 &bucket_count));
 
   Histogram* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
     BucketRanges* ranges = new BucketRanges(bucket_count + 1);
     InitializeBucketRanges(minimum, maximum, bucket_count, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     LinearHistogram* tentative_histogram =
         new LinearHistogram(name, minimum, maximum, bucket_count,
                             registered_ranges);
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   CHECK_EQ(LINEAR_HISTOGRAM, histogram->histogram_type());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
 Histogram* LinearHistogram::FactoryTimeGet(const string& name,
                                            TimeDelta minimum,
                                            TimeDelta maximum,
                                            size_t bucket_count,
-                                           Flags flags) {
+                                           int32 flags) {
   return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
                     bucket_count, flags);
 }
 
 Histogram::ClassType LinearHistogram::histogram_type() const {
   return LINEAR_HISTOGRAM;
 }
 
 void LinearHistogram::SetRangeDescriptions(
     const DescriptionPair descriptions[]) {
@@ skipping 45 matching lines @@
     ranges->set_range(i, static_cast<Sample>(linear_range + 0.5));
   }
   ranges->set_range(ranges->size() - 1, HistogramBase::kSampleType_MAX);
   ranges->ResetChecksum();
 }
 
 //------------------------------------------------------------------------------
 // This section provides implementation for BooleanHistogram.
 //------------------------------------------------------------------------------
 
-Histogram* BooleanHistogram::FactoryGet(const string& name, Flags flags) {
+Histogram* BooleanHistogram::FactoryGet(const string& name, int32 flags) {
   Histogram* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
     BucketRanges* ranges = new BucketRanges(4);
     LinearHistogram::InitializeBucketRanges(1, 2, 3, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     BooleanHistogram* tentative_histogram =
         new BooleanHistogram(name, registered_ranges);
@@ skipping 17 matching lines @@
 BooleanHistogram::BooleanHistogram(const string& name,
                                    const BucketRanges* ranges)
     : LinearHistogram(name, 1, 2, 3, ranges) {}
 
 //------------------------------------------------------------------------------
 // CustomHistogram:
 //------------------------------------------------------------------------------
 
 Histogram* CustomHistogram::FactoryGet(const string& name,
                                        const vector<Sample>& custom_ranges,
-                                       Flags flags) {
+                                       int32 flags) {
   CHECK(ValidateCustomRanges(custom_ranges));
 
   Histogram* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     BucketRanges* ranges = CreateBucketRangesFromCustomRanges(custom_ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     // To avoid racy destruction at shutdown, the following will be leaked.
     CustomHistogram* tentative_histogram =
@@ skipping 82 matching lines @@
 
   BucketRanges* bucket_ranges = new BucketRanges(ranges.size());
   for (size_t i = 0; i < ranges.size(); i++) {
     bucket_ranges->set_range(i, ranges[i]);
   }
   bucket_ranges->ResetChecksum();
   return bucket_ranges;
 }
 
 }  // namespace base