dart2js: Measure time of individual optimization passes.

pkg/compiler/lib/src/js_backend/codegen/task.dart

 // Copyright (c) 2014, 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.
 
 /// Generate code using the cps-based IR pipeline.
 library code_generator_task;
 
 import 'glue.dart';
 import 'codegen.dart';
 import 'unsugar.dart';
@@ skipping 21 matching lines @@
 import '../../cps_ir/optimizers.dart';
 import '../../cps_ir/optimizers.dart' as cps_opt;
 import '../../tracer.dart';
 import '../../js_backend/codegen/codegen.dart';
 import '../../ssa/ssa.dart' as ssa;
 import '../../tree_ir/optimization/optimization.dart';
 import '../../tree_ir/optimization/optimization.dart' as tree_opt;
 import '../../tree_ir/tree_ir_integrity.dart';
 import '../../cps_ir/cps_ir_nodes_sexpr.dart';
 import '../../cps_ir/type_mask_system.dart';
+import '../../common/tasks.dart';
 
 class CpsFunctionCompiler implements FunctionCompiler {
   final ConstantSystem constantSystem;
   // TODO(karlklose): remove the compiler.
   final Compiler compiler;
   final Glue glue;
   final SourceInformationStrategy sourceInformationFactory;
 
   // TODO(karlklose,sigurdm): remove and update dart-doc of [compile].
   final FunctionCompiler fallbackCompiler;
   TypeMaskSystem typeSystem;
 
   Tracer get tracer => compiler.tracer;
 
-  IrBuilderTask get irBuilderTask => compiler.irBuilder;
+  final IrBuilderTask cpsBuilderTask;
+  final GenericTask cpsOptimizationTask;
+  final GenericTask treeBuilderTask;
+  final GenericTask treeOptimizationTask;
 
   CpsFunctionCompiler(Compiler compiler, JavaScriptBackend backend,
                       SourceInformationStrategy sourceInformationFactory)
       : fallbackCompiler =
             new ssa.SsaFunctionCompiler(backend, sourceInformationFactory),
+        cpsBuilderTask = new IrBuilderTask(compiler, sourceInformationFactory),
         this.sourceInformationFactory = sourceInformationFactory,
         constantSystem = backend.constantSystem,
         compiler = compiler,
-        glue = new Glue(compiler);
+        glue = new Glue(compiler),
+        cpsOptimizationTask = new GenericTask('CPS optimization', compiler),
+        treeBuilderTask = new GenericTask('Tree builder', compiler),
+        treeOptimizationTask = new GenericTask('Tree optimization', compiler);
 
   String get name => 'CPS Ir pipeline';
 
   JavaScriptBackend get backend => compiler.backend;
 
   /// Generates JavaScript code for `work.element`.
   js.Fun compile(CodegenWorkItem work) {
     AstElement element = work.element;
     return compiler.withCurrentElement(element, () {
       typeSystem = new TypeMaskSystem(compiler);
@@ skipping 25 matching lines @@
     throw new CodegenBailout(null, reason);
   }
 
   void traceGraph(String title, var irObject) {
     if (tracer != null) {
       tracer.traceGraph(title, irObject);
     }
   }
 
   void applyCpsPass(cps_opt.Pass pass, cps.FunctionDefinition cpsFunction) {
-    pass.rewrite(cpsFunction);
+    cpsOptimizationTask.measureSubtask(pass.passName, () {
+      pass.rewrite(cpsFunction);
+    });
     traceGraph(pass.passName, cpsFunction);
     dumpTypedIr(pass.passName, cpsFunction);
     assert(checkCpsIntegrity(cpsFunction));
   }
 
   cps.FunctionDefinition compileToCpsIr(AstElement element) {
-    cps.FunctionDefinition cpsFunction = irBuilderTask.buildNode(element);
+    cps.FunctionDefinition cpsFunction = cpsBuilderTask.buildNode(element);
     if (cpsFunction == null) {
-      if (irBuilderTask.bailoutMessage == null) {
+      if (cpsBuilderTask.bailoutMessage == null) {
         giveUp('unable to build cps definition of $element');
       } else {
-        giveUp(irBuilderTask.bailoutMessage);
+        giveUp(cpsBuilderTask.bailoutMessage);
       }
     }
     traceGraph('IR Builder', cpsFunction);
     dumpTypedIr('IR Builder', cpsFunction);
     // Eliminating redundant phis before the unsugaring pass will make it
     // insert fewer getInterceptor calls.
     applyCpsPass(new RedundantPhiEliminator(), cpsFunction);
     applyCpsPass(new UnsugarVisitor(glue), cpsFunction);
     return cpsFunction;
   }
@@ skipping 54 matching lines @@
     applyCpsPass(new LoopInvariantCodeMotion(), cpsFunction);
     applyCpsPass(new ShareInterceptors(), cpsFunction);
     applyCpsPass(new ShrinkingReducer(), cpsFunction);
 
     return cpsFunction;
   }
 
   tree_ir.FunctionDefinition compileToTreeIr(cps.FunctionDefinition cpsNode) {
     tree_builder.Builder builder = new tree_builder.Builder(
         compiler.internalError);
-    tree_ir.FunctionDefinition treeNode = builder.buildFunction(cpsNode);
+    tree_ir.FunctionDefinition treeNode =
+        treeBuilderTask.measure(() => builder.buildFunction(cpsNode));
     assert(treeNode != null);
     traceGraph('Tree builder', treeNode);
     assert(checkTreeIntegrity(treeNode));
     return treeNode;
   }
 
   static bool checkTreeIntegrity(tree_ir.FunctionDefinition node) {
     new CheckTreeIntegrity().check(node);
     return true; // So this can be used from assert().
   }
 
   tree_ir.FunctionDefinition optimizeTreeIr(tree_ir.FunctionDefinition node) {
     void applyTreePass(tree_opt.Pass pass) {
-      pass.rewrite(node);
+      treeOptimizationTask.measureSubtask(pass.passName, () {
+        pass.rewrite(node);
+      });
       traceGraph(pass.passName, node);
       assert(checkTreeIntegrity(node));
     }
 
     applyTreePass(new StatementRewriter());
     applyTreePass(new VariableMerger());
     applyTreePass(new LoopRewriter());
     applyTreePass(new LogicalRewriter());
     applyTreePass(new PullIntoInitializers());
 
     return node;
   }
 
   js.Fun compileToJavaScript(CodegenWorkItem work,
                              tree_ir.FunctionDefinition definition) {
     CodeGenerator codeGen = new CodeGenerator(glue, work.registry);
     Element element = work.element;
     js.Fun code = codeGen.buildFunction(definition);
     if (element is FunctionElement && element.asyncMarker != AsyncMarker.SYNC) {
       code = backend.rewriteAsync(element, code);
       work.registry.registerAsyncMarker(element);
     }
     return attachPosition(code, element);
   }
 
   Iterable<CompilerTask> get tasks {
-    // TODO(sigurdm): Make a better list of tasks.
-    return <CompilerTask>[irBuilderTask]..addAll(fallbackCompiler.tasks);
+    return <CompilerTask>[
+        cpsBuilderTask,
+        cpsOptimizationTask,
+        treeBuilderTask,
+        treeOptimizationTask]
+      ..addAll(fallbackCompiler.tasks);
   }
 
   js.Node attachPosition(js.Node node, AstElement element) {
     return node.withSourceInformation(
         sourceInformationFactory.createBuilderForContext(element)
             .buildDeclaration(element));
   }
 }