Add support for persistent sparse histograms.

base/metrics/sparse_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.
 
 #include "base/metrics/sparse_histogram.h"
 
 #include <utility>
 
+#include "base/metrics/histogram_persistence.h"
 #include "base/metrics/metrics_hashes.h"
+#include "base/metrics/persistent_sample_map.h"
 #include "base/metrics/sample_map.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/pickle.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 
 namespace base {
 
 typedef HistogramBase::Count Count;
 typedef HistogramBase::Sample Sample;
 
 // static
 HistogramBase* SparseHistogram::FactoryGet(const std::string& name,
                                            int32_t flags) {
+  // Import histograms from known persistent storage. Histograms could have
+  // been added by other processes and they must be fetched and recognized
+  // locally in order to be found by FindHistograms() below. If the persistent
+  // memory segment is not shared between processes, this call does nothing.
+  ImportPersistentHistograms();
+
   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
+  if (!histogram) {
+    // 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.
+    PersistentMemoryAllocator::Reference histogram_ref = 0;
+    HistogramBase* tentative_histogram = nullptr;
+    PersistentMemoryAllocator* allocator =
+        GetPersistentHistogramMemoryAllocator();
+    if (allocator) {
+      flags |= HistogramBase::kIsPersistent;

[Alexei Svitkine (slow), 2016/03/09 20:35:19]

Can we move this to inside AllocatePersistentHistogram() so that callers don't
need to set it explicitly?

[bcwhite, 2016/03/09 22:57:33]

It would get overwritten below on line 65...  but that's probably wrong because
the flags need to be known by Allocate so they can be properly stored in
persistent memory.

Fixed, here and in histogram.cc.

+      tentative_histogram = AllocatePersistentHistogram(
+          allocator,
+          SPARSE_HISTOGRAM,
+          name,
+          0,
+          0,
+          nullptr,
+          flags,
+          &histogram_ref);
+    }
 
-  if (!histogram) {
-    // To avoid racy destruction at shutdown, the following will be leaked.
-    HistogramBase* tentative_histogram = new SparseHistogram(name);
+    // Handle the case where no persistent allocator is present or the
+    // persistent allocation fails (perhaps because it is full).
+    if (!tentative_histogram) {
+      DCHECK(!histogram_ref);  // Should never have been set.
+      DCHECK(!allocator);      // Shouldn't have failed.
+      flags &= ~HistogramBase::kIsPersistent;
+      tentative_histogram = new SparseHistogram(name);
+    }
+
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
+
+    // Persistent histograms need some follow-up processing.
+    if (histogram_ref) {
+      FinalizePersistentHistogram(histogram_ref,
+                                  histogram == tentative_histogram);
+    }
   }
+
   DCHECK_EQ(SPARSE_HISTOGRAM, histogram->GetHistogramType());
   return histogram;
 }
 
+// static
+HistogramBase* SparseHistogram::PersistentGet(
+    PersistentMemoryAllocator* allocator,
+    const std::string& name,
+    HistogramSamples::Metadata* meta,
+    HistogramSamples::Metadata* logged_meta) {
+  return new SparseHistogram(allocator, name, meta, logged_meta);
+}
+
 SparseHistogram::~SparseHistogram() {}
 
 uint64_t SparseHistogram::name_hash() const {
-  return samples_.id();
+  return samples_->id();
 }
 
 HistogramType SparseHistogram::GetHistogramType() const {
   return SPARSE_HISTOGRAM;
 }
 
 bool SparseHistogram::HasConstructionArguments(
     Sample expected_minimum,
     Sample expected_maximum,
     uint32_t expected_bucket_count) const {
   // SparseHistogram never has min/max/bucket_count limit.
   return false;
 }
 
 void SparseHistogram::Add(Sample value) {
   AddCount(value, 1);
 }
 
 void SparseHistogram::AddCount(Sample value, int count) {
   if (count <= 0) {
     NOTREACHED();
     return;
   }
   {
     base::AutoLock auto_lock(lock_);
-    samples_.Accumulate(value, count);
+    samples_->Accumulate(value, count);
   }
 
   FindAndRunCallback(value);
 }
 
 scoped_ptr<HistogramSamples> SparseHistogram::SnapshotSamples() const {
   scoped_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
 
   base::AutoLock auto_lock(lock_);
-  snapshot->Add(samples_);
+  snapshot->Add(*samples_);
   return std::move(snapshot);
 }
 
 scoped_ptr<HistogramSamples> SparseHistogram::SnapshotDelta() {
   scoped_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
   base::AutoLock auto_lock(lock_);
-  snapshot->Add(samples_);
+  snapshot->Add(*samples_);
 
   // Subtract what was previously logged and update that information.
-  snapshot->Subtract(logged_samples_);
-  logged_samples_.Add(*snapshot);
+  snapshot->Subtract(*logged_samples_);
+  logged_samples_->Add(*snapshot);
   return std::move(snapshot);
 }
 
 void SparseHistogram::AddSamples(const HistogramSamples& samples) {
   base::AutoLock auto_lock(lock_);
-  samples_.Add(samples);
+  samples_->Add(samples);
 }
 
 bool SparseHistogram::AddSamplesFromPickle(PickleIterator* iter) {
   base::AutoLock auto_lock(lock_);
-  return samples_.AddFromPickle(iter);
+  return samples_->AddFromPickle(iter);
 }
 
 void SparseHistogram::WriteHTMLGraph(std::string* output) const {
   output->append("<PRE>");
   WriteAsciiImpl(true, "<br>", output);
   output->append("</PRE>");
 }
 
 void SparseHistogram::WriteAscii(std::string* output) const {
   WriteAsciiImpl(true, "\n", output);
 }
 
 bool SparseHistogram::SerializeInfoImpl(Pickle* pickle) const {
   return pickle->WriteString(histogram_name()) && pickle->WriteInt(flags());
 }
 
 SparseHistogram::SparseHistogram(const std::string& name)
     : HistogramBase(name),
-      samples_(HashMetricName(name)) {}
+      samples_(new SampleMap(HashMetricName(name))),
+      logged_samples_(new SampleMap(samples_->id())) {}
+
+SparseHistogram::SparseHistogram(PersistentMemoryAllocator* allocator,
+                                 const std::string& name,
+                                 HistogramSamples::Metadata* meta,
+                                 HistogramSamples::Metadata* logged_meta)
+    : HistogramBase(name),
+      samples_(new PersistentSampleMap(HashMetricName(name), allocator, meta)),
+      // The ID must be different so as to not confuse sample records.

[Alexei Svitkine (slow), 2016/03/09 20:35:19]

Why is this the case here but not for other histogram types? Please expand the
comment.

[bcwhite, 2016/03/09 22:57:33]

Done.

+      logged_samples_(
+          new PersistentSampleMap(samples_->id() + 1, allocator, logged_meta)) {
+}
 
 HistogramBase* SparseHistogram::DeserializeInfoImpl(PickleIterator* iter) {
   std::string histogram_name;
   int flags;
   if (!iter->ReadString(&histogram_name) || !iter->ReadInt(&flags)) {
     DLOG(ERROR) << "Pickle error decoding Histogram: " << histogram_name;
     return NULL;
   }
 
   DCHECK(flags & HistogramBase::kIPCSerializationSourceFlag);
@@ skipping 69 matching lines @@
                                        std::string* output) const {
   StringAppendF(output,
                 "Histogram: %s recorded %d samples",
                 histogram_name().c_str(),
                 total_count);
   if (flags() & ~kHexRangePrintingFlag)
     StringAppendF(output, " (flags = 0x%x)", flags() & ~kHexRangePrintingFlag);
 }
 
 }  // namespace base