[Turbofan] don't optimize from bytecode > 250K in size.

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 39 matching lines @@
 static const int kOSRCodeSizeAllowancePerTickIgnition =
     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;
 
+// Certain functions are simply too big to be worth optimizing.
+static const int kMaxSizeOptFromBytecode = 250 * 1024;

[Michael Starzinger, 2017/01/30 12:42:11]

nit: Can we call this "kMaxSizeOptIgnition" to follow the same naming convention
as the above constants. Also, it might make sense to mention that the only
reason this is not based on kCodeSizeMultiplier is because there is no such
heuristic for optimization of baseline frames (i.e. no kMaxSizeOpt).

[mvstanton, 2017/01/30 14:55:37]

"We are not using the code size multiplier here because there is no
"kMaxSizeOpt" with which we would need to normalize."

Better name: kMaxSizeOptIgnition.


Done.

+
 #define OPTIMIZATION_REASON_LIST(V)                            \
   V(DoNotOptimize, "do not optimize")                          \
   V(HotAndStable, "hot and stable")                            \
   V(HotEnoughForBaseline, "hot enough for baseline")           \
   V(HotWithoutMuchTypeInfo, "not much type info but very hot") \
   V(SmallFunction, "small function")
 
 enum class OptimizationReason : uint8_t {
 #define OPTIMIZATION_REASON_CONSTANTS(Constant, message) k##Constant,
   OPTIMIZATION_REASON_LIST(OPTIMIZATION_REASON_CONSTANTS)
@@ skipping 317 matching lines @@
     return true;
   }
   return false;
 }
 
 OptimizationReason RuntimeProfiler::ShouldOptimizeIgnition(
     JSFunction* function, JavaScriptFrame* frame) {
   SharedFunctionInfo* shared = function->shared();
   int ticks = shared->profiler_ticks();
 
+  if (shared->bytecode_array()->Size() > kMaxSizeOptFromBytecode) {

[Michael Starzinger, 2017/01/30 12:42:11]

nit: s/Size/instruction_size/ to avoid dispatched getter and for readability and
to keep it in sync with the other heuristics in this file that are based on
"bytecode" size.

[Michael Starzinger, 2017/01/30 12:54:48]

Ooops, looked at the wrong use-site. Please disregard. Sorry for the noise.

[mvstanton, 2017/01/30 14:55:37]

Per discussion, Size() is now the right predicate.

+    return OptimizationReason::kDoNotOptimize;
+  }
+
   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.
       return OptimizationReason::kHotAndStable;
     } else if (ticks >= kTicksWhenNotEnoughTypeInfo) {
@@ skipping 65 matching lines @@
       if (ticks < Smi::kMaxValue) {
         shared_function_info->set_profiler_ticks(ticks + 1);
       }
     }
   }
   any_ic_changed_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8