Skeleton code of SparseHistogram

base/metrics/histogram.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.
 
 // 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 46 matching lines @@
 
 #ifndef BASE_METRICS_HISTOGRAM_H_
 #define BASE_METRICS_HISTOGRAM_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
+#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/metrics/bucket_ranges.h"
 #include "base/metrics/histogram_base.h"
 #include "base/time.h"
 
 class Pickle;
 class PickleIterator;
 
@@ skipping 24 matching lines @@
     // Acquire_Load() ensures that we acquire visibility to the pointed-to data
     // in the histogrom.
     base::Histogram* histogram_pointer(reinterpret_cast<base::Histogram*>(
         base::subtle::Acquire_Load(&atomic_histogram_pointer)));
 
     if (!histogram_pointer) {
       // This is the slow path, which will construct OR find the matching
       // histogram.  FactoryGet includes locks on a global histogram name map
       // and is completely thread safe.
       histogram_pointer = base::Histogram::FactoryGet(
-          name, min, max, bucket_count, base::Histogram::kNoFlags);
+          name, min, max, bucket_count, base::HistogramBase::kNoFlags);
 
       // Use Release_Store to ensure that the histogram data is made available
       // globally before we make the pointer visible.
       // Several threads may perform this store, but the same value will be
       // stored in all cases (for a given named/spec'ed histogram).
       // We could do this without any barrier, since FactoryGet entered and
       // exited a lock after construction, but this barrier makes things clear.
       base::subtle::Release_Store(&atomic_histogram_pointer,
           reinterpret_cast<base::subtle::AtomicWord>(histogram_pointer));
     }
@@ skipping 42 matching lines @@
 
 #define HISTOGRAM_COUNTS_100(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
     name, sample, 1, 100, 50)
 
 #define HISTOGRAM_COUNTS_10000(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
     name, sample, 1, 10000, 50)
 
 #define HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) \
     STATIC_HISTOGRAM_POINTER_BLOCK(name, Add(sample), \
         base::Histogram::FactoryGet(name, min, max, bucket_count, \
-                                    base::Histogram::kNoFlags))
+                                    base::HistogramBase::kNoFlags))
 
 #define HISTOGRAM_PERCENTAGE(name, under_one_hundred) \
     HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
 
 // For folks that need real specific times, use this to select a precise range
 // of times you want plotted, and the number of buckets you want used.
 #define HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
     STATIC_HISTOGRAM_POINTER_BLOCK(name, AddTime(sample), \
         base::Histogram::FactoryTimeGet(name, min, max, bucket_count, \
-                                        base::Histogram::kNoFlags))
+                                        base::HistogramBase::kNoFlags))
 
 // Support histograming of an enumerated value.  The samples should always be
 // strictly less than |boundary_value| -- this prevents you from running into
 // problems down the line if you add additional buckets to the histogram.  Note
 // also that, despite explicitly setting the minimum bucket value to |1| below,
 // it is fine for enumerated histograms to be 0-indexed -- this is because
 // enumerated histograms should never have underflow.
 #define HISTOGRAM_ENUMERATION(name, sample, boundary_value) \
     STATIC_HISTOGRAM_POINTER_BLOCK(name, Add(sample), \
         base::LinearHistogram::FactoryGet(name, 1, boundary_value, \
-            boundary_value + 1, base::Histogram::kNoFlags))
+            boundary_value + 1, base::HistogramBase::kNoFlags))
 
 // Support histograming of an enumerated value. Samples should be one of the
 // std::vector<int> list provided via |custom_ranges|. See comments above
 // CustomRanges::FactoryGet about the requirement of |custom_ranges|.
 // You can use the helper function CustomHistogram::ArrayToCustomRanges to
 // transform a C-style array of valid sample values to a std::vector<int>.
 #define HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) \
     STATIC_HISTOGRAM_POINTER_BLOCK(name, Add(sample), \
         base::CustomHistogram::FactoryGet(name, custom_ranges, \
-                                          base::Histogram::kNoFlags))
+                                          base::HistogramBase::kNoFlags))
 
 //------------------------------------------------------------------------------
 // Define Debug vs non-debug flavors of macros.
 #ifndef NDEBUG
 
 #define DHISTOGRAM_TIMES(name, sample) HISTOGRAM_TIMES(name, sample)
 #define DHISTOGRAM_COUNTS(name, sample) HISTOGRAM_COUNTS(name, sample)
 #define DHISTOGRAM_PERCENTAGE(name, under_one_hundred) HISTOGRAM_PERCENTAGE(\
     name, under_one_hundred)
 #define DHISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
@@ skipping 143 matching lines @@
     CUSTOM_HISTOGRAM,
     NOT_VALID_IN_RENDERER,
   };
 
   enum BucketLayout {
     EXPONENTIAL,
     LINEAR,
     CUSTOM,
   };
 
-  enum Flags {
-    kNoFlags = 0,
-    kUmaTargetedHistogramFlag = 0x1,  // Histogram should be UMA uploaded.
-
-    // Indicate that the histogram was pickled to be sent across an IPC Channel.
-    // If we observe this flag on a histogram being aggregated into after IPC,
-    // then we are running in a single process mode, and the aggregation should
-    // not take place (as we would be aggregating back into the source
-    // histogram!).
-    kIPCSerializationSourceFlag = 0x10,
-
-    kHexRangePrintingFlag = 0x8000,  // Fancy bucket-naming supported.
-  };
-
   enum Inconsistencies {
     NO_INCONSISTENCIES = 0x0,
     RANGE_CHECKSUM_ERROR = 0x1,
     BUCKET_ORDER_ERROR = 0x2,
     COUNT_HIGH_ERROR = 0x4,
     COUNT_LOW_ERROR = 0x8,
 
     NEVER_EXCEEDED_VALUE = 0x10
   };
 
@@ skipping 60 matching lines @@
   // maximum > minimum
   // buckets > 2 [minimum buckets needed: underflow, overflow and the range]
   // Additionally,
   // buckets <= (maximum - minimum + 2) - this is to ensure that we don't have
   // more buckets than the range of numbers; having more buckets than 1 per
   // value in the range would be nonsensical.
   static Histogram* FactoryGet(const std::string& name,
                                Sample minimum,
                                Sample maximum,
                                size_t bucket_count,
-                               Flags flags);
+                               int32 flags);
   static Histogram* FactoryTimeGet(const std::string& name,
                                    base::TimeDelta minimum,
                                    base::TimeDelta maximum,
                                    size_t bucket_count,
-                                   Flags flags);
+                                   int32 flags);
 
   // Time call for use with DHISTOGRAM*.
   // Returns TimeTicks::Now() in debug and TimeTicks() in release build.
   static TimeTicks DebugNow();
 
   static void InitializeBucketRanges(Sample minimum,
                                      Sample maximum,
                                      size_t bucket_count,
                                      BucketRanges* ranges);
 
   virtual void Add(Sample value) OVERRIDE;
 
   // This method is an interface, used only by BooleanHistogram.
   virtual void AddBoolean(bool value);
 
   // Accept a TimeDelta to increment.
   void AddTime(TimeDelta time) {
     Add(static_cast<int>(time.InMilliseconds()));
   }
 
   void AddSampleSet(const SampleSet& sample);
 
   // This method is an interface, used only by LinearHistogram.
   virtual void SetRangeDescriptions(const DescriptionPair descriptions[]);
 
   // The following methods provide graphical histogram displays.
   virtual void WriteHTMLGraph(std::string* output) const OVERRIDE;
   virtual void WriteAscii(std::string* output) const OVERRIDE;
 
-  // Support generic flagging of Histograms.
-  // 0x1 Currently used to mark this histogram to be recorded by UMA..
-  // 0x8000 means print ranges in hex.
-  void SetFlags(Flags flags) { flags_ = static_cast<Flags> (flags_ | flags); }
-  void ClearFlags(Flags flags) { flags_ = static_cast<Flags>(flags_ & ~flags); }
-  int flags() const { return flags_; }
-
   // Convenience methods for serializing/deserializing the histograms.
   // Histograms from Renderer process are serialized and sent to the browser.
   // Browser process reconstructs the histogram from the pickled version
   // accumulates the browser-side shadow copy of histograms (that mirror
   // histograms created in the renderer).
 
   // Serialize the given snapshot of a Histogram into a String. Uses
   // Pickle class to flatten the object.
   static std::string SerializeHistogramInfo(const Histogram& histogram,
                                             const SampleSet& snapshot);
@@ skipping 116 matching lines @@
   void WriteAsciiBucketGraph(double current_size, double max_size,
                              std::string* output) const;
 
   // Does not own this object. Should get from StatisticsRecorder.
   const BucketRanges* bucket_ranges_;
 
   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_;
-
   // Finally, provide the state that changes with the addition of each new
   // sample.
   SampleSet sample_;
 
   DISALLOW_COPY_AND_ASSIGN(Histogram);
 };
 
 //------------------------------------------------------------------------------
 
 // LinearHistogram is a more traditional histogram, with evenly spaced
 // buckets.
 class BASE_EXPORT LinearHistogram : public Histogram {
  public:
   virtual ~LinearHistogram();
 
   /* minimum should start from 1. 0 is as minimum is invalid. 0 is an implicit
      default underflow bucket. */
   static Histogram* FactoryGet(const std::string& name,
                                Sample minimum,
                                Sample maximum,
                                size_t bucket_count,
-                               Flags flags);
+                               int32 flags);
   static Histogram* FactoryTimeGet(const std::string& name,
                                    TimeDelta minimum,
                                    TimeDelta maximum,
                                    size_t bucket_count,
-                                   Flags flags);
+                                   int32 flags);
 
   static void InitializeBucketRanges(Sample minimum,
                                      Sample maximum,
                                      size_t bucket_count,
                                      BucketRanges* ranges);
 
   // Overridden from Histogram:
   virtual ClassType histogram_type() const OVERRIDE;
 
   // Store a list of number/text values for use in rendering the histogram.
@@ skipping 26 matching lines @@
   BucketDescriptionMap bucket_description_;
 
   DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // BooleanHistogram is a histogram for booleans.
 class BASE_EXPORT BooleanHistogram : public LinearHistogram {
  public:
-  static Histogram* FactoryGet(const std::string& name, Flags flags);
+  static Histogram* FactoryGet(const std::string& name, int32 flags);
 
   virtual ClassType histogram_type() const OVERRIDE;
 
   virtual void AddBoolean(bool value) OVERRIDE;
 
  private:
   BooleanHistogram(const std::string& name, const BucketRanges* ranges);
 
   DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // CustomHistogram is a histogram for a set of custom integers.
 class BASE_EXPORT CustomHistogram : public Histogram {
  public:
   // |custom_ranges| contains a vector of limits on ranges. Each limit should be
   // > 0 and < kSampleType_MAX. (Currently 0 is still accepted for backward
   // compatibility). The limits can be unordered or contain duplication, but
   // client should not depend on this.
   static Histogram* FactoryGet(const std::string& name,
                                const std::vector<Sample>& custom_ranges,
-                               Flags flags);
+                               int32 flags);
 
   // Overridden from Histogram:
   virtual ClassType histogram_type() const OVERRIDE;
 
   // Helper method for transforming an array of valid enumeration values
   // to the std::vector<int> expected by HISTOGRAM_CUSTOM_ENUMERATION.
   // 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.
   // TODO(kaiwang): Change name to ArrayToCustomEnumRanges.
@@ skipping 16 matching lines @@
   static bool ValidateCustomRanges(const std::vector<Sample>& custom_ranges);
   static BucketRanges* CreateBucketRangesFromCustomRanges(
       const std::vector<Sample>& custom_ranges);
 
   DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_H_