Removed loop depth info tracking at graph build time.

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/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_inlining, false, "Trace inlining");
 DEFINE_FLAG(charp, inlining_filter, NULL, "Inline only in named function");
 
 // Flags for inlining heuristics.
 DEFINE_FLAG(int, inlining_depth_threshold, 3,
     "Inline function calls up to threshold nesting depth");
 DEFINE_FLAG(int, inlining_size_threshold, 20,
     "Always inline functions that have threshold or fewer instructions");
-DEFINE_FLAG(int, inlining_in_loop_size_threshold, 80,
-    "Inline functions in loops 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_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 255 matching lines @@
       : caller_graph_(flow_graph),
         inlined_(false),
         initial_size_(flow_graph->InstructionCount()),
         inlined_size_(0),
         inlining_depth_(1),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
         function_cache_() { }
 
   // Inlining heuristics based on Cooper et al. 2008.
-  bool ShouldWeInline(intptr_t loop_depth,
-                      intptr_t instr_count,
+  bool ShouldWeInline(intptr_t instr_count,
                       intptr_t call_site_count,
                       intptr_t const_arg_count) {
     if (instr_count <= FLAG_inlining_size_threshold) {
       return true;
     }
     if (call_site_count <= FLAG_inlining_callee_call_sites_threshold) {
       return true;
     }
-    if ((loop_depth > 0) &&
-        (instr_count <= FLAG_inlining_in_loop_size_threshold)) {
-      return true;
-    }
     if ((const_arg_count >= FLAG_inlining_constant_arguments_count) &&
         (instr_count <= FLAG_inlining_constant_arguments_size_threshold)) {
       return true;
     }
     return false;
   }
 
   // TODO(srdjan): Handle large 'skip_static_call_deopt_ids'. Currently
   // max. size observed is 11 (dart2js).
   void InlineCalls() {
@@ skipping 48 matching lines @@
     }
 
     // Abort if this function has deoptimized too much.
     if (function.deoptimization_counter() >=
         FLAG_deoptimization_counter_threshold) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: deoptimization threshold\n"));
       return false;
     }
 
-    const intptr_t loop_depth = call->GetBlock()->loop_depth();
     const intptr_t constant_arguments = CountConstants(*arguments);
-    if (!ShouldWeInline(loop_depth,
-                        function.optimized_instruction_count(),
+    if (!ShouldWeInline(function.optimized_instruction_count(),
                         function.optimized_call_site_count(),
                         constant_arguments)) {
       TRACE_INLINING(OS::Print("     Bailout: early heuristics with "
-                               "loop depth: %"Pd", "
                                "code size:  %"Pd", "
                                "call sites: %"Pd", "
                                "const args: %"Pd"\n",
-                               loop_depth,
                                function.optimized_instruction_count(),
                                function.optimized_call_site_count(),
                                constant_arguments));
       return false;
     }
 
     // Abort if this is a recursive occurrence.
     if (IsCallRecursive(function, call)) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: recursive function\n"));
@@ skipping 38 matching lines @@
 
       // Build the callee graph.
       ValueInliningContext* inlining_context = new ValueInliningContext();
       FlowGraphBuilder builder(*parsed_function, inlining_context);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
       FlowGraph* callee_graph;
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_build_timer,
                          isolate);
-        callee_graph = builder.BuildGraph(loop_depth);
+        callee_graph = builder.BuildGraph();
       }
 
       // The parameter stubs are a copy of the actual arguments providing
       // concrete information about the values, for example constant values,
       // without linking between the caller and callee graphs.
       // TODO(zerny): Put more information in the stubs, eg, type information.
       GrowableArray<Definition*> param_stubs(function.NumParameters());
 
       // Create a parameter stub for each fixed positional parameter.
       for (intptr_t i = 0; i < function.num_fixed_parameters(); ++i) {
@@ skipping 61 matching lines @@
         if (param_stubs[i]->IsConstant()) ++constants_count;
       }
       GraphInfoCollector info;
       info.Collect(*callee_graph);
       const intptr_t size = info.instruction_count();
 
       function.set_optimized_instruction_count(size);
       function.set_optimized_call_site_count(info.call_site_count());
 
       // Use heuristics do decide if this call should be inlined.
-      if (!ShouldWeInline(loop_depth,
-                          size,
+      if (!ShouldWeInline(size,
                           info.call_site_count(),
                           constants_count)) {
         // If size is larger than all thresholds, don't consider it again.
         if ((size > FLAG_inlining_size_threshold) &&
-            (size > FLAG_inlining_in_loop_size_threshold) &&
             (size > FLAG_inlining_callee_call_sites_threshold) &&
             (size > FLAG_inlining_constant_arguments_size_threshold)) {
           function.set_is_inlinable(false);
         }
         isolate->set_long_jump_base(base);
         isolate->set_deopt_id(prev_deopt_id);
         isolate->set_ic_data_array(prev_ic_data.raw());
         TRACE_INLINING(OS::Print("     Bailout: heuristics with "
-                                 "loop depth: %"Pd", "
                                  "code size:  %"Pd", "
                                  "call sites: %"Pd", "
                                  "const args: %"Pd"\n",
-                                 loop_depth,
                                  size,
                                  info.call_site_count(),
                                  constants_count));
         return false;
       }
 
       // If depth is less or equal to threshold recursively add call sites.
       if (inlining_depth_ < FLAG_inlining_depth_threshold) {
         collected_call_sites_->FindCallSites(callee_graph);
       }
@@ skipping 313 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart