Reduce histogram creation time by avoiding import of those just created.

base/metrics/histogram_persistence.cc

 // Copyright (c) 2015 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/histogram_persistence.h"
 
+#include "base/atomicops.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/synchronization/lock.h"
 
 namespace base {
@@ skipping 63 matching lines @@
   PersistentMemoryAllocator::Reference counts_ref;
   HistogramSamples::Metadata samples_metadata;
   HistogramSamples::Metadata logged_metadata;
 
   // Space for the histogram name will be added during the actual allocation
   // request. This must be the last field of the structure. A zero-size array
   // or a "flexible" array would be preferred but is not (yet) valid C++.
   char name[1];
 };
 
+// This is the offset of the last histogram that was created. It is used to
+// avoid trying to import the same thing just to have it rejected because
+// it already exists.
+subtle::AtomicWord g_last_created_histogram = 0;
+
 // The object held here will obviously not be destructed at process exit
 // but that's okay since PersistentMemoryAllocator objects are explicitly
 // forbidden from doing anything essential at exit anyway due to the fact
 // that they depend on data managed elsewhere and which could be destructed
 // first.
 PersistentMemoryAllocator* g_allocator = nullptr;
 
 // Take an array of range boundaries and create a proper BucketRanges object
 // which is returned to the caller. A return of nullptr indicates that the
 // passed boundaries are invalid.
@@ skipping 118 matching lines @@
       // If that memory segment were to be deleted, future calls to create
       // persistent histograms would crash. To avoid this, have the test call
       // the method GetCreateHistogramResultHistogram() *before* setting the
       // (temporary) memory allocator via SetPersistentMemoryAllocator() so
       // that the histogram is instead allocated from the process heap.
       DCHECK_NE(kResultHistogram, histogram_data->name);
     }
   }
 
   g_allocator = nullptr;
+  subtle::NoBarrier_Store(&g_last_created_histogram, 0);
   return allocator;
 };
 
 HistogramBase* CreatePersistentHistogram(
     PersistentMemoryAllocator* allocator,
     PersistentHistogramData* histogram_data_ptr) {
   if (!histogram_data_ptr) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_METADATA_POINTER);
     NOTREACHED();
     return nullptr;
@@ skipping 225 matching lines @@
     // Create the histogram using resources in persistent memory. This ends up
     // resolving the "ref" values stored in histogram_data instad of just
     // using what is already known above but avoids duplicating the switch
     // statement here and serves as a double-check that everything is
     // correct before commiting the new histogram to persistent space.
     HistogramBase* histogram =
         CreatePersistentHistogram(allocator, histogram_data);
     DCHECK(histogram);
     if (ref_ptr != nullptr)
       *ref_ptr = histogram_ref;
+    subtle::NoBarrier_Store(&g_last_created_histogram, histogram_ref);
     return histogram;
   }
 
   CreateHistogramResultType result;
   if (allocator->IsCorrupt()) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_ALLOCATOR_NEWLY_CORRUPT);
     result = CREATE_HISTOGRAM_ALLOCATOR_CORRUPT;
   } else if (allocator->IsFull()) {
     result = CREATE_HISTOGRAM_ALLOCATOR_FULL;
   } else {
@@ skipping 13 matching lines @@
   if (g_allocator) {
     base::AutoLock auto_lock(lock.Get());
 
     // Each call resumes from where it last left off so need persistant
     // iterator. This class has a constructor so even the definition has
     // to be protected by the lock in order to be thread-safe.
     static PersistentMemoryAllocator::Iterator iter;
     if (iter.is_clear())
       g_allocator->CreateIterator(&iter);
 
-    while (true) {
-      HistogramBase* histogram = GetNextPersistentHistogram(g_allocator, &iter);
-      if (!histogram)
-        break;
-      StatisticsRecorder::RegisterOrDeleteDuplicate(histogram);
+    PersistentMemoryAllocator::Reference last_created =
+        subtle::NoBarrier_Load(&g_last_created_histogram);
+
+    PersistentMemoryAllocator::Reference ref;
+    uint32_t type_id;
+    while ((ref = g_allocator->GetNextIterable(&iter, &type_id)) != 0) {
+      // Ignore any other type of objects in the allocator.
+      if (type_id != kTypeIdHistogram)
+        continue;
+
+      // Skip the import if it's the histogram that was last created.
+      // Should a race condition cause the "last created" to be overwritten
+      // before it is recognized here then the histogram will be created
+      // and be ignored when it is detected as a duplicate by the
+      // statistics-recorder.
+      if (ref == last_created)
+        continue;
+
+      // Create the histogram from contents in persistent memory and add it
+      // to the set of known ones.
+      HistogramBase* histogram = GetPersistentHistogram(g_allocator, ref);
+      if (histogram)
+        StatisticsRecorder::RegisterOrDeleteDuplicate(histogram);
     }
   }
 }
 
 }  // namespace base