-
Notifications
You must be signed in to change notification settings - Fork 29.1k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
src: move process.nextTick and promise setup into node_task_queue.cc
This patch:
- Moves the process.nextTick and promise setup C++ code into
node_task_queue.cc which is exposed as
`internalBinding('task_queue')`
- Makes `lib/internal/process/promises.js` and
`lib/internal/process/next_tick.js` as side-effect-free
as possible
- Removes the bootstrapper object being passed into
`bootstrap/node.js`, let `next_tick.js` and `promises.js`
load whatever they need from `internalBinding('task_queue')`
instead.
- Rename `process._tickCallback` to `runNextTicks` internally
for clarity but still expose it as `process._tickCallback`.
PR-URL: #25163
Refs: #24961
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>- Loading branch information
1 parent
fa74cd3
commit 2e33ad1
Showing
13 changed files
with
199 additions
and
192 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Original file line | Diff line number | Diff line change |
|---|---|---|---|
| @@ -1,128 +1,138 @@ | |||
| 'use strict'; | 'use strict'; | ||
|
|
|
||
| exports.setup = setupNextTick; | const { | ||
|
|
// For easy access to the nextTick state in the C++ land, | ||
| function setupNextTick(_setupNextTick, _setupPromises) { | // and to avoid unnecessary calls into JS land. | ||
| const { | tickInfo, | ||
| getDefaultTriggerAsyncId, | // Used to run V8's micro task queue. | ||
| newAsyncId, | runMicrotasks, | ||
| initHooksExist, | setTickCallback, | ||
| destroyHooksExist, | initializePromiseRejectCallback | ||
| emitInit, | } = internalBinding('task_queue'); | ||
| emitBefore, |
|
||
| emitAfter, | const { | ||
| emitDestroy, | promiseRejectHandler, | ||
| symbols: { async_id_symbol, trigger_async_id_symbol } | emitPromiseRejectionWarnings | ||
| } = require('internal/async_hooks'); | } = require('internal/process/promises'); | ||
| const emitPromiseRejectionWarnings = |
|
||
| require('internal/process/promises').setup(_setupPromises); | const { | ||
| const { ERR_INVALID_CALLBACK } = require('internal/errors').codes; | getDefaultTriggerAsyncId, | ||
| const FixedQueue = require('internal/fixed_queue'); | newAsyncId, | ||
|
|
initHooksExist, | ||
| // tickInfo is used so that the C++ code in src/node.cc can | destroyHooksExist, | ||
| // have easy access to our nextTick state, and avoid unnecessary | emitInit, | ||
| // calls into JS land. | emitBefore, | ||
| // runMicrotasks is used to run V8's micro task queue. | emitAfter, | ||
| const [ | emitDestroy, | ||
| tickInfo, | symbols: { async_id_symbol, trigger_async_id_symbol } | ||
| runMicrotasks | } = require('internal/async_hooks'); | ||
| ] = _setupNextTick(internalTickCallback); | const { ERR_INVALID_CALLBACK } = require('internal/errors').codes; | ||
|
|
const FixedQueue = require('internal/fixed_queue'); | ||
| // *Must* match Environment::TickInfo::Fields in src/env.h. |
|
||
| const kHasScheduled = 0; | // *Must* match Environment::TickInfo::Fields in src/env.h. | ||
| const kHasPromiseRejections = 1; | const kHasScheduled = 0; | ||
|
|
const kHasPromiseRejections = 1; | ||
| const queue = new FixedQueue(); |
|
||
|
|
const queue = new FixedQueue(); | ||
| process.nextTick = nextTick; |
|
||
| // Needs to be accessible from beyond this scope. | function runNextTicks() { | ||
| process._tickCallback = _tickCallback; | if (tickInfo[kHasScheduled] === 0 && tickInfo[kHasPromiseRejections] === 0) | ||
|
|
runMicrotasks(); | ||
| function _tickCallback() { | if (tickInfo[kHasScheduled] === 0 && tickInfo[kHasPromiseRejections] === 0) | ||
| if (tickInfo[kHasScheduled] === 0 && tickInfo[kHasPromiseRejections] === 0) | return; | ||
| runMicrotasks(); |
|
||
| if (tickInfo[kHasScheduled] === 0 && tickInfo[kHasPromiseRejections] === 0) | internalTickCallback(); | ||
| return; | } | ||
|
|
|||
| internalTickCallback(); | |||
| } | |||
|
|
|||
| function internalTickCallback() { | |||
| let tock; | |||
| do { | |||
| while (tock = queue.shift()) { | |||
| const asyncId = tock[async_id_symbol]; | |||
| emitBefore(asyncId, tock[trigger_async_id_symbol]); | |||
| // emitDestroy() places the async_id_symbol into an asynchronous queue | |||
| // that calls the destroy callback in the future. It's called before | |||
| // calling tock.callback so destroy will be called even if the callback | |||
| // throws an exception that is handled by 'uncaughtException' or a | |||
| // domain. | |||
| // TODO(trevnorris): This is a bit of a hack. It relies on the fact | |||
| // that nextTick() doesn't allow the event loop to proceed, but if | |||
| // any async hooks are enabled during the callback's execution then | |||
| // this tock's after hook will be called, but not its destroy hook. | |||
| if (destroyHooksExist()) | |||
| emitDestroy(asyncId); | |||
|
|
|||
| const callback = tock.callback; | |||
| if (tock.args === undefined) | |||
| callback(); | |||
| else | |||
| Reflect.apply(callback, undefined, tock.args); | |||
|
|
|||
| emitAfter(asyncId); | |||
| } | |||
| tickInfo[kHasScheduled] = 0; | |||
| runMicrotasks(); | |||
| } while (!queue.isEmpty() || emitPromiseRejectionWarnings()); | |||
| tickInfo[kHasPromiseRejections] = 0; | |||
| } | |||
|
|
|
||
| class TickObject { | function internalTickCallback() { | ||
| constructor(callback, args, triggerAsyncId) { | let tock; | ||
| // This must be set to null first to avoid function tracking | do { | ||
| // on the hidden class, revisit in V8 versions after 6.2 | while (tock = queue.shift()) { | ||
| this.callback = null; | const asyncId = tock[async_id_symbol]; | ||
| this.callback = callback; | emitBefore(asyncId, tock[trigger_async_id_symbol]); | ||
| this.args = args; | // emitDestroy() places the async_id_symbol into an asynchronous queue | ||
|
|
// that calls the destroy callback in the future. It's called before | ||
| const asyncId = newAsyncId(); | // calling tock.callback so destroy will be called even if the callback | ||
| this[async_id_symbol] = asyncId; | // throws an exception that is handled by 'uncaughtException' or a | ||
| this[trigger_async_id_symbol] = triggerAsyncId; | // domain. | ||
|
|
// TODO(trevnorris): This is a bit of a hack. It relies on the fact | ||
| if (initHooksExist()) { | // that nextTick() doesn't allow the event loop to proceed, but if | ||
| emitInit(asyncId, | // any async hooks are enabled during the callback's execution then | ||
| 'TickObject', | // this tock's after hook will be called, but not its destroy hook. | ||
| triggerAsyncId, | if (destroyHooksExist()) | ||
| this); | emitDestroy(asyncId); | ||
| } |
|
||
| const callback = tock.callback; | |||
| if (tock.args === undefined) | |||
| callback(); | |||
| else | |||
| Reflect.apply(callback, undefined, tock.args); | |||
|
|
|||
| emitAfter(asyncId); | |||
| } | } | ||
| } | tickInfo[kHasScheduled] = 0; | ||
| runMicrotasks(); | |||
| } while (!queue.isEmpty() || emitPromiseRejectionWarnings()); | |||
| tickInfo[kHasPromiseRejections] = 0; | |||
| } | |||
|
|
|
||
| // `nextTick()` will not enqueue any callback when the process is about to | class TickObject { | ||
| // exit since the callback would not have a chance to be executed. | constructor(callback, args, triggerAsyncId) { | ||
| function nextTick(callback) { | // This must be set to null first to avoid function tracking | ||
| if (typeof callback !== 'function') | // on the hidden class, revisit in V8 versions after 6.2 | ||
| throw new ERR_INVALID_CALLBACK(); | this.callback = null; | ||
|
|
this.callback = callback; | ||
| if (process._exiting) | this.args = args; | ||
| return; |
|
||
|
|
const asyncId = newAsyncId(); | ||
| var args; | this[async_id_symbol] = asyncId; | ||
| switch (arguments.length) { | this[trigger_async_id_symbol] = triggerAsyncId; | ||
| case 1: break; |
|
||
| case 2: args = [arguments[1]]; break; | if (initHooksExist()) { | ||
| case 3: args = [arguments[1], arguments[2]]; break; | emitInit(asyncId, | ||
| case 4: args = [arguments[1], arguments[2], arguments[3]]; break; | 'TickObject', | ||
| default: | triggerAsyncId, | ||
| args = new Array(arguments.length - 1); | this); | ||
| for (var i = 1; i < arguments.length; i++) | |||
| args[i - 1] = arguments[i]; | |||
| } | } | ||
| } | |||
| } | |||
|
|
|
||
| if (queue.isEmpty()) | // `nextTick()` will not enqueue any callback when the process is about to | ||
| tickInfo[kHasScheduled] = 1; | // exit since the callback would not have a chance to be executed. | ||
| queue.push(new TickObject(callback, args, getDefaultTriggerAsyncId())); | function nextTick(callback) { | ||
| if (typeof callback !== 'function') | |||
| throw new ERR_INVALID_CALLBACK(); | |||
|
|
|||
| if (process._exiting) | |||
| return; | |||
|
|
|||
| var args; | |||
| switch (arguments.length) { | |||
| case 1: break; | |||
| case 2: args = [arguments[1]]; break; | |||
| case 3: args = [arguments[1], arguments[2]]; break; | |||
| case 4: args = [arguments[1], arguments[2], arguments[3]]; break; | |||
| default: | |||
| args = new Array(arguments.length - 1); | |||
| for (var i = 1; i < arguments.length; i++) | |||
| args[i - 1] = arguments[i]; | |||
| } | } | ||
|
|
|||
| if (queue.isEmpty()) | |||
| tickInfo[kHasScheduled] = 1; | |||
| queue.push(new TickObject(callback, args, getDefaultTriggerAsyncId())); | |||
| } | } | ||
|
|
|||
| // TODO(joyeecheung): make this a factory class so that node.js can | |||
| // control the side effects caused by the initializers. | |||
| exports.setup = function() { | |||
| // Initializes the per-isolate promise rejection callback which | |||
| // will call the handler being passed into this function. | |||
| initializePromiseRejectCallback(promiseRejectHandler); | |||
| // Sets the callback to be run in every tick. | |||
| setTickCallback(internalTickCallback); | |||
| return { | |||
| nextTick, | |||
| runNextTicks | |||
| }; | |||
| }; | |||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.