Restructure code generation timers and add sub-timers for inlining phases.

runtime/vm/flow_graph_inliner.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/flow_graph_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_inlining, false, "Trace inlining");
 DEFINE_FLAG(charp, inlining_filter, NULL, "Inline only in named function");
 DEFINE_FLAG(int, inlining_size_threshold, 50,
     "Inline only functions with up to threshold instructions (default 50)");
 // TODO(srdjan): set to 3 once crash in apidoc.dart is resolved.
 DEFINE_FLAG(int, inlining_depth_threshold, 3,
     "Inline recursively up to threshold depth (default 3)");
 DEFINE_FLAG(bool, inline_control_flow, true,
     "Inline functions with control flow.");
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, verify_compiler);
+DECLARE_FLAG(bool, compiler_stats);
 
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
     if (FLAG_trace_inlining) statement;                                        \
   } while (false)
 
 
 // Test if a call is recursive by looking in the deoptimization environment.
 static bool IsCallRecursive(const Function& function, Definition* call) {
   Environment* env = call->env();
@@ skipping 220 matching lines @@
     // Save and clear deopt id.
     const intptr_t prev_deopt_id = isolate->deopt_id();
     isolate->set_deopt_id(0);
     // Install bailout jump.
     LongJump* base = isolate->long_jump_base();
     LongJump jump;
     isolate->set_long_jump_base(&jump);
     if (setjmp(*jump.Set()) == 0) {
       // Parse the callee function.
       bool in_cache;
-      ParsedFunction* parsed_function = ParseFunction(function, &in_cache);
+      ParsedFunction* parsed_function;
+      {
+        TimerScope timer(FLAG_compiler_stats,
+                         &CompilerStats::graphinliner_parse_timer,
+                         isolate);
+        parsed_function = ParseFunction(function, &in_cache);
+      }
 
       // Load IC data for the callee.
       if (function.HasCode()) {
         const Code& unoptimized_code =
             Code::Handle(function.unoptimized_code());
         isolate->set_ic_data_array(unoptimized_code.ExtractTypeFeedbackArray());
       }
 
       // Build the callee graph.
       FlowGraphBuilder builder(*parsed_function);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
-      FlowGraph* callee_graph =
-          builder.BuildGraph(FlowGraphBuilder::kValueContext);
+      FlowGraph* callee_graph;
+      {
+        TimerScope timer(FLAG_compiler_stats,
+                         &CompilerStats::graphinliner_build_timer,
+                         isolate);
+        callee_graph = builder.BuildGraph(FlowGraphBuilder::kValueContext);
+      }
 
       // Abort if the callee graph contains control flow.
       if (!FLAG_inline_control_flow &&
           (callee_graph->preorder().length() != 2)) {
         function.set_is_inlinable(false);
         isolate->set_long_jump_base(base);
         isolate->set_ic_data_array(prev_ic_data.raw());
         TRACE_INLINING(OS::Print("     Bailout: control flow\n"));
         return false;
       }
 
-      // Compute SSA on the callee graph, catching bailouts.
-      callee_graph->ComputeSSA(next_ssa_temp_index_);
-      callee_graph->ComputeUseLists();
+      {
+        TimerScope timer(FLAG_compiler_stats,
+                         &CompilerStats::graphinliner_ssa_timer,
+                         isolate);
+        // Compute SSA on the callee graph, catching bailouts.
+        callee_graph->ComputeSSA(next_ssa_temp_index_);
+        callee_graph->ComputeUseLists();
+      }
 
-      // TODO(zerny): Do more optimization passes on the callee graph.
-      FlowGraphOptimizer optimizer(callee_graph);
-      optimizer.ApplyICData();
-      callee_graph->ComputeUseLists();
+      {
+        TimerScope timer(FLAG_compiler_stats,
+                         &CompilerStats::graphinliner_opt_timer,
+                         isolate);
+        // TODO(zerny): Do more optimization passes on the callee graph.
+        FlowGraphOptimizer optimizer(callee_graph);
+        optimizer.ApplyICData();
+        callee_graph->ComputeUseLists();
+      }
 
       if (FLAG_trace_inlining && FLAG_print_flow_graph) {
         OS::Print("Callee graph for inlining %s\n",
                   function.ToFullyQualifiedCString());
         FlowGraphPrinter printer(*callee_graph);
         printer.PrintBlocks();
       }
 
       // If result is more than size threshold then abort.
       // TODO(zerny): Do this after CP and dead code elimination.
       intptr_t size = callee_graph->InstructionCount();
       if (size > FLAG_inlining_size_threshold) {
         function.set_is_inlinable(false);
         isolate->set_long_jump_base(base);
         isolate->set_deopt_id(prev_deopt_id);
         isolate->set_ic_data_array(prev_ic_data.raw());
         TRACE_INLINING(OS::Print("     Bailout: graph size %"Pd"\n", size));
         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);
       }
 
-      // Plug result in the caller graph.
-      caller_graph_->InlineCall(call, callee_graph);
-      next_ssa_temp_index_ = caller_graph_->max_virtual_register_number();
+      {
+        TimerScope timer(FLAG_compiler_stats,
+                         &CompilerStats::graphinliner_subst_timer,
+                         isolate);
 
-      // Remove push arguments of the call.
-      for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
-        PushArgumentInstr* push = call->ArgumentAt(i);
-        push->ReplaceUsesWith(push->value()->definition());
-        push->RemoveFromGraph();
+        // Plug result in the caller graph.
+        caller_graph_->InlineCall(call, callee_graph);
+        next_ssa_temp_index_ = caller_graph_->max_virtual_register_number();
+
+        // Remove push arguments of the call.
+        for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
+          PushArgumentInstr* push = call->ArgumentAt(i);
+          push->ReplaceUsesWith(push->value()->definition());
+          push->RemoveFromGraph();
+        }
+
+        // Replace formal parameters with actuals.
+        intptr_t arg_index = 0;
+        GrowableArray<Definition*>* defns =
+            callee_graph->graph_entry()->initial_definitions();
+        for (intptr_t i = 0; i < defns->length(); ++i) {
+          ParameterInstr* param = (*defns)[i]->AsParameter();
+          if (param != NULL) {
+            param->ReplaceUsesWith((*arguments)[arg_index++]->definition());
+          }
+        }
+        ASSERT(arg_index == arguments->length());
+
+        // Replace callee's null constant with caller's null constant.
+        callee_graph->graph_entry()->constant_null()->ReplaceUsesWith(
+            caller_graph_->graph_entry()->constant_null());
       }
 
-      // Replace formal parameters with actuals.
-      intptr_t arg_index = 0;
-      GrowableArray<Definition*>* defns =
-          callee_graph->graph_entry()->initial_definitions();
-      for (intptr_t i = 0; i < defns->length(); ++i) {
-        ParameterInstr* param = (*defns)[i]->AsParameter();
-        if (param != NULL) {
-          param->ReplaceUsesWith((*arguments)[arg_index++]->definition());
-        }
-      }
-      ASSERT(arg_index == arguments->length());
-
-      // Replace callee's null constant with caller's null constant.
-      callee_graph->graph_entry()->constant_null()->ReplaceUsesWith(
-          caller_graph_->graph_entry()->constant_null());
-
       TRACE_INLINING(OS::Print("     Success\n"));
 
       // Add the function to the cache.
       if (!in_cache) function_cache.Add(parsed_function);
 
       // Check that inlining maintains use lists.
       DEBUG_ASSERT(!FLAG_verify_compiler || caller_graph_->ValidateUseLists());
 
       // Build succeeded so we restore the bailout jump.
       inlined_ = true;
@@ skipping 139 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart