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 43 matching lines @@
         computeMixinClass,
         Emitter,
         InterceptorStubGenerator,
         MainCallStubGenerator,
         ParameterStubGenerator,
         RuntimeTypeGenerator,
         TypeTestProperties;
 import '../model.dart';
 import '../sorter.dart';
 
+part 'allocated_classes_profile.dart';
 part 'collector.dart';
 part 'field_visitor.dart';
 part 'registry.dart';
 
+const allocatedClassesPath =
+    const String.fromEnvironment("dart2js.allocatedClasses");

[sra1, 2017/05/02 20:40:12]

Can you make this a command-line option?

[floitsch, 2017/05/06 19:25:43]

done.

+
 /// 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 ElementEnvironment _elementEnvironment;
   final CommonElements _commonElements;
   final DartTypes _types;
   final DeferredLoadTask _deferredLoadTask;
   final ClosureTask _closureToClassMapper;
   final CodegenWorldBuilder _worldBuilder;
@@ skipping 175 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();
   }
 
   /// Builds a map from loadId to outputs-to-load.
   Map<String, List<Fragment>> _buildLoadMap() {
     Map<String, List<Fragment>> loadMap = <String, List<Fragment>>{};
     _deferredLoadTask.hunksToLoad
@@ skipping 297 matching lines @@
         .toList(growable: false);
 
     bool visitStatics = true;
     List<Field> staticFieldsForReflection =
         _buildFields(library, visitStatics: visitStatics);
 
     return new Library(
         library, uri, statics, classes, staticFieldsForReflection);
   }
 
+  Set<ClassElement> _notSoftDeferred;
+
+  bool _isSoftDeferred(ClassElement element) {
+    if (_notSoftDeferred == null &&
+        (allocatedClassesPath != null || allocatedClassesJson != null)) {

[sra1, 2017/05/02 20:40:13]

Does this execute once?
Perhaps make it more clear by putting some code in a helper init method.

[floitsch, 2017/05/06 19:25:43]

done.

+      var blackList = [
+        'dart:_interceptors',
+        'dart:html',
+        'dart:typed_data_implementation',
+        'dart:_native_typed_data'
+      ].toSet();
+      String data = allocatedClassesPath != null
+          ? new File(allocatedClassesPath).readAsStringSync()
+          : allocatedClassesJson;
+      Set<String> allocatedClassesKeys = JSON.decode(data).keys.toSet();
+      Set<ClassElement> allocatedClasses = new Set<ClassElement>();
+
+      void collect(ClassElement element) {
+        allocatedClasses.add(element);
+        if (element.isMixinApplication) {
+          collect(computeMixinClass(element));
+        }
+        if (element.superclass != null) {
+          collect(element.superclass);
+        }
+      }
+
+      collector.outputClassLists.forEach((_, List<ClassElement> elements) {
+        for (ClassElement element in elements) {
+          var key = "${element.library.canonicalUri}:${element.name}";
+          if (allocatedClassesKeys.contains(key) ||
+              _nativeData.isJsInteropClass(element) ||
+              blackList.contains(element.library.canonicalUri.toString())) {
+            collect(element);
+          }
+        }
+      });
+      _notSoftDeferred = allocatedClasses;
+    }
+    if (_notSoftDeferred == null) return false;
+    return !_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);
   }
 }