[Interpreter] Tune runtime profiler parameters for turbofan and 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"
 #include "src/compilation-cache.h"
 #include "src/compiler.h"
 #include "src/execution.h"
 #include "src/frames-inl.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/global-handles.h"
 #include "src/interpreter/interpreter.h"
 
 namespace v8 {
 namespace internal {
 
 
 // Number of times a function has to be seen on the stack before it is
 // compiled for baseline.
 static const int kProfilerTicksBeforeBaseline = 1;
 // Number of times a function has to be seen on the stack before it is
 // optimized.
 static const int kProfilerTicksBeforeOptimization = 2;
+// Number of times a interpreted function has to be seen on the stack before
+// it is optimized (with Turbofan, ignition is only optimized with Turbofan).
+static const int kProfilerTicksBeforeOptimizingInterpretedFunction = 4;

[mythria, 2016/10/26 08:17:15]

In my experiments on Octane I found 4 to be a good value, we can tune it further
depending on the results from bots. 

 // If the function optimization was disabled due to high deoptimization count,
 // but the function is hot and has been seen on the stack this number of times,
 // then we try to reenable optimization for this function.
 static const int kProfilerTicksBeforeReenablingOptimization = 250;
 // If a function does not have enough type info (according to
 // FLAG_type_info_threshold), but has seen a huge number of ticks,
 // optimize it as it is.
 static const int kTicksWhenNotEnoughTypeInfo = 100;
 // We only have one byte to store the number of ticks.
 STATIC_ASSERT(kProfilerTicksBeforeOptimization < 256);
+STATIC_ASSERT(kProfilerTicksBeforeOptimizingInterpretedFunction < 256);
 STATIC_ASSERT(kProfilerTicksBeforeReenablingOptimization < 256);
 STATIC_ASSERT(kTicksWhenNotEnoughTypeInfo < 256);
 
 // Maximum size in bytes of generate code for a function to allow OSR.
 static const int kOSRCodeSizeAllowanceBase =
     100 * FullCodeGenerator::kCodeSizeMultiplier;

[mythria, 2016/10/26 08:17:15]

In my initial patch, I also changed this metric for default pipeline. It seems
to help Octane (+7% overall) but regresses sunspider (-1% overall) on the bots.
I can't reproduce the improvements on octane (Gameboy improves by 50% on the
bots), so I reset it to the default values. I will look into this after I
investigate why Gameboy and Box2d are varying a lot. 

 static const int kOSRCodeSizeAllowanceBaseIgnition =
-    100 * interpreter::Interpreter::kCodeSizeMultiplier;
+    10 * interpreter::Interpreter::kCodeSizeMultiplier;

[mythria, 2016/10/26 08:17:15]

This and the change to OSRCodeSizeAllowancePerTIck helps sunspider quite a bit.
Overall 11% improvement. Jetstream improves by 5%. If the bots are to be trusted
we get 1-2% overall improvement on Octane and Kraken. Though locally I don't see
similar improvements on octane. 

 
 static const int kOSRCodeSizeAllowancePerTick =
     4 * FullCodeGenerator::kCodeSizeMultiplier;
 static const int kOSRCodeSizeAllowancePerTickIgnition =
-    4 * interpreter::Interpreter::kCodeSizeMultiplier;
+    2 * interpreter::Interpreter::kCodeSizeMultiplier;
 
 // Maximum size in bytes of generated code for a function to be optimized
 // the very first time it is seen on the stack.
 static const int kMaxSizeEarlyOpt =
     5 * FullCodeGenerator::kCodeSizeMultiplier;
 static const int kMaxSizeEarlyOptIgnition =
     5 * interpreter::Interpreter::kCodeSizeMultiplier;
 
 #define OPTIMIZATION_REASON_LIST(V)                            \
   V(DoNotOptimize, "do not optimize")                          \
@@ skipping 335 matching lines @@
     return true;
   }
   return false;
 }
 
 OptimizationReason RuntimeProfiler::ShouldOptimizeIgnition(
     JSFunction* function, JavaScriptFrame* frame) {
   SharedFunctionInfo* shared = function->shared();
   int ticks = shared->profiler_ticks();
 
-  if (ticks >= kProfilerTicksBeforeOptimization) {
+  if (ticks >= kProfilerTicksBeforeOptimizingInterpretedFunction) {
     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.
       return OptimizationReason::kHotAndStable;
     } else if (ticks >= kTicksWhenNotEnoughTypeInfo) {
       return OptimizationReason::kHotWithoutMuchTypeInfo;
@@ skipping 61 matching lines @@
     } else {
       DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
       MaybeOptimizeFullCodegen(function, frame, frame_count);
     }
   }
   any_ic_changed_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8