Add support for profile-based startup optimizations.

An experimental (and undocumented) flag '--experimental-track-allocations' makes the '--fast-startup' compiler add instructions that track which classes are allocated.

By going to the JavaScript console and dumping this information as JSON into `allocated_classes_profile` the next dart2js compilation can optimize the startup by deferring the initialization of the classes that weren't necessary for startup.

The workflow would look something like:
```
dart2js --fast-startup --experimental-track-allocations -o foo.js -o foo.dart
// Run the program in Chrome and run the following command in the console:
JSON.stringify($__dart_deferred_initializers__.allocations)
// Take the result and copy it into a file, say "allocations.json".
// Then rerun the compilation with the allocation-information.
dart2js --experimental-allocations-path=allocations.json --fast-startup -o foo.js -o foo.dart
```

[email protected]

Review-Url: https://codereview.chromium.org/2847343002 .

Author: floitschG

pkg/compiler/lib/src/commandline_options.dart

@@ -23,6 +23,10 @@ class Flags {
   static const String enableDiagnosticColors = '--enable-diagnostic-colors';
   static const String enableExperimentalMirrors =
       '--enable-experimental-mirrors';
+  static const String experimentalTrackAllocations =
+      '--experimental-track-allocations';
+  static const String experimentalAllocationsPath =
+      '--experimental-allocations-path';
   static const String fastStartup = '--fast-startup';
   static const String fatalWarnings = '--fatal-warnings';
   static const String generateCodeWithCompileTimeErrors =

pkg/compiler/lib/src/dart2js.dart

@@ -404,6 +404,14 @@ Future<api.CompilationResult> compile(List<String> argv) {
     new OptionHandler(Flags.useNewSourceInfo, passThrough),
     new OptionHandler(Flags.testMode, passThrough),
 
+    // Experimental features.
+    // We don't provide documentation for these yet.
+    // TODO(29574): provide documentation when this feature is supported.
+    // TODO(29574): provide a warning/hint/error, when profile-based data is
+    // used without `--fast-startup`.
+    new OptionHandler(Flags.experimentalTrackAllocations, passThrough),
+    new OptionHandler("${Flags.experimentalAllocationsPath}=.+", passThrough),
+
     // The following three options must come last.
     new OptionHandler('-D.+=.*', addInEnvironment),
     new OptionHandler('-.*', (String argument) {

pkg/compiler/lib/src/js_emitter/code_emitter_task.dart

@@ -189,6 +189,7 @@ class CodeEmitterTask extends CompilerTask {
       _finalizeRti();
       ProgramBuilder programBuilder = new ProgramBuilder(
           compiler.options,
+          compiler.reporter,
           compiler.elementEnvironment,
           compiler.commonElements,
           compiler.types,

pkg/compiler/lib/src/js_emitter/model.dart

@@ -16,6 +16,7 @@ class Program {
   final bool outputContainsConstantList;
   final bool needsNativeSupport;
   final bool hasIsolateSupport;
+  final bool hasSoftDeferredClasses;
 
   /// A map from load id to the list of fragments that need to be loaded.
   final Map<String, List<Fragment>> loadMap;
@@ -38,7 +39,8 @@ class Program {
       this.typeToInterceptorMap, this._metadataCollector, this.finalizers,
       {this.needsNativeSupport,
       this.outputContainsConstantList,
-      this.hasIsolateSupport}) {
+      this.hasIsolateSupport,
+      this.hasSoftDeferredClasses}) {
     assert(needsNativeSupport != null);
     assert(outputContainsConstantList != null);
     assert(hasIsolateSupport != null);
@@ -232,6 +234,11 @@ class Class implements FieldContainer {
   final bool isNative;
   final bool isClosureBaseClass; // Common base class for closures.
 
+  /// Whether this class should be soft deferred.
+  ///
+  /// A soft-deferred class is only fully initialized at first instantiation.
+  final bool isSoftDeferred;
+
   // If the class implements a function type, and the type is encoded in the
   // metatada table, then this field contains the index into that field.
   final js.Expression functionTypeIndex;
@@ -264,7 +271,8 @@ class Class implements FieldContainer {
       this.onlyForRti,
       this.isDirectlyInstantiated,
       this.isNative,
-      this.isClosureBaseClass}) {
+      this.isClosureBaseClass,
+      this.isSoftDeferred = false}) {
     assert(onlyForRti != null);
     assert(isDirectlyInstantiated != null);
     assert(isNative != null);

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart

@@ -4,6 +4,9 @@
 
 library dart2js.js_emitter.program_builder;
 
+import 'dart:io';
+import 'dart:convert' show JSON;
+
 import '../../closure.dart' show ClosureTask, ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
@@ -75,6 +78,7 @@ part 'registry.dart';
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
   final CompilerOptions _options;
+  final DiagnosticReporter _reporter;
   final ElementEnvironment _elementEnvironment;
   final CommonElements _commonElements;
   final DartTypes _types;
@@ -117,6 +121,7 @@ class ProgramBuilder {
 
   ProgramBuilder(
       this._options,
+      this._reporter,
       this._elementEnvironment,
       this._commonElements,
       this._types,
@@ -184,8 +189,17 @@ class ProgramBuilder {
 
   Set<Class> _unneededNativeClasses;
 
+  /// Classes that have been allocated during a profile run.
+  ///
+  /// These classes should not be soft-deferred.
+  ///
+  /// Also contains classes that are not tracked by the profile run (like
+  /// interceptors, ...).
+  Set<ClassElement> _notSoftDeferred;
+
   Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
     collector.collect();
+    _initializeSoftDeferredMap();
 
     this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
@@ -266,13 +280,77 @@ class ProgramBuilder {
         _buildTypeToInterceptorMap(), _task.metadataCollector, finalizers,
         needsNativeSupport: needsNativeSupport,
         outputContainsConstantList: collector.outputContainsConstantList,
-        hasIsolateSupport: _backendUsage.isIsolateInUse);
+        hasIsolateSupport: _backendUsage.isIsolateInUse,
+        hasSoftDeferredClasses: _notSoftDeferred != null);
   }
 
   void _markEagerClasses() {
     _markEagerInterceptorClasses();
   }
 
+  void _initializeSoftDeferredMap() {
+    var allocatedClassesPath = _options.experimentalAllocationsPath;
+    if (allocatedClassesPath != null) {
+      // TODO(29574): the following blacklist is ad-hoc and potentially
+      // incomplete. We need to mark all classes as black listed, that are
+      // used without code going through the class' constructor.
+      var blackList = [
+        'dart:_interceptors',
+        'dart:html',
+        'dart:typed_data_implementation',
+        'dart:_native_typed_data'
+      ].toSet();
+
+      // TODO(29574): the compiler should not just use dart:io to get the
+      // contents of a file.
+      File file = new File(allocatedClassesPath);
+
+      // TODO(29574): are the following checks necessary?
+      // To make compilation in build-systems easier, we ignore non-existing
+      // or empty profiles.
+      if (!file.existsSync()) {
+        _reporter.log("Profile file does not exist: $allocatedClassesPath");
+        return;
+      }
+      if (file.lengthSync() == 0) {
+        _reporter.log("Profile information (allocated classes) is empty.");
+        return;
+      }
+
+      String data = new File(allocatedClassesPath).readAsStringSync();
+      Set<String> allocatedClassesKeys = JSON.decode(data).keys.toSet();
+      Set<ClassElement> allocatedClasses = new Set<ClassElement>();
+
+      // Collects all super and mixin classes of a class.
+      void collect(ClassElement element) {
+        allocatedClasses.add(element);
+        if (element.isMixinApplication) {
+          collect(computeMixinClass(element));
+        }
+        if (element.superclass != null) {
+          collect(element.superclass);
+        }
+      }
+
+      // For every known class, see if it was allocated in the profile. If yes,
+      // collect its dependencies (supers and mixins) and mark them as
+      // not-soft-deferrable.
+      collector.outputClassLists.forEach((_, List<ClassElement> elements) {
+        for (ClassElement element in elements) {
+          // TODO(29574): share the encoding of the element with the code
+          // that emits the profile-run.
+          var key = "${element.library.canonicalUri}:${element.name}";
+          if (allocatedClassesKeys.contains(key) ||
+              _nativeData.isJsInteropClass(element) ||
+              blackList.contains(element.library.canonicalUri.toString())) {
+            collect(element);
+          }
+        }
+      });
+      _notSoftDeferred = allocatedClasses;
+    }
+  }
+
   /// Builds a map from loadId to outputs-to-load.
   Map<String, List<Fragment>> _buildLoadMap() {
     Map<String, List<Fragment>> loadMap = <String, List<Fragment>>{};
@@ -582,6 +660,10 @@ class ProgramBuilder {
         library, uri, statics, classes, staticFieldsForReflection);
   }
 
+  bool _isSoftDeferred(ClassElement element) {
+    return _notSoftDeferred != null && !_notSoftDeferred.contains(element);
+  }
+
   Class _buildClass(ClassElement element) {
     bool onlyForRti = collector.classesOnlyNeededForRti.contains(element);
     bool hasRtiField = _rtiNeed.classNeedsRtiField(element);
@@ -745,7 +827,8 @@ class ProgramBuilder {
           hasRtiField: hasRtiField,
           onlyForRti: onlyForRti,
           isNative: _nativeData.isNativeClass(element),
-          isClosureBaseClass: isClosureBaseClass);
+          isClosureBaseClass: isClosureBaseClass,
+          isSoftDeferred: _isSoftDeferred(element));
     }
     _classes[element] = result;
     return result;