VM: Speculative inlining in precompiled code.

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 394 matching lines @@
 
   // We may reattempt compilation if the function needs to be assembled using
   // far branches on ARM and MIPS. In the else branch of the setjmp call,
   // done is set to false, and use_far_branches is set to true if there is a
   // longjmp from the ARM or MIPS assemblers. In all other paths through this
   // while loop, done is set to true. use_far_branches is always false on ia32
   // and x64.
   bool done = false;
   // volatile because the variable may be clobbered by a longjmp.
   volatile bool use_far_branches = false;
+  volatile bool use_speculative_inlining = true;
+  GrowableArray<intptr_t> inlining_black_list;
+
   while (!done) {
     const intptr_t prev_deopt_id = thread->deopt_id();
     thread->set_deopt_id(0);
     LongJumpScope jump;
-    if (setjmp(*jump.Set()) == 0) {
+    intptr_t val = setjmp(*jump.Set());

[srdjan, 2015/11/17 17:35:23]

const intptr_t val =

[srdjan, 2015/11/17 17:35:23]

Add Comment that val may contain deopt_id of the failed inlining attempt.

[Florian Schneider, 2015/11/17 19:38:56]

Done.

[Florian Schneider, 2015/11/17 19:38:56]

Done.

+    if (val == 0) {
       FlowGraph* flow_graph = NULL;
 
       // Class hierarchy analysis is registered with the isolate in the
       // constructor and unregisters itself upon destruction.
       CHA cha(thread);
 
       // TimerScope needs an isolate to be properly terminated in case of a
       // LongJump.
       {
         CSTAT_TIMER_SCOPE(thread, graphbuilder_timer);
@@ skipping 63 matching lines @@
       GrowableArray<intptr_t> caller_inline_id;
       // Collect all instance fields that are loaded in the graph and
       // have non-generic type feedback attached to them that can
       // potentially affect optimizations.
       if (optimized) {
         inline_id_to_function.Add(&function);
         // Top scope function has no caller (-1).
         caller_inline_id.Add(-1);
         CSTAT_TIMER_SCOPE(thread, graphoptimizer_timer);
 
-        FlowGraphOptimizer optimizer(flow_graph);
+        FlowGraphOptimizer optimizer(flow_graph,
+                                     use_speculative_inlining,
+                                     &inlining_black_list);
         if (Compiler::always_optimize()) {
           optimizer.PopulateWithICData();
+
+          optimizer.ApplyClassIds();

[Florian Schneider, 2015/11/17 12:39:25]

Adding an early pass of specializing based on guessed-cids early, so that later
passes of ApplyICData/ApplyClassIds can benefit from it.

+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
+
+          FlowGraphTypePropagator::Propagate(flow_graph);
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
         optimizer.ApplyICData();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run early in order to have more opportunity to optimize left shifts.
         optimizer.TryOptimizePatterns();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         FlowGraphInliner::SetInliningId(flow_graph, 0);
@@ skipping 347 matching lines @@
       // We bailed out or we encountered an error.
       const Error& error = Error::Handle(
           isolate->object_store()->sticky_error());
 
       if (error.raw() == Object::branch_offset_error().raw()) {
         // Compilation failed due to an out of range branch offset in the
         // assembler. We try again (done = false) with far branches enabled.
         done = false;
         ASSERT(!use_far_branches);
         use_far_branches = true;
+      } else if (error.raw() == Object::speculative_inlining_error().raw()) {
+        done = false;
+        ASSERT(use_speculative_inlining);
+        for (intptr_t i = 0; i < inlining_black_list.length(); ++i) {
+          ASSERT(inlining_black_list[i] != val);
+        }

[srdjan, 2015/11/17 17:35:23]

The loop above should be tun in DEBUG mode only. Add comment: Do not repeatedly
abort speculative inlining at the same call.

[Florian Schneider, 2015/11/17 19:38:56]

Done.

+        inlining_black_list.Add(val);
+        const intptr_t kMaxAttempts = 1;
+        if (inlining_black_list.length() >= kMaxAttempts) {

[srdjan, 2015/11/17 17:35:23]

Use flag instead of kMaxAttempt.

[Florian Schneider, 2015/11/17 19:38:56]

Done.

+          use_speculative_inlining = false;
+          if (FLAG_trace_compiler) {
+            THR_Print("Disabled speculative inlining after %" Pd " attempts.\n",
+                      inlining_black_list.length());
+          }
+        }
       } else {
         // If the error isn't due to an out of range branch offset, we don't
         // try again (done = true), and indicate that we did not finish
         // compiling (is_compiled = false).
         if (FLAG_trace_bailout) {
           THR_Print("%s\n", error.ToErrorCString());
         }
         done = true;
       }
 
@@ skipping 1082 matching lines @@
       isolate->set_background_compiler(task);
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart