Add support for profile-based startup optimizations.

pkg/compiler/lib/src/js_emitter/startup_emitter/fragment_emitter.dart

 // Copyright (c) 2015, 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.js_emitter.startup_emitter.model_emitter;
 
 /// The name of the property that stores the tear-off getter on a static
 /// function.
 ///
 /// This property is only used when isolates are used.
@@ skipping 279 matching lines @@
 // Every deferred hunk (i.e. fragment) is a function that we can invoke to
 // initialize it. At this moment it contributes its data to the main hunk.
 function initializeDeferredHunk(hunk) {
   // Update the typesOffset for the next deferred library.
   typesOffset = #embeddedTypes.length;
 
   // TODO(floitsch): extend natives.
   hunk(inherit, mixin, lazy, makeConstList, convertToFastObject, installTearOff,
        setFunctionNamesIfNecessary, updateHolder, updateTypes,
        setOrUpdateInterceptorsByTag, setOrUpdateLeafTags,
-       #embeddedGlobalsObject, #holdersList, #staticState);
+       #embeddedGlobalsObject, holders, #staticState);
 }
 
 // Returns the global with the given [name].
 function getGlobalFromName(name) {
   // TODO(floitsch): we are running through all holders. Since negative
   // lookups are expensive we might need to improve this.
   // Relies on the fact that all names are unique across all holders.
   for (var i = 0; i < holders.length; i++) {
     // The constant holder reuses the same names. Therefore we must skip it.
     if (holders[i] == #constantHolderReference) continue;
     // Relies on the fact that all variables are unique.
     if (holders[i][name]) return holders[i][name];
   }
 }
 
+if (#hasSoftDeferredClasses) {
+  // Loads the soft-deferred classes and initializes them.
+  // Updates the prototype of the given object.
+  function softDef(o) {
+    softDef = function(o) {};  // Replace ourselves.
+    #deferredGlobal[#softId](
+        holders, #embeddedGlobalsObject, #staticState, inherit, mixin,
+        installTearOff);
+    o.__proto__ = o.constructor.prototype;

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

This will make Firefox angry.

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

Yes. I added a comment.

+  }
+}
+
+if (#isTrackingAllocations) {
+  var allocations = #deferredGlobal['allocations'] = {};
+}
+
 // Creates the holders.
 #holders;
 
 // If the name is not set on the functions, do it now.
-setFunctionNamesIfNecessary(#holdersList);
+setFunctionNamesIfNecessary(holders);
 
 // TODO(floitsch): we should build this object as a literal.
 var #staticStateDeclaration = {};
 
 // Sets the prototypes of classes.
 #prototypes;
 // Sets aliases of methods (on the prototypes of classes).
 #aliases;
 // Installs the tear-offs of functions.
 #tearOffs;
@@ skipping 91 matching lines @@
 #staticNonFinalFields;
 // Creates lazy getters for statics that must run initializers on first access.
 #lazyStatics;
 
 updateTypes(#types);
 
 // Native-support uses setOrUpdateInterceptorsByTag and setOrUpdateLeafTags.
 #nativeSupport;
 }''';
 
+/// Soft-deferred fragments are built similarly to the main fragment.
+///
+/// However, they don't contribute anything to global namespace, but just
+/// initialize existing classes. For example, they update the inheritance
+/// hierarchy, and add methods the prototypes.
+const String softDeferredBoilerplate = '''
+#deferredGlobal[#softId] =
+    function(holdersList, #embeddedGlobalsObject, #staticState, inherit, mixin,
+    installTearOff) {
+
+// Installs the holders as local variables.
+#installHoldersAsLocals;
+// Sets the prototypes of the new classes.
+#prototypes;
+// Sets aliases of methods (on the prototypes of classes).
+#aliases;
+// Installs the tear-offs of functions.
+#tearOffs;
+// Builds the inheritance structure.
+#inheritance;
+}''';
+
 /**
  * This class builds a JavaScript tree for a given fragment.
  *
  * A fragment is generally written into a separate file so that it can be
  * loaded dynamically when a deferred library is loaded.
  *
  * This class is stateless and can be reused for different fragments.
  */
 class FragmentEmitter {
   final Compiler compiler;
@@ skipping 15 matching lines @@
     return js.js('#.#', [cls.holder.name, cls.name]);
   }
 
   js.Statement emitMainFragment(Program program,
       Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     MainFragment fragment = program.fragments.first;
 
     Iterable<Holder> nonStaticStateHolders =
         program.holders.where((Holder holder) => !holder.isStaticStateHolder);
 
-    return js.js.statement(mainBoilerplate, {
-      'directAccessTestExpression': js.js(directAccessTestExpression),
-      'typeNameProperty': js.string(ModelEmitter.typeNameProperty),
-      'cyclicThrow': backend.emitter
-          .staticFunctionAccess(compiler.commonElements.cyclicThrowHelper),
-      'operatorIsPrefix': js.string(namer.operatorIsPrefix),
-      'tearOffCode': new js.Block(buildTearOffCode(compiler.options,
-          backend.emitter.emitter, backend.namer, compiler.commonElements)),
-      'embeddedTypes': generateEmbeddedGlobalAccess(TYPES),
-      'embeddedInterceptorTags':
-          generateEmbeddedGlobalAccess(INTERCEPTORS_BY_TAG),
-      'embeddedLeafTags': generateEmbeddedGlobalAccess(LEAF_TAGS),
-      'embeddedGlobalsObject': js.js("init"),
-      'holdersList': new js.ArrayInitializer(nonStaticStateHolders
-          .map((holder) => js.js("#", holder.name))
-          .toList(growable: false)),
-      'staticStateDeclaration': new js.VariableDeclaration(
-          namer.staticStateHolder,
-          allowRename: false),
-      'staticState': js.js('#', namer.staticStateHolder),
-      'constantHolderReference': buildConstantHolderReference(program),
-      'holders': emitHolders(program.holders, fragment),
-      'callName': js.string(namer.callNameField),
-      'stubName': js.string(namer.stubNameField),
-      'argumentCount': js.string(namer.requiredParameterField),
-      'defaultArgumentValues': js.string(namer.defaultValuesField),
-      'prototypes': emitPrototypes(fragment),
-      'inheritance': emitInheritance(fragment),
-      'aliases': emitInstanceMethodAliases(fragment),
-      'tearOffs': emitInstallTearOffs(fragment),
-      'constants': emitConstants(fragment),
-      'staticNonFinalFields': emitStaticNonFinalFields(fragment),
-      'lazyStatics': emitLazilyInitializedStatics(fragment),
-      'embeddedGlobals': emitEmbeddedGlobals(program, deferredLoadHashes),
-      'nativeSupport': program.needsNativeSupport
-          ? emitNativeSupport(fragment)
+    String softDeferredId = "softDeferred${new Random().nextInt(0x7FFFFFFF)}";
+
+    return new js.Block([
+      program.hasSoftDeferredClasses
+          ? js.js.statement(softDeferredBoilerplate, {
+              'deferredGlobal': ModelEmitter.deferredInitializersGlobal,
+              'softId': js.string(softDeferredId),
+              // TODO(floitsch): don't just reference 'init'.
+              'embeddedGlobalsObject': new js.Parameter('init'),
+              'staticState': new js.Parameter(namer.staticStateHolder),
+              'installHoldersAsLocals':
+                  emitInstallHoldersAsLocals(nonStaticStateHolders),
+              'prototypes': emitPrototypes(fragment, softDeferred: true),
+              'aliases':
+                  emitInstanceMethodAliases(fragment, softDeferred: true),
+              'tearOffs': emitInstallTearOffs(fragment, softDeferred: true),
+              'inheritance': emitInheritance(fragment, softDeferred: true),
+            })
           : new js.EmptyStatement(),
-      'jsInteropSupport': backend.jsInteropAnalysis.enabledJsInterop
-          ? backend.jsInteropAnalysis.buildJsInteropBootstrap()
-          : new js.EmptyStatement(),
-      'invokeMain': fragment.invokeMain,
-    });
+      js.js.statement(mainBoilerplate, {
+        'directAccessTestExpression': js.js(directAccessTestExpression),
+        'typeNameProperty': js.string(ModelEmitter.typeNameProperty),
+        'cyclicThrow': backend.emitter
+            .staticFunctionAccess(compiler.commonElements.cyclicThrowHelper),
+        'operatorIsPrefix': js.string(namer.operatorIsPrefix),
+        'tearOffCode': new js.Block(buildTearOffCode(compiler.options,
+            backend.emitter.emitter, backend.namer, compiler.commonElements)),
+        'embeddedTypes': generateEmbeddedGlobalAccess(TYPES),
+        'embeddedInterceptorTags':
+            generateEmbeddedGlobalAccess(INTERCEPTORS_BY_TAG),
+        'embeddedLeafTags': generateEmbeddedGlobalAccess(LEAF_TAGS),
+        'embeddedGlobalsObject': js.js("init"),
+        'staticStateDeclaration': new js.VariableDeclaration(
+            namer.staticStateHolder,
+            allowRename: false),
+        'staticState': js.js('#', namer.staticStateHolder),
+        'constantHolderReference': buildConstantHolderReference(program),
+        'holders': emitHolders(program.holders, fragment),
+        'callName': js.string(namer.callNameField),
+        'stubName': js.string(namer.stubNameField),
+        'argumentCount': js.string(namer.requiredParameterField),
+        'defaultArgumentValues': js.string(namer.defaultValuesField),
+        'deferredGlobal': ModelEmitter.deferredInitializersGlobal,
+        'hasSoftDeferredClasses': program.hasSoftDeferredClasses,
+        'softId': js.string(softDeferredId),
+        'isTrackingAllocations': compiler.options.trackAllocations,
+        'prototypes': emitPrototypes(fragment),
+        'inheritance': emitInheritance(fragment),
+        'aliases': emitInstanceMethodAliases(fragment),
+        'tearOffs': emitInstallTearOffs(fragment),
+        'constants': emitConstants(fragment),
+        'staticNonFinalFields': emitStaticNonFinalFields(fragment),
+        'lazyStatics': emitLazilyInitializedStatics(fragment),
+        'embeddedGlobals': emitEmbeddedGlobals(program, deferredLoadHashes),
+        'nativeSupport': program.needsNativeSupport
+            ? emitNativeSupport(fragment)
+            : new js.EmptyStatement(),
+        'jsInteropSupport': backend.jsInteropAnalysis.enabledJsInterop
+            ? backend.jsInteropAnalysis.buildJsInteropBootstrap()
+            : new js.EmptyStatement(),
+        'invokeMain': fragment.invokeMain,
+      }),
+    ]);
+  }
+
+  js.Statement emitInstallHoldersAsLocals(Iterable<Holder> holders) {
+    List<js.Statement> holderInits = <js.Statement>[];
+    int counter = 0;
+    for (Holder holder in holders) {
+      holderInits.add(new js.ExpressionStatement(new js.VariableInitialization(
+          new js.VariableDeclaration(holder.name, allowRename: false),
+          js.js("holdersList[#]", js.number(counter++)))));
+    }
+    return new js.Block(holderInits);
   }
 
   js.Expression emitDeferredFragment(DeferredFragment fragment,
       js.Expression deferredTypes, List<Holder> holders) {
     List<Holder> nonStaticStateHolders = holders
         .where((Holder holder) => !holder.isStaticStateHolder)
         .toList(growable: false);
 
     List<js.Statement> updateHolderAssignments = <js.Statement>[];
     for (int i = 0; i < nonStaticStateHolders.length; i++) {
@@ skipping 131 matching lines @@
     // If the class is not directly instantiated we only need it for inheritance
     // or RTI. In either case we don't need its fields.
     if (cls.isNative || !cls.isDirectlyInstantiated) {
       return js.js('function #() { }', name);
     }
 
     var statements = <js.Statement>[];
     var parameters = <js.Name>[];
     var thisRef;
 
+    if (cls.isSoftDeferred) {
+      statements.add(js.js.statement('softDef(this)'));
+    } else if (compiler.options.trackAllocations) {
+      String qualifiedName =
+          "${cls.element.library.canonicalUri}:${cls.element.name}";
+      statements.add(js.js.statement('allocations["$qualifiedName"] = true'));
+    }
+
     // If there are many references to `this`, cache it in a local.
     if (cls.fields.length + (cls.hasRtiField ? 1 : 0) >= 4) {
       // TODO(29455): Fix js_ast printer and minifier to avoid conflicts between
       // js.Name and string-named variables, then use '_' in the js template
       // text.
 
       // We pick '_' in minified mode because no field minifies to '_'. This
       // avoids a conflict with one of the parameters which are named the same
       // as the fields.  Unminified, a field might have the name '_', so we pick
       // '$_', which is an impossible member name since we escape '$'s in names.
@@ skipping 20 matching lines @@
           .statement('#.# = #', [thisRef, namer.rtiFieldJsName, paramName]));
     }
 
     return js.js('function #(#) { # }', [name, parameters, statements]);
   }
 
   /// Emits the prototype-section of the fragment.
   ///
   /// This section updates the prototype-property of all constructors in the
   /// global holders.
-  js.Statement emitPrototypes(Fragment fragment) {
+  js.Statement emitPrototypes(Fragment fragment, {softDeferred = false}) {
     List<js.Statement> assignments = fragment.libraries
         .expand((Library library) => library.classes)
+        .where((Class cls) => cls.isSoftDeferred == softDeferred)
         .map((Class cls) {
       var proto = js.js.statement(
           '#.prototype = #;', [classReference(cls), emitPrototype(cls)]);
       ClassElement element = cls.element;
       compiler.dumpInfoTask.registerElementAst(element, proto);
       compiler.dumpInfoTask.registerElementAst(element.library, proto);
       return proto;
     }).toList(growable: false);
 
     return new js.Block(assignments);
@@ skipping 144 matching lines @@
       }
     }
 
     return properties;
   }
 
   /// Emits the inheritance block of the fragment.
   ///
   /// In this section prototype chains are updated and mixin functions are
   /// copied.
-  js.Statement emitInheritance(Fragment fragment) {
+  js.Statement emitInheritance(Fragment fragment, {bool softDeferred = false}) {
     List<js.Statement> inheritCalls = <js.Statement>[];
     List<js.Statement> mixinCalls = <js.Statement>[];
 
     Set<Class> classesInFragment = new Set<Class>();
     for (Library library in fragment.libraries) {
-      classesInFragment.addAll(library.classes);
+      classesInFragment.addAll(library.classes
+          .where(((Class cls) => cls.isSoftDeferred == softDeferred)));
     }
 
     Map<Class, List<Class>> subclasses = <Class, List<Class>>{};
     Set<Class> seen = new Set<Class>();
 
     void collect(cls) {
       if (cls == null || seen.contains(cls)) return;
 
       Class superclass = cls.superclass;
       if (classesInFragment.contains(superclass)) {
         collect(superclass);
       }
 
       subclasses.putIfAbsent(superclass, () => <Class>[]).add(cls);
 
       seen.add(cls);
     }
 
     for (Library library in fragment.libraries) {
       for (Class cls in library.classes) {
+        if (cls.isSoftDeferred != softDeferred) continue;
         collect(cls);
 
         if (cls.isMixinApplication) {
           MixinApplication mixin = cls;
           mixinCalls.add(js.js.statement('mixin(#, #)',
               [classReference(cls), classReference(mixin.mixinClass)]));
         }
       }
     }
 
@@ skipping 26 matching lines @@
     }
 
     return wrapPhase(
         'inheritance', js.js.statement('{#; #;}', [inheritCalls, mixinCalls]));
   }
 
   /// Emits the setup of method aliases.
   ///
   /// This step consists of simply copying JavaScript functions to their
   /// aliased names so they point to the same function.
-  js.Statement emitInstanceMethodAliases(Fragment fragment) {
+  js.Statement emitInstanceMethodAliases(Fragment fragment,
+      {bool softDeferred = false}) {
     List<js.Statement> assignments = <js.Statement>[];
 
     for (Library library in fragment.libraries) {
       for (Class cls in library.classes) {
+        if (cls.isSoftDeferred != softDeferred) continue;
         for (InstanceMethod method in cls.methods) {
           if (method.aliasName != null) {
             assignments.add(js.js.statement('#.prototype.# = #.prototype.#', [
               classReference(cls),
               js.quoteName(method.aliasName),
               classReference(cls),
               js.quoteName(method.name)
             ]));
           }
         }
@@ skipping 104 matching lines @@
   }
 
   /// Wraps the statement in a named function to that it shows up as a unit in
   /// profiles.
   // TODO(sra): Should this be conditional?
   js.Statement wrapPhase(String name, js.Statement statement) {
     return js.js.statement('(function #(){#})();', [name, statement]);
   }
 
   /// Emits the section that installs tear-off getters.
-  js.Statement emitInstallTearOffs(Fragment fragment) {
+  js.Statement emitInstallTearOffs(Fragment fragment,
+      {bool softDeferred = false}) {
     List<js.Statement> inits = <js.Statement>[];
     js.Expression temp;
 
     for (Library library in fragment.libraries) {
       for (StaticMethod method in library.statics) {
         // TODO(floitsch): can there be anything else than a StaticDartMethod?
         if (method is StaticDartMethod) {
           if (method.needsTearOff) {
             Holder holder = method.holder;
             inits.add(
                 emitInstallTearOff(new js.VariableUse(holder.name), method));
           }
         }
       }
       for (Class cls in library.classes) {
+        if (cls.isSoftDeferred != softDeferred) continue;
         var methods = cls.methods.where((m) => m.needsTearOff).toList();
         js.Expression container = js.js("#.prototype", classReference(cls));
         js.Expression reference = container;
         if (methods.length > 1) {
           if (temp == null) {
             inits.add(js.js.statement('var _;'));
             temp = js.js('_');
           }
           // First call uses assignment to temp to cache the container.
           reference = js.js('# = #', [temp, container]);
@@ skipping 371 matching lines @@
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
     statements.add(
         js.js.statement("setOrUpdateLeafTags(#);", js.objectLiteral(leafTags)));
     statements.addAll(subclassAssignments);
 
     return wrapPhase('nativeSupport', new js.Block(statements));
   }
 }