Use lock-free lazy initialization for static histogram references

base/metrics/histogram.cc

 // Copyright (c) 2011 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 55 matching lines @@
 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL,
 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
 0x2d02ef8dL,
 };
 
 typedef Histogram::Count Count;
 
 // static
 const size_t Histogram::kBucketCount_MAX = 16384u;
 
-scoped_refptr<Histogram> Histogram::FactoryGet(const std::string& name,
-    Sample minimum, Sample maximum, size_t bucket_count, Flags flags) {
-  scoped_refptr<Histogram> histogram(NULL);
+Histogram* Histogram::FactoryGet(const std::string& name,
+                                 Sample minimum,
+                                 Sample maximum,
+                                 size_t bucket_count,
+                                 Flags flags) {
+  Histogram* histogram(NULL);
 
   // Defensive code.
   if (minimum < 1)
     minimum = 1;
   if (maximum > kSampleType_MAX - 1)
     maximum = kSampleType_MAX - 1;
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    histogram = new Histogram(name, minimum, maximum, bucket_count);
-    histogram->InitializeBucketRange();
-    histogram->SetFlags(flags);
-    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
+    // Extra variable is not needed... but this keeps this section basically
+    // identical to other derived classes in this file (and compiler will
+    // optimize away the extra variable.
+    // To avoid racy destruction at shutdown, the following will be leaked.
+    Histogram* tentative_histogram =
+        new Histogram(name, minimum, maximum, bucket_count);
+    tentative_histogram->InitializeBucketRange();
+    tentative_histogram->SetFlags(flags);
+    histogram =
+        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   DCHECK_EQ(HISTOGRAM, histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
-scoped_refptr<Histogram> Histogram::FactoryTimeGet(const std::string& name,
-                                                   TimeDelta minimum,
-                                                   TimeDelta maximum,
-                                                   size_t bucket_count,
-                                                   Flags flags) {
+Histogram* Histogram::FactoryTimeGet(const std::string& name,
+                                     TimeDelta minimum,
+                                     TimeDelta maximum,
+                                     size_t bucket_count,
+                                     Flags flags) {
   return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
                     bucket_count, flags);
 }
 
 void Histogram::Add(int value) {
   if (value > kSampleType_MAX - 1)
     value = kSampleType_MAX - 1;
   if (value < 0)
     value = 0;
   size_t index = BucketIndex(value);
@@ skipping 139 matching lines @@
   if (declared_max <= 0 || declared_min <= 0 || declared_max < declared_min ||
       INT_MAX / sizeof(Count) <= bucket_count || bucket_count < 2) {
     LOG(ERROR) << "Values error decoding Histogram: " << histogram_name;
     return false;
   }
 
   Flags flags = static_cast<Flags>(pickle_flags & ~kIPCSerializationSourceFlag);
 
   DCHECK_NE(NOT_VALID_IN_RENDERER, histogram_type);
 
-  scoped_refptr<Histogram> render_histogram(NULL);
+  Histogram* render_histogram(NULL);
 
   if (histogram_type == HISTOGRAM) {
     render_histogram = Histogram::FactoryGet(
         histogram_name, declared_min, declared_max, bucket_count, flags);
   } else if (histogram_type == LINEAR_HISTOGRAM) {
     render_histogram = LinearHistogram::FactoryGet(
         histogram_name, declared_min, declared_max, bucket_count, flags);
   } else if (histogram_type == BOOLEAN_HISTOGRAM) {
     render_histogram = BooleanHistogram::FactoryGet(histogram_name, flags);
   } else {
@@ skipping 481 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 // LinearHistogram: This histogram uses a traditional set of evenly spaced
 // buckets.
 //------------------------------------------------------------------------------
 
 LinearHistogram::~LinearHistogram() {
 }
 
-scoped_refptr<Histogram> LinearHistogram::FactoryGet(const std::string& name,
-                                                     Sample minimum,
-                                                     Sample maximum,
-                                                     size_t bucket_count,
-                                                     Flags flags) {
-  scoped_refptr<Histogram> histogram(NULL);
+Histogram* LinearHistogram::FactoryGet(const std::string& name,
+                                       Sample minimum,
+                                       Sample maximum,
+                                       size_t bucket_count,
+                                       Flags flags) {
+  Histogram* histogram(NULL);
 
   if (minimum < 1)
     minimum = 1;
   if (maximum > kSampleType_MAX - 1)
     maximum = kSampleType_MAX - 1;
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    LinearHistogram* linear_histogram =
+    // To avoid racy destruction at shutdown, the following will be leaked.
+    LinearHistogram* tentative_histogram =
         new LinearHistogram(name, minimum, maximum, bucket_count);
-    linear_histogram->InitializeBucketRange();
-    histogram = linear_histogram;
-    histogram->SetFlags(flags);
-    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
+    tentative_histogram->InitializeBucketRange();
+    tentative_histogram->SetFlags(flags);
+    histogram =
+        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   DCHECK_EQ(LINEAR_HISTOGRAM, histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
-scoped_refptr<Histogram> LinearHistogram::FactoryTimeGet(
-    const std::string& name,
-    TimeDelta minimum,
-    TimeDelta maximum,
-    size_t bucket_count,
-    Flags flags) {
+Histogram* LinearHistogram::FactoryTimeGet(const std::string& name,
+                                           TimeDelta minimum,
+                                           TimeDelta maximum,
+                                           size_t bucket_count,
+                                           Flags 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 49 matching lines @@
 
 bool LinearHistogram::PrintEmptyBucket(size_t index) const {
   return bucket_description_.find(ranges(index)) == bucket_description_.end();
 }
 
 
 //------------------------------------------------------------------------------
 // This section provides implementation for BooleanHistogram.
 //------------------------------------------------------------------------------
 
-scoped_refptr<Histogram> BooleanHistogram::FactoryGet(const std::string& name,
-                                                      Flags flags) {
-  scoped_refptr<Histogram> histogram(NULL);
+Histogram* BooleanHistogram::FactoryGet(const std::string& name, Flags flags) {
+  Histogram* histogram(NULL);
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    BooleanHistogram* boolean_histogram = new BooleanHistogram(name);
-    boolean_histogram->InitializeBucketRange();
-    histogram = boolean_histogram;
-    histogram->SetFlags(flags);
-    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
+    // To avoid racy destruction at shutdown, the following will be leaked.
+    BooleanHistogram* tentative_histogram = new BooleanHistogram(name);
+    tentative_histogram->InitializeBucketRange();
+    tentative_histogram->SetFlags(flags);
+    histogram =
+        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   DCHECK_EQ(BOOLEAN_HISTOGRAM, histogram->histogram_type());
   return histogram;
 }
 
 Histogram::ClassType BooleanHistogram::histogram_type() const {
   return BOOLEAN_HISTOGRAM;
 }
 
 void BooleanHistogram::AddBoolean(bool value) {
   Add(value ? 1 : 0);
 }
 
 BooleanHistogram::BooleanHistogram(const std::string& name)
     : LinearHistogram(name, 1, 2, 3) {
 }
 
 //------------------------------------------------------------------------------
 // CustomHistogram:
 //------------------------------------------------------------------------------
 
-scoped_refptr<Histogram> CustomHistogram::FactoryGet(
-    const std::string& name,
-    const std::vector<Sample>& custom_ranges,
-    Flags flags) {
-  scoped_refptr<Histogram> histogram(NULL);
+Histogram* CustomHistogram::FactoryGet(const std::string& name,
+                                       const std::vector<Sample>& custom_ranges,
+                                       Flags flags) {
+  Histogram* histogram(NULL);
 
   // Remove the duplicates in the custom ranges array.
   std::vector<int> ranges = custom_ranges;
   ranges.push_back(0);  // Ensure we have a zero value.
   std::sort(ranges.begin(), ranges.end());
   ranges.erase(std::unique(ranges.begin(), ranges.end()), ranges.end());
   if (ranges.size() <= 1) {
     DCHECK(false);
     // Note that we pushed a 0 in above, so for defensive code....
     ranges.push_back(1);  // Put in some data so we can index to [1].
   }
 
   DCHECK_LT(ranges.back(), kSampleType_MAX);
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    CustomHistogram* custom_histogram = new CustomHistogram(name, ranges);
-    custom_histogram->InitializedCustomBucketRange(ranges);
-    histogram = custom_histogram;
-    histogram->SetFlags(flags);
-    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
+    // To avoid racy destruction at shutdown, the following will be leaked.
+    CustomHistogram* tentative_histogram = new CustomHistogram(name, ranges);
+    tentative_histogram->InitializedCustomBucketRange(ranges);
+    tentative_histogram->SetFlags(flags);
+    histogram =
+        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   DCHECK_EQ(histogram->histogram_type(), CUSTOM_HISTOGRAM);
   DCHECK(histogram->HasConstructorArguments(ranges[1], ranges.back(),
                                             ranges.size()));
   return histogram;
 }
 
 Histogram::ClassType CustomHistogram::histogram_type() const {
   return CUSTOM_HISTOGRAM;
@@ skipping 65 matching lines @@
 }
 
 // static
 bool StatisticsRecorder::IsActive() {
   if (lock_ == NULL)
     return false;
   base::AutoLock auto_lock(*lock_);
   return NULL != histograms_;
 }
 
-// Note: We can't accept a ref_ptr to |histogram| because we *might* not keep a
-// reference, and we are called while in the Histogram constructor. In that
-// scenario, a ref_ptr would have incremented the ref count when the histogram
-// was passed to us, decremented it when we returned, and the instance would be
-// destroyed before assignment (when value was returned by new).
-// static
-void StatisticsRecorder::RegisterOrDiscardDuplicate(
-    scoped_refptr<Histogram>* histogram) {
-  DCHECK((*histogram)->HasValidRangeChecksum());
+Histogram* StatisticsRecorder::RegisterOrDeleteDuplicate(Histogram* histogram) {
+  DCHECK(histogram->HasValidRangeChecksum());
   if (lock_ == NULL)
-    return;
+    return histogram;
   base::AutoLock auto_lock(*lock_);
   if (!histograms_)
-    return;
-  const std::string name = (*histogram)->histogram_name();
+    return histogram;
+  const std::string name = histogram->histogram_name();
   HistogramMap::iterator it = histograms_->find(name);
   // Avoid overwriting a previous registration.
-  if (histograms_->end() == it)
-    (*histograms_)[name] = *histogram;
-  else
-    *histogram = it->second;
+  if (histograms_->end() == it) {
+    (*histograms_)[name] = histogram;
+  } else {
+    delete histogram;  // We already have one by this name.
+    histogram = it->second;
+  }
+  return histogram;
 }
 
 // static
 void StatisticsRecorder::WriteHTMLGraph(const std::string& query,
                                         std::string* output) {
   if (!IsActive())
     return;
   output->append("<html><head><title>About Histograms");
   if (!query.empty())
     output->append(" - " + query);
@@ skipping 42 matching lines @@
     return;
   for (HistogramMap::iterator it = histograms_->begin();
        histograms_->end() != it;
        ++it) {
     DCHECK_EQ(it->first, it->second->histogram_name());
     output->push_back(it->second);
   }
 }
 
 bool StatisticsRecorder::FindHistogram(const std::string& name,
-                                       scoped_refptr<Histogram>* histogram) {
+                                       Histogram** histogram) {
   if (lock_ == NULL)
     return false;
   base::AutoLock auto_lock(*lock_);
   if (!histograms_)
     return false;
   HistogramMap::iterator it = histograms_->find(name);
   if (histograms_->end() == it)
     return false;
   *histogram = it->second;
   return true;
@@ skipping 16 matching lines @@
 }
 
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 base::Lock* StatisticsRecorder::lock_ = NULL;
 // static
 bool StatisticsRecorder::dump_on_exit_ = false;
 
 }  // namespace base