[profiler] Emit runtime call stats into sampling profile

src/profiler/profile-generator.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/profiler/profile-generator.h"
 
 #include "src/base/adapters.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/global-handles.h"
@@ skipping 630 matching lines @@
   // As starting / stopping profiles is rare relatively to this
   // method, we don't bother minimizing the duration of lock holding,
   // e.g. copying contents of the list to a local vector.
   current_profiles_semaphore_.Wait();
   for (int i = 0; i < current_profiles_.length(); ++i) {
     current_profiles_[i]->AddPath(timestamp, path, src_line, update_stats);
   }
   current_profiles_semaphore_.Signal();
 }
 
-ProfileGenerator::ProfileGenerator(CpuProfilesCollection* profiles)
-    : profiles_(profiles) {}
+ProfileGenerator::ProfileGenerator(Isolate* isolate,
+                                   CpuProfilesCollection* profiles)
+    : isolate_(isolate), profiles_(profiles) {}
 
 void ProfileGenerator::RecordTickSample(const TickSample& sample) {
   std::vector<CodeEntry*> entries;
   // Conservatively reserve space for stack frames + pc + function + vm-state.
   // There could in fact be more of them because of inlined entries.
   entries.reserve(sample.frames_count + 3);
 
   // The ProfileNode knows nothing about all versions of generated code for
   // the same JS function. The line number information associated with
   // the latest version of generated code is used to find a source line number
   // for a JS function. Then, the detected source line is passed to
   // ProfileNode to increase the tick count for this source line.
   int src_line = v8::CpuProfileNode::kNoLineNumberInfo;
   bool src_line_not_found = true;
 
   if (sample.pc != nullptr) {
     if (sample.has_external_callback && sample.state == EXTERNAL) {
       // Don't use PC when in external callback code, as it can point
       // inside callback's code, and we will erroneously report
       // that a callback calls itself.
-      entries.push_back(code_map_.FindEntry(
-          reinterpret_cast<Address>(sample.external_callback_entry)));
+      entries.push_back(FindEntry(sample.external_callback_entry));
     } else {
-      CodeEntry* pc_entry =
-          code_map_.FindEntry(reinterpret_cast<Address>(sample.pc));
+      CodeEntry* pc_entry = FindEntry(sample.pc);
       // If there is no pc_entry we're likely in native code.
       // Find out, if top of stack was pointing inside a JS function
       // meaning that we have encountered a frameless invocation.
       if (!pc_entry && !sample.has_external_callback) {
-        pc_entry = code_map_.FindEntry(reinterpret_cast<Address>(sample.tos));
+        pc_entry = FindEntry(sample.tos);
       }
       // If pc is in the function code before it set up stack frame or after the
       // frame was destroyed SafeStackFrameIterator incorrectly thinks that
       // ebp contains return address of the current function and skips caller's
       // frame. Check for this case and just skip such samples.
       if (pc_entry) {
         int pc_offset = static_cast<int>(reinterpret_cast<Address>(sample.pc) -
                                          pc_entry->instruction_start());
         src_line = pc_entry->GetSourceLine(pc_offset);
         if (src_line == v8::CpuProfileNode::kNoLineNumberInfo) {
@@ skipping 12 matching lines @@
           // 'unresolved' entry.
           if (!sample.has_external_callback) {
             entries.push_back(CodeEntry::unresolved_entry());
           }
         }
       }
     }
 
     for (unsigned i = 0; i < sample.frames_count; ++i) {
       Address stack_pos = reinterpret_cast<Address>(sample.stack[i]);
-      CodeEntry* entry = code_map_.FindEntry(stack_pos);
-
+      CodeEntry* entry = FindEntry(stack_pos);
       if (entry) {
         // Find out if the entry has an inlining stack associated.
         int pc_offset =
             static_cast<int>(stack_pos - entry->instruction_start());
         const std::vector<CodeEntry*>* inline_stack =
             entry->GetInlineStack(pc_offset);
         if (inline_stack) {
           entries.insert(entries.end(), inline_stack->rbegin(),
                          inline_stack->rend());
         }
@@ skipping 22 matching lines @@
     // If no frames were symbolized, put the VM state entry in.
     if (no_symbolized_entries) {
       entries.push_back(EntryForVMState(sample.state));
     }
   }
 
   profiles_->AddPathToCurrentProfiles(sample.timestamp, entries, src_line,
                                       sample.update_stats);
 }
 
+CodeEntry* ProfileGenerator::FindEntry(void* address) {
+  CodeEntry* entry = code_map_.FindEntry(reinterpret_cast<Address>(address));
+  if (!entry) {
+    RuntimeCallStats* rcs = isolate_->counters()->runtime_call_stats();
+    void* start = reinterpret_cast<void*>(rcs);
+    void* end = reinterpret_cast<void*>(rcs + 1);
+    if (start <= address && address < end) {
+      RuntimeCallCounter* counter =
+          reinterpret_cast<RuntimeCallCounter*>(address);
+      entry = new CodeEntry(CodeEventListener::FUNCTION_TAG, counter->name,

[fmeawad, 2016/10/28 19:51:32]

I don't think they should be considered as CodeEntry's instead I think we should
build a new Node type for them

And we should inject them statically, since the counter names are predefined.

I do not think they should live on the same stack either.

[alph, 2016/10/28 20:15:34]

I don't think we need an extra class here. CodeEntry is an universal one. We use
tags to distinguish between different frame types. I will probably introduce a
tag for it in an upcoming patch.
I was going to do that, but postponed for later. It's just more code, but should
speedup the lookup. 
Having them on the same stack is a big advantage as otherwise it would be
impossible to tell how these interleave with user functions. Having them on the
same stack simplifies data structure and also gives us flexibility to split them
into two stacks on post processing if needed.

+                            CodeEntry::kEmptyNamePrefix, "native V8Runtime");
+      code_map_.AddCode(reinterpret_cast<Address>(address), entry, 1);
+    }
+  }
+  return entry;
+}
 
 CodeEntry* ProfileGenerator::EntryForVMState(StateTag tag) {
   switch (tag) {
     case GC:
       return CodeEntry::gc_entry();
     case JS:
     case COMPILER:
     // DOM events handlers are reported as OTHER / EXTERNAL entries.
     // To avoid confusing people, let's put all these entries into
     // one bucket.
     case OTHER:
     case EXTERNAL:
       return CodeEntry::program_entry();
     case IDLE:
       return CodeEntry::idle_entry();
     default: return NULL;
   }
 }
 
 }  // namespace internal
 }  // namespace v8