Add more compiler timeline durations

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 396 matching lines @@
                                         bool optimized,
                                         intptr_t osr_id) {
   const Function& function = parsed_function->function();
   if (optimized && !function.IsOptimizable()) {
     return false;
   }
   bool is_compiled = false;
   Thread* const thread = Thread::Current();
   Zone* const zone = thread->zone();
   Isolate* const isolate = thread->isolate();
+  TimelineStream* compiler_timeline = isolate->GetCompilerStream();
   CSTAT_TIMER_SCOPE(thread, codegen_timer);
   HANDLESCOPE(thread);
 
   // Get current generation count so that we can check and ensure that the code
   // was not invalidated while we were compiling in the background.
   uint32_t cha_invalidation_gen_at_start = isolate->cha_invalidation_gen();
   uint32_t field_invalidation_gen_at_start = isolate->field_invalidation_gen();
   uint32_t prefix_invalidation_gen_at_start =
       isolate->prefix_invalidation_gen();
 
@@ skipping 41 matching lines @@
           if (FLAG_print_ic_data_map) {
             for (intptr_t i = 0; i < ic_data_array->length(); i++) {
               if ((*ic_data_array)[i] != NULL) {
                 THR_Print("%" Pd " ", i);
                 FlowGraphPrinter::PrintICData(*(*ic_data_array)[i]);
               }
             }
           }
         }
 
+        TimelineDurationScope tds(thread,
+                                  compiler_timeline,
+                                  "BuildFlowGraph");
         flow_graph = pipeline->BuildFlowGraph(zone,
                                               parsed_function,
                                               *ic_data_array,
                                               osr_id);
       }
 
       const bool print_flow_graph =
           (FLAG_print_flow_graph ||
           (optimized && FLAG_print_flow_graph_optimized)) &&
           FlowGraphPrinter::ShouldPrint(function);
 
       if (print_flow_graph) {
         if (osr_id == Compiler::kNoOSRDeoptId) {
           FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
         } else {
           FlowGraphPrinter::PrintGraph("For OSR", flow_graph);
         }
       }
 
       BlockScheduler block_scheduler(flow_graph);
       const bool reorder_blocks =
           FlowGraph::ShouldReorderBlocks(function, optimized);
       if (reorder_blocks) {
+        TimelineDurationScope tds(thread,
+                                  compiler_timeline,
+                                  "BlockScheduler::AssignEdgeWeights");
         block_scheduler.AssignEdgeWeights();
       }
 
       if (optimized) {
         CSTAT_TIMER_SCOPE(thread, ssa_timer);
         // Transform to SSA (virtual register 0 and no inlining arguments).
         flow_graph->ComputeSSA(0, NULL);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
         if (print_flow_graph) {
           FlowGraphPrinter::PrintGraph("After SSA", flow_graph);
@@ skipping 236 matching lines @@
           sinking->DetachMaterializations();
         }
 
         // Compute and store graph informations (call & instruction counts)
         // to be later used by the inliner.
         FlowGraphInliner::CollectGraphInfo(flow_graph, true);
 
         // Perform register allocation on the SSA graph.
         FlowGraphAllocator allocator(*flow_graph);
         allocator.AllocateRegisters();
-        if (reorder_blocks) block_scheduler.ReorderBlocks();
+        if (reorder_blocks) {
+          TimelineDurationScope tds(thread,
+                                    compiler_timeline,
+                                    "BlockScheduler::ReorderBlocks");
+          block_scheduler.ReorderBlocks();
+        }
 
         if (print_flow_graph) {
           FlowGraphPrinter::PrintGraph("After Optimizations", flow_graph);
         }
       }

[Florian Schneider, 2015/12/15 09:47:27]

Why just measure this phase? I think the whole optimizations phase from "Before
Optimizations" to here would be better suitable.

[Cutch, 2015/12/15 16:59:25]

Done.

[Florian Schneider, 2015/12/15 17:15:34]

Oh ok - that's more than I expected. I thought one aggregate scope for all
optimization passes would be enough - maybe split out inlining, register
allocation.
This works as well, but note that some of the phases are really really short
(like Canonicalize), so I would remove those.

 
       ASSERT(inline_id_to_function.length() == caller_inline_id.length());
       Assembler assembler(use_far_branches);
       FlowGraphCompiler graph_compiler(&assembler, flow_graph,
                                        *parsed_function, optimized,
                                        inline_id_to_function,
                                        caller_inline_id);
       {
         CSTAT_TIMER_SCOPE(thread, graphcompiler_timer);
+        TimelineDurationScope tds(thread,
+                                  compiler_timeline,
+                                  "CompileGraph");
         graph_compiler.CompileGraph();
         pipeline->FinalizeCompilation();
       }
       {
+        TimelineDurationScope tds(thread,
+                                  compiler_timeline,
+                                  "FinalizeCompilation");
         // This part of compilation must be at a safepoint.
         if (!Thread::Current()->IsMutatorThread()) {
           // Stop mutator thread before creating the instruction object and
           // installing code.
           // Mutator thread may not run code while we are creating the
           // instruction object, since the creation of instruction object
           // changes code page access permissions (makes them temporary not
           // executable).
           isolate->thread_registry()->SafepointThreads();
         }
@@ skipping 1102 matching lines @@
 }
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
 #endif  // DART_PRECOMPILED
 
 }  // namespace dart