Add flag inlining_callee_size_threshold_with_constants (default 200) which causes more aggressive i…

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 18 matching lines @@
 DEFINE_FLAG(int, inline_getters_setters_smaller_than, 10,
     "Always inline getters and setters that have fewer instructions");
 DEFINE_FLAG(int, inlining_depth_threshold, 6,
     "Inline function calls up to threshold nesting depth");
 DEFINE_FLAG(int, inlining_size_threshold, 25,
     "Always inline functions that have threshold or fewer instructions");
 DEFINE_FLAG(int, inlining_callee_call_sites_threshold, 1,
     "Always inline functions containing threshold or fewer calls.");
 DEFINE_FLAG(int, inlining_callee_size_threshold, 80,
     "Do not inline callees larger than threshold");
+DEFINE_FLAG(int, inlining_callee_size_threshold_with_constants, 200,
+    "Do not inline callees larger than threshold if constant arguments");
 DEFINE_FLAG(int, inlining_caller_size_threshold, 50000,
     "Stop inlining once caller reaches the threshold.");
 DEFINE_FLAG(int, inlining_constant_arguments_count, 1,
     "Inline function calls with sufficient constant arguments "
     "and up to the increased threshold on instructions");
 DEFINE_FLAG(int, inlining_constant_arguments_size_threshold, 60,
     "Inline function calls with sufficient constant arguments "
     "and up to the increased threshold on instructions");
 DEFINE_FLAG(int, inlining_hotness, 10,
     "Inline only hotter calls, in percents (0 .. 100); "
@@ skipping 442 matching lines @@
 
   // Inlining heuristics based on Cooper et al. 2008.
   bool ShouldWeInline(const Function& callee,
                       intptr_t instr_count,
                       intptr_t call_site_count,
                       intptr_t const_arg_count) {
     if (inlined_size_ > FLAG_inlining_caller_size_threshold) {
       // Prevent methods becoming humongous and thus slow to compile.
       return false;
     }
-    if (instr_count > FLAG_inlining_callee_size_threshold) {
+    if (const_arg_count > 0) {
+      if (instr_count > FLAG_inlining_callee_size_threshold_with_constants) {
+        return false;
+      }
+    } else if (instr_count > FLAG_inlining_callee_size_threshold) {
       return false;
     }
     // 'instr_count' can be 0 if it was not computed yet.
     if ((instr_count != 0) && (instr_count <= FLAG_inlining_size_threshold)) {
       return true;
     }
     if (call_site_count <= FLAG_inlining_callee_call_sites_threshold) {
       return true;
     }
     if ((const_arg_count >= FLAG_inlining_constant_arguments_count) &&
         (instr_count <= FLAG_inlining_constant_arguments_size_threshold)) {

[Vyacheslav Egorov (Google), 2014/12/08 19:11:30]

maybe renamed this flag because now we have a positive threshold (one that
forces inlining  of small methods with constant arguments) and negative
threshold which are called in a similar way. 

[srdjan, 2014/12/08 21:19:09]

Renamed flags to:
inlining_constant_arguments_max_size_threshold(above no inlining)
inlining_constant_arguments_min_size_threshold (below, always inline if
arg-count sufficient).

       return true;
     }
     if (FlowGraphInliner::AlwaysInline(callee)) {
       return true;
     }
     return false;
   }
 
   void InlineCalls() {
     // If inlining depth is less then one abort.
@@ skipping 1252 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function()->function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart