[interpreter] Switch profiler to use frames for OSR.

src/runtime-profiler.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/runtime-profiler.h"
 
 #include "src/assembler.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 109 matching lines @@
 void RuntimeProfiler::Baseline(JSFunction* function, const char* reason) {
   TraceRecompile(function, reason, "baseline");
 
   // TODO(4280): Fix this to check function is compiled for the interpreter
   // once we have a standard way to check that. For now function will only
   // have a bytecode array if compiled for the interpreter.
   DCHECK(function->shared()->HasBytecodeArray());
   function->MarkForBaseline();
 }
 
-void RuntimeProfiler::AttemptOnStackReplacement(JSFunction* function,
+void RuntimeProfiler::AttemptOnStackReplacement(JavaScriptFrame* frame,
                                                 int loop_nesting_levels) {
+  JSFunction* function = frame->function();
   SharedFunctionInfo* shared = function->shared();
   if (!FLAG_use_osr || function->shared()->IsBuiltin()) {
     return;
   }
 
   // If the code is not optimizable, don't try OSR.
   if (shared->optimization_disabled()) return;
 
   // We are not prepared to do OSR for a function that already has an
   // allocated arguments object.  The optimized code would bypass it for
   // arguments accesses, which is unsound.  Don't try OSR.
   if (shared->uses_arguments()) return;
 
   // We're using on-stack replacement: modify unoptimized code so that
   // certain back edges in any unoptimized frame will trigger on-stack
   // replacement for that frame.
   //  - Ignition: Store new loop nesting level in BytecodeArray header.
   //  - FullCodegen: Patch back edges up to new level using BackEdgeTable.
   if (FLAG_trace_osr) {
     PrintF("[OSR - arming back edges in ");
     function->PrintName();
     PrintF("]\n");
   }
 
-  if (shared->code()->kind() == Code::FUNCTION) {
+  if (frame->type() == StackFrame::JAVA_SCRIPT) {
+    DCHECK(shared->HasBaselineCode());
     DCHECK(BackEdgeTable::Verify(shared->GetIsolate(), shared->code()));
     for (int i = 0; i < loop_nesting_levels; i++) {
       BackEdgeTable::Patch(isolate_, shared->code());
     }
-  } else if (shared->HasBytecodeArray()) {
-    DCHECK(FLAG_ignition_osr);  // Should only happen when enabled.
+  } else if (frame->type() == StackFrame::INTERPRETED) {
+    DCHECK(shared->HasBytecodeArray());
+    if (!FLAG_ignition_osr) return;  // Only use this when enabled.
     int level = shared->bytecode_array()->osr_loop_nesting_level();
     shared->bytecode_array()->set_osr_loop_nesting_level(
         Min(level + loop_nesting_levels, AbstractCode::kMaxLoopNestingMarker));
   } else {
     UNREACHABLE();
   }
 }
 
 void RuntimeProfiler::MaybeOptimizeFullCodegen(JSFunction* function,
-                                               int frame_count,
-                                               bool frame_optimized) {
+                                               JavaScriptFrame* frame,
+                                               int frame_count) {
   SharedFunctionInfo* shared = function->shared();
   Code* shared_code = shared->code();
   if (shared_code->kind() != Code::FUNCTION) return;
   if (function->IsInOptimizationQueue()) return;
 
   if (FLAG_always_osr) {
-    AttemptOnStackReplacement(function, AbstractCode::kMaxLoopNestingMarker);
+    AttemptOnStackReplacement(frame, AbstractCode::kMaxLoopNestingMarker);
     // Fall through and do a normal optimized compile as well.
-  } else if (!frame_optimized &&
+  } else if (!frame->is_optimized() &&
              (function->IsMarkedForOptimization() ||
               function->IsMarkedForConcurrentOptimization() ||
               function->IsOptimized())) {
     // Attempt OSR if we are still running unoptimized code even though the
     // the function has long been marked or even already been optimized.
     int ticks = shared_code->profiler_ticks();
     int64_t allowance =
         kOSRCodeSizeAllowanceBase +
         static_cast<int64_t>(ticks) * kOSRCodeSizeAllowancePerTick;
     if (shared_code->CodeSize() > allowance &&
         ticks < Code::ProfilerTicksField::kMax) {
       shared_code->set_profiler_ticks(ticks + 1);
     } else {
-      AttemptOnStackReplacement(function);
+      AttemptOnStackReplacement(frame);
     }
     return;
   }
 
   // Only record top-level code on top of the execution stack and
   // avoid optimizing excessively large scripts since top-level code
   // will be executed only once.
   const int kMaxToplevelSourceSize = 10 * 1024;
   if (shared->is_toplevel() &&
       (frame_count > 1 || shared->SourceSize() > kMaxToplevelSourceSize)) {
@@ skipping 51 matching lines @@
       Optimize(function, "small function");
     } else {
       shared_code->set_profiler_ticks(ticks + 1);
     }
   } else {
     shared_code->set_profiler_ticks(ticks + 1);
   }
 }
 
 void RuntimeProfiler::MaybeBaselineIgnition(JSFunction* function,
-                                            bool frame_optimized) {
+                                            JavaScriptFrame* frame) {
   if (function->IsInOptimizationQueue()) return;
 
   SharedFunctionInfo* shared = function->shared();
   int ticks = shared->profiler_ticks();
 
   // TODO(rmcilroy): Also ensure we only OSR top-level code if it is smaller
   // than kMaxToplevelSourceSize.
 
-  if (FLAG_ignition_osr && FLAG_always_osr) {
-    AttemptOnStackReplacement(function, AbstractCode::kMaxLoopNestingMarker);
+  if (FLAG_always_osr) {
+    AttemptOnStackReplacement(frame, AbstractCode::kMaxLoopNestingMarker);
     // Fall through and do a normal baseline compile as well.
-  } else if (!frame_optimized &&
+  } else if (!frame->is_optimized() &&
              (function->IsMarkedForBaseline() ||
               function->IsMarkedForOptimization() ||
               function->IsMarkedForConcurrentOptimization() ||
               function->IsOptimized())) {
     // Attempt OSR if we are still running interpreted code even though the
     // the function has long been marked or even already been optimized.
     int64_t allowance =
         kOSRCodeSizeAllowanceBaseIgnition +
         static_cast<int64_t>(ticks) * kOSRCodeSizeAllowancePerTickIgnition;
-    if (FLAG_ignition_osr && shared->HasBytecodeArray() &&
-        shared->bytecode_array()->Size() <= allowance) {
-      AttemptOnStackReplacement(function);
+    if (shared->bytecode_array()->Size() <= allowance) {
+      AttemptOnStackReplacement(frame);
     }
     return;
   }
 
   if (shared->optimization_disabled() &&
       shared->disable_optimization_reason() == kOptimizationDisabledForTest) {
     // Don't baseline functions which have been marked by NeverOptimizeFunction
     // in a test.
     return;
   }
 
   if (ticks >= kProfilerTicksBeforeBaseline) {
     Baseline(function, "hot enough for baseline");
   }
 }
 
 void RuntimeProfiler::MaybeOptimizeIgnition(JSFunction* function,
-                                            bool frame_optimized) {
+                                            JavaScriptFrame* frame) {
   if (function->IsInOptimizationQueue()) return;
 
   SharedFunctionInfo* shared = function->shared();
   int ticks = shared->profiler_ticks();
 
   // TODO(rmcilroy): Also ensure we only OSR top-level code if it is smaller
   // than kMaxToplevelSourceSize.
 
-  if (FLAG_ignition_osr && FLAG_always_osr) {
-    AttemptOnStackReplacement(function, AbstractCode::kMaxLoopNestingMarker);
+  if (FLAG_always_osr) {
+    AttemptOnStackReplacement(frame, AbstractCode::kMaxLoopNestingMarker);
     // Fall through and do a normal optimized compile as well.
-  } else if (!frame_optimized &&
+  } else if (!frame->is_optimized() &&
              (function->IsMarkedForBaseline() ||
               function->IsMarkedForOptimization() ||
               function->IsMarkedForConcurrentOptimization() ||
               function->IsOptimized())) {
     // Attempt OSR if we are still running interpreted code even though the
     // the function has long been marked or even already been optimized.
     int64_t allowance =
         kOSRCodeSizeAllowanceBaseIgnition +
         static_cast<int64_t>(ticks) * kOSRCodeSizeAllowancePerTickIgnition;
-    if (FLAG_ignition_osr && shared->HasBytecodeArray() &&
-        shared->bytecode_array()->Size() <= allowance) {
-      AttemptOnStackReplacement(function);
+    if (shared->bytecode_array()->Size() <= allowance) {
+      AttemptOnStackReplacement(frame);
     }
     return;
   }
 
   if (shared->optimization_disabled()) {
     if (shared->deopt_count() >= FLAG_max_opt_count) {
       // If optimization was disabled due to many deoptimizations,
       // then check if the function is hot and try to reenable optimization.
       if (ticks >= kProfilerTicksBeforeReenablingOptimization) {
         shared->set_profiler_ticks(0);
@@ skipping 53 matching lines @@
       int ticks = shared_function_info->profiler_ticks();
       if (ticks < Smi::kMaxValue) {
         shared_function_info->set_profiler_ticks(ticks + 1);
       }
     }
 
     Compiler::CompilationTier next_tier =
         Compiler::NextCompilationTier(function);
     if (function->shared()->HasBytecodeArray()) {
       if (next_tier == Compiler::BASELINE) {
-        MaybeBaselineIgnition(function, frame->is_optimized());
+        MaybeBaselineIgnition(function, frame);
       } else {
         DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
-        MaybeOptimizeIgnition(function, frame->is_optimized());
+        MaybeOptimizeIgnition(function, frame);
       }
     } else {
       DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
-      MaybeOptimizeFullCodegen(function, frame_count, frame->is_optimized());
+      MaybeOptimizeFullCodegen(function, frame, frame_count);
     }
   }
   any_ic_changed_ = false;
 }
 
 
 }  // namespace internal
 }  // namespace v8