Improve measuring

dart/sdk/lib/_internal/compiler/implementation/compiler.dart

 // Copyright (c) 2012, 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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 40 matching lines @@
   bool isAnalyzed() => resolutionTree != null;
 
   void run(Compiler compiler, Enqueuer world) {
     CodeBuffer codeBuffer = world.universe.generatedCode[element];
     if (codeBuffer != null) return;
     resolutionTree = compiler.analyze(this, world);
     compiler.codegen(this, world);
   }
 }
 
+class ReadingFilesTask extends CompilerTask {
+  ReadingFilesTask(Compiler compiler) : super(compiler);
+  String get name => 'Reading input files';
+}
+
 abstract class Backend {
   final Compiler compiler;
   final ConstantSystem constantSystem;
 
   Backend(this.compiler,
           [ConstantSystem constantSystem = DART_CONSTANT_SYSTEM])
       : this.constantSystem = constantSystem;
 
   void enqueueAllTopLevelFunctions(LibraryElement lib, Enqueuer world) {
     lib.forEachExport((Element e) {
@@ skipping 22 matching lines @@
   ItemCompilationContext createItemCompilationContext() {
     return new ItemCompilationContext();
   }
 
   SourceString getCheckedModeHelper(DartType type) => null;
   void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {}
 }
 
 abstract class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
+  final Stopwatch totalCompileTime = new Stopwatch();
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Types types;
 
   final bool enableMinification;
   final bool enableTypeAssertions;
   final bool enableUserAssertions;
   final bool enableConcreteTypeInference;
   final bool analyzeAll;
@@ skipping 70 matching lines @@
   PatchParserTask patchParser;
   LibraryLoader libraryLoader;
   TreeValidatorTask validator;
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   ti.TypesTask typesTask;
   Backend backend;
   ConstantHandler constantHandler;
   EnqueueTask enqueuer;
+  CompilerTask fileReadingTask;
 
   static const SourceString MAIN = const SourceString('main');
   static const SourceString CALL_OPERATOR_NAME = const SourceString('call');
   static const SourceString NO_SUCH_METHOD = const SourceString('noSuchMethod');
   static const int NO_SUCH_METHOD_ARG_COUNT = 1;
   static const SourceString INVOKE_ON = const SourceString('invokeOn');
   static const SourceString RUNTIME_TYPE = const SourceString('runtimeType');
   static const SourceString START_ROOT_ISOLATE =
       const SourceString('startRootIsolate');
   bool enabledNoSuchMethod = false;
@@ skipping 22 matching lines @@
             bool generateSourceMap: true,
             bool disallowUnsafeEval: false,
             this.analyzeAll: false,
             this.rejectDeprecatedFeatures: false,
             this.checkDeprecationInSdk: false,
             List<String> strips: const []})
       : libraries = new Map<String, LibraryElement>(),
         progress = new Stopwatch() {
     progress.start();
     world = new World(this);
-    scanner = new ScannerTask(this);
-    dietParser = new DietParserTask(this);
-    parser = new ParserTask(this);
-    patchParser = new PatchParserTask(this);
-    libraryLoader = new LibraryLoaderTask(this);
-    validator = new TreeValidatorTask(this);
-    resolver = new ResolverTask(this);
-    closureToClassMapper = new closureMapping.ClosureTask(this);
-    checker = new TypeCheckerTask(this);
-    typesTask = new ti.TypesTask(this, enableConcreteTypeInference);
     backend = emitJavaScript ?
         new js_backend.JavaScriptBackend(this,
                                          generateSourceMap,
                                          disallowUnsafeEval) :
         new dart_backend.DartBackend(this, strips);
-    constantHandler = new ConstantHandler(this, backend.constantSystem);
-    enqueuer = new EnqueueTask(this);
-    tasks = [scanner, dietParser, parser, patchParser, libraryLoader,
-             resolver, closureToClassMapper, checker, typesTask,
-             constantHandler, enqueuer];
+
+    // No-op in production mode.
+    validator = new TreeValidatorTask(this);
+
+    tasks = [
+      fileReadingTask = new ReadingFilesTask(this),
+      libraryLoader = new LibraryLoaderTask(this),
+      scanner = new ScannerTask(this),
+      dietParser = new DietParserTask(this),
+      parser = new ParserTask(this),
+      patchParser = new PatchParserTask(this),
+      resolver = new ResolverTask(this),
+      closureToClassMapper = new closureMapping.ClosureTask(this),
+      checker = new TypeCheckerTask(this),
+      typesTask = new ti.TypesTask(this, enableConcreteTypeInference),
+      constantHandler = new ConstantHandler(this, backend.constantSystem),
+      enqueuer = new EnqueueTask(this)];
+
     tasks.addAll(backend.tasks);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   int getNextFreeClassId() => nextFreeClassId++;
 
   void ensure(bool condition) {
     if (!condition) cancel('failed assertion in leg');
@@ skipping 68 matching lines @@
       cancel(reason, node: node, token: token, instruction: instruction,
              element: element);
     });
   }
 
   void log(message) {
     reportDiagnostic(null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
   bool run(Uri uri) {
+    totalCompileTime.start();
     try {
       runCompiler(uri);
     } on CompilerCancelledException catch (exception) {
       log('Error: $exception');
       return false;
+    } finally {
+      tracer.close();
+      totalCompileTime.stop();
     }
-    tracer.close();
     return true;
   }
 
   void enableNoSuchMethod(Element element) {
     // TODO(ahe): Move this method to Enqueuer.
     if (enabledNoSuchMethod) return;
     if (identical(element.getEnclosingClass(), objectClass)) {
       enqueuer.resolution.registerDynamicInvocationOf(element);
       return;
     }
@@ skipping 496 matching lines @@
 class CompilerTask {
   final Compiler compiler;
   final Stopwatch watch;
 
   CompilerTask(this.compiler) : watch = new Stopwatch();
 
   String get name => 'Unknown task';
   int get timing => watch.elapsedMilliseconds;
 
   measure(Function action) {
-    // TODO(kasperl): Do we have to worry about exceptions here?
     CompilerTask previous = compiler.measuredTask;
+    if (identical(this, previous)) return action();
     compiler.measuredTask = this;
     if (previous != null) previous.watch.stop();
     watch.start();
-    var result = action();
-    watch.stop();
-    if (previous != null) previous.watch.start();
-    compiler.measuredTask = previous;
-    return result;
+    try {
+      return action();
+    } finally {
+      watch.stop();
+      if (previous != null) previous.watch.start();
+      compiler.measuredTask = previous;
+    }
   }
 }
 
 class CompilerCancelledException implements Exception {
   final String reason;
   CompilerCancelledException(this.reason);
 
   String toString() {
     String banner = 'compiler cancelled';
     return (reason != null) ? '$banner: $reason' : '$banner';
@@ skipping 52 matching lines @@
   // TODO(johnniwinther): Use [spannable] and [message] to provide better
   // information on assertion errors.
   if (condition is Function){
     condition = condition();
   }
   if (spannable == null || !condition) {
     throw new SpannableAssertionFailure(spannable, message);
   }
   return true;
 }