[counter] Properly measure own-time of runtime counters.

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 194 matching lines @@
          << std::string(86, '=') << std::endl;
       for (Entry& entry : entries) {
         entry.SetTotal(total_time, total_call_count);
         entry.Print(os);
       }
       os << std::string(86, '-') << std::endl;
       Entry("Total", total_time, total_call_count).Print(os);
     }
   }
 
-  void Add(const char* name, base::TimeDelta time, uint32_t count) {
-    entries.push_back(Entry(name, time, count));
-    total_time += time;
-    total_call_count += count;
+  void Add(const char* name, RuntimeCallCounter counter) {
+    entries.push_back(Entry(name, counter.time, counter.count));
+    total_time += counter.time;
+    total_call_count += counter.count;
   }
 
  private:
   class Entry {
    public:
     Entry(const char* name, base::TimeDelta time, uint64_t count)
         : name_(name),
           time_(time.InMilliseconds()),
           count_(count),
           time_percent_(100),
@@ skipping 27 matching lines @@
     uint64_t count_;
     double time_percent_;
     double count_percent_;
   };
 
   uint64_t total_call_count = 0;
   base::TimeDelta total_time;
   std::vector<Entry> entries;
 };
 
+void RuntimeCallCounter::Reset() {
+  count = 0;
+  time = base::TimeDelta();
+}
+
+void RuntimeCallStats::Enter(RuntimeCallCounter* counter) {
+  counter->count++;
+  counter->parent_counter = current_counter;
+  current_counter = counter;
+}
+void RuntimeCallStats::Leave(base::TimeDelta time) {
+  RuntimeCallCounter* counter = current_counter;
+  counter->time += time;
+  current_counter = counter->parent_counter;
+  counter->parent_counter = NULL;
+  if (current_counter != NULL) {
+    current_counter->time -= time;
+  }
+}
+
 void RuntimeCallStats::Print(std::ostream& os) {
   RuntimeCallStatEntries entries;
 
-#define PRINT_COUNTER(name, nargs, ressize)                                    \
-  if (this->Count_Runtime_##name > 0) {                                        \
-    entries.Add(#name, this->Time_Runtime_##name, this->Count_Runtime_##name); \
+#define PRINT_COUNTER(name, nargs, ressize)   \
+  if (this->Runtime_##name.count > 0) {       \
+    entries.Add(#name, this->Runtime_##name); \
   }
   FOR_EACH_INTRINSIC(PRINT_COUNTER)
 #undef PRINT_COUNTER
-#define PRINT_COUNTER(name, type)                                              \
-  if (this->Count_Builtin_##name > 0) {                                        \
-    entries.Add(#name, this->Time_Builtin_##name, this->Count_Builtin_##name); \
+#define PRINT_COUNTER(name, type)             \
+  if (this->Builtin_##name.count > 0) {       \
+    entries.Add(#name, this->Builtin_##name); \
   }
   BUILTIN_LIST_C(PRINT_COUNTER)
 #undef PRINT_COUNTER
   entries.Print(os);
 }
 
 void RuntimeCallStats::Reset() {
-#define RESET_COUNTER(name, nargs, ressize) \
-  Count_Runtime_##name = 0;                 \
-  Time_Runtime_##name = base::TimeDelta();
+#define RESET_COUNTER(name, nargs, ressize) this->Runtime_##name.Reset();
   FOR_EACH_INTRINSIC(RESET_COUNTER)
 #undef RESET_COUNTER
-#define RESET_COUNTER(name, type) \
-  Count_Builtin_##name = 0;       \
-  Time_Builtin_##name = base::TimeDelta();
+#define RESET_COUNTER(name, type) this->Builtin_##name.Reset();
   BUILTIN_LIST_C(RESET_COUNTER)
 #undef RESET_COUNTER
 }
 
 }  // namespace internal
 }  // namespace v8