Subtract scan/parse time from unlinked summary perf statistic.

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;
 
@@ skipping 17 matching lines @@
 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;
 
 /// Cumulative time spent scanning.
 Stopwatch scanTimer = new Stopwatch();
 
+/// Cumulative time spent parsing.
+Stopwatch parseTimer = new Stopwatch();
+
+/// Cumulative time spent building unlinked summaries.
+Stopwatch unlinkedSummarizeTimer = new Stopwatch();
+
 /// Factory to load and resolve app, packages, and sdk sources.
 SourceFactory sources;
 
 main(List<String> args) async {
   // TODO(sigmund): provide sdk folder as well.
   if (args.length < 2) {
     print('usage: perf.dart <bench-id> <entry.dart>');
     exit(1);
   }
   var totalTimer = new Stopwatch()..start();
@@ skipping 111 matching lines @@
 
 /// Parses every file in [files] and reports the time spent doing so.
 void parseFiles(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 parseTimer = new Stopwatch()..start();
+  parseTimer = new Stopwatch();
   for (var source in files) {
     parseFull(source);
   }
-  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);
+  report("parse", parseTimer.elapsedMicroseconds);
 }
 
 /// 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();
+  parseTimer = new Stopwatch();
+  unlinkedSummarizeTimer = new Stopwatch();
   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);
+  report("scan", scanTimer.elapsedMicroseconds);
+  report("parse", parseTimer.elapsedMicroseconds);
+  report('unlinked summarize', unlinkedSummarizeTimer.elapsedMicroseconds);

[Siggi Cherem (dart-lang), 2016/12/04 05:01:48]

I wonder if we should continue to include the parse time here (or add one more
result with parse + summarize). In particular, I'm thinking we might want to use
the parse+summary time when we run this as a benchmark, since it will make it
easier to do a comparison with alternatives that avoid the full cost of parsing
(e.g.  if we use a technique that generates summaries using selective parsing
like the experiment from this week). 

We can always compute the parse+summarize totals in the benchmark runners
though, it's just easier to have it here already.

[Paul Berry, 2016/12/05 16:01:01]

Good idea.  PTAL.

 }
 
 /// 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);
+  parseTimer.start();
   var parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
-  return parser.parseCompilationUnit(token);
+  var unit = parser.parseCompilationUnit(token);
+  parseTimer.stop();
+  return unit;
 }
 
 UnlinkedUnitBuilder unlinkedSummarize(Source source) {
   var unit = parseFull(source);
-  return serializeAstUnlinked(unit);
+  unlinkedSummarizeTimer.start();
+  var unlinkedUnit = serializeAstUnlinked(unit);
+  unlinkedSummarizeTimer.stop();
+  return unlinkedUnit;
 }
 
 /// 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);
@@ skipping 37 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;
 }