Rework analysis server performance measurement code.

pkg/analysis_server/lib/src/analysis_server.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;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' show max;
 
@@ skipping 10 matching lines @@
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/package_map_provider.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/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/generated/utilities_general.dart';
 
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);
 
 
 /**
  * Enum representing reasons why analysis might be done for a given file.
  */
 class AnalysisDoneReason {
   /**
@@ skipping 621 matching lines @@
       contextAnalysisDoneCompleters[context] = completer;
     }
     return completer.future;
   }
 
   /**
    * Perform the next available [ServerOperation].
    */
   void performOperation() {
     assert(performOperationPending);
+    PerformanceTag.UNKNOWN.makeCurrent();
     performOperationPending = false;
     if (!running) {
       // An error has occurred, or the connection to the client has been
       // closed, since this method was scheduled on the event queue.  So
       // don't do anything.  Instead clear the operation queue.
       operationQueue.clear();
       return;
     }
     // prepare next operation
     ServerOperation operation = operationQueue.take();
     if (operation == null) {
       // This can happen if the operation queue is cleared while the operation
       // loop is in progress.  No problem; we just need to exit the operation
       // loop and wait for the next operation to be added.
+      ServerPerformanceStatistics.idle.makeCurrent();
       return;
     }
     sendStatusNotification(operation);
     // perform the operation
     try {
       operation.perform(this);
     } catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logError("${exception}\n${stackTrace}");
       if (rethrowExceptions) {
         throw new AnalysisException(
             'Unexpected exception during analysis',
             new CaughtException(exception, stackTrace));
       }
       sendServerErrorNotification(exception, stackTrace, fatal: true);
       shutdown();
     } finally {
       if (!operationQueue.isEmpty) {
+        ServerPerformanceStatistics.intertask.makeCurrent();
         _schedulePerformOperation();
       } else {
         sendStatusNotification(null);
         if (_onAnalysisCompleteCompleter != null) {
           _onAnalysisCompleteCompleter.complete();
           _onAnalysisCompleteCompleter = null;
         }
+        ServerPerformanceStatistics.idle.makeCurrent();
       }
     }
   }
 
   /**
    * Trigger reanalysis of all files from disk.
    */
   void reanalyze() {
     // Clear any operations that are pending.
     operationQueue.clear();
@@ skipping 517 matching lines @@
     UriResolver resourceResolver = new ResourceUriResolver(resourceProvider);
     List<UriResolver> resolvers = packageUriResolver != null ?
         <UriResolver>[dartResolver, packageUriResolver, resourceResolver] :
         <UriResolver>[dartResolver, resourceResolver];
     return new SourceFactory(resolvers);
   }
 }
 
 
 /**
+ * Container with global [AnalysisServer] performance statistics.
+ */
+class ServerPerformanceStatistics {
+  /**
+   * The [PerformanceTag] for time spent in
+   * PerformAnalysisOperation._updateIndex.
+   */
+  static PerformanceTag index = new PerformanceTag('index');
+
+  /**
+   * The [PerformanceTag] for time spent in
+   * PerformAnalysisOperation._sendNotices.
+   */
+  static PerformanceTag notices = new PerformanceTag('notices');
+
+  /**
+   * The [PerformanceTag] for time spent performing a _DartIndexOperation.
+   */
+  static PerformanceTag indexOperation = new PerformanceTag('indexOperation');
+
+  /**
+   * The [PerformanceTag] for time spent between calls to
+   * AnalysisServer.performOperation when the server is not idle.
+   */
+  static PerformanceTag intertask = new PerformanceTag('intertask');
+
+  /**
+   * The [PerformanceTag] for time spent between calls to
+   * AnalysisServer.performOperation when the server is idle.
+   */
+  static PerformanceTag idle = new PerformanceTag('idle');
+}
+
+
+/**
  * A class used by [AnalysisServer] to record performance information
  * such as request latency.
  */
 class ServerPerformance {
 
   /**
    * The creation time and the time when performance information
    * started to be recorded here.
    */
   int startTime = new DateTime.now().millisecondsSinceEpoch;
@@ skipping 28 matching lines @@
           new DateTime.now().millisecondsSinceEpoch -
           request.clientRequestTime;
       requestLatency += latency;
       maxLatency = max(maxLatency, latency);
       if (latency > 150) {
         ++slowRequestCount;
       }
     }
   }
 }