Support "shared" histograms between processes.

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"
 
 #include <math.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
+#include "base/memory/persistent_memory_allocator.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/metrics/sample_vector.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/pickle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 
@@ skipping 54 matching lines @@
 const size_t Histogram::kBucketCount_MAX = 16384u;
 
 HistogramBase* Histogram::FactoryGet(const std::string& name,
                                      Sample minimum,
                                      Sample maximum,
                                      size_t bucket_count,
                                      int32 flags) {
   bool valid_arguments =
       InspectConstructionArguments(name, &minimum, &maximum, &bucket_count);
   DCHECK(valid_arguments);
+  ImportPersistentHistograms();
 
   HistogramBase* 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, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
-    Histogram* tentative_histogram =
-        new Histogram(name, minimum, maximum, registered_ranges);
+    PersistentMemoryAllocator::Reference histogram_ref = 0;
+    HistogramBase* tentative_histogram = nullptr;
+    if (allocator_) {
+      flags |= kIsPersistent;
+      tentative_histogram = AllocatePersistentHistogram(
+          GetDefaultPersistentMemoryAllocator(),
+          HISTOGRAM,
+          name,
+          minimum,
+          maximum,
+          registered_ranges,
+          flags,
+          &histogram_ref);
+    }
+    if (!tentative_histogram) {
+      flags &= ~kIsPersistent;
+      tentative_histogram = new Histogram(
+          name, minimum, maximum, registered_ranges);
+    }
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
+
+    // Persistent histograms need some follow-up processing.
+    if (histogram_ref) {
+      // If the created persistent histogram is canonical then it needs to be
+      // marked as "iterable" in order to be found by other processes.
+      if (histogram == tentative_histogram)
+        GetDefaultPersistentMemoryAllocator()->MakeIterable(histogram_ref);
+      // If it's not the canonical one then a race condition must have caused
+      // two to be created. The allocator does not support releasing the
+      // acquired memory so just change the type to be empty.
+      else
+        GetDefaultPersistentMemoryAllocator()->SetType(histogram_ref, 0);
+    }
   }
 
   DCHECK_EQ(HISTOGRAM, histogram->GetHistogramType());
   if (!histogram->HasConstructionArguments(minimum, maximum, bucket_count)) {
     // The construction arguments do not match the existing histogram.  This can
     // come about if an extension updates in the middle of a chrome run and has
     // changed one of them, or simply by bad code within Chrome itself.  We
     // return NULL here with the expectation that bad code in Chrome will crash
     // on dereference, but extension/Pepper APIs will guard against NULL and not
     // crash.
@@ skipping 218 matching lines @@
                      Sample maximum,
                      const BucketRanges* ranges)
   : HistogramBase(name),
     bucket_ranges_(ranges),
     declared_min_(minimum),
     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,
+                     size_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));
+}
+
 Histogram::~Histogram() {
 }
 
 bool Histogram::PrintEmptyBucket(size_t index) const {
   return true;
 }
 
 // Use the actual bucket widths (like a linear histogram) until the widths get
 // over some transition value, and then use that transition width.  Exponentials
 // get so big so fast (and we don't expect to see a lot of entries in the large
@@ skipping 35 matching lines @@
 
   if (!ValidateRangeChecksum(*histogram, range_checksum)) {
     // The serialized histogram might be corrupted.
     return NULL;
   }
   return histogram;
 }
 
 scoped_ptr<SampleVector> Histogram::SnapshotSampleVector() const {
   scoped_ptr<SampleVector> samples(
-      new SampleVector(HashMetricName(histogram_name()), bucket_ranges()));
+      new SampleVector(HashMetricName(histogram_name()),
+                       bucket_ranges()));
   samples->Add(*samples_);
   return samples;
 }
 
 void Histogram::WriteAsciiImpl(bool graph_it,
                                const std::string& newline,
                                std::string* output) const {
   // Get local (stack) copies of all effectively volatile class data so that we
   // are consistent across our output activities.
   scoped_ptr<SampleVector> snapshot = SnapshotSampleVector();
@@ skipping 173 matching lines @@
 HistogramBase* LinearHistogram::FactoryGetWithRangeDescription(
       const std::string& name,
       Sample minimum,
       Sample maximum,
       size_t bucket_count,
       int32 flags,
       const DescriptionPair descriptions[]) {
   bool valid_arguments = Histogram::InspectConstructionArguments(
       name, &minimum, &maximum, &bucket_count);
   DCHECK(valid_arguments);
+  ImportPersistentHistograms();
 
   HistogramBase* 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, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
-    LinearHistogram* tentative_histogram =
-        new LinearHistogram(name, minimum, maximum, registered_ranges);
+    PersistentMemoryAllocator::Reference histogram_ref = 0;
+    LinearHistogram* tentative_histogram = nullptr;
+    if (allocator_) {
+      flags |= kIsPersistent;
+      tentative_histogram = static_cast<LinearHistogram*>(
+          AllocatePersistentHistogram(
+              GetDefaultPersistentMemoryAllocator(),
+              LINEAR_HISTOGRAM,
+              name,
+              minimum,
+              maximum,
+              registered_ranges,
+              flags,
+              &histogram_ref));
+    }
+    if (!tentative_histogram) {
+      flags &= ~kIsPersistent;
+      tentative_histogram = new LinearHistogram(
+          name, minimum, maximum, registered_ranges);
+    }
 
     // Set range descriptions.
     if (descriptions) {
       for (int i = 0; descriptions[i].description; ++i) {
         tentative_histogram->bucket_description_[descriptions[i].sample] =
             descriptions[i].description;
       }
     }
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
+
+    // Persistent histograms need some follow-up processing.
+    if (histogram_ref) {
+      // If the created persistent histogram is canonical then it needs to be
+      // marked as "iterable" in order to be found by other processes.
+      if (histogram == tentative_histogram)
+        GetDefaultPersistentMemoryAllocator()->MakeIterable(histogram_ref);
+      // If it's not the canonical one then a race condition must have caused
+      // two to be created. The allocator does not support releasing the
+      // acquired memory so just change the type to be empty.
+      else
+        GetDefaultPersistentMemoryAllocator()->SetType(histogram_ref, 0);
+    }
   }
 
   DCHECK_EQ(LINEAR_HISTOGRAM, histogram->GetHistogramType());
   if (!histogram->HasConstructionArguments(minimum, maximum, bucket_count)) {
     // The construction arguments do not match the existing histogram.  This can
     // come about if an extension updates in the middle of a chrome run and has
     // changed one of them, or simply by bad code within Chrome itself.  We
     // return NULL here with the expectation that bad code in Chrome will crash
     // on dereference, but extension/Pepper APIs will guard against NULL and not
     // crash.
     DLOG(ERROR) << "Histogram " << name << " has bad construction arguments";
     return NULL;
   }
   return histogram;
 }
 
 HistogramType LinearHistogram::GetHistogramType() const {
   return LINEAR_HISTOGRAM;
 }
 
 LinearHistogram::LinearHistogram(const std::string& name,
                                  Sample minimum,
                                  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,
+                                 size_t counts_size,
+                                 HistogramSamples::Metadata* meta)
+    : Histogram(name,
+                minimum,
+                maximum,
+                ranges,
+                counts,
+                counts_size,
+                meta) {}
+
 double LinearHistogram::GetBucketSize(Count current, size_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(size_t i) const {
   int range = ranges(i);
@@ skipping 45 matching lines @@
   }
   return histogram;
 }
 
 //------------------------------------------------------------------------------
 // This section provides implementation for BooleanHistogram.
 //------------------------------------------------------------------------------
 
 HistogramBase* BooleanHistogram::FactoryGet(const std::string& name,
                                             int32 flags) {
+  ImportPersistentHistograms();
+
   HistogramBase* 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, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
-    BooleanHistogram* tentative_histogram =
-        new BooleanHistogram(name, registered_ranges);
+    PersistentMemoryAllocator::Reference histogram_ref = 0;
+    HistogramBase* tentative_histogram = nullptr;
+    if (allocator_) {
+      flags |= kIsPersistent;
+      tentative_histogram = AllocatePersistentHistogram(
+          GetDefaultPersistentMemoryAllocator(),
+          BOOLEAN_HISTOGRAM,
+          name,
+          1, 2,
+          registered_ranges,
+          flags,
+          &histogram_ref);
+    }
+    if (!tentative_histogram) {
+      flags &= ~kIsPersistent;
+      tentative_histogram = new BooleanHistogram(name, registered_ranges);
+    }
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
+
+    // Persistent histograms need some follow-up processing.
+    if (histogram_ref) {
+      // If the created persistent histogram is canonical then it needs to be
+      // marked as "iterable" in order to be found by other processes.
+      if (histogram == tentative_histogram)
+        GetDefaultPersistentMemoryAllocator()->MakeIterable(histogram_ref);
+      // If it's not the canonical one then a race condition must have caused
+      // two to be created. The allocator does not support releasing the
+      // acquired memory so just change the type to be empty.
+      else
+        GetDefaultPersistentMemoryAllocator()->SetType(histogram_ref, 0);
+    }

[Alexei Svitkine (slow), 2015/12/04 18:27:36]

The code from 817 to 850 is repeated in several places (with some small
differences). Please find a way to refactor this to share more code, e.g. using
a helper function.

[bcwhite, 2015/12/07 23:27:19]

Done.

   }
 
   DCHECK_EQ(BOOLEAN_HISTOGRAM, histogram->GetHistogramType());
   return histogram;
 }
 
 HistogramBase* BooleanHistogram::FactoryGet(const char* name, int32 flags) {
   return FactoryGet(std::string(name), flags);
 }
 
 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* BooleanHistogram::DeserializeInfoImpl(PickleIterator* iter) {
   std::string histogram_name;
   int flags;
   int declared_min;
   int declared_max;
   size_t bucket_count;
   uint32 range_checksum;
 
   if (!ReadHistogramArguments(iter, &histogram_name, &flags, &declared_min,
                               &declared_max, &bucket_count, &range_checksum)) {
@@ skipping 11 matching lines @@
 
 //------------------------------------------------------------------------------
 // CustomHistogram:
 //------------------------------------------------------------------------------
 
 HistogramBase* CustomHistogram::FactoryGet(
     const std::string& name,
     const std::vector<Sample>& custom_ranges,
     int32 flags) {
   CHECK(ValidateCustomRanges(custom_ranges));
+  ImportPersistentHistograms();
 
   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
+    // To avoid racy destruction at shutdown, the following will be leaked.
     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 =
-        new CustomHistogram(name, registered_ranges);
+    PersistentMemoryAllocator::Reference histogram_ref = 0;
+    HistogramBase* tentative_histogram = nullptr;
+    if (allocator_) {
+      flags |= kIsPersistent;
+      tentative_histogram = AllocatePersistentHistogram(
+          GetDefaultPersistentMemoryAllocator(),
+          CUSTOM_HISTOGRAM,
+          name,
+          registered_ranges->range(1),
+          registered_ranges->range(registered_ranges->bucket_count() - 1),
+          registered_ranges,
+          flags,
+          &histogram_ref);
+    }
+    if (!tentative_histogram) {
+      flags &= ~kIsPersistent;
+      tentative_histogram = new CustomHistogram(name, registered_ranges);
+    }
 
     tentative_histogram->SetFlags(flags);
-
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
+
+    // Persistent histograms need some follow-up processing.
+    if (histogram_ref) {
+      // If the created persistent histogram is canonical then it needs to be
+      // marked as "iterable" in order to be found by other processes.
+      if (histogram == tentative_histogram)
+        GetDefaultPersistentMemoryAllocator()->MakeIterable(histogram_ref);
+      // If it's not the canonical one then a race condition must have caused
+      // two to be created. The allocator does not support releasing the
+      // acquired memory so just change the type to be empty.
+      else
+        GetDefaultPersistentMemoryAllocator()->SetType(histogram_ref, 0);
+    }
   }
 
   DCHECK_EQ(histogram->GetHistogramType(), CUSTOM_HISTOGRAM);
   return histogram;
 }
 
 HistogramBase* CustomHistogram::FactoryGet(
     const char* name,
     const std::vector<Sample>& custom_ranges,
     int32 flags) {
@@ skipping 19 matching lines @@
   return all_values;
 }
 
 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,
+                                 size_t counts_size,
+                                 HistogramSamples::Metadata* meta)
+    : Histogram(name,
+                ranges->range(1),
+                ranges->range(ranges->bucket_count() - 1),
+                ranges,
+                counts,
+                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 (size_t i = 1; i < bucket_ranges()->bucket_count(); ++i) {
     if (!pickle->WriteInt(bucket_ranges()->range(i)))
       return false;
   }
@@ skipping 61 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