performance measurement mods:

pkg/analysis_server/benchmark/integration/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 server.driver;
 
 import 'dart:async';
 import 'dart:math' show max, sqrt;
 
-import 'package:analyzer/src/generated/engine.dart' as engine;
 import 'package:logging/logging.dart';
 
 import '../../test/integration/integration_test_methods.dart';
 import '../../test/integration/integration_tests.dart';
 import 'operation.dart';
 
 final SPACE = ' '.codeUnitAt(0);
 
 void _printColumn(StringBuffer sb, String text, int keyLen,
     {bool rightJustified: false}) {
@@ skipping 16 matching lines @@
  * reads a stream of operations, sends requests to analysis server
  * based upon those operations, and evaluates the results.
  */
 class Driver extends IntegrationTestMixin {
   /**
    * The amount of time to give the server to respond to a shutdown request
    * before forcibly terminating it.
    */
   static const Duration SHUTDOWN_TIMEOUT = const Duration(seconds: 5);
 
-  final Logger logger;
+  final Logger logger = new Logger('Driver');
+
+  final bool newTaskModel;
+
+  /**
+   * The diagnostic port for Analysis Server or `null` if none.
+   */
+  final int diagnosticPort;
 
   /**
    * A flag indicating whether the server is running.
    */
   bool running = false;
 
   @override
   Server server;
 
   /**
    * The results collected while running analysis server.
    */
   final Results results = new Results();
 
   /**
    * The [Completer] for [runComplete].
    */
   Completer<Results> _runCompleter = new Completer<Results>();
 
-  Driver(this.logger);
+  Driver({this.newTaskModel, this.diagnosticPort});
 
   /**
    * Return a [Future] that completes with the [Results] of running
    * the analysis server once all operations have been performed.
    */
   Future<Results> get runComplete => _runCompleter.future;
 
   /**
    * Perform the given operation.
    * Return a [Future] that completes when the next operation can be performed,
@@ skipping 12 matching lines @@
    * error response, the future will be completed with an error.
    */
   Future send(String method, Map<String, dynamic> params) {
     return server.send(method, params);
   }
 
   /**
    * Launch the analysis server.
    * Return a [Future] that completes when analysis server has started.
    */
-  Future startServer({int diagnosticPort}) async {
+  Future startServer() async {
     logger.log(Level.FINE, 'starting server');
     initializeInttestMixin();
     server = new Server();
     Completer serverConnected = new Completer();
     onServerConnected.listen((_) {
       logger.log(Level.FINE, 'connected to server');
       serverConnected.complete();
     });
     running = true;
     return server
-        .start(diagnosticPort: diagnosticPort /*profileServer: true*/)
+        .start(
+            diagnosticPort: diagnosticPort,
+            newTaskModel: newTaskModel /*profileServer: true*/)
         .then((params) {
       server.listenToOutput(dispatchNotification);
       server.exitCode.then((_) {
         logger.log(Level.FINE, 'server stopped');
         running = false;
         _resultsReady();
       });
       return serverConnected.future;
     });
   }
@@ skipping 64 matching lines @@
     int standardDeviation = sqrt(variance).round();
 
     StringBuffer sb = new StringBuffer();
     _printColumn(sb, tag, keyLen);
     _printColumn(sb, count.toString(), 6, rightJustified: true);
     _printColumn(sb, errorCount.toString(), 6, rightJustified: true);
     _printColumn(sb, unexpectedResultCount.toString(), 6, rightJustified: true);
     _printDuration(sb, new Duration(microseconds: meanTime));
     _printDuration(sb, time90th);
     _printDuration(sb, time99th);
-    _printColumn(sb, standardDeviation.toString(), 15, rightJustified: true);
+    _printDuration(sb, new Duration(microseconds: standardDeviation));
     _printDuration(sb, minTime);
     _printDuration(sb, maxTime);
     _printDuration(sb, new Duration(microseconds: totalTimeMicros));
     print(sb.toString());
   }
 
   void record(bool success, Duration elapsed) {
     if (!success) {
       ++errorCount;
     }
     elapsedTimes.add(elapsed);
   }
 
   void recordUnexpectedResults() {
     ++unexpectedResultCount;
   }
 
   void _printDuration(StringBuffer sb, Duration duration) {
-    sb.write('  ');
-    sb.write(duration);
-    sb.write(',');
+    _printColumn(sb, duration.inMilliseconds.toString(), 15,
+        rightJustified: true);
   }
 }
 
 /**
  * [Results] contains information gathered by [Driver]
  * while running the analysis server
  */
 class Results {
   Map<String, Measurement> measurements = new Map<String, Measurement>();
 
   /**
    * Display results on stdout.
    */
   void printResults() {
     print('');
     print('==================================================================');
-    if (engine.AnalysisEngine.instance.useTaskModel) {
-      print('New task model');
-    } else {
-      print('Old task model');
-    }
     print('');
     List<String> keys = measurements.keys.toList()..sort();
     int keyLen = keys.fold(0, (int len, String key) => max(len, key.length));
     _printGroupHeader('Request/Response', keyLen);
     int totalCount = 0;
     int totalErrorCount = 0;
     int totalUnexpectedResultCount = 0;
     for (String tag in keys) {
       Measurement m = measurements[tag];
       if (!m.notification) {
         m.printSummary(keyLen);
         totalCount += m.count;
         totalErrorCount += m.errorCount;
         totalUnexpectedResultCount += m.unexpectedResultCount;
       }
     }
     _printTotals(
         keyLen, totalCount, totalErrorCount, totalUnexpectedResultCount);
     print('');
     _printGroupHeader('Notifications', keyLen);
     for (String tag in keys) {
       Measurement m = measurements[tag];
       if (m.notification) {
         m.printSummary(keyLen);
       }
     }
     /// TODO(danrubel) *** print warnings if driver caches are not empty ****
-    print('');
-    print(
-        '(1) uxr = UneXpected Results, or responses received from the server');
-    print(
-        '          that do not match the recorded response for that request.');
+    print('''
+
+(1) uxr = UneXpected Results or responses received from the server
+          that do not match the recorded response for that request.
+(2) all times in milliseconds''');
   }
 
   /**
    * Record the elapsed time for the given operation.
    */
   void record(String tag, Duration elapsed,
       {bool notification: false, bool success: true}) {
     Measurement measurement = measurements[tag];
     if (measurement == null) {
       measurement = new Measurement(tag, notification);
       measurements[tag] = measurement;
     }
     measurement.record(success, elapsed);
   }
 
   void recordUnexpectedResults(String tag) {
     measurements[tag].recordUnexpectedResults();
   }
 
   void _printGroupHeader(String groupName, int keyLen) {
     StringBuffer sb = new StringBuffer();
     _printColumn(sb, groupName, keyLen);
     _printColumn(sb, 'count', 6, rightJustified: true);
     _printColumn(sb, 'error', 6, rightJustified: true);
     _printColumn(sb, 'uxr(1)', 6, rightJustified: true);
     sb.write('  ');
-    _printColumn(sb, 'mean', 15);
+    _printColumn(sb, 'mean(2)', 15);
     _printColumn(sb, '90th', 15);
     _printColumn(sb, '99th', 15);
     _printColumn(sb, 'std-dev', 15);
     _printColumn(sb, 'minimum', 15);
     _printColumn(sb, 'maximum', 15);
     _printColumn(sb, 'total', 15);
     print(sb.toString());
   }
 
   void _printTotals(int keyLen, int totalCount, int totalErrorCount,
       int totalUnexpectedResultCount) {
     StringBuffer sb = new StringBuffer();
     _printColumn(sb, 'Totals', keyLen);
     _printColumn(sb, totalCount.toString(), 6, rightJustified: true);
     _printColumn(sb, totalErrorCount.toString(), 6, rightJustified: true);
     _printColumn(sb, totalUnexpectedResultCount.toString(), 6,
         rightJustified: true);
     print(sb.toString());
   }
 }