Compute and display tasks input timings.

pkg/analyzer/lib/src/task/driver.dart

 // Copyright (c) 2015, 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 analyzer.src.task.driver;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
     hide AnalysisTask, AnalysisContextImpl, WorkManager;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/model.dart';
 
-final PerformanceTag workOrderMoveNextPerfTag =
+final PerformanceTag workOrderMoveNextPerformanceTag =
     new PerformanceTag('WorkOrder.moveNext');
 
 /**
  * An object that is used to cause analysis to be performed until all of the
  * required analysis information has been computed.
  */
 class AnalysisDriver {
   /**
    * The task manager used to figure out how to compute analysis results.
    */
@@ skipping 482 matching lines @@
    * if [nodes] has multiple elements, this will always be `true`.  However, if
    * [nodes] has exactly one element, this may be either `true` or `false`
    * depending on whether the node has a dependency on itself.
    */
   final bool containsCycle;
 
   StronglyConnectedComponent(this.nodes, this.containsCycle);
 }
 
 /**
- * A description of a single anaysis task that can be performed to advance
+ * A description of a single analysis task that can be performed to advance
  * analysis.
  */
 class WorkItem {
   /**
+   * A table mapping the names of analysis tasks to the number of times each
+   * kind of task has been performed.
+   */
+  static final Map<String, int> countMap = new HashMap<String, int>();
+
+  /**
+   * A table mapping the names of analysis tasks to stopwatches used to compute
+   * how much time was spent between creating an item and creating (for
+   * performing) of each kind of task
+   */
+  static final Map<String, Stopwatch> stopwatchMap =
+  new HashMap<String, Stopwatch>();
+
+  /**
    * The context in which the task will be performed.
    */
   final InternalAnalysisContext context;
 
   /**
    * The target for which a task is to be performed.
    */
   final AnalysisTarget target;
 
   /**
    * A description of the task to be performed.
    */
   final TaskDescriptor descriptor;
 
   /**
    * The [ResultDescriptor] which was led to this work item being spawned.
    */
   final ResultDescriptor spawningResult;
 
   /**
+   * The current inputs computing stopwatch.
+   */
+  Stopwatch stopwatch;
+
+  /**
    * An iterator used to iterate over the descriptors of the inputs to the task,
    * or `null` if all of the inputs have been collected and the task can be
    * created.
    */
   TaskInputBuilder builder;
 
   /**
    * The [TargetedResult]s outputs of this task depends on.
    */
   final HashSet<TargetedResult> inputTargetedResults =
@@ skipping 29 matching lines @@
         identical(target, AnalysisContextTarget.request)
             ? new AnalysisContextTarget(context)
             : target;
     Map<String, TaskInput> inputDescriptors =
         descriptor.createTaskInputs(actualTarget);
     builder = new TopLevelTaskInputBuilder(inputDescriptors);
     if (!builder.moveNext()) {
       builder = null;
     }
     inputs = new HashMap<String, dynamic>();
+    // Update performance counters.
+    {
+      stopwatch = stopwatchMap[descriptor.name];

[Brian Wilkerson, 2015/10/23 16:27:11]

The descriptors are long-lived and unique, so you could use the descriptor as
the key directly. Not sure it matters, though.

+      if (stopwatch == null) {
+        stopwatch = new Stopwatch();
+        stopwatchMap[descriptor.name] = stopwatch;
+      }
+      stopwatch.start();
+    }
+    {
+      int count = countMap[descriptor.name];
+      countMap[descriptor.name] = count == null ? 1 : count + 1;
+    }
   }
 
   @override
   int get hashCode =>
       JenkinsSmiHash.hash2(descriptor.hashCode, target.hashCode);
 
   @override
   bool operator ==(other) {
     if (other is WorkItem) {
       return this.descriptor == other.descriptor && this.target == other.target;
     } else {
       return false;
     }
   }
 
   /**
    * Build the task represented by this work item.
    */
   AnalysisTask buildTask() {
+    stopwatch.stop();
     if (builder != null) {
       throw new StateError("some inputs have not been computed");
     }
     AnalysisTask task = descriptor.createTask(context, target, inputs);
     task.dependencyCycle = dependencyCycle;
     return task;
   }
 
   /**
    * Gather all of the inputs needed to perform the task.
@@ skipping 97 matching lines @@
   WorkItem get current {
     if (currentItems == null) {
       return null;
     } else {
       return currentItems.last;
     }
   }
 
   @override
   bool moveNext() {
-    return workOrderMoveNextPerfTag.makeCurrentWhile(() {
+    return workOrderMoveNextPerformanceTag.makeCurrentWhile(() {
       if (currentItems != null && currentItems.length > 1) {
         // Yield more items.
         currentItems.removeLast();
         return true;
       } else {
         // Get a new strongly connected component.
         StronglyConnectedComponent<WorkItem> nextStronglyConnectedComponent =
             _dependencyWalker.getNextStronglyConnectedComponent();
         if (nextStronglyConnectedComponent == null) {
           currentItems = null;
           return false;
         }
         currentItems = nextStronglyConnectedComponent.nodes;
         if (nextStronglyConnectedComponent.containsCycle) {
           // A cycle has been found.
           for (WorkItem item in currentItems) {
             item.dependencyCycle = currentItems.toList();
           }
         } else {
           assert(currentItems.length == 1);
         }
         return true;
       }
     });
   }
 }
 
 /**
- * Specilaization of [CycleAwareDependencyWalker] for use by [WorkOrder].
+ * Specialization of [CycleAwareDependencyWalker] for use by [WorkOrder].
  */
 class _WorkOrderDependencyWalker extends CycleAwareDependencyWalker<WorkItem> {
   /**
    * The task manager used to build work items.
    */
   final TaskManager taskManager;
 
   _WorkOrderDependencyWalker(this.taskManager, WorkItem startingNode)
       : super(startingNode);
 
   @override
   WorkItem getNextInput(WorkItem node, List<WorkItem> skipInputs) {
     return node.gatherInputs(taskManager, skipInputs);
   }
 }