Check if the frame is optimized before marking a function for optimization.

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 248 matching lines @@
       int ticks = shared_code->profiler_ticks();
       if (ticks >= kProfilerTicksBeforeReenablingOptimization) {
         shared_code->set_profiler_ticks(0);
         shared->TryReenableOptimization();
       } else {
         shared_code->set_profiler_ticks(ticks + 1);
       }
     }
     return;
   }
-  if (function->IsOptimized()) return;
+  if (frame->is_optimized()) return;
 
   int ticks = shared_code->profiler_ticks();
 
   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
@@ skipping 54 matching lines @@
   }
 }
 
 void RuntimeProfiler::MaybeOptimizeIgnition(JSFunction* function,
                                             JavaScriptFrame* frame) {
   if (function->IsInOptimizationQueue()) return;
 
   if (FLAG_always_osr) {
     AttemptOnStackReplacement(frame, AbstractCode::kMaxLoopNestingMarker);
     // Fall through and do a normal optimized compile as well.
   } else if (MaybeOSRIgnition(function, frame)) {

[mythria, 2016/10/31 16:02:03]

when FLAG_ignition_osr is disabled MaybeOSRIgnition just returns false. So we
will execute the later part of the function even when the function is optimized.
When I change the check from function->IsOptimized to frame->is_optimized(), we
may end up marking optimized functions for optimization again if we haven't
moved to the optimized code yet. So we have three choices here:

1. Remove the FLAG_ignition_osr check in MaybeOSRIgnition. Since this is already
handled in AttemptOnStackReplacement.

2. Also add a check for function->IsOptimized() where we check for optimized
frames.

3. Just retain the check for optimized functions.

I listed them in my order of preference. Let me know what you think would be the
best. 

[Michael Starzinger, 2016/11/03 11:40:27]

I would also prefer (1), especially given that we also want to enable
--ignition-osr by default anyways. See:
https://codereview.chromium.org/2432413004/

[mythria, 2016/11/04 11:12:32]

Done.

     return;
   }
 
   SharedFunctionInfo* shared = function->shared();
   int ticks = shared->profiler_ticks();
 
   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 (frame->is_optimized()) return;
 
   OptimizationReason reason = ShouldOptimizeIgnition(function, frame);
 
   if (reason != OptimizationReason::kDoNotOptimize) {
     Optimize(function, reason);
   }
 }
 
 bool RuntimeProfiler::MaybeOSRIgnition(JSFunction* function,
                                        JavaScriptFrame* frame) {
   if (!FLAG_ignition_osr) return false;

[mythria, 2016/10/31 16:02:03]

This is the check I was referring to in my earlier comment.

 
   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.
 
   bool osr_before_baselined = function->IsMarkedForBaseline() &&
                               ShouldOptimizeIgnition(function, frame) !=
                                   OptimizationReason::kDoNotOptimize;
@@ skipping 94 matching lines @@
     } else {
       DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
       MaybeOptimizeFullCodegen(function, frame, frame_count);
     }
   }
   any_ic_changed_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8