Store optimized flow graph statistics on the function itself.

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2012, 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"
@@ skipping 335 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;
     }
 
+    if (!ShouldWeInline(call->GetBlock()->loop_depth(),
+                        function.optimized_instruction_count(),
+                        function.optimized_call_site_count(),
+                        CountConstants(*arguments))) {
+      TRACE_INLINING(OS::Print("     Bailout: early heuristics\n"));

[srdjan, 2012/12/13 19:00:17]

Maybe print also the arguments that led to inlining bailout.

[Vyacheslav Egorov (Google), 2012/12/13 19:14:11]

Done.

+      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"));
       return false;
     }
 
     // Abort if the callee has an intrinsic translation.
     if (Intrinsifier::CanIntrinsify(function)) {
       function.set_is_inlinable(false);
@@ skipping 24 matching lines @@
       }
 
       // Load IC data for the callee.
       if (function.HasCode()) {
         const Code& unoptimized_code =
             Code::Handle(function.unoptimized_code());
         isolate->set_ic_data_array(unoptimized_code.ExtractTypeFeedbackArray());
       }
 
       // Build the callee graph.
       const intptr_t loop_depth = call->GetBlock()->loop_depth();

[Kevin Millikin (Google), 2012/12/13 16:43:40]

Move this above the first call to ShouldWeInline.

[Vyacheslav Egorov (Google), 2012/12/13 18:54:46]

Done.

       FlowGraphBuilder builder(*parsed_function);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
       FlowGraph* callee_graph;
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_build_timer,
                          isolate);
         callee_graph =
             builder.BuildGraph(FlowGraphBuilder::kValueContext, loop_depth);
       }
@@ skipping 57 matching lines @@
 
       if (FLAG_trace_inlining && FLAG_print_flow_graph) {
         OS::Print("Callee graph for inlining %s\n",
                   function.ToFullyQualifiedCString());
         FlowGraphPrinter printer(*callee_graph);
         printer.PrintBlocks();
       }
 
       // Collect information about the call site and caller graph.
       // TODO(zerny): Do this after CP and dead code elimination.
       intptr_t constants_count = 0;

[Kevin Millikin (Google), 2012/12/13 16:43:40]

There's no reason to count this again, is there?

[Vyacheslav Egorov (Google), 2012/12/13 18:54:46]

Actually the count above is just an approximation because arguments might be
padded with default values for optional parameters to obtain param_stubs.

And I can't use the same helper here because param_stubs are definitions and
arguments are values.

       for (intptr_t i = 0; i < param_stubs.length(); ++i) {
         if (param_stubs[i]->IsConstant()) ++constants_count;
       }
       GraphInfoCollector info;
       info.Collect(*callee_graph);
       const intptr_t size = info.instruction_count();
       // Use heuristics do decide if this call should be inlined.
       if (!ShouldWeInline(loop_depth,

[Kevin Millikin (Google), 2012/12/13 16:43:40]

It seems strange to call this twice?  Is it needed?

[Vyacheslav Egorov (Google), 2012/12/13 18:54:46]

Yes. Sometimes we attempt to inline big function that was not optimized itself
yet and thus we don't have any information about its counters so they are all
zeros (and thus we don't get an early bailout).

                           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);
         }
+        function.set_optimized_instruction_count(size);

[Kevin Millikin (Google), 2012/12/13 16:43:40]

Also a bit strange to set this only when we decide not to inline.  Can't it
communicate useful information if we succeeded?  (E.g., we might succeed here
due to hotness or loop nesting, but fail at other sites).

[Vyacheslav Egorov (Google), 2012/12/13 18:54:46]

Yep, this is wrong.

+        function.set_optimized_call_site_count(info.call_site_count());
         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,
@@ skipping 66 matching lines @@
       error = isolate->object_store()->sticky_error();
       isolate->object_store()->clear_sticky_error();
       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: %s\n", error.ToErrorCString()));
       return false;
     }
   }
 
+  static intptr_t CountConstants(const GrowableArray<Value*>& arguments) {
+    intptr_t count = 0;
+    for (intptr_t i = 0; i < arguments.length(); i++) {
+      if (arguments[i]->BindsToConstant()) count++;
+    }
+    return count;
+  }
+
   // Parse a function reusing the cache if possible.
   ParsedFunction* GetParsedFunction(const Function& function, bool* in_cache) {
     // TODO(zerny): Use a hash map for the cache.
     for (intptr_t i = 0; i < function_cache_.length(); ++i) {
       ParsedFunction* parsed_function = function_cache_[i];
       if (parsed_function->function().raw() == function.raw()) {
         *in_cache = true;
         SourceLabelResetter reset;
         parsed_function->node_sequence()->Visit(&reset);
         return parsed_function;
@@ skipping 169 matching lines @@
   intptr_t inlined_size_;
   intptr_t inlining_depth_;
   CallSites* collected_call_sites_;
   CallSites* inlining_call_sites_;
   GrowableArray<ParsedFunction*> function_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSiteInliner);
 };
 
 
+void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph) {
+  GraphInfoCollector info;
+  info.Collect(*flow_graph);
+  const Function& function = flow_graph->parsed_function().function();
+  function.set_optimized_instruction_count(
+    static_cast<uint16_t>(info.instruction_count()));
+  function.set_optimized_call_site_count(
+    static_cast<uint16_t>(info.call_site_count()));
+}
+
+
 void FlowGraphInliner::Inline() {
   if ((FLAG_inlining_filter != NULL) &&
       (strstr(flow_graph_->
               parsed_function().function().ToFullyQualifiedCString(),
               FLAG_inlining_filter) == NULL)) {
     return;
   }
 
   TRACE_INLINING(OS::Print(
       "Inlining calls in %s\n",
@@ skipping 17 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart