Reduce Histogram object size.

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 146 matching lines @@
     // In most cases, the bucket-count, minimum, and maximum values are known
     // when the code is written and so are passed in explicitly. In other
     // cases (such as with a CustomHistogram), they are calculated dynamically
     // at run-time. In the latter case, those ctor parameters are zero and
     // the results extracted from the result of CreateRanges().
     if (bucket_count_ == 0) {
       bucket_count_ = static_cast<uint32_t>(registered_ranges->bucket_count());
       minimum_ = registered_ranges->range(1);
       maximum_ = registered_ranges->range(bucket_count_ - 1);
     }
+    DCHECK_EQ(minimum_, registered_ranges->range(1));
+    DCHECK_EQ(maximum_, registered_ranges->range(bucket_count_ - 1));
 
     // Try to create the histogram using a "persistent" allocator. As of
     // 2016-02-25, the availability of such is controlled by a base::Feature
     // that is off by default. If the allocator doesn't exist or if
     // allocating from it fails, code below will allocate the histogram from
     // the process heap.
     PersistentHistogramAllocator::Reference histogram_ref = 0;
     std::unique_ptr<HistogramBase> tentative_histogram;
     PersistentHistogramAllocator* allocator = GlobalHistogramAllocator::Get();
     if (allocator) {
@@ skipping 174 matching lines @@
     } else {
       DCHECK_GT(0, delta);
       UMA_HISTOGRAM_COUNTS("Histogram.InconsistentCountLow", -delta);
       if (-delta > kCommonRaceBasedCountMismatch)
         inconsistencies |= COUNT_LOW_ERROR;
     }
   }
   return inconsistencies;
 }
 
+Sample Histogram::declared_min() const {
+  if (bucket_ranges_->bucket_count() < 2)
+    return -1;
+  return bucket_ranges_->range(1);
+}
+
+Sample Histogram::declared_max() const {
+  if (bucket_ranges_->bucket_count() < 2)
+    return -1;
+  return bucket_ranges_->range(bucket_ranges_->bucket_count() - 1);
+}
+
 Sample Histogram::ranges(uint32_t i) const {
   return bucket_ranges_->range(i);
 }
 
 uint32_t Histogram::bucket_count() const {
   return static_cast<uint32_t>(bucket_ranges_->bucket_count());
 }
 
 // static
 bool Histogram::InspectConstructionArguments(const std::string& name,
@@ skipping 53 matching lines @@
   return unlogged_samples_->id();
 }
 
 HistogramType Histogram::GetHistogramType() const {
   return HISTOGRAM;
 }
 
 bool Histogram::HasConstructionArguments(Sample expected_minimum,
                                          Sample expected_maximum,
                                          uint32_t expected_bucket_count) const {
-  return ((expected_minimum == declared_min_) &&
-          (expected_maximum == declared_max_) &&
-          (expected_bucket_count == bucket_count()));
+  return (expected_bucket_count == bucket_count() &&
+          expected_minimum == declared_min() &&
+          expected_maximum == declared_max());
 }
 
 void Histogram::Add(int value) {
   AddCount(value, 1);
 }
 
 void Histogram::AddCount(int value, int count) {
   DCHECK_EQ(0, ranges(0));
   DCHECK_EQ(kSampleType_MAX, ranges(bucket_count()));
 
   if (value > kSampleType_MAX - 1)
     value = kSampleType_MAX - 1;
   if (value < 0)
     value = 0;
   if (count <= 0) {
     NOTREACHED();
     return;
   }
   unlogged_samples_->Accumulate(value, count);
 
   FindAndRunCallback(value);
 }
 
 std::unique_ptr<HistogramSamples> Histogram::SnapshotSamples() const {
   return SnapshotAllSamples();
 }
 
 std::unique_ptr<HistogramSamples> Histogram::SnapshotDelta() {
+#if DCHECK_IS_ON()
   DCHECK(!final_delta_created_);
+#endif
+
   // The code below has subtle thread-safety guarantees! All changes to
   // the underlying SampleVectors use atomic integer operations, which guarantee
   // eventual consistency, but do not guarantee full synchronization between
   // different entries in the SampleVector. In particular, this means that
   // concurrent updates to the histogram might result in the reported sum not
   // matching the individual bucket counts; or there being some buckets that are
   // logically updated "together", but end up being only partially updated when
   // a snapshot is captured. Note that this is why it's important to subtract
   // exactly the snapshotted unlogged samples, rather than simply resetting the
   // vector: this way, the next snapshot will include any concurrent updates
   // missed by the current snapshot.
 
   std::unique_ptr<HistogramSamples> snapshot = SnapshotUnloggedSamples();
   unlogged_samples_->Subtract(*snapshot);
   logged_samples_->Add(*snapshot);
 
   return snapshot;
 }
 
 std::unique_ptr<HistogramSamples> Histogram::SnapshotFinalDelta() const {
+#if DCHECK_IS_ON()
   DCHECK(!final_delta_created_);
   final_delta_created_ = true;
+#endif
 
   return SnapshotUnloggedSamples();
 }
 
 void Histogram::AddSamples(const HistogramSamples& samples) {
   unlogged_samples_->Add(samples);
 }
 
 bool Histogram::AddSamplesFromPickle(PickleIterator* iter) {
   return unlogged_samples_->AddFromPickle(iter);
@@ skipping 14 matching lines @@
 bool Histogram::SerializeInfoImpl(Pickle* pickle) const {
   DCHECK(bucket_ranges()->HasValidChecksum());
   return pickle->WriteString(histogram_name()) &&
       pickle->WriteInt(flags()) &&
       pickle->WriteInt(declared_min()) &&
       pickle->WriteInt(declared_max()) &&
       pickle->WriteUInt32(bucket_count()) &&
       pickle->WriteUInt32(bucket_ranges()->checksum());
 }
 
+// TODO(bcwhite): Remove minimum/maximum parameters from here and call chain.
 Histogram::Histogram(const std::string& name,
                      Sample minimum,
                      Sample maximum,
                      const BucketRanges* ranges)
-  : HistogramBase(name),
-    bucket_ranges_(ranges),
-    declared_min_(minimum),
-    declared_max_(maximum) {
+    : HistogramBase(name), bucket_ranges_(ranges) {
   // TODO(bcwhite): Make this a DCHECK once crbug/734049 is resolved.
   CHECK(ranges) << name << ": " << minimum << "-" << maximum;
   unlogged_samples_.reset(new SampleVector(HashMetricName(name), ranges));
   logged_samples_.reset(new SampleVector(unlogged_samples_->id(), ranges));
 }
 
 Histogram::Histogram(const std::string& name,
                      Sample minimum,
                      Sample maximum,
                      const BucketRanges* ranges,
                      const DelayedPersistentAllocation& counts,
                      const DelayedPersistentAllocation& logged_counts,
                      HistogramSamples::Metadata* meta,
                      HistogramSamples::Metadata* logged_meta)
-    : HistogramBase(name),
-      bucket_ranges_(ranges),
-      declared_min_(minimum),
-      declared_max_(maximum) {
+    : HistogramBase(name), bucket_ranges_(ranges) {
   // TODO(bcwhite): Make this a DCHECK once crbug/734049 is resolved.
   CHECK(ranges) << name << ": " << minimum << "-" << maximum;
   unlogged_samples_.reset(
       new PersistentSampleVector(HashMetricName(name), ranges, meta, counts));
   logged_samples_.reset(new PersistentSampleVector(
       unlogged_samples_->id(), ranges, logged_meta, logged_counts));
 }
 
 Histogram::~Histogram() {
 }
@@ skipping 663 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