From dcc17a966e55e137a38e463954acd8b2a01abff3 Mon Sep 17 00:00:00 2001 From: Andrew Clark Date: Tue, 6 Dec 2016 19:19:11 -0800 Subject: [PATCH] Don't check for a pendingCommit on every iteration Only check if we're in a deferred work batch and performUnitOfWork returns null. --- .../shared/fiber/ReactFiberScheduler.js | 180 ++++++++++-------- .../fiber/__tests__/ReactIncremental-test.js | 11 +- .../ReactIncrementalScheduling-test.js | 6 +- 3 files changed, 100 insertions(+), 97 deletions(-) diff --git a/src/renderers/shared/fiber/ReactFiberScheduler.js b/src/renderers/shared/fiber/ReactFiberScheduler.js index e43358a26e..823de733d5 100644 --- a/src/renderers/shared/fiber/ReactFiberScheduler.js +++ b/src/renderers/shared/fiber/ReactFiberScheduler.js @@ -82,8 +82,6 @@ module.exports = function(config : HostConfig) { // Keeps track of whether we're currently in a work loop. Used to batch // nested updates. let isPerformingWork : boolean = false; - // This lets us know if we should defer a commit until the next frame. - let isPerformingDeferredWork : boolean = false; // The next work in progress fiber that we're currently working on. let nextUnitOfWork : ?Fiber = null; @@ -148,10 +146,7 @@ module.exports = function(config : HostConfig) { // If there's no work on it, it will get unscheduled too. nextScheduledRoot = next; } - if (pendingCommit) { - nextPriorityLevel = pendingCommit.pendingWorkPriority; - return null; - } + let root = nextScheduledRoot; let highestPriorityRoot = null; let highestPriorityLevel = NoWork; @@ -178,7 +173,7 @@ module.exports = function(config : HostConfig) { } // Returns true if the commit phase finishes without any errors. - function commitAllWork(finishedWork : Fiber): boolean { + function commitAllWork(finishedWork : Fiber) { // We keep track of this so that captureError can collect any boundaries // that capture an error during the commit phase. The reason these aren't // local to this function is because errors that occur during cWU are @@ -325,7 +320,6 @@ module.exports = function(config : HostConfig) { } continue pass2; } - priorityContext = previousPriorityContext; break; } @@ -333,19 +327,18 @@ module.exports = function(config : HostConfig) { // If we caught any errors during this commit, schedule their boundaries // to update. - let noErrors; if (commitPhaseBoundaries) { - noErrors = false; commitPhaseBoundaries.forEach(scheduleUpdate); commitPhaseBoundaries = null; - } else { - noErrors = true; } priorityContext = previousPriorityContext; - nextUnitOfWork = null; - return noErrors; + // Clear any errors that may have occurred during this commit + // TODO: Possibly recursive. Can we move this into performWork? Not sure how + // because we need to clear errors after every commit, and one of the call + // sites of commitAllWork is completeUnitOfWork. + errorLoop(); } function resetWorkPriority(workInProgress : Fiber) { @@ -429,8 +422,16 @@ module.exports = function(config : HostConfig) { workInProgress = returnFiber; continue; } else { - // If we've reached the root, commit during the next unit of work. - pendingCommit = workInProgress; + // We've reached the root. Unless we're current performing deferred + // work, we should commit the completed work immediately. If we are + // performing deferred work, returning null indicates to the caller + // that we just completed the root so they can handle that case correctly. + if (nextPriorityLevel < HighPriority) { + // Otherwise, we should commit immediately. + commitAllWork(workInProgress); + } else { + pendingCommit = workInProgress; + } return null; } } @@ -515,84 +516,71 @@ module.exports = function(config : HostConfig) { } function errorLoop() { + if (!nextUnitOfWork) { + nextUnitOfWork = findNextUnitOfWork(); + } // Keep performing work until there are no more errors - while (capturedErrors && capturedErrors.size) { - if (!nextUnitOfWork && !pendingCommit) { - nextUnitOfWork = findNextUnitOfWork(); - } - if (pendingCommit) { - commitAllWork(pendingCommit); - } else if (nextUnitOfWork) { - if (hasCapturedError(nextUnitOfWork)) { - // Use a forked version of performUnitOfWork - nextUnitOfWork = performFailedUnitOfWork(nextUnitOfWork); - } else { - nextUnitOfWork = performUnitOfWork(nextUnitOfWork); - } + while (capturedErrors && capturedErrors.size && + nextUnitOfWork && + nextPriorityLevel !== NoWork && + nextPriorityLevel <= TaskPriority) { + if (hasCapturedError(nextUnitOfWork)) { + // Use a forked version of performUnitOfWork + nextUnitOfWork = performFailedUnitOfWork(nextUnitOfWork); } else { - return; + nextUnitOfWork = performUnitOfWork(nextUnitOfWork); + } + if (!nextUnitOfWork) { + nextUnitOfWork = findNextUnitOfWork(); } } } function workLoop(priorityLevel) { - while (true) { - if (!nextUnitOfWork && !pendingCommit) { + if (!nextUnitOfWork) { + nextUnitOfWork = findNextUnitOfWork(); + } + while (nextUnitOfWork && + nextPriorityLevel !== NoWork && + nextPriorityLevel <= priorityLevel) { + nextUnitOfWork = performUnitOfWork(nextUnitOfWork); + if (!nextUnitOfWork) { nextUnitOfWork = findNextUnitOfWork(); } - - // If we're performing Task work and we're inside a deferred work batch, - // then we shouldn't commit any work yet. Defer it to the next frame. - // TODO: Is there a better way check if the pending commit should be - // deferred? It's not as simple as retaining work priority because - // the root may receive a lower priority update before the completed - // work is flushed, causing the new update to be up-prioritized. - if ( - pendingCommit && - !(priorityLevel === TaskPriority && isPerformingDeferredWork) - ) { - const noError = commitAllWork(pendingCommit); - if (!noError) { - // There was an error during the commit phase. Clear them before - // continuing. - errorLoop(); - continue; - } - } else if (nextUnitOfWork && nextPriorityLevel !== NoWork && nextPriorityLevel <= priorityLevel) { - nextUnitOfWork = performUnitOfWork(nextUnitOfWork); - } else { - return; - } } } - function deferredWorkLoop(deadline) { + // Returns true if we exit because the deadline has expired + function deferredWorkLoop(deadline) : boolean { + let deadlineHasExpired = false; if (!nextUnitOfWork) { nextUnitOfWork = findNextUnitOfWork(); } - - while (true) { + while (nextUnitOfWork && !deadlineHasExpired) { if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) { - if (!nextUnitOfWork && !pendingCommit) { - nextUnitOfWork = findNextUnitOfWork(); - } - if (pendingCommit) { - const noError = commitAllWork(pendingCommit); - if (!noError) { - // There was an error during the commit phase. Clear them before - // continuing. - errorLoop(); - continue; + nextUnitOfWork = performUnitOfWork(nextUnitOfWork); + // The order of the checks here is important: we should only check if + // there's a pending commit if performUnitOfWork returns null. + // Alternatively, to avoid checking for the pending commit, we could + // get it from the nextScheduledRoot. However, that requires additional + // checks to satisfy Flow. Since the logical operator short-circuits, + // this should be fine. + if (!nextUnitOfWork && pendingCommit) { + // performUnitOfWork returned null and we have a pendingCommit. If we + // have time, we should commit the work now. + if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) { + commitAllWork(pendingCommit); + nextUnitOfWork = findNextUnitOfWork(); + } else { + deadlineHasExpired = true; } - } else if (nextUnitOfWork) { - nextUnitOfWork = performUnitOfWork(nextUnitOfWork); - } else { - return; + // Otherwise the root will committed in the next frame. } } else { - return; + deadlineHasExpired = true; } } + return deadlineHasExpired; } function performWork(priorityLevel : PriorityLevel, deadline : null | Deadline) { @@ -600,7 +588,8 @@ module.exports = function(config : HostConfig) { throw new Error('performWork was called recursively.'); } isPerformingWork = true; - isPerformingDeferredWork = priorityLevel >= HighPriority; + const isPerformingDeferredWork = Boolean(deadline); + let deadlineHasExpired = false; // Perform work until either there's no more work at this priority level, or // (in the case of deferred work) we've run out of time. @@ -612,19 +601,35 @@ module.exports = function(config : HostConfig) { // work. The loop we're in now runs infrequently: to flush task work at // the end of a frame, or to restart after an error. while (priorityLevel !== NoWork) { - // If there are errors, clear them first. - if (capturedErrors && capturedErrors.size) { - errorLoop(); + // Before starting any work, check to see if there are any pending + // commits from the previous frame. An exception if we're flushing + // Task work in a deferred batch and the pending commit does not + // have Task priority. + if (pendingCommit) { + const isFlushingTaskWorkInDeferredBatch = + priorityLevel === TaskPriority && + isPerformingDeferredWork && + pendingCommit.pendingWorkPriority !== TaskPriority; + if (!isFlushingTaskWorkInDeferredBatch) { + commitAllWork(pendingCommit); + } } - if (priorityLevel >= HighPriority) { - if (!deadline) { - throw new Error('Cannot perform deferred work without a deadline.'); - } + // Clear any errors. + errorLoop(); + + if (deadline) { // The deferred work loop will run until there's no time left in - // the current frame - deferredWorkLoop(deadline); + // the current frame. + if (!deadlineHasExpired) { + deadlineHasExpired = deferredWorkLoop(deadline); + } } else { + if (priorityLevel >= HighPriority) { + throw new Error( + 'Deferred work should only be performed using deferredWorkLoop' + ); + } // The non-deferred work loop will run until there's no more work // at the given priority level workLoop(priorityLevel); @@ -633,6 +638,14 @@ module.exports = function(config : HostConfig) { // Stop performing work priorityLevel = NoWork; + // If we additional work, and we're in a deferred batch, check to see + // if the deadline has expired. If not, we may have more time to + // do work. + if (nextPriorityLevel !== NoWork && isPerformingDeferredWork && !deadlineHasExpired) { + priorityLevel = nextPriorityLevel; + continue; + } + // There might still be work left. Depending on the priority, we should // either perform it now or schedule a callback to perform it later. switch (nextPriorityLevel) { @@ -691,7 +704,6 @@ module.exports = function(config : HostConfig) { // We're done performing work. Time to clean up. isPerformingWork = false; - isPerformingDeferredWork = false; capturedErrors = null; failedBoundaries = null; diff --git a/src/renderers/shared/fiber/__tests__/ReactIncremental-test.js b/src/renderers/shared/fiber/__tests__/ReactIncremental-test.js index 2d823c9958..f69a013d49 100644 --- a/src/renderers/shared/fiber/__tests__/ReactIncremental-test.js +++ b/src/renderers/shared/fiber/__tests__/ReactIncremental-test.js @@ -625,16 +625,7 @@ describe('ReactIncremental', () => { // we should be able to reuse the reconciliation work that we already did // without restarting. ReactNoop.flush(); - // TODO: Content never fully completed its render so can't completely bail - // out on the entire subtree. However, we could do a shallow bail out and - // not rerender Content, but keep going down the incomplete tree. - // Normally shouldComponentUpdate->false is not enough to determine that we - // can safely reuse the old props, but I think in this case it would be ok, - // since it is a resume of already started work. - // Because of the above we can not reuse the work of Bar because the - // rerender of Content will generate a new element which will mean we don't - // auto-bail out from Bar. - expect(ops).toEqual(['Bar', 'Middle']); + expect(ops).toEqual(['Middle']); }); diff --git a/src/renderers/shared/fiber/__tests__/ReactIncrementalScheduling-test.js b/src/renderers/shared/fiber/__tests__/ReactIncrementalScheduling-test.js index b14279a534..4ef5c36997 100644 --- a/src/renderers/shared/fiber/__tests__/ReactIncrementalScheduling-test.js +++ b/src/renderers/shared/fiber/__tests__/ReactIncrementalScheduling-test.js @@ -419,11 +419,11 @@ describe('ReactIncrementalScheduling', () => { }); // We're flushing deferred work // Still, roots with animation work are handled first - ReactNoop.flushDeferredPri(15 + 5); + ReactNoop.flushDeferredPri(15); expect(ReactNoop.getChildren('a')).toEqual([span('a:1')]); expect(ReactNoop.getChildren('b')).toEqual([span('b:2')]); expect(ReactNoop.getChildren('c')).toEqual([span('c:1')]); - ReactNoop.flushDeferredPri(15 + 5); + ReactNoop.flushDeferredPri(15); expect(ReactNoop.getChildren('a')).toEqual([span('a:1')]); expect(ReactNoop.getChildren('b')).toEqual([span('b:2')]); expect(ReactNoop.getChildren('c')).toEqual([span('c:2')]); @@ -434,7 +434,7 @@ describe('ReactIncrementalScheduling', () => { ReactNoop.renderToRootWithID(, 'b'); }); // Animation is still handled first - ReactNoop.flushDeferredPri(15 + 5); + ReactNoop.flushDeferredPri(15); expect(ReactNoop.getChildren('a')).toEqual([span('a:1')]); expect(ReactNoop.getChildren('b')).toEqual([span('b:3')]); expect(ReactNoop.getChildren('c')).toEqual([span('c:2')]);