Polymorphic inlining for some recognized methods in the optimizing compiler.

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 147 matching lines @@
   void Collect(const FlowGraph& graph) {
     call_site_count_ = 0;
     instruction_count_ = 0;
     for (BlockIterator block_it = graph.postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       for (ForwardInstructionIterator it(block_it.Current());
            !it.Done();
            it.Advance()) {
         ++instruction_count_;
-        if (it.Current()->IsStaticCall() ||
-            it.Current()->IsClosureCall() ||
-            it.Current()->IsPolymorphicInstanceCall()) {
+        Instruction* current = it.Current();
+        if (current->IsStaticCall() ||
+            current->IsClosureCall() ||
+            (current->IsPolymorphicInstanceCall() &&
+             !current->AsPolymorphicInstanceCall()->HasRecognizedTarget())) {
           ++call_site_count_;
         }
       }
     }
   }
 
   intptr_t call_site_count() const { return call_site_count_; }
   intptr_t instruction_count() const { return instruction_count_; }
 
  private:
@@ skipping 98 matching lines @@
          block_it.Advance()) {
       for (ForwardInstructionIterator it(block_it.Current());
            !it.Done();
            it.Advance()) {
         it.Current()->Accept(this);
       }
     }
     ComputeCallSiteRatio(static_call_start_ix, instance_call_start_ix);
   }
 
+  void FindRecognizedCallSites(FlowGraph* graph) {

[Kevin Millikin (Google), 2013/08/13 11:47:40]

Instead of a separate function which is a copy of the other one, you could use
the other one and just change the Visit functions to not add at the inlining
depth except the case of recognized calls.

[Florian Schneider, 2013/08/14 12:30:24]

Done.

+    ASSERT(graph != NULL);
+
+    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()) {
+        PolymorphicInstanceCallInstr* call =
+            it.Current()->AsPolymorphicInstanceCall();
+        if (call != NULL && call->HasRecognizedTarget()) {

[srdjan, 2013/08/12 21:49:47]

Add ()

[Florian Schneider, 2013/08/14 12:30:24]

Done.

+          instance_calls_.Add(InstanceCallInfo(call));
+        }
+      }
+    }
+    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;
@@ skipping 88 matching lines @@
     if ((const_arg_count >= FLAG_inlining_constant_arguments_count) &&
         (instr_count <= FLAG_inlining_constant_arguments_size_threshold)) {
       return true;
     }
     if (MethodRecognizer::AlwaysInline(callee)) {
       return true;
     }
     return false;
   }
 
-  // TODO(srdjan): Handle large 'skip_static_call_deopt_ids'. Currently
-  // max. size observed is 11 (dart2js).

[Florian Schneider, 2013/08/12 15:48:14]

I think this TODO is obsolete.

   void InlineCalls() {
     // If inlining depth is less then one abort.
     if (FLAG_inlining_depth_threshold < 1) return;
     if (caller_graph_->parsed_function().function().deoptimization_counter() >=
         FLAG_deoptimization_counter_inlining_threshold) {
       return;
     }
     // Create two call site collections to swap between.
     CallSites sites1(caller_graph_);
     CallSites sites2(caller_graph_);
@@ skipping 219 matching lines @@
                                  "const args: %"Pd"\n",
                                  size,
                                  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);
+      } else if (inlining_depth_ == FLAG_inlining_depth_threshold) {

[Kevin Millikin (Google), 2013/08/13 11:47:40]

In any case, even if you keep the separate function, we need a comment that we
inline recognized calls at the inlining limit because they are not 'really'
calls (and don't themselves have calls).

[Florian Schneider, 2013/08/14 12:30:24]

Done. I use only one function. Also change CallSites class to not subclass
FlowGraphVisitor.

+        collected_call_sites_->FindRecognizedCallSites(callee_graph);
       }
 
       // Add the function to the cache.
       if (!in_cache) function_cache_.Add(parsed_function);
 
       // Build succeeded so we restore the bailout jump.
       inlined_ = true;
       inlined_size_ += size;
       isolate->set_long_jump_base(base);
       isolate->set_deopt_id(prev_deopt_id);
@@ skipping 409 matching lines @@
     if (target.raw() == non_inlined_variants_[i].target->raw()) {
       return true;
     }
   }
 
   return false;
 }
 
 
 bool PolymorphicInliner::TryInlining(const Function& target) {
-  if (!target.is_optimizable()) {

[Kevin Millikin (Google), 2013/08/13 11:47:40]

Why remove this check?

[Florian Schneider, 2013/08/14 12:30:24]

It's not strictly necessary, but I'll put it back in as an early bailout.

-    return false;
-  }
   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 (!owner_->TryInlining(target,
                            call_->instance_call()->argument_names(),
                            &call_data)) {
     return false;
   }
@@ skipping 344 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart