Embed a single sample in histogram metadata.

base/metrics/sample_vector.h

 // 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.
 
 // SampleVector implements HistogramSamples interface. It is used by all
 // Histogram based classes to store samples.
 
 #ifndef BASE_METRICS_SAMPLE_VECTOR_H_
 #define BASE_METRICS_SAMPLE_VECTOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
+#include "base/atomicops.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
+#include "base/metrics/persistent_memory_allocator.h"
 
 namespace base {
 
 class BucketRanges;
 
-class BASE_EXPORT SampleVector : public HistogramSamples {
+class BASE_EXPORT SampleVectorBase : public HistogramSamples {
  public:
-  explicit SampleVector(const BucketRanges* bucket_ranges);
-  SampleVector(uint64_t id, const BucketRanges* bucket_ranges);
-  SampleVector(uint64_t id,
-               HistogramBase::AtomicCount* counts,
-               size_t counts_size,
-               Metadata* meta,
-               const BucketRanges* bucket_ranges);
-  ~SampleVector() override;
+  SampleVectorBase(uint64_t id, const BucketRanges* bucket_ranges);
+  SampleVectorBase(uint64_t id,
+                   Metadata* meta,
+                   const BucketRanges* bucket_ranges);
+  ~SampleVectorBase() override;
 
-  // HistogramSamples implementation:
+  // HistogramSamples:
   void Accumulate(HistogramBase::Sample value,
                   HistogramBase::Count count) override;
   HistogramBase::Count GetCount(HistogramBase::Sample value) const override;
   HistogramBase::Count TotalCount() const override;
   std::unique_ptr<SampleCountIterator> Iterator() const override;
 
   // Get count of a specific bucket.
   HistogramBase::Count GetCountAtIndex(size_t bucket_index) const;
 
  protected:
   bool AddSubtractImpl(
       SampleCountIterator* iter,
       HistogramSamples::Operator op) override;  // |op| is ADD or SUBTRACT.
 
   virtual size_t GetBucketIndex(HistogramBase::Sample value) const;
 
+  // Moves the single-sample value to a mounted "counts" array.
+  void MoveSingleSampleToCounts();
+
+  // Mounts (creating if necessary) an array of "counts" for multi-value
+  // storage.
+  void MountCountsStorageAndMoveSingleSample();
+
+  // Mounts "counts" storage that already exists. This does not attempt to move
+  // any single-sample information to that storage as that would violate the
+  // "const" restriction that is often used to indicate read-only memory.
+  virtual bool MountExistingCountsStorage() const = 0;
+
+  // Creates "counts" storage and returns a pointer to it. Ownership of the
+  // array remains with the called method but will never change. This must be
+  // called while some sort of lock is held to prevent reentry.
+  virtual HistogramBase::Count* CreateCountsStorageWhileLocked() = 0;
+
+  HistogramBase::AtomicCount* counts() {
+    return reinterpret_cast<HistogramBase::AtomicCount*>(
+        subtle::Acquire_Load(&counts_));
+  }
+
+  const HistogramBase::AtomicCount* counts() const {
+    return reinterpret_cast<HistogramBase::AtomicCount*>(
+        subtle::Acquire_Load(&counts_));
+  }
+
+  void set_counts(const HistogramBase::AtomicCount* counts) const {
+    subtle::Release_Store(&counts_, reinterpret_cast<uintptr_t>(counts));
+  }
+
+  size_t counts_size() const { return counts_size_; }
+
  private:
+  friend class SampleVectorTest;
   FRIEND_TEST_ALL_PREFIXES(HistogramTest, CorruptSampleCounts);
   FRIEND_TEST_ALL_PREFIXES(SharedHistogramTest, CorruptSampleCounts);
 
-  // In the case where this class manages the memory, here it is.
-  std::vector<HistogramBase::AtomicCount> local_counts_;
-
-  // These are raw pointers rather than objects for flexibility. The actual
-  // memory is either managed by local_counts_ above or by an external object
-  // and passed in directly.
-  HistogramBase::AtomicCount* counts_;
-  size_t counts_size_;
+  // |counts_| is actually a pointer to a HistogramBase::AtomicCount array but
+  // is held as an AtomicWord for concurrency reasons. When combined with the
+  // single_sample held in the metadata, there are four possible states:
+  //   1) single_sample == zero, counts_ == null
+  //   2) single_sample != zero, counts_ == null
+  //   3) single_sample != zero, counts_ != null BUT IS EMPTY
+  //   4) single_sample == zero, counts_ != null and may have data
+  // Once |counts_| is set, it can never revert and any existing single-sample
+  // must be moved to this storage. It is mutable because changing it doesn't
+  // change the (const) data but must adapt if a non-const object causes the
+  // storage to be allocated and updated.
+  mutable subtle::AtomicWord counts_ = 0;
+  const size_t counts_size_;

[Alexei Svitkine (slow), 2017/04/20 19:56:14]

Do we need this as a separate field or can we get rid of this given we can get
this from the bucket_ranges_ object?

(I was going to originally suggest to add a comment about this always being
initialized even when counts isn't... but seems simpler to just get rid of it
and just use bucket_ranges_?)

[bcwhite, 2017/04/20 21:18:08]

Done.

 
   // Shares the same BucketRanges with Histogram object.
   const BucketRanges* const bucket_ranges_;
 
+  DISALLOW_COPY_AND_ASSIGN(SampleVectorBase);
+};
+
+// A sample vector that uses local memory for the counts array.
+class BASE_EXPORT SampleVector : public SampleVectorBase {
+ public:
+  explicit SampleVector(const BucketRanges* bucket_ranges);
+  SampleVector(uint64_t id, const BucketRanges* bucket_ranges);
+  ~SampleVector() override;
+
+ private:
+  // SampleVectorBase:
+  bool MountExistingCountsStorage() const override;
+  HistogramBase::Count* CreateCountsStorageWhileLocked() override;
+
+  // Simple local storage for counts.
+  mutable std::vector<HistogramBase::AtomicCount> local_counts_;
+
   DISALLOW_COPY_AND_ASSIGN(SampleVector);
 };
 
+// A sample vector that uses persistent memory for the counts array.
+class BASE_EXPORT PersistentSampleVector : public SampleVectorBase {
+ public:
+  PersistentSampleVector(uint64_t id,
+                         const BucketRanges* bucket_ranges,
+                         Metadata* meta,
+                         const DelayedPersistentAllocation& counts);
+  ~PersistentSampleVector() override;
+
+ private:
+  // SampleVectorBase:
+  bool MountExistingCountsStorage() const override;
+  HistogramBase::Count* CreateCountsStorageWhileLocked() override;
+
+  // Persistent storage for counts.
+  DelayedPersistentAllocation persistent_counts_;
+
+  DISALLOW_COPY_AND_ASSIGN(PersistentSampleVector);
+};
+
+// An iterator for sample vectors. This could be defined privately in the .cc
+// file but is here for easy testing.
 class BASE_EXPORT SampleVectorIterator : public SampleCountIterator {
  public:
   SampleVectorIterator(const std::vector<HistogramBase::AtomicCount>* counts,
                        const BucketRanges* bucket_ranges);
   SampleVectorIterator(const HistogramBase::AtomicCount* counts,
                        size_t counts_size,
                        const BucketRanges* bucket_ranges);
   ~SampleVectorIterator() override;
 
   // SampleCountIterator implementation:
@@ skipping 12 matching lines @@
   const HistogramBase::AtomicCount* counts_;
   size_t counts_size_;
   const BucketRanges* bucket_ranges_;
 
   size_t index_;
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_SAMPLE_VECTOR_H_