Initial support for Renderer Side Histograms...

base/histogram.h

 // Copyright (c) 2006-2008 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 18 matching lines @@
 // gigantic range with the addition of very few buckets.
 
 #ifndef BASE_HISTOGRAM_H__
 #define BASE_HISTOGRAM_H__
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/lock.h"
+#include "base/pickle.h"
 #include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
 
 //------------------------------------------------------------------------------
 // Provide easy general purpose histogram in a macro, just like stats counters.
 // The first two macros use 50 buckets.
 
 #define HISTOGRAM_TIMES(name, sample) do { \
     static Histogram counter((name), base::TimeDelta::FromMilliseconds(1), \
                              base::TimeDelta::FromSeconds(10), 50); \
@@ skipping 62 matching lines @@
 #endif  // NDEBUG
 
 //------------------------------------------------------------------------------
 // The following macros provide typical usage scenarios for callers that wish
 // to record histogram data, and have the data submitted/uploaded via UMA.
 // Not all systems support such UMA, but if they do, the following macros
 // should work with the service.
 
 static const int kUmaTargetedHistogramFlag = 0x1;
 
+// This indicates the histogram is shadow copy of renderer histrogram
+// constructed by unpick method and updated regularly from renderer upload
+// of histograms.
+static const int kRendererHistogramFlag = 1 << 4;
+
 #define UMA_HISTOGRAM_TIMES(name, sample) do { \
     static Histogram counter((name), base::TimeDelta::FromMilliseconds(1), \
                              base::TimeDelta::FromSeconds(10), 50); \
     counter.SetFlags(kUmaTargetedHistogramFlag); \
     counter.AddTime(sample); \
   } while (0)
 
 #define UMA_HISTOGRAM_MEDIUM_TIMES(name, sample) do { \
     static Histogram counter((name), base::TimeDelta::FromMilliseconds(10), \
                              base::TimeDelta::FromMinutes(3), 50); \
@@ skipping 45 matching lines @@
  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;
 
   typedef std::vector<Count> Counts;
   typedef std::vector<Sample> Ranges;
 
   static const int kHexRangePrintingFlag;
 
+  enum BucketLayout {
+    EXPONENTIAL,
+    LINEAR
+  };
+
   //----------------------------------------------------------------------------
   // Statistic values, developed over the life of the histogram.
 
   class SampleSet {
    public:
     explicit SampleSet();
     // Adjust size of counts_ for use with given histogram.
     void Resize(const Histogram& histogram);
     void CheckSize(const Histogram& histogram) const;
 
     // Accessor for histogram to make routine additions.
     void Accumulate(Sample value, Count count, size_t index);
 
     // Accessor methods.
     Count counts(size_t i) const { return counts_[i]; }
     Count TotalCount() const;
     int64 sum() const { return sum_; }
     int64 square_sum() const { return square_sum_; }
 
     // Arithmetic manipulation of corresponding elements of the set.
     void Add(const SampleSet& other);
     void Subtract(const SampleSet& other);
 
+    bool Serialize(Pickle* pickle) const;
+    bool Deserialize(void** iter, const Pickle& pickle);
+
    protected:
     // Actual histogram data is stored in buckets, showing the count of values
     // that fit into each bucket.
     Counts counts_;
 
     // Save simple stats locally.  Note that this MIGHT get done in base class
     // without shared memory at some point.
     int64 sum_;         // sum of samples.
     int64 square_sum_;  // sum of squares of samples.
   };
   //----------------------------------------------------------------------------
 
   Histogram(const char* name, Sample minimum,
             Sample maximum, size_t bucket_count);
   Histogram(const char* name, base::TimeDelta minimum,
             base::TimeDelta maximum, size_t bucket_count);
   virtual ~Histogram();
 
   // Hooks to override stats counter methods.  This ensures that we gather all
   // input the stats counter sees.
   virtual void Add(int value);
 
+  void AddSampleSet(const SampleSet& sample);
+
   // The following methods provide graphical histogram displays.
   void WriteHTMLGraph(std::string* output) const;
   void WriteAscii(bool graph_it, const std::string& newline,
                   std::string* output) const;
 
   // 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(int flags) { flags_ |= flags; }
   void ClearFlags(int flags) { flags_ &= ~flags; }
   int flags() const { return flags_; }
 
+  virtual BucketLayout histogram_type() const { return EXPONENTIAL; }
+
+  // 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);
+  // The following method accepts a list of pickled histograms and
+  // builds a histogram and updates shadow copy of histogram data in the
+  // browser process.
+  static void DeserializeHistogramList(
+      const std::vector<std::string>& histograms);
+  static bool DeserializeHistogramInfo(const std::string& state);
+
+
   //----------------------------------------------------------------------------
   // Accessors for serialization and testing.
   //----------------------------------------------------------------------------
   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 { return ranges_[i];}
   virtual size_t bucket_count() const { return bucket_count_; }
   // Snapshot the current complete set of sample data.
   // Override with atomic/locked snapshot if needed.
@@ skipping 84 matching lines @@
   // The dimension of ranges_ is bucket_count + 1.
   Ranges ranges_;
 
   // Finally, provide the state that changes with the addition of each new
   // sample.
   SampleSet sample_;
 
   // Indicate if successfully registered.
   bool registered_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(Histogram);
+  DISALLOW_COPY_AND_ASSIGN(Histogram);
 };
 
 //------------------------------------------------------------------------------
 
 // LinearHistogram is a more traditional histogram, with evenly spaced
 // buckets.
 class LinearHistogram : public Histogram {
  public:
   struct DescriptionPair {
     Sample sample;
     const char* description;  // Null means end of a list of pairs.
   };
   LinearHistogram(const char* name, Sample minimum,
-            Sample maximum, size_t bucket_count);
+                  Sample maximum, size_t bucket_count);
+
   LinearHistogram(const char* name, base::TimeDelta minimum,
-            base::TimeDelta maximum, size_t bucket_count);
+                  base::TimeDelta maximum, size_t bucket_count);
   ~LinearHistogram() {}
 
   // Store a list of number/text values for use in rendering the histogram.
   // The last element in the array has a null in its "description" slot.
   void SetRangeDescriptions(const DescriptionPair descriptions[]);
 
+  virtual BucketLayout histogram_type() const { return LINEAR; }
+
  protected:
   // Initialize ranges_ mapping.
   virtual void InitializeBucketRange();
   // Find bucket to increment for sample value.
   virtual size_t BucketIndex(Sample value) const;
   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;
 
  private:
   // For some ranges, we store a printable description of a bucket range.
   // If there is no desciption, then GetAsciiBucketRange() uses parent class
   // to provide a description.
   typedef std::map<Sample, std::string> BucketDescriptionMap;
   BucketDescriptionMap bucket_description_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(LinearHistogram);
+  DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // BooleanHistogram is a histogram for booleans.
 class BooleanHistogram : public LinearHistogram {
  public:
   explicit BooleanHistogram(const char* name)
     : LinearHistogram(name, 0, 2, 3) {
   }
 
   virtual void AddBoolean(bool value) { Add(value ? 1 : 0); }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(BooleanHistogram);
+  DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
 };
 
 //------------------------------------------------------------------------------
 // This section provides implementation for ThreadSafeHistogram.
 //------------------------------------------------------------------------------
 
 class ThreadSafeHistogram : public Histogram {
  public:
   ThreadSafeHistogram(const char* name, Sample minimum,
                       Sample maximum, size_t bucket_count);
 
   // Provide the analog to Add()
   void Remove(int value);
 
  protected:
   // Provide locked versions to get precise counts.
   virtual void Accumulate(Sample value, Count count, size_t index);
 
   virtual void SnapshotSample(SampleSet* sample);
 
  private:
   Lock lock_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(ThreadSafeHistogram);
+  DISALLOW_COPY_AND_ASSIGN(ThreadSafeHistogram);
 };
 
 //------------------------------------------------------------------------------
 // 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 StatisticsRecorder {
  public:
-  typedef std::vector<const Histogram*> Histograms;
+  typedef std::vector<Histogram*> Histograms;
 
   StatisticsRecorder();
 
   ~StatisticsRecorder();
 
   // Find out if histograms can now be registered into our list.
   static bool WasStarted();
 
   // Register, or add a new histogram to the collection of statistics.
   // Return true if registered.
-  static bool Register(const Histogram& histogram);
+  static bool Register(Histogram* histogram);
   // Unregister, or remove, a histogram from the collection of statistics.
-  static void UnRegister(const Histogram& histogram);
+  static void UnRegister(Histogram* histogram);
 
   // 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);
 
+  static Histogram* GetHistogram(const std::string& query);
+
   static void set_dump_on_exit(bool enable) { dump_on_exit_ = enable; }
 
- private:
-  typedef std::map<std::string, const Histogram*> HistogramMap;
-  // We keep all registered histograms in a map, from name to histogram.
-
   // 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;
+
   static HistogramMap* histograms_;
+
   // lock protects access to the above map.
   static Lock* lock_;
 
   // Dump all known histograms to log.
   static bool dump_on_exit_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(StatisticsRecorder);
+  DISALLOW_COPY_AND_ASSIGN(StatisticsRecorder);
 };
 
 #endif  // BASE_HISTOGRAM_H__