Move StatsTable into the Counters class.

src/counters.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COUNTERS_H_
 #define V8_COUNTERS_H_
 
 #include "include/v8.h"
 #include "src/allocation.h"
 #include "src/base/atomic-utils.h"
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/time.h"
 #include "src/globals.h"
 #include "src/isolate.h"
 #include "src/objects.h"
 #include "src/runtime/runtime.h"
 #include "src/tracing/trace-event.h"
 #include "src/tracing/traced-value.h"
 #include "src/tracing/tracing-category-observer.h"
 
 namespace v8 {
 namespace internal {
 
 // StatsCounters is an interface for plugging into external
 // counters for monitoring.  Counters can be looked up and
 // manipulated by name.
 
+class Counters;
+
 class StatsTable {
  public:
   // Register an application-defined function where
   // counters can be looked up. Note: Must be called on main thread,
   // so that threaded stats counters can be created now.
-  void SetCounterFunction(CounterLookupCallback f, Isolate* isolate);
+  void SetCounterFunction(CounterLookupCallback f);
 
   // Register an application-defined function to create
   // a histogram for passing to the AddHistogramSample function
   void SetCreateHistogramFunction(CreateHistogramCallback f) {
     create_histogram_function_ = f;
   }
 
   // Register an application-defined function to add a sample
   // to a histogram created with CreateHistogram function
   void SetAddHistogramSampleFunction(AddHistogramSampleCallback f) {
@@ skipping 29 matching lines @@
   }
 
   // Add a sample to a histogram created with the CreateHistogram
   // function.
   void AddHistogramSample(void* histogram, int sample) {
     if (!add_histogram_sample_function_) return;
     return add_histogram_sample_function_(histogram, sample);
   }
 
  private:
-  StatsTable();
+  explicit StatsTable(Counters* counters);
 
+  Counters* counters_;
   CounterLookupCallback lookup_function_;
   CreateHistogramCallback create_histogram_function_;
   AddHistogramSampleCallback add_histogram_sample_function_;
 
-  friend class Isolate;
+  friend class Counters;
 
   DISALLOW_COPY_AND_ASSIGN(StatsTable);
 };
 
 // Base class for stats counters.
 class StatsCounterBase {
- public:
-  StatsCounterBase() {}
-  StatsCounterBase(Isolate* isolate, const char* name)
-      : isolate_(isolate), name_(name), ptr_(nullptr) {}
-
  protected:
-  Isolate* isolate_;
+  Counters* counters_;
   const char* name_;
   int* ptr_;
 
+  StatsCounterBase() {}
+  StatsCounterBase(Counters* counters, const char* name)
+      : counters_(counters), name_(name), ptr_(nullptr) {}
+
   void SetLoc(int* loc, int value) { *loc = value; }
   void IncrementLoc(int* loc) { (*loc)++; }
   void IncrementLoc(int* loc, int value) { (*loc) += value; }
   void DecrementLoc(int* loc) { (*loc)--; }
   void DecrementLoc(int* loc, int value) { (*loc) -= value; }
 
   int* FindLocationInStatsTable() const;
 };
 
 // StatsCounters are dynamically created values which can be tracked in
 // the StatsTable.  They are designed to be lightweight to create and
 // easy to use.
 //
 // Internally, a counter represents a value in a row of a StatsTable.
 // The row has a 32bit value for each process/thread in the table and also
 // a name (stored in the table metadata).  Since the storage location can be
 // thread-specific, this class cannot be shared across threads.
 class StatsCounter : public StatsCounterBase {
  public:
   StatsCounter() { }
-  StatsCounter(Isolate* isolate, const char* name)
-      : StatsCounterBase(isolate, name), lookup_done_(false) {}
+  StatsCounter(Counters* counters, const char* name)
+      : StatsCounterBase(counters, name), lookup_done_(false) {}
 
   // Sets the counter to a specific value.
   void Set(int value) {
     if (int* loc = GetPtr()) SetLoc(loc, value);
   }
 
   // Increments the counter.
   void Increment() {
     if (int* loc = GetPtr()) IncrementLoc(loc);
   }
@@ skipping 40 matching lines @@
 
   bool lookup_done_;
 };
 
 // Thread safe version of StatsCounter. WARNING: Unlike StatsCounter,
 // StatsCounterThreadSafe's constructor and method Reset() actually do
 // the table lookup, and should be called from the main thread
 // (i.e. not workers).
 class StatsCounterThreadSafe : public StatsCounterBase {
  public:
-  StatsCounterThreadSafe(Isolate* isolate, const char* name);
+  StatsCounterThreadSafe(Counters* counters, const char* name);
 
   void Set(int Value);
   void Increment();
   void Increment(int value);
   void Decrement();
   void Decrement(int value);
   bool Enabled() { return ptr_ != NULL; }
   int* GetInternalPointer() {
     DCHECK(ptr_ != NULL);
     return ptr_;
   }
   void Reset() { GetPtr(); }
 
  private:
   int* GetPtr();
 
   base::Mutex mutex_;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(StatsCounterThreadSafe);
 };
 
 // A Histogram represents a dynamically created histogram in the StatsTable.
 // It will be registered with the histogram system on first use.
 class Histogram {
  public:
   Histogram() { }
-  Histogram(const char* name,
-            int min,
-            int max,
-            int num_buckets,
-            Isolate* isolate)
+  Histogram(const char* name, int min, int max, int num_buckets,
+            Counters* counters)
       : name_(name),
         min_(min),
         max_(max),
         num_buckets_(num_buckets),
         histogram_(NULL),
         lookup_done_(false),
-        isolate_(isolate) { }
+        counters_(counters) {}
 
   // Add a single sample to this histogram.
   void AddSample(int sample);
 
   // Returns true if this histogram is enabled.
   bool Enabled() {
     return GetHistogram() != NULL;
   }
 
   // Reset the cached internal pointer.
   void Reset() {
     lookup_done_ = false;
   }
 
   const char* name() { return name_; }
 
  protected:
   // Returns the handle to the histogram.
   void* GetHistogram() {
     if (!lookup_done_) {
       lookup_done_ = true;
       histogram_ = CreateHistogram();
     }
     return histogram_;
   }
 
-  Isolate* isolate() const { return isolate_; }
+  Counters* counters() const { return counters_; }
 
  private:
   void* CreateHistogram() const;
 
   const char* name_;
   int min_;
   int max_;
   int num_buckets_;
   void* histogram_;
   bool lookup_done_;
-  Isolate* isolate_;
+  Counters* counters_;
 };
 
 // A HistogramTimer allows distributions of results to be created.
 class HistogramTimer : public Histogram {
  public:
   enum Resolution {
     MILLISECOND,
     MICROSECOND
   };
 
   HistogramTimer() {}
   HistogramTimer(const char* name, int min, int max, Resolution resolution,
-                 int num_buckets, Isolate* isolate)
-      : Histogram(name, min, max, num_buckets, isolate),
+                 int num_buckets, Counters* counters)
+      : Histogram(name, min, max, num_buckets, counters),
         resolution_(resolution) {}
 
   // Start the timer.
   void Start();
 
   // Stop the timer and record the results.
   void Stop();
 
   // Returns true if the timer is running.
   bool Running() {
@@ skipping 61 matching lines @@
 //
 // Helpers:
 // - AggregatingHistogramTimerScope, the "outer" scope within which
 //     times will be summed up.
 // - AggregatedHistogramTimerScope, the "inner" scope which defines the
 //     events to be timed.
 class AggregatableHistogramTimer : public Histogram {
  public:
   AggregatableHistogramTimer() {}
   AggregatableHistogramTimer(const char* name, int min, int max,
-                             int num_buckets, Isolate* isolate)
-      : Histogram(name, min, max, num_buckets, isolate) {}
+                             int num_buckets, Counters* counters)
+      : Histogram(name, min, max, num_buckets, counters) {}
 
   // Start/stop the "outer" scope.
   void Start() { time_ = base::TimeDelta(); }
   void Stop() { AddSample(static_cast<int>(time_.InMicroseconds())); }
 
   // Add a time value ("inner" scope).
   void Add(base::TimeDelta other) { time_ += other; }
 
  private:
   base::TimeDelta time_;
@@ skipping 955 matching lines @@
     stats_counter_count
   };
   // clang-format on
 
   void ResetCounters();
   void ResetHistograms();
   void InitializeHistograms();
 
   RuntimeCallStats* runtime_call_stats() { return &runtime_call_stats_; }
 
+  StatsTable* stats_table() { return &stats_table_; }
+
+  Isolate* isolate() { return isolate_; }
+
  private:
+  Isolate* isolate_;
+  StatsTable stats_table_;
+
 #define HR(name, caption, min, max, num_buckets) Histogram name##_;
   HISTOGRAM_RANGE_LIST(HR)
 #undef HR
 
 #define HT(name, caption, max, res) HistogramTimer name##_;
   HISTOGRAM_TIMER_LIST(HT)
 #undef HT
 
 #define AHT(name, caption) \
   AggregatableHistogramTimer name##_;
@@ skipping 45 matching lines @@
 #undef SC
 
 #define SC(name) \
   StatsCounter size_of_CODE_AGE_##name##_; \
   StatsCounter count_of_CODE_AGE_##name##_;
   CODE_AGE_LIST_COMPLETE(SC)
 #undef SC
 
   RuntimeCallStats runtime_call_stats_;
 
-  friend class Isolate;
-
   DISALLOW_IMPLICIT_CONSTRUCTORS(Counters);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COUNTERS_H_