[counters] Implement off-isolate RuntimeCallStats for the Preparser

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/isolate.h"
@@ skipping 266 matching lines @@
   time = base::TimeDelta();
 }
 
 void RuntimeCallCounter::Dump(v8::tracing::TracedValue* value) {
   value->BeginArray(name);
   value->AppendLongInteger(count);
   value->AppendLongInteger(time.InMicroseconds());
   value->EndArray();
 }
 
+void RuntimeCallCounter::Add(RuntimeCallCounter* other) {
+  count += other->count;
+  time += other->time;
+}
+
 // static
 void RuntimeCallStats::Enter(RuntimeCallStats* stats, RuntimeCallTimer* timer,
                              CounterId counter_id) {
   RuntimeCallCounter* counter = &(stats->*counter_id);
+  DCHECK(counter->name != NULL);
   timer->Start(counter, stats->current_timer_.Value());
   stats->current_timer_.SetValue(timer);
 }
 
 // static
 void RuntimeCallStats::Leave(RuntimeCallStats* stats, RuntimeCallTimer* timer) {
   if (stats->current_timer_.Value() == timer) {
     stats->current_timer_.SetValue(timer->Stop());
   } else {
     // Must be a Threading cctest. Walk the chain of Timers to find the
     // buried one that's leaving. We don't care about keeping nested timings
     // accurate, just avoid crashing by keeping the chain intact.
     RuntimeCallTimer* next = stats->current_timer_.Value();
-    while (next && next->parent() != timer) next = next->parent();
-    if (next == nullptr) return;
+    while (next->parent() != timer) next = next->parent();
     next->parent_.SetValue(timer->Stop());
   }
 }
 
+void RuntimeCallStats::Add(RuntimeCallStats* other) {
+  RuntimeCallCounter* current = &(this->First);

[vogelheim, 2016/11/14 10:20:33]

(here and below):

I take it you use First & Last counters only to be able to iterate over all your
counters. But, as I read it, unlike begin() + end() your First points to
*before* the counter range; it's effectively begin() - 1. If so, I'd expect all
your iterations to start from First() + 1.

[No big deal; I take it the additional First() is harmless. But it's certainly
weird.]

[Camillo Bruni, 2016/11/14 12:43:46]

Yes, that's right, given that First and Last are just dummy counters it dosn't
matter.
I can add a comment to make this assumption obvious.

+  RuntimeCallCounter* other_counter = &(other->First);
+  while (current < &(this->Last)) {
+    current = reinterpret_cast<RuntimeCallCounter*>(
+        reinterpret_cast<intptr_t>(current) + sizeof(RuntimeCallCounter));
+    other_counter = reinterpret_cast<RuntimeCallCounter*>(
+        reinterpret_cast<intptr_t>(other_counter) + sizeof(RuntimeCallCounter));

[vogelheim, 2016/11/14 10:20:33]

A nitpick, loosely related to the comment above: These reinterpret_casts +
pointer arithmetic seems quite gratuitous. I take it this is because they're
declared as regular members, and now we want to iterate over the members of a
class, which C++ doesn't provide for. Maybe we can change the declaration to put
all of the RuntimeCallCounters into an array?

[Camillo Bruni, 2016/11/14 12:43:46]

Right, I had some discussions around this as it is far from pretty the way we do
it now.
Having an array would probably clean this up at the cost of yet another pointer
indirection to access the current timer.

+    current->Add(other_counter);
+  }
+}
+
 // static
 void RuntimeCallStats::CorrectCurrentCounterId(RuntimeCallStats* stats,
                                                CounterId counter_id) {
   RuntimeCallTimer* timer = stats->current_timer_.Value();
   // When RCS are enabled dynamically there might be no current timer set up.
   if (timer == nullptr) return;
   timer->counter_ = &(stats->*counter_id);
 }
 
 void RuntimeCallStats::Print(std::ostream& os) {
   RuntimeCallStatEntries entries;
   if (current_timer_.Value() != nullptr) {
     current_timer_.Value()->Elapsed();
   }
-
-#define PRINT_COUNTER(name) entries.Add(&this->name);
-  FOR_EACH_MANUAL_COUNTER(PRINT_COUNTER)
-#undef PRINT_COUNTER
-
-#define PRINT_COUNTER(name, nargs, ressize) entries.Add(&this->Runtime_##name);
-  FOR_EACH_INTRINSIC(PRINT_COUNTER)
-#undef PRINT_COUNTER
-
-#define PRINT_COUNTER(name) entries.Add(&this->Builtin_##name);
-  BUILTIN_LIST_C(PRINT_COUNTER)
-#undef PRINT_COUNTER
-
-#define PRINT_COUNTER(name) entries.Add(&this->API_##name);
-  FOR_EACH_API_COUNTER(PRINT_COUNTER)
-#undef PRINT_COUNTER
-
-#define PRINT_COUNTER(name) entries.Add(&this->Handler_##name);
-  FOR_EACH_HANDLER_COUNTER(PRINT_COUNTER)
-#undef PRINT_COUNTER
-
+  RuntimeCallCounter* current = &(this->First);
+  while (current < &(this->Last)) {
+    current = reinterpret_cast<RuntimeCallCounter*>(
+        reinterpret_cast<intptr_t>(current) + sizeof(RuntimeCallCounter));
+    entries.Add(current);
+  }
   entries.Print(os);
 }
 
 void RuntimeCallStats::Reset() {
   if (V8_LIKELY(FLAG_runtime_stats == 0)) return;
 
   // In tracing, we only what to trace the time spent on top level trace events,
   // if runtime counter stack is not empty, we should clear the whole runtime
   // counter stack, and then reset counters so that we can dump counters into
   // top level trace events accurately.
   while (current_timer_.Value()) {
     current_timer_.SetValue(current_timer_.Value()->Stop());
   }
 
-#define RESET_COUNTER(name) this->name.Reset();
-  FOR_EACH_MANUAL_COUNTER(RESET_COUNTER)
-#undef RESET_COUNTER
-
-#define RESET_COUNTER(name, nargs, result_size) this->Runtime_##name.Reset();
-  FOR_EACH_INTRINSIC(RESET_COUNTER)
-#undef RESET_COUNTER
-
-#define RESET_COUNTER(name) this->Builtin_##name.Reset();
-  BUILTIN_LIST_C(RESET_COUNTER)
-#undef RESET_COUNTER
-
-#define RESET_COUNTER(name) this->API_##name.Reset();
-  FOR_EACH_API_COUNTER(RESET_COUNTER)
-#undef RESET_COUNTER
-
-#define RESET_COUNTER(name) this->Handler_##name.Reset();
-  FOR_EACH_HANDLER_COUNTER(RESET_COUNTER)
-#undef RESET_COUNTER
+  RuntimeCallCounter* current = &(this->First);
+  while (current < &(this->Last)) {
+    current = reinterpret_cast<RuntimeCallCounter*>(
+        reinterpret_cast<intptr_t>(current) + sizeof(RuntimeCallCounter));
+    current->Reset();
+  }
 
   in_use_ = true;
 }
 
 void RuntimeCallStats::Dump(v8::tracing::TracedValue* value) {
-#define DUMP_COUNTER(name) \
-  if (this->name.count > 0) this->name.Dump(value);
-  FOR_EACH_MANUAL_COUNTER(DUMP_COUNTER)
-#undef DUMP_COUNTER
-
-#define DUMP_COUNTER(name, nargs, result_size) \
-  if (this->Runtime_##name.count > 0) this->Runtime_##name.Dump(value);
-  FOR_EACH_INTRINSIC(DUMP_COUNTER)
-#undef DUMP_COUNTER
-
-#define DUMP_COUNTER(name) \
-  if (this->Builtin_##name.count > 0) this->Builtin_##name.Dump(value);
-  BUILTIN_LIST_C(DUMP_COUNTER)
-#undef DUMP_COUNTER
-
-#define DUMP_COUNTER(name) \
-  if (this->API_##name.count > 0) this->API_##name.Dump(value);
-  FOR_EACH_API_COUNTER(DUMP_COUNTER)
-#undef DUMP_COUNTER
-
-#define DUMP_COUNTER(name) \
-  if (this->Handler_##name.count > 0) this->Handler_##name.Dump(value);
-  FOR_EACH_HANDLER_COUNTER(DUMP_COUNTER)
-#undef DUMP_COUNTER
+  RuntimeCallCounter* current = &(this->First);
+  while (current < &(this->Last)) {
+    current = reinterpret_cast<RuntimeCallCounter*>(
+        reinterpret_cast<intptr_t>(current) + sizeof(RuntimeCallCounter));
+    if (current->count > 0) current->Dump(value);
+  }
 
   in_use_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8