Redesign inlining interval computation.

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 174 matching lines @@
 class CallSites : public ValueObject {
  public:
   explicit CallSites(FlowGraph* flow_graph)
       : static_calls_(),
         closure_calls_(),
         instance_calls_() { }
 
   struct InstanceCallInfo {
     PolymorphicInstanceCallInstr* call;
     double ratio;
-    const Function* caller;
+    const FlowGraph* caller_graph;
     InstanceCallInfo(PolymorphicInstanceCallInstr* call_arg,
                      FlowGraph* flow_graph)
         : call(call_arg),
           ratio(0.0),
-          caller(&flow_graph->function()) {}
+          caller_graph(flow_graph) {}
+    const Function& caller() const { return caller_graph->function(); }
   };
 
   struct StaticCallInfo {
     StaticCallInstr* call;
     double ratio;
-    const Function* caller;
+    FlowGraph* caller_graph;
     StaticCallInfo(StaticCallInstr* value, FlowGraph* flow_graph)
         : call(value),
           ratio(0.0),
-          caller(&flow_graph->function()) {}
+          caller_graph(flow_graph) {}
+    const Function& caller() const { return caller_graph->function(); }
   };
 
   struct ClosureCallInfo {
     ClosureCallInstr* call;
-    const Function* caller;
+    FlowGraph* caller_graph;
     ClosureCallInfo(ClosureCallInstr* value, FlowGraph* flow_graph)
         : call(value),
-          caller(&flow_graph->function()) {}
+          caller_graph(flow_graph) {}
+    const Function& caller() const { return caller_graph->function(); }
   };
 
   const GrowableArray<InstanceCallInfo>& instance_calls() const {
     return instance_calls_;
   }
 
   const GrowableArray<StaticCallInfo>& static_calls() const {
     return static_calls_;
   }
 
@@ skipping 168 matching lines @@
   GrowableArray<ClosureCallInfo> closure_calls_;
   GrowableArray<InstanceCallInfo> instance_calls_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
 
 struct InlinedCallData {
   InlinedCallData(Definition* call,
                   GrowableArray<Value*>* arguments,
-                  const Function& caller)
+                  const Function& caller,
+                  intptr_t caller_inlining_id)
       : call(call),
         arguments(arguments),
         callee_graph(NULL),
         parameter_stubs(NULL),
         exit_collector(NULL),
-        caller(caller) { }
+        caller(caller),
+        caller_inlining_id_(caller_inlining_id) { }
 
   Definition* call;
   GrowableArray<Value*>* arguments;
   FlowGraph* callee_graph;
   ZoneGrowableArray<Definition*>* parameter_stubs;
   InlineExitCollector* exit_collector;
   const Function& caller;
+  const intptr_t caller_inlining_id_;
 };
 
 
 class CallSiteInliner;
 
 class PolymorphicInliner : public ValueObject {
  public:
   PolymorphicInliner(CallSiteInliner* owner,
                      PolymorphicInstanceCallInstr* call,
-                     const Function& caller_function);
+                     const Function& caller_function,
+                     intptr_t caller_inlining_id);
 
   void Inline();
 
  private:
   bool CheckInlinedDuplicate(const Function& target);
   bool CheckNonInlinedDuplicate(const Function& target);
 
   bool TryInliningPoly(intptr_t receiver_cid, const Function& target);
   bool TryInlineRecognizedMethod(intptr_t receiver_cid, const Function& target);
 
   TargetEntryInstr* BuildDecisionGraph();
 
   Isolate* isolate() const;
   Zone* zone() const;
 
   CallSiteInliner* const owner_;
   PolymorphicInstanceCallInstr* const call_;
   const intptr_t num_variants_;
   GrowableArray<CidTarget> variants_;
 
   GrowableArray<CidTarget> inlined_variants_;
   GrowableArray<CidTarget> non_inlined_variants_;
   GrowableArray<BlockEntryInstr*> inlined_entries_;
   InlineExitCollector* exit_collector_;
 
   const Function& caller_function_;
+  const intptr_t caller_inlining_id_;
 };
 
 
 static bool HasAnnotation(const Function& function, const char* annotation) {
   const Class& owner = Class::Handle(function.Owner());
   const Library& library = Library::Handle(owner.library());
   const Array& metadata =
       Array::Cast(Object::Handle(library.GetMetadata(function)));
 
   if (metadata.Length() > 0) {
@@ skipping 378 matching lines @@
       // When inlined, we add the guarded fields of the callee to the caller's
       // list of guarded fields.
       for (intptr_t i = 0; i < callee_graph->guarded_fields()->length(); ++i) {
         FlowGraph::AddToGuardedFields(caller_graph_->guarded_fields(),
                                       (*callee_graph->guarded_fields())[i]);
       }
       // When inlined, we add the deferred prefixes of the callee to the
       // caller's list of deferred prefixes.
       caller_graph()->AddToDeferredPrefixes(callee_graph->deferred_prefixes());
 
-      FlowGraphInliner::SetInliningId(*callee_graph,
-          inliner_->NextInlineId(callee_graph->function()));
+      FlowGraphInliner::SetInliningId(callee_graph,
+          inliner_->NextInlineId(callee_graph->function(),
+                                 call_data->caller_inlining_id_));
       // We allocate a ZoneHandle for the unoptimized code so that it cannot be
       // disconnected from its function during the rest of compilation.
       Code::ZoneHandle(unoptimized_code.raw());
       TRACE_INLINING(ISL_Print("     Success\n"));
       PRINT_INLINING_TREE(NULL,
           &call_data->caller, &function, call);
       return true;
     } else {
       Error& error = Error::Handle();
       error = isolate()->object_store()->sticky_error();
@@ skipping 180 matching lines @@
       }
       const Function& target = call->function();
       if (!inliner_->AlwaysInline(target) &&
           (call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
         TRACE_INLINING(ISL_Print(
             "  => %s (deopt count %d)\n     Bailout: cold %f\n",
             target.ToCString(),
             target.deoptimization_counter(),
             call_info[call_idx].ratio));
         PRINT_INLINING_TREE("Too cold",
-            call_info[call_idx].caller, &call->function(), call);
+            &call_info[call_idx].caller(), &call->function(), call);
         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, *call_info[call_idx].caller);
+      InlinedCallData call_data(
+          call, &arguments, call_info[call_idx].caller(),
+          call_info[call_idx].caller_graph->inlining_id());
       if (TryInlining(call->function(), call->argument_names(), &call_data)) {
         InlineCall(&call_data);
       }
     }
   }
 
   void InlineClosureCalls() {
     const GrowableArray<CallSites::ClosureCallInfo>& call_info =
         inlining_call_sites_->closure_calls();
     TRACE_INLINING(ISL_Print("  Closure Calls (%" Pd ")\n",
@@ skipping 18 matching lines @@
       }
 
       if (target.IsNull()) {
         TRACE_INLINING(ISL_Print("     Bailout: non-closure operator\n"));
         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, *call_info[call_idx].caller);
+      InlinedCallData call_data(
+          call, &arguments, call_info[call_idx].caller(),
+          call_info[call_idx].caller_graph->inlining_id());
       if (TryInlining(target,
                       call->argument_names(),
                       &call_data)) {
         InlineCall(&call_data);
       }
     }
   }
 
   void InlineInstanceCalls() {
     const GrowableArray<CallSites::InstanceCallInfo>& call_info =
         inlining_call_sites_->instance_calls();
     TRACE_INLINING(ISL_Print("  Polymorphic Instance Calls (%" Pd ")\n",
                              call_info.length()));
     for (intptr_t call_idx = 0; call_idx < call_info.length(); ++call_idx) {
       PolymorphicInstanceCallInstr* call = call_info[call_idx].call;
       if (call->with_checks()) {
-        const Function& cl = *call_info[call_idx].caller;
-        PolymorphicInliner inliner(this, call, cl);
+        const Function& cl = call_info[call_idx].caller();
+        intptr_t caller_inlining_id =
+            call_info[call_idx].caller_graph->inlining_id();
+        PolymorphicInliner inliner(this, call, cl, caller_inlining_id);
         inliner.Inline();
         continue;
       }
 
       const ICData& ic_data = call->ic_data();
       const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
       if (!inliner_->AlwaysInline(target) &&
           (call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
         TRACE_INLINING(ISL_Print(
             "  => %s (deopt count %d)\n     Bailout: cold %f\n",
             target.ToCString(),
             target.deoptimization_counter(),
             call_info[call_idx].ratio));
         PRINT_INLINING_TREE("Too cold",
-            call_info[call_idx].caller, &target, call);
+            &call_info[call_idx].caller(), &target, call);
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int arg_i = 0; arg_i < call->ArgumentCount(); ++arg_i) {
         arguments.Add(call->PushArgumentAt(arg_i)->value());
       }
-      InlinedCallData call_data(call, &arguments, *call_info[call_idx].caller);
+      InlinedCallData call_data(
+          call, &arguments, call_info[call_idx].caller(),
+          call_info[call_idx].caller_graph->inlining_id());
       if (TryInlining(target,
                       call->instance_call()->argument_names(),
                       &call_data)) {
         InlineCall(&call_data);
       }
     }
   }
 
   bool AdjustForOptionalParameters(const ParsedFunction& parsed_function,
                                    const Array& argument_names,
@@ skipping 99 matching lines @@
   CallSites* inlining_call_sites_;
   GrowableArray<ParsedFunction*> function_cache_;
   GrowableArray<InlinedInfo> inlined_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSiteInliner);
 };
 
 
 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner,
                                        PolymorphicInstanceCallInstr* call,
-                                       const Function& caller_function)
+                                       const Function& caller_function,
+                                       intptr_t caller_inlining_id)
     : owner_(owner),
       call_(call),
       num_variants_(call->ic_data().NumberOfChecks()),
       variants_(num_variants_),
       inlined_variants_(num_variants_),
       non_inlined_variants_(num_variants_),
       inlined_entries_(num_variants_),
       exit_collector_(new(Z)
           InlineExitCollector(owner->caller_graph(), call)),
-      caller_function_(caller_function) {
+      caller_function_(caller_function),
+      caller_inlining_id_(caller_inlining_id) {
 }
 
 
 Isolate* PolymorphicInliner::isolate() const {
   return owner_->caller_graph()->isolate();
 }
 
 
 Zone* PolymorphicInliner::zone() const {
   return owner_->caller_graph()->zone();
@@ skipping 77 matching lines @@
                                         const Function& target) {
   if (TryInlineRecognizedMethod(receiver_cid, target)) {
     owner_->inlined_ = true;
     return true;
   }
 
   GrowableArray<Value*> arguments(call_->ArgumentCount());
   for (int i = 0; i < call_->ArgumentCount(); ++i) {
     arguments.Add(call_->PushArgumentAt(i)->value());
   }
-  InlinedCallData call_data(call_, &arguments, caller_function_);
+  InlinedCallData call_data(call_, &arguments,
+                            caller_function_,
+                            caller_inlining_id_);
   if (!owner_->TryInlining(target,
                            call_->instance_call()->argument_names(),
                            &call_data)) {
     return false;
   }
 
   FlowGraph* callee_graph = call_data.callee_graph;
   call_data.exit_collector->PrepareGraphs(callee_graph);
   inlined_entries_.Add(callee_graph->graph_entry());
   exit_collector_->Union(call_data.exit_collector);
@@ skipping 357 matching lines @@
 
 
 static bool ShouldTraceInlining(FlowGraph* flow_graph) {
   const Function& top = flow_graph->parsed_function().function();
   return FLAG_trace_inlining && FlowGraphPrinter::ShouldPrint(top);
 }
 
 
 FlowGraphInliner::FlowGraphInliner(
     FlowGraph* flow_graph,
-    GrowableArray<const Function*>* inline_id_to_function)
+    GrowableArray<const Function*>* inline_id_to_function,
+    GrowableArray<intptr_t>* caller_inline_id)
     : flow_graph_(flow_graph),
       inline_id_to_function_(inline_id_to_function),
+      caller_inline_id_(caller_inline_id),
       trace_inlining_(ShouldTraceInlining(flow_graph)) {
 }
 
 
 void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph, bool force) {
   const Function& function = flow_graph->function();
   if (force || (function.optimized_instruction_count() == 0)) {
     GraphInfoCollector info;
     info.Collect(*flow_graph);
 
     function.set_optimized_instruction_count(
         ClampUint16(info.instruction_count()));
     function.set_optimized_call_site_count(ClampUint16(info.call_site_count()));
   }
 }
 
 
 // TODO(srdjan): This is only needed when disassembling and/or profiling.
-void FlowGraphInliner::SetInliningId(const FlowGraph& flow_graph,
+// Sets inlining id for all instructions of this flow-graph, as well for the
+// FlowGraph itself.
+void FlowGraphInliner::SetInliningId(FlowGraph* flow_graph,
                                      intptr_t inlining_id) {
-  for (BlockIterator block_it = flow_graph.postorder_iterator();
+  ASSERT(flow_graph->inlining_id() < 0);
+  flow_graph->set_inlining_id(inlining_id);
+  for (BlockIterator block_it = flow_graph->postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     for (ForwardInstructionIterator it(block_it.Current());
          !it.Done();
          it.Advance()) {
       Instruction* current = it.Current();
       // Do not overwrite owner function.
       ASSERT(!current->has_inlining_id());
       current->set_inlining_id(inlining_id);
     }
@@ skipping 56 matching lines @@
         ISL_Print("After Inlining of %s\n", flow_graph_->
                   function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 
-intptr_t FlowGraphInliner::NextInlineId(const Function& function) {
+intptr_t FlowGraphInliner::NextInlineId(const Function& function,
+                                        intptr_t parent_id) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
+  caller_inline_id_->Add(parent_id);
   return id;
 }
 
 
 }  // namespace dart