[Intepreter] Always use BytecodeGraphBuilder when --turbo-from-bytecode

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/ast/scopeinfo.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 95 matching lines @@
     }
     PrintF("]\n");
   }
 }
 
 void RuntimeProfiler::Optimize(JSFunction* function, const char* reason) {
   TraceRecompile(function, reason, "optimized");
 
   // TODO(4280): Fix this to check function is compiled to baseline once we
   // have a standard way to check that. For now, if baseline code doesn't have
   // a bytecode array.

[Michael Starzinger, 2016/07/19 16:00:07]

nit: The TODO applied to the assertion I think, let's also drop the TODO.

[rmcilroy, 2016/07/20 21:48:40]

Done.

-  DCHECK(!function->shared()->HasBytecodeArray());
   function->AttemptConcurrentOptimization();
 }
 
 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());
@@ skipping 118 matching lines @@
         generic_percentage <= FLAG_generic_ic_threshold) {
       Optimize(function, "small function");
     } else {
       shared_code->set_profiler_ticks(ticks + 1);
     }
   } else {
     shared_code->set_profiler_ticks(ticks + 1);
   }
 }
 
-void RuntimeProfiler::MaybeOptimizeIgnition(JSFunction* function) {
+void RuntimeProfiler::MaybeBaselineIgnition(JSFunction* function) {
   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.
-  // TODO(rmcilroy): Consider whether we should optimize small functions when
-  // they are first seen on the stack (e.g., kMaxSizeEarlyOpt).
 
   if (function->IsMarkedForBaseline() || function->IsMarkedForOptimization() ||
       function->IsMarkedForConcurrentOptimization() ||
       function->IsOptimized()) {
     // TODO(rmcilroy): Support OSR in these cases.
     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) {
+  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 (function->IsMarkedForBaseline() || function->IsMarkedForOptimization() ||
+      function->IsMarkedForConcurrentOptimization() ||
+      function->IsOptimized()) {
+    // TODO(rmcilroy): Support OSR in these cases.
+    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);
+        shared->TryReenableOptimization();
+      }
+    }
+    return;
+  }
+  if (function->IsOptimized()) return;
+
+  if (ticks >= kProfilerTicksBeforeOptimization) {
+    int typeinfo, generic, total, type_percentage, generic_percentage;
+    GetICCounts(function, &typeinfo, &generic, &total, &type_percentage,
+                &generic_percentage);
+    if (type_percentage >= FLAG_type_info_threshold &&
+        generic_percentage <= FLAG_generic_ic_threshold) {
+      // If this particular function hasn't had any ICs patched for enough
+      // ticks, optimize it now.
+      Optimize(function, "hot and stable");
+    } else if (ticks >= kTicksWhenNotEnoughTypeInfo) {
+      Optimize(function, "not much type info but very hot");
+    } else {
+      if (FLAG_trace_opt_verbose) {
+        PrintF("[not yet optimizing ");
+        function->PrintName();
+        PrintF(", not enough type info: %d/%d (%d%%)]\n", typeinfo, total,
+               type_percentage);
+      }
+    }
+  }
+  // TODO(rmcilroy): Consider whether we should optimize small functions when
+  // they are first seen on the stack (e.g., kMaxSizeEarlyOpt).
+}
+
 void RuntimeProfiler::MarkCandidatesForOptimization() {
   HandleScope scope(isolate_);
 
   if (!isolate_->use_crankshaft()) return;
 
   DisallowHeapAllocation no_gc;
 
   // Run through the JavaScript frames and collect them. If we already
   // have a sample of the function, we mark it for optimizations
   // (eagerly or lazily).
   int frame_count = 0;
   int frame_count_limit = FLAG_frame_count;
   for (JavaScriptFrameIterator it(isolate_);
        frame_count++ < frame_count_limit && !it.done();
        it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     JSFunction* function = frame->function();
 
     List<JSFunction*> functions(4);
     frame->GetFunctions(&functions);
     for (int i = functions.length(); --i >= 0; ) {
       SharedFunctionInfo* shared_function_info = functions[i]->shared();
       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 (frame->is_interpreted()) {
-      DCHECK(!frame->is_optimized());
-      MaybeOptimizeIgnition(function);
+      if (next_tier == Compiler::BASELINE) {
+        DCHECK(!frame->is_optimized());
+        MaybeBaselineIgnition(function);
+      } else {
+        DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
+        MaybeOptimizeIgnition(function);
+      }
     } else {
+      DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
       MaybeOptimizeFullCodegen(function, frame_count, frame->is_optimized());
     }
   }
   any_ic_changed_ = false;
 }
 
 
 }  // namespace internal
 }  // namespace v8