dart2js: Reduce overhead of --verbose measurements

pkg/compiler/lib/src/common/tasks.dart

 // 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.
 
 library dart2js.common.tasks;
 
 import 'dart:async'
     show Future, Zone, ZoneDelegate, ZoneSpecification, runZoned;
 
 /// Used to measure where time is spent in the compiler.
 ///
 /// This exposes [measure] and [measureIo], which wrap an action and associate
 /// the time spent during that action with this task. Nested measurementsccan be
 /// introduced by using [measureSubtask].
 // TODO(sigmund): rename to MeasurableTask
 abstract class CompilerTask {
   final Measurer measurer;
   final Stopwatch _watch;
   final Map<String, GenericTask> _subtasks = <String, GenericTask>{};
 
   int asyncCount = 0;
 
+  // Each task has a fixed, lazily computed, ZoneSpecification and zoneValues
+  // for [_measureZoned].
+  ZoneSpecification _zoneSpecification;
+  Map _zoneValues;
+
   CompilerTask(Measurer measurer)
       : measurer = measurer,
         _watch = measurer.enableTaskMeasurements ? new Stopwatch() : null;
 
   /// Whether measurement is disabled. The functions [measure] and [measureIo]
   /// only measure time if measurements are enabled.
   bool get _isDisabled => _watch == null;
 
   /// Name to use for reporting timing information. Subclasses should override
   /// this with a proper name, otherwise we use the runtime type of the task.
@@ skipping 57 matching lines @@
     // Using zones, we're able to track asynchronous operations correctly, as
     // our zone will be asked to invoke `then` blocks. Then blocks (the closure
     // passed to runZoned, and other closures) are run via the `run` functions
     // below.
 
     assert(_watch != null);
 
     // The current zone is already measuring `this` task.
     if (Zone.current[measurer] == this) return action();
 
-    /// Run [f] in [zone]. Running must be delegated to [parent] to ensure that
-    /// various state is set up correctly (in particular that `Zone.current`
-    /// has the right value). Since [_measureZoned] can be called recursively
-    /// (synchronously), some of the measuring zones we create will be parents
-    /// of other measuring zones, but we still need to call through the parent
-    /// chain. Consequently, we use a zone value keyed by [measurer] to see if
-    /// we should measure or not when delegating.
-    run(Zone self, ZoneDelegate parent, Zone zone, f()) {
-      if (zone[measurer] != this) return parent.run(zone, f);
-      CompilerTask previous = _start();
-      try {
-        return parent.run(zone, f);
-      } finally {
-        _stop(previous);
-      }
+    return runZoned(action,
+        zoneValues: _zoneValues ??= {measurer: this},
+        zoneSpecification: _zoneSpecification ??= new ZoneSpecification(
+            run: _run, runUnary: _runUnary, runBinary: _runBinary));
+  }
+
+  /// Run [f] in [zone]. Running must be delegated to [parent] to ensure that
+  /// various state is set up correctly (in particular that `Zone.current`
+  /// has the right value). Since [_measureZoned] can be called recursively
+  /// (synchronously), some of the measuring zones we create will be parents
+  /// of other measuring zones, but we still need to call through the parent
+  /// chain. Consequently, we use a zone value keyed by [measurer] to see if
+  /// we should measure or not when delegating.
+  _run(Zone self, ZoneDelegate parent, Zone zone, f()) {
+    if (zone[measurer] != this) return parent.run(zone, f);
+    CompilerTask previous = _start();
+    try {
+      return parent.run(zone, f);
+    } finally {
+      _stop(previous);
     }
+  }
 
-    /// Same as [run] except that [f] takes one argument, [arg].
-    runUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg) {
-      if (zone[measurer] != this) return parent.runUnary(zone, f, arg);
-      CompilerTask previous = _start();
-      try {
-        return parent.runUnary(zone, f, arg);
-      } finally {
-        _stop(previous);
-      }
+  /// Same as [run] except that [f] takes one argument, [arg].
+  _runUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg) {
+    if (zone[measurer] != this) return parent.runUnary(zone, f, arg);
+    CompilerTask previous = _start();
+    try {
+      return parent.runUnary(zone, f, arg);
+    } finally {
+      _stop(previous);
     }
+  }
 
-    /// Same as [run] except that [f] takes two arguments ([a1] and [a2]).
-    runBinary(Zone self, ZoneDelegate parent, Zone zone, f(a1, a2), a1, a2) {
-      if (zone[measurer] != this) return parent.runBinary(zone, f, a1, a2);
-      CompilerTask previous = _start();
-      try {
-        return parent.runBinary(zone, f, a1, a2);
-      } finally {
-        _stop(previous);
-      }
+  /// Same as [run] except that [f] takes two arguments ([a1] and [a2]).
+  _runBinary(Zone self, ZoneDelegate parent, Zone zone, f(a1, a2), a1, a2) {
+    if (zone[measurer] != this) return parent.runBinary(zone, f, a1, a2);
+    CompilerTask previous = _start();
+    try {
+      return parent.runBinary(zone, f, a1, a2);
+    } finally {
+      _stop(previous);
     }
-
-    return runZoned(action,
-        zoneValues: {measurer: this},
-        zoneSpecification: new ZoneSpecification(
-            run: run, runUnary: runUnary, runBinary: runBinary));
   }
 
   /// Asynchronous version of [measure]. Use this when action returns a future
   /// that's truly asynchronous, such I/O. Only one task can use this method
   /// concurrently.
   ///
   /// Note: we assume that this method is used only by the compiler input
   /// provider, but it could be used by other tasks as long as the input
   /// provider will not be called by those tasks.
   measureIo(Future action()) {
@@ skipping 90 matching lines @@
   }
 
   /// Call this when the eventloop returns control to us.
   void stopAsyncWallClock() {
     if (currentAsyncTask != null) {
       currentAsyncTask._watch.stop();
     }
     asyncWallClock.stop();
   }
 }