Add a front end perf test that computes unlinked summaries.

pkg/front_end/tool/perf.dart

 // Copyright (c) 2016, 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.
 
 /// An entrypoint used to run portions of front_end and measure its performance.
 library front_end.tool.perf;
 
 import 'dart:async';
 import 'dart:io' show exit, stderr;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart' show ResourceUriResolver;
 import 'package:analyzer/file_system/physical_file_system.dart'
     show PhysicalResourceProvider;
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/context/builder.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart' show FolderBasedDartSdk;
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/summary/summarize_ast.dart';
 import 'package:kernel/analyzer/loader.dart';
 import 'package:kernel/kernel.dart';
 import 'package:package_config/discovery.dart';
 
 import 'package:front_end/src/scanner/reader.dart';
 import 'package:front_end/src/scanner/scanner.dart';
 import 'package:front_end/src/scanner/token.dart';
 
 /// Cumulative total number of chars scanned.
 int scanTotalChars = 0;
@@ skipping 30 matching lines @@
     },
     'kernel_gen_e2e': () async {
       // TODO(sigmund): remove. This is used to compute the input size, we
       // should extract input size from frontend instead.
       scanReachableFiles(entryUri);
       // TODO(sigmund): replace this warmup. Note that for very large programs,
       // the GC pressure on the VM seems to make this worse with time (maybe we
       // are leaking memory?). That's why we run it twice and not 10 times.
       for (int i = 0; i < 2; i++) await generateKernel(entryUri);
     },
+    'unlinked_summarize': () async {
+      Set<Source> files = scanReachableFiles(entryUri);
+      // TODO(sigmund): replace the warmup with instrumented snapshots.
+      for (int i = 0; i < 10; i++) unlinkedSummarizeFiles(files);
+    }
   };
 
   var handler = handlers[bench];
   if (handler == null) {
     // TODO(sigmund): implement the remaining benchmarks.
     print('unsupported bench-id: $bench. Please specify one of the following: '
         '${handlers.keys.join(", ")}');
     exit(1);
   }
   await handler();
@@ skipping 84 matching lines @@
   parseTimer.stop();
 
   // Report size and scanning time again. See discussion above.
   if (old != scanTotalChars) print('input size changed? ${old} chars');
   report("scan", scanTimer.elapsedMicroseconds);
 
   var pTime = parseTimer.elapsedMicroseconds - scanTimer.elapsedMicroseconds;
   report("parse", pTime);
 }
 
+/// Produces unlinked summaries for every file in [files] and reports the time
+/// spent doing so.
+void unlinkedSummarizeFiles(Set<Source> files) {
+  // The code below will record again how many chars are scanned and how long it
+  // takes to scan them, even though we already did so in [scanReachableFiles].
+  // Recording and reporting this twice is unnecessary, but we do so for now to
+  // validate that the results are consistent.
+  scanTimer = new Stopwatch();
+  var old = scanTotalChars;
+  scanTotalChars = 0;
+  var summarizeTimer = new Stopwatch()..start();
+  for (var source in files) {
+    unlinkedSummarize(source);
+  }
+  summarizeTimer.stop();
+
+  if (old != scanTotalChars) print('input size changed? ${old} chars');
+
+  // TODO(paulberry): subtract out scan/parse time?
+  var summarizeTime = summarizeTimer.elapsedMicroseconds;
+  report('unlinked summarize', summarizeTime);
+}
+
 /// Add to [files] all sources reachable from [start].
 void collectSources(Source start, Set<Source> files) {
   if (!files.add(start)) return;
   var unit = parseDirectives(start);
   for (var directive in unit.directives) {
     if (directive is UriBasedDirective) {
       var next = sources.resolveUri(start, directive.uri.stringValue);
       collectSources(next, files);
     }
   }
 }
 
 /// Uses the diet-parser to parse only directives in [source].
 CompilationUnit parseDirectives(Source source) {
   var token = tokenize(source);
   var parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
   return parser.parseDirectives(token);
 }
 
 /// Parse the full body of [source] and return it's compilation unit.
 CompilationUnit parseFull(Source source) {
   var token = tokenize(source);
   var parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
   return parser.parseCompilationUnit(token);
 }
 
+UnlinkedUnitBuilder unlinkedSummarize(Source source) {
+  var unit = parseFull(source);
+  return serializeAstUnlinked(unit);
+}
+
 /// Scan [source] and return the first token produced by the scanner.
 Token tokenize(Source source) {
   scanTimer.start();
   var contents = source.contents.data;
   scanTotalChars += contents.length;
   // TODO(sigmund): is there a way to scan from a random-access-file without
   // first converting to String?
   var scanner = new _Scanner(contents);
   var token = scanner.tokenize();
   scanTimer.stop();
@@ skipping 35 matching lines @@
     const int errorLimit = 100;
     stderr.writeln(errors.take(errorLimit).join('\n'));
     if (errors.length > errorLimit) {
       stderr.writeln('[error] ${errors.length - errorLimit} errors not shown');
     }
   }
   dartkTimer.stop();
   report("kernel_gen_e2e", dartkTimer.elapsedMicroseconds);
   return program;
 }