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);
+    if (o != null) {
+      // TODO(29574): should we do something different for Firefox?
+      // If we recommend that the program triggers the load by itself before
+      // classes are needed, then this line should rarely be hit.
+      // Also, it is only hit at most once (per soft-deferred chunk).
+      o.__proto__ = o.constructor.prototype;
+    }
+  }
+}
+
+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, {
+    String softDeferredId = "softDeferred${new Random().nextInt(0x7FFFFFFF)}";
+
+    js.Statement mainCode = 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),
+      'deferredGlobal': ModelEmitter.deferredInitializersGlobal,
+      'hasSoftDeferredClasses': program.hasSoftDeferredClasses,
+      'softId': js.string(softDeferredId),
+      'isTrackingAllocations': compiler.options.experimentalTrackAllocations,
       '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.nativeBasicData.isJsInteropUsed
           ? backend.jsInteropAnalysis.buildJsInteropBootstrap()
           : new js.EmptyStatement(),
       'invokeMain': fragment.invokeMain,
     });
+    if (program.hasSoftDeferredClasses) {
+      return new js.Block([
+        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),
+        }),
+        mainCode
+      ]);
+    }
+    return mainCode;
+  }
+
+  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.experimentalTrackAllocations) {
+      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));
   }
 }