Merge multiple histogram snapshots into single one for reporting.

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/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 204 matching lines @@
     NOTREACHED();
     return nullptr;
   }
   ranges = StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
   HistogramBase::AtomicCount* counts_data =
       allocator->GetAsObject<HistogramBase::AtomicCount>(
           histogram_data.counts_ref, kTypeIdCountsArray);
   if (!counts_data ||
       allocator->GetAllocSize(histogram_data.counts_ref) <
-          histogram_data.bucket_count * sizeof(HistogramBase::AtomicCount)) {
+          2 * histogram_data.bucket_count *
+          sizeof(HistogramBase::AtomicCount)) {

[Alexei Svitkine (slow), 2016/02/09 19:46:51]

Nit: Can you make a variable to store the size and a comment above for the
calculation? Then, the if can be a but more concise.

Or make a helper for it, since you use it on line 364 too.

[bcwhite, 2016/02/11 16:42:38]

Done.

     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_COUNTS_ARRAY);
     NOTREACHED();
     return nullptr;
   }
+  HistogramBase::AtomicCount* logged_data =

[Alexei Svitkine (slow), 2016/02/09 19:46:51]

Add a comment mentioning the second half of the counts data is the logged data.

[bcwhite, 2016/02/11 16:42:38]

Done.

+      counts_data + histogram_data.bucket_count;
 
   std::string name(histogram_data_ptr->name);
   HistogramBase* histogram = nullptr;
   switch (histogram_data.histogram_type) {
     case HISTOGRAM:
       histogram = Histogram::PersistentGet(
           name,
           histogram_data.minimum,
           histogram_data.maximum,
           ranges,
           counts_data,
+          logged_data,
           histogram_data.bucket_count,
           &histogram_data_ptr->samples_metadata);
       DCHECK(histogram);
       break;
     case LINEAR_HISTOGRAM:
       histogram = LinearHistogram::PersistentGet(
           name,
           histogram_data.minimum,
           histogram_data.maximum,
           ranges,
           counts_data,
+          logged_data,
           histogram_data.bucket_count,
           &histogram_data_ptr->samples_metadata);
       DCHECK(histogram);
       break;
     case BOOLEAN_HISTOGRAM:
       histogram = BooleanHistogram::PersistentGet(
           name,
           ranges,
           counts_data,
+          logged_data,
           &histogram_data_ptr->samples_metadata);
       DCHECK(histogram);
       break;
     case CUSTOM_HISTOGRAM:
       histogram = CustomHistogram::PersistentGet(
           name,
           ranges,
           counts_data,
+          logged_data,
           histogram_data.bucket_count,
           &histogram_data_ptr->samples_metadata);
       DCHECK(histogram);
       break;
     default:
       NOTREACHED();
   }
 
   if (histogram) {
     DCHECK_EQ(histogram_data.histogram_type, histogram->GetHistogramType());
@@ skipping 65 matching lines @@
 
   size_t bucket_count = bucket_ranges->bucket_count();
   // An overflow such as this, perhaps as the result of a milicious actor,
   // could lead to writing beyond the allocation boundary and into other
   // memory. Just fail the allocation and let the caller deal with it.
   if (bucket_count > std::numeric_limits<int32_t>::max() /
                      sizeof(HistogramBase::AtomicCount)) {
     NOTREACHED();
     return nullptr;
   }
-  size_t counts_bytes = bucket_count * sizeof(HistogramBase::AtomicCount);
+
+  // Allocate persistent memory for 2x bucket counts (one for "live" and one
+  // for "logged") and memory for bucket ranges.
+  size_t counts_bytes = 2 * bucket_count * sizeof(HistogramBase::AtomicCount);
   size_t ranges_bytes = (bucket_count + 1) * sizeof(HistogramBase::Sample);
   PersistentMemoryAllocator::Reference ranges_ref =
       allocator->Allocate(ranges_bytes, kTypeIdRangesArray);
   PersistentMemoryAllocator::Reference counts_ref =
       allocator->Allocate(counts_bytes, kTypeIdCountsArray);
   PersistentMemoryAllocator::Reference histogram_ref =
       allocator->Allocate(offsetof(PersistentHistogramData, name) +
                           name.length() + 1, kTypeIdHistogram);
   HistogramBase::Sample* ranges_data =
       allocator->GetAsObject<HistogramBase::Sample>(ranges_ref,
@@ skipping 65 matching lines @@
     for (;;) {
       HistogramBase* histogram = GetNextPersistentHistogram(g_allocator, &iter);
       if (!histogram)
         break;
       StatisticsRecorder::RegisterOrDeleteDuplicate(histogram);
     }
   }
 }
 
 }  // namespace base