Move StatsTable into the Counters class.

src/counters.cc

 // 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.
 
 #include "src/counters.h"
 
 #include <iomanip>
 
 #include "src/base/platform/platform.h"
 #include "src/builtins/builtins-definitions.h"
 #include "src/isolate.h"
 #include "src/log-inl.h"
 #include "src/log.h"
 
 namespace v8 {
 namespace internal {
 
-StatsTable::StatsTable()
-    : lookup_function_(NULL),
+StatsTable::StatsTable(Counters* counters)
+    : counters_(counters),
+      lookup_function_(NULL),
       create_histogram_function_(NULL),
       add_histogram_sample_function_(NULL) {}
 
-void StatsTable::SetCounterFunction(CounterLookupCallback f, Isolate* isolate) {
+void StatsTable::SetCounterFunction(CounterLookupCallback f) {
   lookup_function_ = f;
-  if (!isolate->InitializeCounters()) isolate->counters()->ResetCounters();
+  counters_->ResetCounters();
 }
 
 int* StatsCounterBase::FindLocationInStatsTable() const {
-  return isolate_->stats_table()->FindLocation(name_);
+  return counters_->stats_table()->FindLocation(name_);
 }
 
-StatsCounterThreadSafe::StatsCounterThreadSafe(Isolate* isolate,
+StatsCounterThreadSafe::StatsCounterThreadSafe(Counters* counters,
                                                const char* name)
-    : StatsCounterBase(isolate, name) {
+    : StatsCounterBase(counters, name) {
   GetPtr();
 }
 
 void StatsCounterThreadSafe::Set(int Value) {
   if (ptr_) {
     base::LockGuard<base::Mutex> Guard(&mutex_);
     SetLoc(ptr_, Value);
   }
 }
 
@@ skipping 26 matching lines @@
 }
 
 int* StatsCounterThreadSafe::GetPtr() {
   base::LockGuard<base::Mutex> Guard(&mutex_);
   ptr_ = FindLocationInStatsTable();
   return ptr_;
 }
 
 void Histogram::AddSample(int sample) {
   if (Enabled()) {
-    isolate()->stats_table()->AddHistogramSample(histogram_, sample);
+    counters_->stats_table()->AddHistogramSample(histogram_, sample);
   }
 }
 
 void* Histogram::CreateHistogram() const {
-  return isolate()->stats_table()->
-      CreateHistogram(name_, min_, max_, num_buckets_);
+  return counters_->stats_table()->CreateHistogram(name_, min_, max_,
+                                                   num_buckets_);
 }
 
 
 // Start the timer.
 void HistogramTimer::Start() {
   if (Enabled()) {
     timer_.Start();
   }
-  Logger::CallEventLogger(isolate(), name(), Logger::START, true);
+  Logger::CallEventLogger(counters()->isolate(), name(), Logger::START, true);
 }
 
 
 // Stop the timer and record the results.
 void HistogramTimer::Stop() {
   if (Enabled()) {
     int64_t sample = resolution_ == MICROSECOND
                          ? timer_.Elapsed().InMicroseconds()
                          : timer_.Elapsed().InMilliseconds();
     // Compute the delta between start and stop, in microseconds.
     AddSample(static_cast<int>(sample));
     timer_.Stop();
   }
-  Logger::CallEventLogger(isolate(), name(), Logger::END, true);
+  Logger::CallEventLogger(counters()->isolate(), name(), Logger::END, true);
 }
 
 Counters::Counters(Isolate* isolate)
-    :
+    : isolate_(isolate),
+      stats_table_(this),
 // clang format off
-#define SC(name, caption) name##_(isolate, "c:" #caption),
+#define SC(name, caption) name##_(this, "c:" #caption),
       STATS_COUNTER_TS_LIST(SC)
 #undef SC
       // clang format on
       runtime_call_stats_() {
   static const struct {
     Histogram Counters::*member;
     const char* caption;
     int min;
     int max;
     int num_buckets;
   } kHistograms[] = {
 #define HR(name, caption, min, max, num_buckets) \
   {&Counters::name##_, #caption, min, max, num_buckets},
       HISTOGRAM_RANGE_LIST(HR)
 #undef HR
   };
   for (const auto& histogram : kHistograms) {
     this->*histogram.member =
         Histogram(histogram.caption, histogram.min, histogram.max,
-                  histogram.num_buckets, isolate);
+                  histogram.num_buckets, this);
   }
 
   static const struct {
     HistogramTimer Counters::*member;
     const char* caption;
     int max;
     HistogramTimer::Resolution res;
   } kHistogramTimers[] = {
 #define HT(name, caption, max, res) \
   {&Counters::name##_, #caption, max, HistogramTimer::res},
       HISTOGRAM_TIMER_LIST(HT)
 #undef HT
   };
   for (const auto& timer : kHistogramTimers) {
     this->*timer.member =
-        HistogramTimer(timer.caption, 0, timer.max, timer.res, 50, isolate);
+        HistogramTimer(timer.caption, 0, timer.max, timer.res, 50, this);
   }
 
   static const struct {
     AggregatableHistogramTimer Counters::*member;
     const char* caption;
   } kAggregatableHistogramTimers[] = {
 #define AHT(name, caption) {&Counters::name##_, #caption},
       AGGREGATABLE_HISTOGRAM_TIMER_LIST(AHT)
 #undef AHT
   };
   for (const auto& aht : kAggregatableHistogramTimers) {
     this->*aht.member =
-        AggregatableHistogramTimer(aht.caption, 0, 10000000, 50, isolate);
+        AggregatableHistogramTimer(aht.caption, 0, 10000000, 50, this);
   }
 
   static const struct {
     Histogram Counters::*member;
     const char* caption;
   } kHistogramPercentages[] = {
 #define HP(name, caption) {&Counters::name##_, #caption},
       HISTOGRAM_PERCENTAGE_LIST(HP)
 #undef HP
   };
   for (const auto& percentage : kHistogramPercentages) {
-    this->*percentage.member =
-        Histogram(percentage.caption, 0, 101, 100, isolate);
+    this->*percentage.member = Histogram(percentage.caption, 0, 101, 100, this);
   }
 
   // Exponential histogram assigns bucket limits to points
   // p[1], p[2], ... p[n] such that p[i+1] / p[i] = constant.
   // The constant factor is equal to the n-th root of (high / low),
   // where the n is the number of buckets, the low is the lower limit,
   // the high is the upper limit.
   // For n = 50, low = 1000, high = 500000: the factor = 1.13.
   static const struct {
     Histogram Counters::*member;
     const char* caption;
   } kLegacyMemoryHistograms[] = {
 #define HM(name, caption) {&Counters::name##_, #caption},
       HISTOGRAM_LEGACY_MEMORY_LIST(HM)
 #undef HM
   };
   for (const auto& histogram : kLegacyMemoryHistograms) {
     this->*histogram.member =
-        Histogram(histogram.caption, 1000, 500000, 50, isolate);
+        Histogram(histogram.caption, 1000, 500000, 50, this);
   }
 
   // For n = 100, low = 4000, high = 2000000: the factor = 1.06.
   static const struct {
     Histogram Counters::*member;
     AggregatedMemoryHistogram<Histogram> Counters::*aggregated;
     const char* caption;
   } kMemoryHistograms[] = {
 #define HM(name, caption) \
   {&Counters::name##_, &Counters::aggregated_##name##_, #caption},
       HISTOGRAM_MEMORY_LIST(HM)
 #undef HM
   };
   for (const auto& histogram : kMemoryHistograms) {
     this->*histogram.member =
-        Histogram(histogram.caption, 4000, 2000000, 100, isolate);
+        Histogram(histogram.caption, 4000, 2000000, 100, this);
     this->*histogram.aggregated =
         AggregatedMemoryHistogram<Histogram>(&(this->*histogram.member));
   }
 
   // clang-format off
   static const struct {
     StatsCounter Counters::*member;
     const char* caption;
   } kStatsCounters[] = {
 #define SC(name, caption) {&Counters::name##_, "c:" #caption},
@@ skipping 21 matching lines @@
 #define SC(name)                           \
   {&Counters::count_of_CODE_AGE_##name##_, \
     "c:" "V8.CountOf_CODE_AGE-" #name},     \
   {&Counters::size_of_CODE_AGE_##name##_,  \
     "c:" "V8.SizeOf_CODE_AGE-" #name},
       CODE_AGE_LIST_COMPLETE(SC)
 #undef SC
   };
   // clang-format on
   for (const auto& counter : kStatsCounters) {
-    this->*counter.member = StatsCounter(isolate, counter.caption);
+    this->*counter.member = StatsCounter(this, counter.caption);
   }
 }
 
 void Counters::ResetCounters() {
 #define SC(name, caption) name##_.Reset();
   STATS_COUNTER_LIST_1(SC)
   STATS_COUNTER_LIST_2(SC)
 #undef SC
 
 #define SC(name, caption) name##_.Reset();
@@ skipping 318 matching lines @@
        RuntimeCallStats::counters) {
     RuntimeCallCounter* counter = &(this->*counter_id);
     if (counter->count() > 0) counter->Dump(value);
   }
 
   in_use_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8