[counters] Implement off-isolate RuntimeCallStats for the Preparser

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"
@@ skipping 470 matching lines @@
   // The value is the average for [last_ms_; current_ms].
   // Return the weighted average of the aggregate_value_ and the value.
   return aggregate_value_ * ((last_ms_ - start_ms_) / interval_ms) +
          value * ((current_ms - last_ms_) / interval_ms);
 }
 
 struct RuntimeCallCounter {
   explicit RuntimeCallCounter(const char* name) : name(name) {}
   V8_NOINLINE void Reset();
   V8_NOINLINE void Dump(v8::tracing::TracedValue* value);
+  void Add(RuntimeCallCounter* other);
 
   const char* name;
   int64_t count = 0;
   base::TimeDelta time;
 };
 
 // RuntimeCallTimer is used to keep track of the stack of currently active
 // timers used for properly measuring the own time of a RuntimeCallCounter.
 class RuntimeCallTimer {
  public:
@@ skipping 29 matching lines @@
   inline void Elapsed() {
     base::TimeDelta delta = timer_.Elapsed();
     counter_->time += delta;
     if (parent()) {
       parent()->counter_->time -= delta;
       parent()->Elapsed();
     }
     timer_.Restart();
   }
 
+  const char* name() { return counter_->name; }
+
   RuntimeCallCounter* counter_ = nullptr;
   base::AtomicValue<RuntimeCallTimer*> parent_;
   base::ElapsedTimer timer_;
 };
 
 #define FOR_EACH_API_COUNTER(V)                            \
   V(ArrayBuffer_Cast)                                      \
   V(ArrayBuffer_Neuter)                                    \
   V(ArrayBuffer_New)                                       \
   V(Array_CloneElementAt)                                  \
@@ skipping 168 matching lines @@
   V(IndexedPropertySetterCallback)                  \
   V(InvokeApiInterruptCallbacks)                    \
   V(InvokeFunctionCallback)                         \
   V(JS_Execution)                                   \
   V(Map_SetPrototype)                               \
   V(Map_TransitionToAccessorProperty)               \
   V(Map_TransitionToDataProperty)                   \
   V(Object_DeleteProperty)                          \
   V(OptimizeCode)                                   \
   V(ParseProgram)                                   \
+  V(ParseEval)                                      \
   V(ParseFunction)                                  \
+  V(ParseFunctionLiteral)                           \
+  V(PreParseWithVariableResolution)                 \
+  V(PreParseNoVariableResolution)                   \
+  V(ParseArrowFunctionLiteral)                      \
+  V(PreParseArrowFunctionLiteral)                   \
   V(PropertyCallback)                               \
   V(PrototypeMap_TransitionToAccessorProperty)      \
   V(PrototypeMap_TransitionToDataProperty)          \
   V(PrototypeObject_DeleteProperty)                 \
   V(RecompileConcurrent)                            \
   V(RecompileSynchronous)                           \
   /* Dummy counter for the unexpected stub miss. */ \
   V(UnexpectedStubMiss)
 
 #define FOR_EACH_HANDLER_COUNTER(V)              \
@@ skipping 56 matching lines @@
   V(StoreIC_StoreFieldDH)                        \
   V(StoreIC_StoreFieldStub)                      \
   V(StoreIC_StoreGlobal)                         \
   V(StoreIC_StoreGlobalTransition)               \
   V(StoreIC_StoreInterceptorStub)                \
   V(StoreIC_StoreNormal)                         \
   V(StoreIC_StoreScriptContextFieldStub)         \
   V(StoreIC_StoreTransition)                     \
   V(StoreIC_StoreViaSetter)
 
-class RuntimeCallStats {
+class RuntimeCallStats : public ZoneObject {
  public:
   typedef RuntimeCallCounter RuntimeCallStats::*CounterId;
 
+  RuntimeCallCounter First = RuntimeCallCounter("First");
 #define CALL_RUNTIME_COUNTER(name) \
   RuntimeCallCounter name = RuntimeCallCounter(#name);
   FOR_EACH_MANUAL_COUNTER(CALL_RUNTIME_COUNTER)
 #undef CALL_RUNTIME_COUNTER
 #define CALL_RUNTIME_COUNTER(name, nargs, ressize) \
   RuntimeCallCounter Runtime_##name = RuntimeCallCounter(#name);
   FOR_EACH_INTRINSIC(CALL_RUNTIME_COUNTER)
 #undef CALL_RUNTIME_COUNTER
 #define CALL_BUILTIN_COUNTER(name) \
   RuntimeCallCounter Builtin_##name = RuntimeCallCounter(#name);
   BUILTIN_LIST_C(CALL_BUILTIN_COUNTER)
 #undef CALL_BUILTIN_COUNTER
 #define CALL_BUILTIN_COUNTER(name) \
   RuntimeCallCounter API_##name = RuntimeCallCounter("API_" #name);
   FOR_EACH_API_COUNTER(CALL_BUILTIN_COUNTER)
 #undef CALL_BUILTIN_COUNTER
 #define CALL_BUILTIN_COUNTER(name) \
   RuntimeCallCounter Handler_##name = RuntimeCallCounter(#name);
   FOR_EACH_HANDLER_COUNTER(CALL_BUILTIN_COUNTER)
 #undef CALL_BUILTIN_COUNTER
+  RuntimeCallCounter Last = RuntimeCallCounter("Last");
 
   // Starting measuring the time for a function. This will establish the
   // connection to the parent counter for properly calculating the own times.
   static void Enter(RuntimeCallStats* stats, RuntimeCallTimer* timer,
                     CounterId counter_id);
 
   // Leave a scope for a measured runtime function. This will properly add
   // the time delta to the current_counter and subtract the delta from its
   // parent.
   static void Leave(RuntimeCallStats* stats, RuntimeCallTimer* timer);
 
   // Set counter id for the innermost measurement. It can be used to refine
   // event kind when a runtime entry counter is too generic.
   static void CorrectCurrentCounterId(RuntimeCallStats* stats,
                                       CounterId counter_id);
 
   void Reset();
+  // Add all entries from another stats object.
+  void Add(RuntimeCallStats* other);
   void Print(std::ostream& os);
   V8_NOINLINE void Dump(v8::tracing::TracedValue* value);
 
   RuntimeCallStats() {
     Reset();
     in_use_ = false;
   }
 
   RuntimeCallTimer* current_timer() { return current_timer_.Value(); }
   bool InUse() { return in_use_; }
 
  private:
   // Counter to track recursive time events.
   base::AtomicValue<RuntimeCallTimer*> current_timer_;
   // Used to track nested tracing scopes.
   bool in_use_;
 };
 
-#define TRACE_RUNTIME_CALL_STATS(isolate, counter_name) \
-  do {                                                  \
-    if (V8_UNLIKELY(FLAG_runtime_stats)) {              \
-      RuntimeCallStats::CorrectCurrentCounterId(        \
-          isolate->counters()->runtime_call_stats(),    \
-          &RuntimeCallStats::counter_name);             \
-    }                                                   \
+#define CHANGE_CURRENT_RUNTIME_COUNTER(runtime_call_stats, counter_name) \
+  do {                                                                   \
+    if (V8_UNLIKELY(FLAG_runtime_stats)) {                               \
+      RuntimeCallStats::CorrectCurrentCounterId(                         \
+          runtime_call_stats, &RuntimeCallStats::counter_name);          \
+    }                                                                    \
   } while (false)
 
-#define TRACE_HANDLER_STATS(isolate, counter_name) \
-  TRACE_RUNTIME_CALL_STATS(isolate, Handler_##counter_name)
+#define TRACE_HANDLER_STATS(isolate, counter_name)                          \
+  CHANGE_CURRENT_RUNTIME_COUNTER(isolate->counters()->runtime_call_stats(), \
+                                 Handler_##counter_name)
 
 #define HISTOGRAM_RANGE_LIST(HR)                                              \
   /* Generic range histograms */                                              \
   HR(detached_context_age_in_gc, V8.DetachedContextAgeInGC, 0, 20, 21)        \
   HR(gc_idle_time_allotted_in_ms, V8.GCIdleTimeAllottedInMS, 0, 10000, 101)   \
   HR(gc_idle_time_limit_overshot, V8.GCIdleTimeLimit.Overshot, 0, 10000, 101) \
   HR(gc_idle_time_limit_undershot, V8.GCIdleTimeLimit.Undershot, 0, 10000,    \
      101)                                                                     \
   HR(code_cache_reject_reason, V8.CodeCacheRejectReason, 1, 6, 6)             \
   HR(errors_thrown_per_context, V8.ErrorsThrownPerContext, 0, 200, 20)        \
@@ skipping 402 matching lines @@
 // A RuntimeCallTimerScopes wraps around a RuntimeCallTimer to measure the
 // the time of C++ scope.
 class RuntimeCallTimerScope {
  public:
   inline RuntimeCallTimerScope(Isolate* isolate,
                                RuntimeCallStats::CounterId counter_id);
   // This constructor is here just to avoid calling GetIsolate() when the
   // stats are disabled and the isolate is not directly available.
   inline RuntimeCallTimerScope(HeapObject* heap_object,
                                RuntimeCallStats::CounterId counter_id);
+  inline RuntimeCallTimerScope(RuntimeCallStats* stats,
+                               RuntimeCallStats::CounterId counter_id);
 
   inline ~RuntimeCallTimerScope() {
-    if (V8_UNLIKELY(isolate_ != nullptr)) {
-      RuntimeCallStats::Leave(isolate_->counters()->runtime_call_stats(),
-                              &timer_);
+    if (V8_UNLIKELY(stats_ != nullptr)) {
+      RuntimeCallStats::Leave(stats_, &timer_);
     }
   }
 
  private:
-  V8_INLINE void Initialize(Isolate* isolate,
+  V8_INLINE void Initialize(RuntimeCallStats* stats,
                             RuntimeCallStats::CounterId counter_id) {
-    isolate_ = isolate;
-    RuntimeCallStats::Enter(isolate_->counters()->runtime_call_stats(), &timer_,
-                            counter_id);
+    stats_ = stats;
+    RuntimeCallStats::Enter(stats_, &timer_, counter_id);
   }
 
-  Isolate* isolate_ = nullptr;
+  RuntimeCallStats* stats_ = nullptr;
   RuntimeCallTimer timer_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COUNTERS_H_