This patch adds a better code-splitting strategy for implementing
GWT.runAsync. Instead of lumping all non-exclusive code atoms into
the initial download, the initial download only includes the initially
needed code. Additionally, a custom download is created for each
split point that can be used if that split point is the first one to
be reached. After the first download, a "leftovers" fragment is
downloaded in the background. So, each call to runAsync causes
three fragments to be created: the exclusive fragment as before,
a new custom download, and a "leftovers" fragment.
Review by: bobv (TBR)
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@3959 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
index 15d18c1..0ab97c9 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
@@ -211,7 +211,7 @@
// (10.5) Split up the program into fragments
if (options.isAggressivelyOptimize()) {
- CodeSplitter.exec(jprogram, jsProgram, postStringInterningMap);
+ CodeSplitter.exec(logger, jprogram, jsProgram, postStringInterningMap);
}
// (11) Perform any post-obfuscation normalizations.
diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JVariable.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JVariable.java
index a485615..b37e953 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/JVariable.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JVariable.java
@@ -43,6 +43,10 @@
}
return null;
}
+
+ public JDeclarationStatement getDeclarationStatement() {
+ return declStmt;
+ }
public JExpression getInitializer() {
if (declStmt != null) {
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java b/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java
index 725804b..63cd8ea 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java
@@ -15,6 +15,7 @@
*/
package com.google.gwt.dev.jjs.impl;
+import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.dev.jjs.ast.Context;
import com.google.gwt.dev.jjs.ast.JClassLiteral;
import com.google.gwt.dev.jjs.ast.JExpression;
@@ -25,6 +26,7 @@
import com.google.gwt.dev.jjs.ast.JReferenceType;
import com.google.gwt.dev.jjs.ast.JStringLiteral;
import com.google.gwt.dev.jjs.ast.JVisitor;
+import com.google.gwt.dev.jjs.impl.FragmentExtractor.CfaLivenessPredicate;
import com.google.gwt.dev.jjs.impl.FragmentExtractor.LivenessPredicate;
import com.google.gwt.dev.jjs.impl.FragmentExtractor.NothingAlivePredicate;
import com.google.gwt.dev.jjs.impl.FragmentExtractor.StatementLogger;
@@ -59,12 +61,21 @@
* The precise way the program is fragmented is an implementation detail that is
* subject to change. Whenever the fragment strategy changes,
* <code>AsyncFragmentLoader</code> must be updated in tandem. That said, the
- * current fragmentation strategy is to create one fragment for each call to
- * <code>runAsync()</code>. Each such fragment holds the code that is
- * exclusively needed by that particular call to <code>runAsync()</code>. Any
- * code needed by two or more calls to <code>runAsync()</code> is placed in
- * the initial fragment.
+ * current fragmentation strategy is to create an initial fragment and then
+ * three more fragments for each split point. For each split point, there is:
* </p>
+ *
+ * <ul>
+ * <li>a secondary base fragment, which is downloaded if this split point is
+ * the first one reached. It contains enough code to continue running as soon as
+ * it downloads.
+ * <li>an exclusively live fragment, which is downloaded if this split point is
+ * reached but is not the first one. It includes only that code that is
+ * exclusively needed by this split point.
+ * <li>a leftovers fragment, which includes all code that is in none of: the
+ * initial download, any exclusive fragment, or the secondary base fragment for
+ * this split point.
+ * </ul>
*/
public class CodeSplitter {
/**
@@ -92,7 +103,8 @@
}
/**
- * A map from program atoms to the fragment they should be placed in.
+ * A map from program atoms to the fragment they should be placed in. An entry
+ * of 0 means it did not go into any fragment in particular.
*/
private static class FragmentMap {
public Map<JField, Integer> fields = new HashMap<JField, Integer>();
@@ -148,6 +160,41 @@
}
/**
+ * A liveness predicate that checks two separate underlying predicates.
+ */
+ private static class UnionLivenessPredicate implements LivenessPredicate {
+ private final LivenessPredicate pred1;
+ private final LivenessPredicate pred2;
+
+ public UnionLivenessPredicate(LivenessPredicate pred1,
+ LivenessPredicate pred2) {
+ this.pred1 = pred1;
+ this.pred2 = pred2;
+ }
+
+ public boolean isLive(JField field) {
+ return pred1.isLive(field) || pred2.isLive(field);
+ }
+
+ public boolean isLive(JMethod method) {
+ return pred1.isLive(method) || pred2.isLive(method);
+ }
+
+ public boolean isLive(JReferenceType type) {
+ return pred1.isLive(type) || pred2.isLive(type);
+ }
+
+ public boolean isLive(String literal) {
+ return pred1.isLive(literal) || pred2.isLive(literal);
+ }
+
+ public boolean miscellaneousStatementsAreLive() {
+ return pred1.miscellaneousStatementsAreLive()
+ || pred2.miscellaneousStatementsAreLive();
+ }
+ }
+
+ /**
* A Java property that causes the fragment map to be logged.
*
* TODO(spoon) save the logging data to an auxiliary compiler output and, if
@@ -155,9 +202,14 @@
*/
private static String PROP_LOG_FRAGMENT_MAP = "gwt.jjs.logFragmentMap";
- public static void exec(JProgram jprogram, JsProgram jsprogram,
- JavaToJavaScriptMap map) {
- new CodeSplitter(jprogram, jsprogram, map).execImpl();
+ public static void exec(TreeLogger logger, JProgram jprogram,
+ JsProgram jsprogram, JavaToJavaScriptMap map) {
+ if (jprogram.entryMethods.size() == 1) {
+ // Don't do anything if there is no call to runAsync
+ return;
+ }
+
+ new CodeSplitter(logger, jprogram, jsprogram, map).execImpl();
}
private static <T> int getOrZero(Map<T, Integer> map, T key) {
@@ -182,20 +234,59 @@
}
private final Map<JField, JClassLiteral> fieldToLiteralOfClass;
+
+ private final FragmentExtractor fragmentExtractor;
+ /**
+ * Code that is initially live when the program first downloads.
+ */
+ private final ControlFlowAnalyzer initiallyLive;
private JProgram jprogram;
private JsProgram jsprogram;
+ private final TreeLogger logger;
private final boolean logging;
private JavaToJavaScriptMap map;
private final int numEntries;
- private CodeSplitter(JProgram jprogram, JsProgram jsprogram,
- JavaToJavaScriptMap map) {
+ private CodeSplitter(TreeLogger logger, JProgram jprogram,
+ JsProgram jsprogram, JavaToJavaScriptMap map) {
+ this.logger = logger.branch(TreeLogger.TRACE,
+ "Splitting JavaScript for incremental download");
this.jprogram = jprogram;
this.jsprogram = jsprogram;
this.map = map;
+
numEntries = jprogram.entryMethods.size();
logging = Boolean.getBoolean(PROP_LOG_FRAGMENT_MAP);
fieldToLiteralOfClass = FragmentExtractor.buildFieldToClassLiteralMap(jprogram);
+ fragmentExtractor = new FragmentExtractor(jprogram, jsprogram, map);
+
+ initiallyLive = new ControlFlowAnalyzer(jprogram);
+ traverseEntry(initiallyLive, 0);
+ initiallyLive.finishTraversal();
+ }
+
+ /**
+ * Create a new fragment and add it to the list.
+ *
+ * @param alreadyLoaded The code that should be assumed to have already been
+ * loaded
+ * @param liveNow The code that needs to be live once this fragment loads
+ * @param statsToAppend Additional statements to append to the end of the new
+ * fragment
+ * @param fragmentStats The list of fragments to append to
+ */
+ private void addFragment(LivenessPredicate alreadyLoaded,
+ LivenessPredicate liveNow, List<JsStatement> statsToAppend,
+ List<List<JsStatement>> fragmentStats) {
+ if (logging) {
+ System.out.println();
+ System.out.println("==== Fragment " + fragmentStats.size() + " ====");
+ fragmentExtractor.setStatementLogger(new EchoStatementLogger());
+ }
+ List<JsStatement> stats = fragmentExtractor.extractStatements(liveNow,
+ alreadyLoaded);
+ stats.addAll(statsToAppend);
+ fragmentStats.add(stats);
}
/**
@@ -203,17 +294,15 @@
* traces every other split point.
*/
private List<ControlFlowAnalyzer> computeAllButOneCfas() {
- // Reusing initiallyLive for each entry gives a significant speedup
- ControlFlowAnalyzer initiallyLive = new ControlFlowAnalyzer(jprogram);
- traverseEntry(initiallyLive, 0);
- initiallyLive.finishTraversal();
-
List<ControlFlowAnalyzer> allButOnes = new ArrayList<ControlFlowAnalyzer>(
numEntries - 1);
for (int entry = 1; entry < numEntries; entry++) {
ControlFlowAnalyzer cfa = new ControlFlowAnalyzer(initiallyLive);
traverseAllButEntry(cfa, entry);
+ // Traverse leftoversFragmentHasLoaded, because it should not
+ // go into any of the exclusive fragments.
+ cfa.traverseFromLeftoversFragmentHasLoaded();
cfa.finishTraversal();
allButOnes.add(cfa);
}
@@ -234,55 +323,66 @@
}
private void execImpl() {
- if (numEntries == 1) {
- // Don't do anything if there is no call to runAsync
- return;
- }
-
PerfLogger.start("CodeSplitter");
- // Map code to the fragments
FragmentMap fragmentMap = mapFragments();
List<List<JsStatement>> fragmentStats = new ArrayList<List<JsStatement>>(
- numEntries);
+ 3 * numEntries - 2);
- // Save the extractor for reuse
- FragmentExtractor fragmentExtractor = new FragmentExtractor(jprogram,
- jsprogram, map);
-
- // Extract the code for each fragment, according to fragmentMap
- for (int i = 0; i < numEntries; i++) {
- LivenessPredicate pred = new FragmentMapLivenessPredicate(fragmentMap, i);
-
- LivenessPredicate alreadyLoaded;
- if (i == 0) {
- alreadyLoaded = new NothingAlivePredicate();
- } else {
- alreadyLoaded = new FragmentMapLivenessPredicate(fragmentMap, 0);
- }
-
- if (logging) {
- System.out.println();
- System.out.println("==== Fragment " + i + " ====");
- fragmentExtractor.setStatementLogger(new EchoStatementLogger());
- }
-
- List<JsStatement> entryStats = fragmentExtractor.extractStatements(pred,
- alreadyLoaded);
-
- if (i > 0) {
- /*
- * The fragment mapper drops all calls to entry methods. Add them back.
- */
- fragmentExtractor.addCallsToEntryMethods(i, entryStats);
- }
-
- fragmentStats.add(entryStats);
+ {
+ /*
+ * Compute the base fragment. It includes everything that is live when the
+ * program starts.
+ */
+ LivenessPredicate alreadyLoaded = new NothingAlivePredicate();
+ LivenessPredicate liveNow = new CfaLivenessPredicate(initiallyLive);
+ List<JsStatement> noStats = new ArrayList<JsStatement>();
+ addFragment(alreadyLoaded, liveNow, noStats, fragmentStats);
}
- // Install the new statements in the program fragments
- jsprogram.setFragmentCount(numEntries);
+ /*
+ * Compute the exclusively live fragments. Each includes everything
+ * exclusively live after entry point i.
+ */
+ for (int i = 1; i < numEntries; i++) {
+ LivenessPredicate alreadyLoaded = new FragmentMapLivenessPredicate(
+ fragmentMap, 0);
+ LivenessPredicate liveNow = new FragmentMapLivenessPredicate(fragmentMap,
+ i);
+ List<JsStatement> statsToAppend = fragmentExtractor.createCallsToEntryMethods(i);
+ addFragment(alreadyLoaded, liveNow, statsToAppend, fragmentStats);
+ }
+
+ /*
+ * Add secondary base fragments and their associated leftover fragments.
+ */
+ for (int base = 1; base < numEntries; base++) {
+ ControlFlowAnalyzer baseCfa = new ControlFlowAnalyzer(initiallyLive);
+ traverseEntry(baseCfa, base);
+ baseCfa.finishTraversal();
+ LivenessPredicate baseLive = new CfaLivenessPredicate(baseCfa);
+
+ // secondary base
+ List<JsStatement> baseStatsToAppend = fragmentExtractor.createCallsToEntryMethods(base);
+ addFragment(new CfaLivenessPredicate(initiallyLive), baseLive,
+ baseStatsToAppend, fragmentStats);
+
+ // leftovers
+ LivenessPredicate globalLeftoversLive = new FragmentMapLivenessPredicate(
+ fragmentMap, 0);
+ LivenessPredicate associatedExclusives = new FragmentMapLivenessPredicate(
+ fragmentMap, base);
+ // Be sure to add in anything in the exclusives for base that is
+ // not in its secondary base.
+ LivenessPredicate leftoversLive = new UnionLivenessPredicate(
+ globalLeftoversLive, associatedExclusives);
+ List<JsStatement> statsToAppend = fragmentExtractor.createCallToLeftoversFragmentHasLoaded();
+ addFragment(baseLive, leftoversLive, statsToAppend, fragmentStats);
+ }
+
+ // now install the new statements in the program fragments
+ jsprogram.setFragmentCount(fragmentStats.size());
for (int i = 0; i < fragmentStats.size(); i++) {
JsBlock fragBlock = jsprogram.getFragmentBlock(i);
fragBlock.getStatements().clear();
@@ -310,18 +410,26 @@
*/
private void fixUpLoadOrderDependenciesForClassLiterals(
FragmentMap fragmentMap) {
+ int numClassLitStrings = 0;
+ int numFixups = 0;
for (JField field : fragmentMap.fields.keySet()) {
JClassLiteral classLit = fieldToLiteralOfClass.get(field);
if (classLit != null) {
int classLitFrag = fragmentMap.fields.get(field);
for (String string : stringsIn(field.getInitializer())) {
+ numClassLitStrings++;
int stringFrag = getOrZero(fragmentMap.strings, string);
if (stringFrag != classLitFrag && stringFrag != 0) {
+ numFixups++;
fragmentMap.strings.put(string, 0);
}
}
}
}
+ logger.log(TreeLogger.DEBUG, "Fixed up load-order dependencies by moving "
+ + numFixups
+ + " strings in class literal constructors to fragment 0, out of "
+ + numClassLitStrings);
}
/**
@@ -329,6 +437,7 @@
* superclass.
*/
private void fixUpLoadOrderDependenciesForTypes(FragmentMap fragmentMap) {
+ int numFixups = 0;
Queue<JReferenceType> typesToCheck = new ArrayBlockingQueue<JReferenceType>(
jprogram.getDeclaredTypes().size());
typesToCheck.addAll(jprogram.getDeclaredTypes());
@@ -338,11 +447,15 @@
int typeFrag = getOrZero(fragmentMap.types, type);
int supertypeFrag = getOrZero(fragmentMap.types, type.extnds);
if (typeFrag != supertypeFrag && supertypeFrag != 0) {
+ numFixups++;
fragmentMap.types.put(type.extnds, 0);
typesToCheck.add(type.extnds);
}
}
}
+ logger.log(TreeLogger.DEBUG, "Fixed up load-order dependencies by moving "
+ + numFixups + " types to fragment 0, out of "
+ + jprogram.getDeclaredTypes().size());
}
/**
@@ -428,15 +541,15 @@
* <code>frag</code>. This does not call
* {@link ControlFlowAnalyzer#finishTraversal()}.
*/
- private void traverseEntry(ControlFlowAnalyzer cfa, int entry) {
- for (JMethod entryMethod : jprogram.entryMethods.get(entry)) {
+ private void traverseEntry(ControlFlowAnalyzer cfa, int splitPoint) {
+ for (JMethod entryMethod : jprogram.entryMethods.get(splitPoint)) {
cfa.traverseFrom(entryMethod);
}
- if (entry == 0) {
+ if (splitPoint == 0) {
/*
* Include class literal factories for simplicity. It is possible to move
* them out, if they are only needed by one fragment, but they are tiny,
- * so it does not look like it is worth the complexity in the compiler.
+ * so it does not seem worth the complexity in the compiler.
*/
cfa.traverseFromClassLiteralFactories();
}
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/ControlFlowAnalyzer.java b/dev/core/src/com/google/gwt/dev/jjs/impl/ControlFlowAnalyzer.java
index 8831aec..22ff39d 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/ControlFlowAnalyzer.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/ControlFlowAnalyzer.java
@@ -644,10 +644,6 @@
rescuer.rescue(method);
}
- public void traverseFromReferenceTo(JReferenceType type) {
- rescuer.rescue(type, true, false);
- }
-
/**
* Trace all code needed by class literal constructor expressions except for
* the string literals they include. At the time of writing, these would
@@ -658,8 +654,8 @@
@Override
public void endVisit(JStringLiteral stringLiteral, Context ctx) {
ctx.replaceMe(program.getLiteralString(
- stringLiteral.getSourceInfo().makeChild(ControlFlowAnalyzer.class, "remove string literals"),
- ""));
+ stringLiteral.getSourceInfo().makeChild(ControlFlowAnalyzer.class,
+ "remove string literals"), ""));
}
}
@@ -677,4 +673,14 @@
(new ClassLitTraverser()).accept(program);
}
+
+ public void traverseFromLeftoversFragmentHasLoaded() {
+ if (program.entryMethods.size() > 1) {
+ traverseFrom(program.getIndexedMethod("AsyncFragmentLoader.leftoversFragmentHasLoaded"));
+ }
+ }
+
+ public void traverseFromReferenceTo(JReferenceType type) {
+ rescuer.rescue(type, true, false);
+ }
}
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java b/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java
index 204e90f..3f9df05 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java
@@ -38,6 +38,7 @@
import com.google.gwt.dev.js.ast.JsVars.JsVar;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
@@ -185,16 +186,34 @@
/**
* Add direct calls to the entry methods of the specified entry number.
*/
- public void addCallsToEntryMethods(int entry, List<JsStatement> stats) {
- for (JMethod entryMethod : jprogram.entryMethods.get(entry)) {
+ public List<JsStatement> createCallsToEntryMethods(int splitPoint) {
+ List<JsStatement> callStats = new ArrayList<JsStatement>(
+ jprogram.entryMethods.size());
+ for (JMethod entryMethod : jprogram.entryMethods.get(splitPoint)) {
JsName name = map.nameForMethod(entryMethod);
assert name != null;
SourceInfo sourceInfo = jsprogram.getSourceInfo().makeChild(
- FragmentExtractor.class, "call to entry function " + entry);
+ FragmentExtractor.class, "call to entry function " + splitPoint);
JsInvocation call = new JsInvocation(sourceInfo);
call.setQualifier(name.makeRef(sourceInfo));
- stats.add(call.makeStmt());
+ callStats.add(call.makeStmt());
}
+ return callStats;
+ }
+
+ /**
+ * Create a call to
+ * {@link com.google.gwt.lang.AsyncFragmentLoader#leftoversFragmentHasLoaded()}.
+ */
+ public List<JsStatement> createCallToLeftoversFragmentHasLoaded() {
+ JMethod loadedMethod = jprogram.getIndexedMethod("AsyncFragmentLoader.leftoversFragmentHasLoaded");
+ JsName loadedMethodName = map.nameForMethod(loadedMethod);
+ SourceInfo sourceInfo = jsprogram.getSourceInfo().makeChild(
+ FragmentExtractor.class, "call to leftoversFragmentHasLoaded ");
+ JsInvocation call = new JsInvocation(sourceInfo);
+ call.setQualifier(loadedMethodName.makeRef(sourceInfo));
+ List<JsStatement> newStats = Collections.<JsStatement> singletonList(call.makeStmt());
+ return newStats;
}
/**
@@ -262,6 +281,13 @@
assert name != null;
entryMethodNames.add(name);
}
+
+ JMethod leftoverFragmentLoaded = jprogram.getIndexedMethod("AsyncFragmentLoader.leftoversFragmentHasLoaded");
+ if (leftoverFragmentLoaded != null) {
+ JsName name = map.nameForMethod(leftoverFragmentLoaded);
+ assert name != null;
+ entryMethodNames.add(name);
+ }
}
/**
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java
index 8486fbd..c06573a 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java
@@ -1020,14 +1020,26 @@
}
/*
- * Add calls to all split points other than the initial ones. That way, if
- * the code splitter does not run, the resulting code will still function.
+ * Add calls to all non-initial entry points. That way, if the code
+ * splitter does not run, the resulting code will still function.
+ * Likewise, add a call to
+ * AsyncFragmentLoader.leftoversFragmentHasLoaded().
*/
List<JsFunction> nonInitialEntries = Arrays.asList(entryFunctions).subList(
x.getEntryCount(0), entryFunctions.length);
+ if (!nonInitialEntries.isEmpty()) {
+ JMethod loadedMethod = program.getIndexedMethod("AsyncFragmentLoader.leftoversFragmentHasLoaded");
+ JsName loadedMethodName = names.get(loadedMethod);
+ SourceInfo sourceInfo = jsProgram.getSourceInfo().makeChild(
+ GenerateJavaScriptAST.class, "call to leftoversFragmentHasLoaded ");
+ JsInvocation call = new JsInvocation(sourceInfo);
+ call.setQualifier(loadedMethodName.makeRef(sourceInfo));
+ globalStmts.add(call.makeStmt());
+ }
for (JsFunction func : nonInitialEntries) {
if (func != null) {
- SourceInfo sourceInfo = jsProgram.getSourceInfo().makeChild(GenerateJavaScriptAST.class,
+ SourceInfo sourceInfo = jsProgram.getSourceInfo().makeChild(
+ GenerateJavaScriptAST.class,
"call to entry non-initial entry function");
JsInvocation call = new JsInvocation(sourceInfo);
call.setQualifier(func.getName().makeRef(sourceInfo));
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java b/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
index 4b327ef..231e624 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
@@ -462,6 +462,7 @@
for (JMethod method : program.getAllEntryMethods()) {
livenessAnalyzer.traverseFrom(method);
}
+ livenessAnalyzer.traverseFromLeftoversFragmentHasLoaded();
livenessAnalyzer.finishTraversal();
program.typeOracle.setInstantiatedTypes(livenessAnalyzer.getInstantiatedTypes());
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java b/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java
index f9dfa3c..1ceb55a 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java
@@ -19,6 +19,7 @@
import com.google.gwt.dev.jjs.ast.Context;
import com.google.gwt.dev.jjs.ast.JClassType;
import com.google.gwt.dev.jjs.ast.JExpression;
+import com.google.gwt.dev.jjs.ast.JField;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JMethodCall;
import com.google.gwt.dev.jjs.ast.JModVisitor;
@@ -43,8 +44,8 @@
JExpression asyncCallback = x.getArgs().get(0);
int entryNumber = entryCount++;
- logger.log(TreeLogger.TRACE, "Using island loader #" + entryNumber
- + " in method " + currentMethod);
+ logger.log(TreeLogger.INFO, "Assigning split point #" + entryNumber
+ + " in method " + fullMethodDescription(currentMethod));
JClassType loader = getFragmentLoader(entryNumber);
JMethod loadMethod = getRunAsyncMethod(loader);
@@ -71,6 +72,10 @@
return new ReplaceRunAsyncs(logger, program).execImpl();
}
+ private static String fullMethodDescription(JMethod method) {
+ return (method.getEnclosingType().getName() + "." + JProgram.getJsniSig(method));
+ }
+
private final TreeLogger logger;
private JProgram program;
@@ -83,6 +88,7 @@
private int execImpl() {
AsyncCreateVisitor visitor = new AsyncCreateVisitor();
visitor.accept(program);
+ setNumEntriesInAsyncFragmentLoader(visitor.entryCount);
return visitor.entryCount;
}
@@ -123,4 +129,9 @@
}
return null;
}
+
+ private void setNumEntriesInAsyncFragmentLoader(int entryCount) {
+ JField field = program.getIndexedField("AsyncFragmentLoader.numEntries");
+ field.getDeclarationStatement().initializer = program.getLiteralInt(entryCount);
+ }
}
diff --git a/user/src/com/google/gwt/core/client/AsyncFragmentLoader.java b/user/src/com/google/gwt/core/client/AsyncFragmentLoader.java
index 448472e..e991b89 100644
--- a/user/src/com/google/gwt/core/client/AsyncFragmentLoader.java
+++ b/user/src/com/google/gwt/core/client/AsyncFragmentLoader.java
@@ -15,6 +15,9 @@
*/
package com.google.gwt.core.client;
+import java.util.LinkedList;
+import java.util.Queue;
+
/**
* <p>
* Low-level support to download an extra fragment of code. This should not be
@@ -22,6 +25,22 @@
* </p>
*
* <p>
+ * The fragments are numbered as follows, assuming there are <em>m</em> split
+ * points:
+ *
+ * <ul>
+ * <li> 0 -- the <em>base</em> fragment, which is initially downloaded
+ * <li> 1-m -- the <em>exclusively live</em> fragments, holding the code
+ * needed exclusively for each split point
+ * <li> m -- the <em>secondary base</em> fragment for entry point 1. It holds
+ * precisely that code needed if entry point 1 is the first one reached after
+ * the application downloads.
+ * <li> m+1 -- the <em>leftovers fragment</em> for entry point 1. It holds all
+ * code not in fragments 0-(m-1) nor in fragment m.
+ * <li> (m+2)..(3m) -- secondary bases and leftovers for entry points 2..m
+ * </ul>
+ *
+ * <p>
* Different linkers have different requirements about how the code is
* downloaded and installed. Thus, when it is time to actually download the
* code, this class defers to a JavaScript function named
@@ -30,23 +49,93 @@
*/
public class AsyncFragmentLoader {
/**
+ * The first entry point reached after the program started.
+ */
+ private static int base = -1;
+
+ /**
+ * Whether the secondary base fragment is currently loading.
+ */
+ private static boolean baseLoading = false;
+
+ /**
+ * Whether the leftovers fragment has loaded yet.
+ */
+ private static boolean leftoversLoaded = false;
+
+ /**
+ * Whether the leftovers fragment is currently loading.
+ */
+ private static boolean leftoversLoading = false;
+
+ /**
+ * The total number of split points in the program, counting the initial entry
+ * as a split point. This is changed to the correct value by
+ * {@link com.google.gwt.dev.jjs.impl.ReplaceRunAsyncs}.
+ */
+ private static int numEntries = 1;
+
+ /**
+ * Split points that have been reached, but that cannot be downloaded until
+ * the leftovers fragment finishes downloading.
+ */
+ private static Queue<Integer> waitingForLeftovers = new LinkedList<Integer>();
+
+ /**
* Inform the loader that the code for an entry point has now finished
* loading.
*
* @param entry The entry whose code fragment is now loaded.
*/
public static void fragmentHasLoaded(int entry) {
- // There is nothing to do with the current fragmentation strategy
+ if (base < 0) {
+ // The base fragment has loaded
+ base = entry;
+ baseLoading = false;
+
+ // Go ahead and download the appropriate leftovers fragment
+ leftoversLoading = true;
+ startLoadingFragment(numEntries + 2 * (entry - 1) + 1);
+ }
}
/**
- * Loads the specified fragment asynchronously.
+ * Loads the specified split point.
*
- * @param fragment the fragment to load
+ * @param splitPoint the fragment to load
*/
- public static void inject(int fragment) {
- logEventProgress("download" + fragment, "begin");
- startLoadingFragment(fragment);
+ public static void inject(int splitPoint) {
+ if (leftoversLoaded) {
+ /*
+ * A base and a leftovers fragment have loaded. Load an exclusively live
+ * fragment.
+ */
+ startLoadingFragment(splitPoint);
+ return;
+ }
+
+ if (baseLoading || leftoversLoading) {
+ /*
+ * Wait until the leftovers fragment has loaded before loading this one.
+ */
+ waitingForLeftovers.add(splitPoint);
+ return;
+ }
+
+ // Nothing has loaded or started to load. Treat this fragment as the base.
+ baseLoading = true;
+ startLoadingFragment(numEntries + 2 * (splitPoint - 1));
+ }
+
+ /**
+ * Inform the loader that the "leftovers" fragment has loaded.
+ */
+ public static void leftoversFragmentHasLoaded() {
+ leftoversLoaded = true;
+ leftoversLoading = false;
+ while (!waitingForLeftovers.isEmpty()) {
+ inject(waitingForLeftovers.remove());
+ }
}
/**
@@ -73,13 +162,18 @@
};
}-*/;
+ private static native void gwtStartLoadingFragment(int fragment) /*-{
+ __gwtStartLoadingFragment(fragment);
+ }-*/;
+
private static native boolean isStatsAvailable() /*-{
return !!$stats;
}-*/;
- private static native void startLoadingFragment(int fragment) /*-{
- __gwtStartLoadingFragment(fragment);
- }-*/;
+ private static void startLoadingFragment(int fragment) {
+ logEventProgress("download" + fragment, "begin");
+ gwtStartLoadingFragment(fragment);
+ }
/**
* Always use this as {@link isStatsAvailable} &&
