Use call counts to determine which static calls to inline.

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"
@@ skipping 171 matching lines @@
 // A collection of call sites to consider for inlining.
 class CallSites : public FlowGraphVisitor {
  public:
   explicit CallSites(FlowGraph* flow_graph)
       : FlowGraphVisitor(flow_graph->postorder()),  // We don't use this order.
         static_calls_(),
         closure_calls_(),
         instance_calls_(),
         skip_static_call_deopt_ids_() { }
 
-  const GrowableArray<StaticCallInstr*>& static_calls() const {
-    return static_calls_;
-  }
-
   const GrowableArray<ClosureCallInstr*>& closure_calls() const {
     return closure_calls_;
   }
 
   struct InstanceCallInfo {
     PolymorphicInstanceCallInstr* call;
     double ratio;
     explicit InstanceCallInfo(PolymorphicInstanceCallInstr* call_arg)
         : call(call_arg), ratio(0.0) {}
   };
 
+  struct StaticCallInfo {
+    StaticCallInstr* call;
+    double ratio;
+    explicit StaticCallInfo(StaticCallInstr* value)
+        : call(value), ratio(0.0) {}
+  };
+
   const GrowableArray<InstanceCallInfo>& instance_calls() const {
     return instance_calls_;
   }
 
+  const GrowableArray<StaticCallInfo>& static_calls() const {
+    return static_calls_;
+  }
+
   bool HasCalls() const {
     return !(static_calls_.is_empty() &&
              closure_calls_.is_empty() &&
              instance_calls_.is_empty());
   }
 
   void Clear() {
     static_calls_.Clear();
     closure_calls_.Clear();
     instance_calls_.Clear();
     skip_static_call_deopt_ids_.Clear();
   }
 
+  void ComputeCallSiteRatio(intptr_t static_call_start_ix,
+                            intptr_t instance_call_start_ix) {
+    const intptr_t num_static_calls =
+        static_calls_.length() - static_call_start_ix;
+    const intptr_t num_instance_calls =
+        instance_calls_.length() - instance_call_start_ix;
+
+    intptr_t max_count = 0;
+    GrowableArray<intptr_t> instance_call_counts(num_instance_calls);
+    for (intptr_t i = 0; i < num_instance_calls; ++i) {
+      const intptr_t aggregate_count =
+          instance_calls_[i + instance_call_start_ix].
+              call->ic_data().AggregateCount();
+      instance_call_counts.Add(aggregate_count);
+      if (aggregate_count > max_count) max_count = aggregate_count;
+    }
+
+    GrowableArray<intptr_t> static_call_counts(num_static_calls);
+    for (intptr_t i = 0; i < num_static_calls; ++i) {
+      const intptr_t aggregate_count =
+          static_calls_[i + static_call_start_ix].
+              call->ic_data()->AggregateCount();
+      static_call_counts.Add(aggregate_count);
+      if (aggregate_count > max_count) max_count = aggregate_count;
+    }
+
+    for (intptr_t i = 0; i < num_instance_calls; ++i) {
+      const double ratio =
+          static_cast<double>(instance_call_counts[i]) / max_count;
+      instance_calls_[i + instance_call_start_ix].ratio = ratio;
+    }
+    for (intptr_t i = 0; i < num_static_calls; ++i) {
+      const double ratio =
+          static_cast<double>(static_call_counts[i]) / max_count;
+      static_calls_[i + static_call_start_ix].ratio = ratio;
+    }
+  }
+
   void FindCallSites(FlowGraph* graph) {
     ASSERT(graph != NULL);
     const Function& function = graph->parsed_function().function();
     ASSERT(function.HasCode());
     const Code& code = Code::Handle(function.unoptimized_code());
 
     skip_static_call_deopt_ids_.Clear();
     code.ExtractUncalledStaticCallDeoptIds(&skip_static_call_deopt_ids_);
 
     const intptr_t instance_call_start_ix = instance_calls_.length();
+    const intptr_t static_call_start_ix = static_calls_.length();
     for (BlockIterator block_it = graph->postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       for (ForwardInstructionIterator it(block_it.Current());
            !it.Done();
            it.Advance()) {
         it.Current()->Accept(this);
       }
     }
-    // Compute instance call site ratio.
-    const intptr_t num_instance_calls =
-        instance_calls_.length() - instance_call_start_ix;
-    intptr_t max_count = 0;
-    GrowableArray<intptr_t> call_counts(num_instance_calls);
-    for (intptr_t i = 0; i < num_instance_calls; ++i) {
-      const intptr_t aggregate_count =
-          instance_calls_[i + instance_call_start_ix].
-              call->ic_data().AggregateCount();
-      call_counts.Add(aggregate_count);
-      if (aggregate_count > max_count) max_count = aggregate_count;
-    }
-
-
-    for (intptr_t i = 0; i < num_instance_calls; ++i) {
-      const double ratio = static_cast<double>(call_counts[i]) / max_count;
-      instance_calls_[i + instance_call_start_ix].ratio = ratio;
-    }
+    ComputeCallSiteRatio(static_call_start_ix, instance_call_start_ix);
   }
 
   void VisitClosureCall(ClosureCallInstr* call) {
     closure_calls_.Add(call);
   }
 
   void VisitPolymorphicInstanceCall(PolymorphicInstanceCallInstr* call) {
     instance_calls_.Add(InstanceCallInfo(call));
   }
 
   void VisitStaticCall(StaticCallInstr* call) {
     if (!call->function().IsInlineable()) return;
     const intptr_t call_deopt_id = call->deopt_id();
     for (intptr_t i = 0; i < skip_static_call_deopt_ids_.length(); i++) {
       if (call_deopt_id == skip_static_call_deopt_ids_[i]) {
         // Do not inline this call.
         return;
       }
     }
-    static_calls_.Add(call);
+    static_calls_.Add(StaticCallInfo(call));
   }
 
  private:
-  GrowableArray<StaticCallInstr*> static_calls_;
+  GrowableArray<StaticCallInfo> static_calls_;
   GrowableArray<ClosureCallInstr*> closure_calls_;
   GrowableArray<InstanceCallInfo> instance_calls_;
   GrowableArray<intptr_t> skip_static_call_deopt_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
 
 struct InlinedCallData {
   InlinedCallData(Definition* call, GrowableArray<Value*>* arguments)
@@ skipping 411 matching lines @@
     ParsedFunction* parsed_function = new ParsedFunction(function);
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
     return parsed_function;
   }
 
   // Include special handling for List. factory: inlining it is not helpful
   // if the incoming argument is a non-constant value.
   // TODO(srdjan): Fix inlining of List. factory.
   void InlineStaticCalls() {
-    const GrowableArray<StaticCallInstr*>& calls =
+    const GrowableArray<CallSites::StaticCallInfo>& call_info =
         inlining_call_sites_->static_calls();
-    TRACE_INLINING(OS::Print("  Static Calls (%d)\n", calls.length()));
-    for (intptr_t i = 0; i < calls.length(); ++i) {
-      StaticCallInstr* call = calls[i];
+    TRACE_INLINING(OS::Print("  Static Calls (%d)\n", call_info.length()));
+    for (intptr_t call_idx = 0; call_idx < call_info.length(); ++call_idx) {
+      StaticCallInstr* call = call_info[call_idx].call;
       if (call->function().name() == Symbols::ListFactory().raw()) {
         // Inline only if no arguments or a constant was passed.
         ASSERT(call->function().NumImplicitParameters() == 1);
         ASSERT(call->ArgumentCount() <= 2);
         // Arg 0: Instantiator type arguments.
         // Arg 1: Length (optional).
         if ((call->ArgumentCount() == 2) &&
             (!call->PushArgumentAt(1)->value()->BindsToConstant())) {
           // Do not inline since a non-constant argument was passed.
           continue;
         }
       }
+      if ((call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {

[Florian Schneider, 2013/06/25 08:48:32]

Maybe we need to adapt the threshold now that static calls are also counted.

+        const Function& target = call->function();
+        TRACE_INLINING(OS::Print(
+            "  => %s (deopt count %d)\n     Bailout: cold %f\n",
+            target.ToCString(),
+            target.deoptimization_counter(),
+            call_info[call_idx].ratio));
+        continue;
+      }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
       }
       InlinedCallData call_data(call, &arguments);
       if (TryInlining(call->function(), call->argument_names(), &call_data)) {
         InlineCall(&call_data);
       }
     }
   }
@@ skipping 600 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart