Revert "Save and restore feedback from JIT."

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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
-#include "vm/precompiler.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
 #include "vm/kernel.h"
 #include "vm/kernel_to_il.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_type_propagator.h"
@@ skipping 188 matching lines @@
         inlined(inlined_function),
         inlined_depth(depth),
         call_instr(call),
         bailout_reason(reason) {}
 };
 
 
 // A collection of call sites to consider for inlining.
 class CallSites : public ValueObject {
  public:
-  explicit CallSites(FlowGraph* flow_graph, intptr_t threshold)
-      : inlining_depth_threshold_(threshold),
-        static_calls_(),
-        closure_calls_(),
-        instance_calls_() {}
+  explicit CallSites(FlowGraph* flow_graph)
+      : static_calls_(), closure_calls_(), instance_calls_() {}
 
   struct InstanceCallInfo {
     PolymorphicInstanceCallInstr* call;
     double ratio;
     const FlowGraph* caller_graph;
     InstanceCallInfo(PolymorphicInstanceCallInstr* call_arg,
                      FlowGraph* flow_graph)
         : call(call_arg), ratio(0.0), caller_graph(flow_graph) {}
     const Function& caller() const { return caller_graph->function(); }
   };
@@ skipping 122 matching lines @@
         }
       }
     }
   }
 
 
   void FindCallSites(FlowGraph* graph,
                      intptr_t depth,
                      GrowableArray<InlinedInfo>* inlined_info) {
     ASSERT(graph != NULL);
-    if (depth > inlining_depth_threshold_) {
+    if (depth > FLAG_inlining_depth_threshold) {
       if (FLAG_print_inlining_tree) {
         RecordAllNotInlinedFunction(graph, depth, inlined_info);
       }
       return;
     }
 
     // Recognized methods are not treated as normal calls. They don't have
     // calls in themselves, so we keep adding those even when at the threshold.
     const bool inline_only_recognized_methods =
-        (depth == inlining_depth_threshold_);
+        (depth == FLAG_inlining_depth_threshold);
 
     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()) {
         Instruction* current = it.Current();
         if (current->IsPolymorphicInstanceCall()) {
           PolymorphicInstanceCallInstr* instance_call =
@@ skipping 35 matching lines @@
             ClosureCallInstr* closure_call = current->AsClosureCall();
             closure_calls_.Add(ClosureCallInfo(closure_call, graph));
           }
         }
       }
     }
     ComputeCallSiteRatio(static_call_start_ix, instance_call_start_ix);
   }
 
  private:
-  intptr_t inlining_depth_threshold_;
   GrowableArray<StaticCallInfo> static_calls_;
   GrowableArray<ClosureCallInfo> closure_calls_;
   GrowableArray<InstanceCallInfo> instance_calls_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
 
 struct InlinedCallData {
   InlinedCallData(Definition* call,
@@ skipping 70 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 
 class CallSiteInliner : public ValueObject {
  public:
-  explicit CallSiteInliner(FlowGraphInliner* inliner, intptr_t threshold)
+  explicit CallSiteInliner(FlowGraphInliner* inliner)
       : inliner_(inliner),
         caller_graph_(inliner->flow_graph()),
         inlined_(false),
         initial_size_(inliner->flow_graph()->InstructionCount()),
         inlined_size_(0),
         inlined_recursive_call_(false),
         inlining_depth_(1),
         inlining_recursion_depth_(0),
-        inlining_depth_threshold_(threshold),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
         function_cache_(),
         inlined_info_() {}
 
   FlowGraph* caller_graph() const { return caller_graph_; }
 
   Thread* thread() const { return caller_graph_->thread(); }
   Isolate* isolate() const { return caller_graph_->isolate(); }
   Zone* zone() const { return caller_graph_->zone(); }
@@ skipping 28 matching lines @@
     }
     if ((const_arg_count >= FLAG_inlining_constant_arguments_count) &&
         (instr_count <= FLAG_inlining_constant_arguments_min_size_threshold)) {
       return true;
     }
     return false;
   }
 
   void InlineCalls() {
     // If inlining depth is less then one abort.
-    if (inlining_depth_threshold_ < 1) return;
+    if (FLAG_inlining_depth_threshold < 1) return;
     if (caller_graph_->function().deoptimization_counter() >=
         FLAG_deoptimization_counter_inlining_threshold) {
       return;
     }
     // Create two call site collections to swap between.
-    CallSites sites1(caller_graph_, inlining_depth_threshold_);
-    CallSites sites2(caller_graph_, inlining_depth_threshold_);
+    CallSites sites1(caller_graph_);
+    CallSites sites2(caller_graph_);
     CallSites* call_sites_temp = NULL;
     collected_call_sites_ = &sites1;
     inlining_call_sites_ = &sites2;
     // Collect initial call sites.
     collected_call_sites_->FindCallSites(caller_graph_, inlining_depth_,
                                          &inlined_info_);
     while (collected_call_sites_->HasCalls()) {
       TRACE_INLINING(
           THR_Print("  Depth %" Pd " ----------\n", inlining_depth_));
       if (collected_call_sites_->NumCalls() > FLAG_max_inlined_per_depth) {
@@ skipping 71 matching lines @@
 
     // Do not rely on function type feedback or presence of code to determine
     // if a function was compiled.
     if (!FLAG_precompiled_mode && !function.was_compiled()) {
       TRACE_INLINING(THR_Print("     Bailout: not compiled yet\n"));
       PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function,
                           call_data->call);
       return false;
     }
 
-    if ((inliner_->precompiler_ != NULL) &&
-        inliner_->precompiler_->HasFeedback() &&
-        (function.usage_counter() <= 0) && !inliner_->AlwaysInline(function)) {
-      TRACE_INLINING(THR_Print("     Bailout: not compiled yet\n"));
-      PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function,
-                          call_data->call);
-      return false;
-    }
-
     // Type feedback may have been cleared for this function (ClearICDataArray),
     // but we need it for inlining.
     if (!FLAG_precompiled_mode && (function.ic_data_array() == Array::null())) {
       TRACE_INLINING(THR_Print("     Bailout: type feedback cleared\n"));
       PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function,
                           call_data->call);
       return false;
     }
 
     // Abort if this function has deoptimized too much.
@@ skipping 101 matching lines @@
             callee_graph = builder.BuildGraph();
           }
         } else {
           FlowGraphBuilder builder(*parsed_function, *ic_data_array,
                                    exit_collector, Compiler::kNoOSRDeoptId);
           builder.SetInitialBlockId(caller_graph_->max_block_id());
           {
             CSTAT_TIMER_SCOPE(thread(), graphinliner_build_timer);
             callee_graph = builder.BuildGraph();
           }
-#ifdef DART_PRECOMPILER
-          Precompiler::PopulateWithICData(parsed_function->function(),
-                                          callee_graph);
-          if (inliner_->precompiler_ != NULL) {
-            inliner_->precompiler_->TryApplyFeedback(
-                parsed_function->function(), callee_graph);
-          }
-#endif
         }
 
         // 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.
         ZoneGrowableArray<Definition*>* param_stubs =
             new (Z) ZoneGrowableArray<Definition*>(function.NumParameters());
 
         // Create a parameter stub for each fixed positional parameter.
@@ skipping 47 matching lines @@
 
         {
           CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer);
           // TODO(fschneider): Improve suppression of speculative inlining.
           // Deopt-ids overlap between caller and callee.
           if (FLAG_precompiled_mode) {
 #ifdef DART_PRECOMPILER
             AotOptimizer optimizer(inliner_->precompiler_, callee_graph,
                                    inliner_->use_speculative_inlining_,
                                    inliner_->inlining_black_list_);
+            optimizer.PopulateWithICData();
 
             optimizer.ApplyClassIds();
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
             FlowGraphTypePropagator::Propagate(callee_graph);
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
             optimizer.ApplyICData();
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
@@ skipping 497 matching lines @@
   }
 
   FlowGraphInliner* inliner_;
   FlowGraph* caller_graph_;
   bool inlined_;
   const intptr_t initial_size_;
   intptr_t inlined_size_;
   bool inlined_recursive_call_;
   intptr_t inlining_depth_;
   intptr_t inlining_recursion_depth_;
-  intptr_t inlining_depth_threshold_;
   CallSites* collected_call_sites_;
   CallSites* inlining_call_sites_;
   GrowableArray<ParsedFunction*> function_cache_;
   GrowableArray<InlinedInfo> inlined_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSiteInliner);
 };
 
 
 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner,
@@ skipping 534 matching lines @@
     TRACE_INLINING(
         THR_Print("AlwaysInline annotation for %s\n", function.ToCString()));
     return true;
   }
 
   if (function.IsDispatcherOrImplicitAccessor()) {
     // Smaller or same size as the call.
     return true;
   }
 
-  if (function.is_const()) {
-    // Inlined const fields are smaller than a call.
-    return true;
-  }
-
   if (function.IsGetterFunction() || function.IsSetterFunction() ||
       IsInlineableOperator(function) ||
       (function.kind() == RawFunction::kConstructor)) {
     const intptr_t count = function.optimized_instruction_count();
     if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) {
       return true;
     }
   }
   return MethodRecognizer::AlwaysInline(function);
 }
@@ skipping 13 matching lines @@
   TRACE_INLINING(THR_Print("Inlining calls in %s\n", top.ToCString()));
 
   if (FLAG_support_il_printer && trace_inlining() &&
       (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
     THR_Print("Before Inlining of %s\n",
               flow_graph_->function().ToFullyQualifiedCString());
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 
-  intptr_t inlining_depth_threshold = FLAG_inlining_depth_threshold;
-  if ((precompiler_ != NULL) && precompiler_->HasFeedback() &&
-      (top.usage_counter() <= 0)) {
-    inlining_depth_threshold = 1;
-  }
-
-  CallSiteInliner inliner(this, inlining_depth_threshold);
+  CallSiteInliner inliner(this);
   inliner.InlineCalls();
   if (FLAG_print_inlining_tree) {
     inliner.PrintInlinedInfo(top);
   }
 
   if (inliner.inlined()) {
     flow_graph_->DiscoverBlocks();
     if (trace_inlining()) {
       THR_Print("Inlining growth factor: %f\n", inliner.GrowthFactor());
       if (FLAG_support_il_printer &&
@@ skipping 1621 matching lines @@
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)