[inspector] cache stack frame for call sites

src/isolate.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/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 607 matching lines @@
 
   Handle<StackFrameInfo> NewStackFrameObject(FrameSummary& summ) {
     if (summ.IsJavaScript()) return NewStackFrameObject(summ.AsJavaScript());
     if (summ.IsWasm()) return NewStackFrameObject(summ.AsWasm());
     UNREACHABLE();
     return factory()->NewStackFrameInfo();
   }
 
   Handle<StackFrameInfo> NewStackFrameObject(
       const FrameSummary::JavaScriptFrameSummary& summ) {
+    int code_offset = summ.code_offset();
+    Handle<AbstractCode> code = summ.abstract_code();
+    Object* maybe_cache = code->stack_frame_cache();
+    Handle<UnseededNumberDictionary> cache;
+    if (maybe_cache->IsUnseededNumberDictionary()) {
+      cache = handle(UnseededNumberDictionary::cast(maybe_cache));
+    } else {
+      cache = UnseededNumberDictionary::NewEmpty(isolate_);
+      code->set_stack_frame_cache(*cache);
+    }
+    int entry = cache->FindEntry(code_offset);
+    if (entry != UnseededNumberDictionary::kNotFound) {
+      return handle(StackFrameInfo::cast(cache->ValueAt(entry)), isolate_);
+    }

[rmcilroy, 2017/04/04 09:22:49]

Rather than requiring a new field in both code and bytecode objects (which are
quite common, so this is a not insignificant memory overhead) could we instead
build a side hash-table cache keyed by the code object or some other indicator
of the call site? (Then this would only be an overhead when code generates stack
frames. 

[Yang, 2017/04/04 13:51:58]

+1 for a side table. If you use code objects as hash table key, you will need to
extend GetSimpleHash to also handle Code* and BytecodeArray*.

Actually I think using the source position table as key would make more sense.
You could use its content to compute the hash.

[kozy, 2017/04/04 19:11:07]

Done.

[kozy, 2017/04/04 19:11:07]

Done.

     Handle<StackFrameInfo> frame = factory()->NewStackFrameInfo();
     Handle<Script> script = Handle<Script>::cast(summ.script());
     if (options_ & StackTrace::kLineNumber) {
       Script::PositionInfo info;
       bool valid_pos = Script::GetPositionInfo(script, summ.SourcePosition(),
                                                &info, Script::WITH_OFFSET);
       if (valid_pos) {
         frame->set_line_number(info.line + 1);
         if (options_ & StackTrace::kColumnOffset) {
           frame->set_column_number(info.column + 1);
@@ skipping 12 matching lines @@
       frame->set_is_eval(script->compilation_type() ==
                          Script::COMPILATION_TYPE_EVAL);
     }
     if (options_ & StackTrace::kFunctionName) {
       Handle<String> name = summ.FunctionName();
       frame->set_function_name(*name);
     }
     if (options_ & StackTrace::kIsConstructor) {
       frame->set_is_constructor(summ.is_constructor());
     }
+    auto new_cache =
+        UnseededNumberDictionary::AtNumberPut(cache, code_offset, frame);
+    if (*new_cache != *cache) code->set_stack_frame_cache(*new_cache);
     return frame;
   }
 
   Handle<StackFrameInfo> NewStackFrameObject(
       const FrameSummary::WasmFrameSummary& summ) {
     Handle<StackFrameInfo> info = factory()->NewStackFrameInfo();
 
     if (options_ & StackTrace::kFunctionName) {
       Handle<WasmCompiledModule> compiled_module(
           summ.wasm_instance()->compiled_module(), isolate_);
@@ skipping 2986 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8