Create a thread safe version of StatsCounters and use.

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),
       create_histogram_function_(NULL),
       add_histogram_sample_function_(NULL) {}
 
+void StatsTable::SetCounterFunction(CounterLookupCallback f, Isolate* isolate) {
+  lookup_function_ = f;
+  if (!isolate->InitializeCounters()) isolate->counters()->ResetCounters();
+}
 
 int* StatsCounter::FindLocationInStatsTable() const {
   return isolate_->stats_table()->FindLocation(name_);
 }
 
+StatsCounterThreadSafe::StatsCounterThreadSafe(Isolate* isolate,
+                                               const char* name)
+    : StatsCounter(isolate, name) {
+  lookup_done_ = true;
+  GetPtr();
+}
+
+void StatsCounterThreadSafe::Set(int Value) {
+  base::LockGuard<base::Mutex> Guard(&mutex_);
+  StatsCounter::Set(ptr_, Value);
+}
+
+void StatsCounterThreadSafe::Increment() {
+  base::LockGuard<base::Mutex> Guard(&mutex_);
+  StatsCounter::Increment(ptr_);
+}
+
+void StatsCounterThreadSafe::Increment(int value) {
+  base::LockGuard<base::Mutex> Guard(&mutex_);
+  StatsCounter::Increment(ptr_, value);
+}
+
+void StatsCounterThreadSafe::Decrement() {
+  base::LockGuard<base::Mutex> Guard(&mutex_);
+  StatsCounter::Decrement(ptr_);
+}
+
+void StatsCounterThreadSafe::Decrement(int value) {
+  base::LockGuard<base::Mutex> Guard(&mutex_);
+  StatsCounter::Decrement(ptr_, value);
+}
+
+void StatsCounterThreadSafe::Reset() { GetPtr(); }
+
+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);
   }
 }
 
 void* Histogram::CreateHistogram() const {
   return isolate()->stats_table()->
       CreateHistogram(name_, min_, max_, num_buckets_);
@@ skipping 15 matching lines @@
     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);
 }
 
-
-Counters::Counters(Isolate* isolate) {
+Counters::Counters(Isolate* isolate)
+    :
+// clang format off
+#define SC(name, caption) name##_(isolate, "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)
@@ skipping 118 matching lines @@
     "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);
   }
 }
 
-
 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();
+  STATS_COUNTER_TS_LIST(SC)
+#undef SC
+
 #define SC(name)              \
   count_of_##name##_.Reset(); \
   size_of_##name##_.Reset();
   INSTANCE_TYPE_LIST(SC)
 #undef SC
 
 #define SC(name)                        \
   count_of_CODE_TYPE_##name##_.Reset(); \
   size_of_CODE_TYPE_##name##_.Reset();
   CODE_KIND_LIST(SC)
@@ skipping 305 matching lines @@
        RuntimeCallStats::counters) {
     RuntimeCallCounter* counter = &(this->*counter_id);
     if (counter->count() > 0) counter->Dump(value);
   }
 
   in_use_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8