Support "shared" histograms between processes.

base/metrics/statistics_recorder.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/statistics_recorder.h"
 
 #include "base/at_exit.h"
 #include "base/debug/leak_annotations.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 
 namespace {
 // Initialize histogram statistics gathering system.
 base::LazyInstance<base::StatisticsRecorder>::Leaky g_statistics_recorder_ =
     LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 namespace base {
 
+StatisticsRecorder::HistogramIterator&
+StatisticsRecorder::HistogramIterator::operator++() {
+  const HistogramMap::iterator histograms_end = histograms_->end();
+  while (iter_ != histograms_end) {
+    ++iter_;
+    if (iter_ == histograms_end)
+      break;
+    if (!include_persistent_ && (iter_->second->flags() &
+                                 HistogramBase::kIsPersistent)) {
+      continue;
+    }
+    break;
+  }
+  return *this;
+}
+
 // static
 void StatisticsRecorder::Initialize() {
   // Ensure that an instance of the StatisticsRecorder object is created.
   g_statistics_recorder_.Get();
 }
 
 // static
 bool StatisticsRecorder::IsActive() {
   if (lock_ == NULL)
     return false;
@@ skipping 15 matching lines @@
   }
 
   HistogramBase* histogram_to_delete = NULL;
   HistogramBase* histogram_to_return = NULL;
   {
     base::AutoLock auto_lock(*lock_);
     if (histograms_ == NULL) {
       histogram_to_return = histogram;
     } else {
       const std::string& name = histogram->histogram_name();
-      uint64_t name_hash = histogram->name_hash();
+      const uint64_t name_hash = histogram->name_hash();
+      DCHECK_NE(0, name_hash);
       HistogramMap::iterator it = histograms_->find(name_hash);
       if (histograms_->end() == it) {
         (*histograms_)[name_hash] = histogram;
         ANNOTATE_LEAKING_OBJECT_PTR(histogram);  // see crbug.com/79322
         // If there are callbacks for this histogram, we set the kCallbackExists
         // flag.
         auto callback_iterator = callbacks_->find(name);
         if (callback_iterator != callbacks_->end()) {
           if (!callback_iterator->second.is_null())
             histogram->SetFlags(HistogramBase::kCallbackExists);
@@ skipping 175 matching lines @@
   if (lock_ == NULL)
     return false;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return false;
 
   if (ContainsKey(*callbacks_, name))
     return false;
   callbacks_->insert(std::make_pair(name, cb));
 
-  HistogramMap::iterator it = histograms_->find(HashMetricName(name));
+  auto it = histograms_->find(HashMetricName(name));
   if (it != histograms_->end()) {
     DCHECK_EQ(name, it->second->histogram_name()) << "hash collision";
     it->second->SetFlags(HistogramBase::kCallbackExists);
   }
 
   return true;
 }
 
 // static
 void StatisticsRecorder::ClearCallback(const std::string& name) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return;
 
   callbacks_->erase(name);
 
   // We also clear the flag from the histogram (if it exists).
-  HistogramMap::iterator it = histograms_->find(HashMetricName(name));
+  auto it = histograms_->find(HashMetricName(name));
   if (it != histograms_->end()) {
     DCHECK_EQ(name, it->second->histogram_name()) << "hash collision";
     it->second->ClearFlags(HistogramBase::kCallbackExists);
   }
 }
 
 // static
 StatisticsRecorder::OnSampleCallback StatisticsRecorder::FindCallback(
     const std::string& name) {
   if (lock_ == NULL)
     return OnSampleCallback();
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return OnSampleCallback();
 
   auto callback_iterator = callbacks_->find(name);
   return callback_iterator != callbacks_->end() ? callback_iterator->second
                                                 : OnSampleCallback();
 }
 
-// private static
+// static
+StatisticsRecorder::HistogramIterator StatisticsRecorder::begin(
+    bool include_persistent) {

[Alexei Svitkine (slow), 2016/01/14 16:43:13]

It would be better to make this an enum so that it's clear what's happening from
the callers side.

Then, you can actually have 3 values that all make logical sense:

PERSISTENT_HISTOGRAMS = 1,
NON_PERSISTENT_HISTOGRAM = 2,
ALL_HISTOGRAMS = PERSISTENT_HISTOGRAMS | NON_PERSISTENT_HISTOGRAM

[bcwhite, 2016/01/14 19:20:25]

Sure, though I don't see the use-case of that.  You either want:

1) All histograms created locally (true), or
2) All histograms created locally but not reported elsewhere (false)

I would actually prefer to remove the parameter completely and just do the
"false" case but it's more efficient to find shared histograms here than by
independently iterating over a persistent memory segment.  Once reporting
directly from persistent data is complete (a future optimization), I'll likely
go that way.

+  return HistogramIterator(histograms_->begin(), include_persistent);
+}
+
+// static
+StatisticsRecorder::HistogramIterator StatisticsRecorder::end() {
+  return HistogramIterator(histograms_->end(), true);

[Alexei Svitkine (slow), 2016/01/14 16:43:14]

Why is it correct to pass in true here, rather than relying on a param?

[bcwhite, 2016/01/14 19:20:26]

The second parameter defines what histograms are found within an allocator but
end() doesn't return a valid allocator so the value of the second parameter is
unimportant.

+}
+
+// static
 void StatisticsRecorder::GetSnapshot(const std::string& query,
                                      Histograms* snapshot) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return;
 
   for (const auto& entry : *histograms_) {
     if (entry.second->histogram_name().find(query) != std::string::npos)
@@ skipping 56 matching lines @@
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 StatisticsRecorder::CallbackMap* StatisticsRecorder::callbacks_ = NULL;
 // static
 StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = NULL;
 // static
 base::Lock* StatisticsRecorder::lock_ = NULL;
 
 }  // namespace base