Add support for profile-based startup optimizations.

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

 // Copyright (c) 2014, 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 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;
 import '../../constants/values.dart'
     show ConstantValue, InterceptorConstantValue;
 import '../../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import '../../elements/elements.dart'
     show
         ClassElement,
@@ skipping 51 matching lines @@
 import '../sorter.dart';
 
 part 'collector.dart';
 part 'field_visitor.dart';
 part 'registry.dart';
 
 /// Builds a self-contained representation of the program that can then be
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
   final CompilerOptions _options;
+  final DiagnosticReporter _reporter;
   final ElementEnvironment _elementEnvironment;
   final CommonElements _commonElements;
   final DartTypes _types;
   final DeferredLoadTask _deferredLoadTask;
   final ClosureTask _closureToClassMapper;
   final CodegenWorldBuilder _worldBuilder;
   final NativeCodegenEnqueuer _nativeCodegenEnqueuer;
   final BackendUsage _backendUsage;
   final JavaScriptConstantCompiler _constantHandler;
   final NativeData _nativeData;
@@ skipping 22 matching lines @@
   final Registry _registry;
 
   final FunctionEntity _mainFunction;
   final bool _isMockCompilation;
 
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
   ProgramBuilder(
       this._options,
+      this._reporter,
       this._elementEnvironment,
       this._commonElements,
       this._types,
       this._deferredLoadTask,
       this._closureToClassMapper,
       this._worldBuilder,
       this._nativeCodegenEnqueuer,
       this._backendUsage,
       this._constantHandler,
       this._nativeData,
@@ skipping 47 matching lines @@
 
   /// Mapping from names to strings.
   ///
   /// This mapping is used to support `const Symbol` expressions.
   ///
   /// This map is filled when building classes.
   final Map<js.Name, String> _symbolsMap = <js.Name, String>{};
 
   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
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
     _deferredLoadTask.allOutputUnits.forEach(_registry.registerOutputUnit);
     collector.outputClassLists.forEach(_registry.registerClasses);
     collector.outputStaticLists.forEach(_registry.registerMembers);
     collector.outputConstantLists.forEach(_registerConstants);
     collector.outputStaticNonFinalFieldLists.forEach(_registry.registerMembers);
@@ skipping 60 matching lines @@
     List<js.TokenFinalizer> finalizers = [_task.metadataCollector];
     if (_namer is js.TokenFinalizer) {
       var namingFinalizer = _namer;
       finalizers.add(namingFinalizer as js.TokenFinalizer);
     }
 
     return new Program(fragments, holders, _buildLoadMap(), _symbolsMap,
         _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>>{};
     _deferredLoadTask.hunksToLoad
         .forEach((String loadId, List<OutputUnit> outputUnits) {
       loadMap[loadId] = outputUnits
           .map((OutputUnit unit) => _outputs[unit])
           .toList(growable: false);
     });
     return loadMap;
@@ skipping 291 matching lines @@
         .toList(growable: false);
 
     bool visitStatics = true;
     List<Field> staticFieldsForReflection =
         _buildFields(library, visitStatics: visitStatics);
 
     return new Library(
         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);
     if (_nativeData.isJsInteropClass(element)) {
       // TODO(jacobr): check whether the class has any active static fields
       // if it does not we can suppress it completely.
       onlyForRti = true;
     }
     bool isClosureBaseClass = element == _commonElements.closureClass;
 
@@ skipping 148 matching lines @@
           staticFieldsForReflection,
           callStubs,
           noSuchMethodStubs,
           checkedSetters,
           isChecks,
           typeTests.functionTypeIndex,
           isDirectlyInstantiated: isInstantiated,
           hasRtiField: hasRtiField,
           onlyForRti: onlyForRti,
           isNative: _nativeData.isNativeClass(element),
-          isClosureBaseClass: isClosureBaseClass);
+          isClosureBaseClass: isClosureBaseClass,
+          isSoftDeferred: _isSoftDeferred(element));
     }
     _classes[element] = result;
     return result;
   }
 
   bool _methodNeedsStubs(FunctionElement method) {
     return !method.functionSignature.optionalParameters.isEmpty;
   }
 
   bool _methodCanBeReflected(MethodElement method) {
@@ skipping 336 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }