Cache the ranges_ vector and share the ranges_ vector

base/metrics/histogram.h

 // 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).
 
 // It supports calls to accumulate either time intervals (which are processed
 // as integral number of milliseconds), or arbitrary integral units.
@@ skipping 23 matching lines @@
 // initialization is not a problem as it is always set to point to the same
 // value (i.e., the FactoryGet always returns the same value).  FactoryGet
 // is also completely thread safe, which results in a completely thread safe,
 // and relatively fast, set of counters.  To avoid races at shutdown, the static
 // pointer is NOT deleted, and we leak the histograms at process termination.
 
 #ifndef BASE_METRICS_HISTOGRAM_H_
 #define BASE_METRICS_HISTOGRAM_H_
 #pragma once
 
+#include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/time.h"
 
@@ skipping 255 matching lines @@
             boundary_value + 1, base::Histogram::kUmaTargetedHistogramFlag))
 
 #define UMA_HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) \
     STATIC_HISTOGRAM_POINTER_BLOCK(name, Add(sample), \
         base::CustomHistogram::FactoryGet(name, custom_ranges, \
             base::Histogram::kUmaTargetedHistogramFlag))
 
 //------------------------------------------------------------------------------
 
 class BooleanHistogram;
+class CachedRanges;
 class CustomHistogram;
 class Histogram;
 class LinearHistogram;
 
 class BASE_EXPORT Histogram {
  public:
   typedef int Sample;  // Used for samples (and ranges of samples).
   typedef int Count;  // Used to count samples in a bucket.
   static const Sample kSampleType_MAX = INT_MAX;
   // Initialize maximum number of buckets in histograms as 16,384.
   static const size_t kBucketCount_MAX;
 
   typedef std::vector<Count> Counts;
-  typedef std::vector<Sample> Ranges;
 
   // These enums are used to facilitate deserialization of renderer histograms
   // into the browser.
   enum ClassType {
     HISTOGRAM,
     LINEAR_HISTOGRAM,
     BOOLEAN_HISTOGRAM,
     CUSTOM_HISTOGRAM,
     NOT_VALID_IN_RENDERER
   };
@@ skipping 153 matching lines @@
   //----------------------------------------------------------------------------
   // Accessors for factory constuction, serialization and testing.
   //----------------------------------------------------------------------------
   virtual ClassType histogram_type() const;
   const std::string& histogram_name() const { return histogram_name_; }
   Sample declared_min() const { return declared_min_; }
   Sample declared_max() const { return declared_max_; }
   virtual Sample ranges(size_t i) const;
   uint32 range_checksum() const { return range_checksum_; }
   virtual size_t bucket_count() const;
+  CachedRanges* cached_ranges() const { return cached_ranges_; }
+  void set_cached_ranges(CachedRanges* cached_ranges) {
+    cached_ranges_ = cached_ranges;
+  }
   // Snapshot the current complete set of sample data.
   // Override with atomic/locked snapshot if needed.
   virtual void SnapshotSample(SampleSet* sample) const;
 
   virtual bool HasConstructorArguments(Sample minimum, Sample maximum,
                                        size_t bucket_count);
 
   virtual bool HasConstructorTimeDeltaArguments(TimeDelta minimum,
                                                 TimeDelta maximum,
                                                 size_t bucket_count);
-  // Return true iff the range_checksum_ matches current ranges_ vector.
+  // Return true iff the range_checksum_ matches current |ranges_| vector in
+  // |cached_ranges_|.
   bool HasValidRangeChecksum() const;
 
  protected:
   Histogram(const std::string& name, Sample minimum,
             Sample maximum, size_t bucket_count);
   Histogram(const std::string& name, TimeDelta minimum,
             TimeDelta maximum, size_t bucket_count);
 
   virtual ~Histogram();
 
-  // Initialize ranges_ mapping.
+  // Initialize ranges_ mapping in cached_ranges_.
   void InitializeBucketRange();
 
   // Method to override to skip the display of the i'th bucket if it's empty.
   virtual bool PrintEmptyBucket(size_t index) const;
 
   //----------------------------------------------------------------------------
   // Methods to override to create histogram with different bucket widths.
   //----------------------------------------------------------------------------
   // Find bucket to increment for sample value.
   virtual size_t BucketIndex(Sample value) const;
-  // Get normalized size, relative to the ranges_[i].
+  // Get normalized size, relative to the ranges(i).
   virtual double GetBucketSize(Count current, size_t i) const;
 
   // Recalculate range_checksum_.
   void ResetRangeChecksum();
 
   // Return a string description of what goes in a given bucket.
   // Most commonly this is the numeric value, but in derived classes it may
   // be a name (or string description) given to the bucket.
   virtual const std::string GetAsciiBucketRange(size_t it) const;
 
   //----------------------------------------------------------------------------
   // Methods to override to create thread safe histogram.
   //----------------------------------------------------------------------------
   // Update all our internal data, including histogram
   virtual void Accumulate(Sample value, Count count, size_t index);
 
   //----------------------------------------------------------------------------
   // Accessors for derived classes.
   //----------------------------------------------------------------------------
   void SetBucketRange(size_t i, Sample value);
 
-  // Validate that ranges_ was created sensibly (top and bottom range
-  // values relate properly to the declared_min_ and declared_max_)..
+  // Validate that ranges_ in cached_ranges_ was created sensibly (top and
+  // bottom range values relate properly to the declared_min_ and
+  // declared_max_).
   bool ValidateBucketRanges() const;
 
   virtual uint32 CalculateRangeChecksum() const;
 
  private:
   // Allow tests to corrupt our innards for testing purposes.
   FRIEND_TEST(HistogramTest, CorruptBucketBounds);
   FRIEND_TEST(HistogramTest, CorruptSampleCounts);
   FRIEND_TEST(HistogramTest, Crc32SampleHash);
   FRIEND_TEST(HistogramTest, Crc32TableTest);
@@ skipping 43 matching lines @@
   Sample declared_min_;  // Less than this goes into counts_[0]
   Sample declared_max_;  // Over this goes into counts_[bucket_count_ - 1].
   size_t bucket_count_;  // Dimension of counts_[].
 
   // Flag the histogram for recording by UMA via metric_services.h.
   Flags flags_;
 
   // For each index, show the least value that can be stored in the
   // corresponding bucket. We also append one extra element in this array,
   // containing kSampleType_MAX, to make calculations easy.
-  // The dimension of ranges_ is bucket_count + 1.
-  Ranges ranges_;
+  // The dimension of ranges_ in cached_ranges_ is bucket_count + 1.
+  CachedRanges* cached_ranges_;
 
   // For redundancy, we store a checksum of all the sample ranges when ranges
   // are generated.  If ever there is ever a difference, then the histogram must
   // have been corrupted.
   uint32 range_checksum_;
 
   // Finally, provide the state that changes with the addition of each new
   // sample.
   SampleSet sample_;
 
@@ skipping 28 matching lines @@
   // The last element in the array has a null in its "description" slot.
   virtual void SetRangeDescriptions(const DescriptionPair descriptions[]);
 
  protected:
   LinearHistogram(const std::string& name, Sample minimum,
                   Sample maximum, size_t bucket_count);
 
   LinearHistogram(const std::string& name, TimeDelta minimum,
                   TimeDelta maximum, size_t bucket_count);
 
-  // Initialize ranges_ mapping.
+  // Initialize ranges_ mapping in cached_ranges_.
   void InitializeBucketRange();
   virtual double GetBucketSize(Count current, size_t i) const;
 
   // If we have a description for a bucket, then return that.  Otherwise
   // let parent class provide a (numeric) description.
   virtual const std::string GetAsciiBucketRange(size_t i) const;
 
   // Skip printing of name for numeric range if we have a name (and if this is
   // an empty bucket).
   virtual bool PrintEmptyBucket(size_t index) const;
@@ skipping 43 matching lines @@
   // This function ensures that a guard bucket exists right after any
   // valid sample value (unless the next higher sample is also a valid value),
   // so that invalid samples never fall into the same bucket as valid samples.
   static std::vector<Sample> ArrayToCustomRanges(const Sample* values,
                                                  size_t num_values);
 
  protected:
   CustomHistogram(const std::string& name,
                   const std::vector<Sample>& custom_ranges);
 
-  // Initialize ranges_ mapping.
+  // Initialize ranges_ mapping in cached_ranges_.
   void InitializedCustomBucketRange(const std::vector<Sample>& custom_ranges);
   virtual double GetBucketSize(Count current, size_t i) const;
 
   DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
 };
 
 //------------------------------------------------------------------------------
 // StatisticsRecorder handles all histograms in the system.  It provides a
 // general place for histograms to register, and supports a global API for
 // accessing (i.e., dumping, or graphing) the data in all the histograms.
 
 class BASE_EXPORT StatisticsRecorder {
  public:
   typedef std::vector<Histogram*> Histograms;
 
   StatisticsRecorder();
 
   ~StatisticsRecorder();
 
   // Find out if histograms can now be registered into our list.
   static bool IsActive();
 
   // Register, or add a new histogram to the collection of statistics. If an
   // identically named histogram is already registered, then the argument
   // |histogram| will deleted.  The returned value is always the registered
   // histogram (either the argument, or the pre-existing registered histogram).
   static Histogram* RegisterOrDeleteDuplicate(Histogram* histogram);
 
+  // Register, or add a new cached_ranges_ of |histogram|. If an identical
+  // cached_ranges_ is already registered, then the cached_ranges_ of
+  // |histogram| is deleted and the |histogram|'s cached_ranges_ is reset to the
+  // registered cached_ranges_.  The cached_ranges_ of |histogram| is always the
+  // registered CachedRanges (either the argument's cached_ranges_, or the
+  // pre-existing registered cached_ranges_).
+  static void RegisterOrDeleteDuplicateRanges(Histogram* histogram);
+
+  // Method for collecting stats about histograms created in browser and
+  // renderer processes. |suffix| is appended to histogram names. |suffix| could
+  // be either browser or renderer.
+  static void CollectHistogramStats(const std::string& suffix);
+
   // Methods for printing histograms.  Only histograms which have query as
   // a substring are written to output (an empty string will process all
   // registered histograms).
   static void WriteHTMLGraph(const std::string& query, std::string* output);
   static void WriteGraph(const std::string& query, std::string* output);
 
   // Method for extracting histograms which were marked for use by UMA.
   static void GetHistograms(Histograms* output);
 
   // Find a histogram by name. It matches the exact name. This method is thread
   // safe.  If a matching histogram is not found, then the |histogram| is
   // not changed.
   static bool FindHistogram(const std::string& query, Histogram** histogram);
 
   static bool dump_on_exit() { return dump_on_exit_; }
 
   static void set_dump_on_exit(bool enable) { dump_on_exit_ = enable; }
 
   // GetSnapshot copies some of the pointers to registered histograms into the
   // caller supplied vector (Histograms).  Only histograms with names matching
   // query are returned. The query must be a substring of histogram name for its
   // pointer to be copied.
   static void GetSnapshot(const std::string& query, Histograms* snapshot);
 
 
  private:
   // We keep all registered histograms in a map, from name to histogram.
   typedef std::map<std::string, Histogram*> HistogramMap;
 
+  // We keep all |cached_ranges_| in a map, from checksum to a list of
+  // |cached_ranges_|.  Checksum is calculated from the |ranges_| in
+  // |cached_ranges_|.
+  typedef std::map<uint32, std::list<CachedRanges*>*> RangesMap;
+
   static HistogramMap* histograms_;
 
+  static RangesMap* ranges_;
+
   // lock protects access to the above map.
   static base::Lock* lock_;
 
   // Dump all known histograms to log.
   static bool dump_on_exit_;
 
   DISALLOW_COPY_AND_ASSIGN(StatisticsRecorder);
 };
 
+//------------------------------------------------------------------------------
+
+// CachedRanges stores the Ranges vector. Histograms that have same Ranges
+// vector will use the same CachedRanges object.
+class BASE_EXPORT CachedRanges {
+ public:
+  typedef std::vector<Histogram::Sample> Ranges;
+
+  CachedRanges(size_t bucket_count, int initial_value);
+  ~CachedRanges();
+
+  //----------------------------------------------------------------------------
+  // Accessors methods for ranges_ and range_checksum_.
+  //----------------------------------------------------------------------------
+  size_t size() const { return ranges_.size(); }
+  Histogram::Sample ranges(size_t i) const { return ranges_[i]; }
+  void SetBucketRange(size_t i, Histogram::Sample value);
+  uint32 range_checksum(uint32 checksum) const { return range_checksum_; }
+  void SetRangeChecksum(uint32 checksum) { range_checksum_ = checksum; }
+
+  // Return true iff |other| object has same ranges_ as |this| object's ranges_.
+  bool Equals(CachedRanges* other) const;
+
+ private:
+  // Allow tests to corrupt our innards for testing purposes.
+  FRIEND_TEST(HistogramTest, CorruptBucketBounds);
+
+  // A monotonically increasing list of values which determine which bucket to
+  // put a sample into.  For each index, show the smallest sample that can be
+  // added to the corresponding bucket.
+  Ranges ranges_;
+
+  // Checksum for the conntents of ranges_.  Used to detect random over-writes
+  // of our data, and to quickly see if some other CachedRanges instance is
+  // possibly Equal() to this instance.
+  uint32 range_checksum_;
+
+  DISALLOW_COPY_AND_ASSIGN(CachedRanges);
+};
+
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_H_