Expose timing data for the new task model

pkg/analysis_server/lib/src/get_handler.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.
 
 library analysis_server.src.get_handler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 12 matching lines @@
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/src/status/ast_writer.dart';
 import 'package:analysis_server/src/status/element_writer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
+import 'package:analyzer/task/model.dart' as newTask;
 import 'package:plugin/plugin.dart';
 
 /**
  * A function that can be used to generate HTML output into the given [buffer].
  * The HTML that is generated must be valid (special characters must already be
  * encoded).
  */
 typedef void HtmlGenerator(StringBuffer buffer);
 
 /**
@@ skipping 211 matching lines @@
    */
   void _returnAnalysisPerformance(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server is not running');
     }
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Analysis Performance', [],
           (StringBuffer buffer) {
         buffer.write('<h3>Analysis Performance</h3>');
-
-        {
-          buffer.write('<p><b>Time spent in each phase of analysis</b></p>');
+        if (AnalysisEngine.instance.useTaskModel) {
+          //
+          // Write new task model timing information.
+          //
+          buffer.write('<p><b>Task performace data</b></p>');
           buffer.write(
               '<table style="border-collapse: separate; border-spacing: 10px 5px;">');
-          _writeRow(buffer, ['Time (in ms)', 'Percent', 'Analysis Phase'],
-              header: true);
-          // prepare sorted tags
-          List<PerformanceTag> tags = PerformanceTag.all.toList();
-          tags.remove(ServerPerformanceStatistics.idle);
-          tags.sort((a, b) => b.elapsedMs - a.elapsedMs);
-          // prepare total time
-          int totalTime = 0;
-          tags.forEach((PerformanceTag tag) {
-            totalTime += tag.elapsedMs;
+          _writeRow(buffer, [
+            'Task Name',
+            'Count',
+            'Total Time (in ms)',
+            'Average Time (in ms)'
+          ], header: true);
+
+          Map<Type, int> countMap = newTask.AnalysisTask.countMap;
+          Map<Type, Stopwatch> stopwatchMap = newTask.AnalysisTask.stopwatchMap;
+          List<Type> taskClasses = stopwatchMap.keys.toList();
+          taskClasses.sort((Type first, Type second) =>
+              first.toString().compareTo(second.toString()));
+          taskClasses.forEach((Type taskClass) {
+            int count = countMap[taskClass];
+            if (count == null) {
+              count = 0;
+            }
+            int totalTime = stopwatchMap[taskClass].elapsedMilliseconds;
+            _writeRow(buffer, [
+              taskClass.toString(),
+              count,
+              totalTime,
+              count <= 0 ? '-' : totalTime / count
+            ], classes: [null, "right", "right", "right"]);
           });
-          // write rows
-          void writeRow(PerformanceTag tag) {
-            double percent = (tag.elapsedMs * 100) / totalTime;
-            String percentStr = '${percent.toStringAsFixed(2)}%';
-            _writeRow(buffer, [tag.elapsedMs, percentStr, tag.label],
-                classes: ["right", "right", null]);
-          }
-          tags.forEach(writeRow);
           buffer.write('</table>');
-        }
-
-        Map<DataDescriptor, Map<CacheState, int>> transitionMap =
-            SourceEntry.transitionMap;
-        buffer.write(
-            '<p><b>Number of times a state transitioned to VALID (grouped by descriptor)</b></p>');
-        if (transitionMap.isEmpty) {
-          buffer.write('<p>none</p>');
         } else {
-          List<DataDescriptor> descriptors = transitionMap.keys.toList();
-          descriptors.sort((DataDescriptor first, DataDescriptor second) =>
-              first.toString().compareTo(second.toString()));
-          for (DataDescriptor key in descriptors) {
-            Map<CacheState, int> countMap = transitionMap[key];
-            List<CacheState> oldStates = countMap.keys.toList();
-            oldStates.sort((CacheState first, CacheState second) =>
-                first.toString().compareTo(second.toString()));
-            buffer.write('<p>${key.toString()}</p>');
+          //
+          // Write old task model timing information.
+          //
+          {
+            buffer.write('<p><b>Time spent in each phase of analysis</b></p>');
             buffer.write(
                 '<table style="border-collapse: separate; border-spacing: 10px 5px;">');
-            _writeRow(buffer, ['Count', 'Previous State'], header: true);
-            for (CacheState state in oldStates) {
-              _writeRow(buffer, [countMap[state], state.toString()],
-                  classes: ["right", null]);
+            _writeRow(buffer, ['Time (in ms)', 'Percent', 'Analysis Phase'],
+                header: true);
+            // prepare sorted tags
+            List<PerformanceTag> tags = PerformanceTag.all.toList();
+            tags.remove(ServerPerformanceStatistics.idle);
+            tags.sort((a, b) => b.elapsedMs - a.elapsedMs);
+            // prepare total time
+            int totalTime = 0;
+            tags.forEach((PerformanceTag tag) {
+              totalTime += tag.elapsedMs;
+            });
+            // write rows
+            void writeRow(PerformanceTag tag) {
+              double percent = (tag.elapsedMs * 100) / totalTime;
+              String percentStr = '${percent.toStringAsFixed(2)}%';
+              _writeRow(buffer, [tag.elapsedMs, percentStr, tag.label],
+                  classes: ["right", "right", null]);
             }
+            tags.forEach(writeRow);
             buffer.write('</table>');
           }
+
+          Map<DataDescriptor, Map<CacheState, int>> transitionMap =
+              SourceEntry.transitionMap;
+          buffer.write(
+              '<p><b>Number of times a state transitioned to VALID (grouped by descriptor)</b></p>');
+          if (transitionMap.isEmpty) {
+            buffer.write('<p>none</p>');
+          } else {
+            List<DataDescriptor> descriptors = transitionMap.keys.toList();
+            descriptors.sort((DataDescriptor first, DataDescriptor second) =>
+                first.toString().compareTo(second.toString()));
+            for (DataDescriptor key in descriptors) {
+              Map<CacheState, int> countMap = transitionMap[key];
+              List<CacheState> oldStates = countMap.keys.toList();
+              oldStates.sort((CacheState first, CacheState second) =>
+                  first.toString().compareTo(second.toString()));
+              buffer.write('<p>${key.toString()}</p>');
+              buffer.write(
+                  '<table style="border-collapse: separate; border-spacing: 10px 5px;">');
+              _writeRow(buffer, ['Count', 'Previous State'], header: true);
+              for (CacheState state in oldStates) {
+                _writeRow(buffer, [countMap[state], state.toString()],
+                    classes: ["right", null]);
+              }
+              buffer.write('</table>');
+            }
+          }
         }
       });
     });
   }
 
   /**
    * Return a response containing information about an AST structure.
    */
   void _returnAst(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
@@ skipping 1252 matching lines @@
    */
   static String makeLink(
       String path, Map<String, String> params, String innerHtml,
       [bool hasError = false]) {
     Uri uri = new Uri(path: path, queryParameters: params);
     String href = HTML_ESCAPE.convert(uri.toString());
     String classAttribute = hasError ? ' class="error"' : '';
     return '<a href="$href"$classAttribute>$innerHtml</a>';
   }
 }