bootstrap: lazy load non-essential modules

It turns out that even with startup snapshots, there is a non-trivial
overhead for loading internal modules. This patch makes the loading
of the non-essential modules lazy again.

Caveat: we have to make some of the globals lazily-loaded too,
so the WPT runner is updated to test what the state of the global
scope is after the globals are accessed (and replaced with the
loaded value).

PR-URL: #45659
Backport-PR-URL: #46425
Reviewed-By: Matteo Collina <[email protected]>
Reviewed-By: Yagiz Nizipli <[email protected]>
Reviewed-By: Daeyeon Jeong <[email protected]>
Reviewed-By: Jacob Smith <[email protected]>
Reviewed-By: James M Snell <[email protected]>
Reviewed-By: Rafael Gonzaga <[email protected]>
Reviewed-By: Antoine du Hamel <[email protected]>
Reviewed-By: Minwoo Jung <[email protected]>
Reviewed-By: Tierney Cyren <[email protected]>

Author: joyeecheung

lib/buffer.js

@@ -85,6 +85,7 @@ const {
   lazyDOMException,
   normalizeEncoding,
   kIsEncodingSymbol,
+  defineLazyProperties,
 } = require('internal/util');
 const {
   isAnyArrayBuffer,
@@ -128,15 +129,6 @@ const {
   createUnsafeBuffer,
 } = require('internal/buffer');
 
-const {
-  Blob,
-  resolveObjectURL,
-} = require('internal/blob');
-
-const {
-  File,
-} = require('internal/file');
-
 FastBuffer.prototype.constructor = Buffer;
 Buffer.prototype = FastBuffer.prototype;
 addBufferPrototypeMethods(Buffer.prototype);
@@ -1382,9 +1374,6 @@ function isAscii(input) {
 }
 
 module.exports = {
-  Blob,
-  File,
-  resolveObjectURL,
   Buffer,
   SlowBuffer,
   transcode,
@@ -1413,3 +1402,14 @@ ObjectDefineProperties(module.exports, {
     set(val) { INSPECT_MAX_BYTES = val; },
   },
 });
+
+defineLazyProperties(
+  module.exports,
+  'internal/blob',
+  ['Blob', 'resolveObjectURL'],
+);
+defineLazyProperties(
+  module.exports,
+  'internal/file',
+  ['File'],
+);

lib/fs.js

@@ -87,6 +87,7 @@ const {
     custom: kCustomPromisifiedSymbol,
   },
   SideEffectFreeRegExpPrototypeExec,
+  defineLazyProperties,
 } = require('internal/util');
 const {
   constants: {
@@ -125,11 +126,6 @@ const {
   validatePrimitiveStringAfterArrayBufferView,
   warnOnNonPortableTemplate,
 } = require('internal/fs/utils');
-const {
-  Dir,
-  opendir,
-  opendirSync,
-} = require('internal/fs/dir');
 const {
   CHAR_FORWARD_SLASH,
   CHAR_BACKWARD_SLASH,
@@ -146,9 +142,6 @@ const {
   validateString,
 } = require('internal/validators');
 
-const watchers = require('internal/fs/watchers');
-const ReadFileContext = require('internal/fs/read_file_context');
-
 let truncateWarn = true;
 let fs;
 
@@ -392,6 +385,7 @@ function checkAborted(signal, callback) {
 function readFile(path, options, callback) {
   callback = maybeCallback(callback || options);
   options = getOptions(options, { flag: 'r' });
+  const ReadFileContext = require('internal/fs/read_file_context');
   const context = new ReadFileContext(callback, options.encoding);
   context.isUserFd = isFd(path); // File descriptor ownership
 
@@ -2422,12 +2416,13 @@ function watch(filename, options, listener) {
   if (options.recursive === undefined) options.recursive = false;
   if (options.recursive && !(isOSX || isWindows))
     throw new ERR_FEATURE_UNAVAILABLE_ON_PLATFORM('watch recursively');
+
+  const watchers = require('internal/fs/watchers');
   const watcher = new watchers.FSWatcher();
   watcher[watchers.kFSWatchStart](filename,
                                   options.persistent,
                                   options.recursive,
                                   options.encoding);
-
   if (listener) {
     watcher.addListener('change', listener);
   }
@@ -2486,7 +2481,7 @@ function watchFile(filename, options, listener) {
   validateFunction(listener, 'listener');
 
   stat = statWatchers.get(filename);
-
+  const watchers = require('internal/fs/watchers');
   if (stat === undefined) {
     stat = new watchers.StatWatcher(options.bigint);
     stat[watchers.kFSStatWatcherStart](filename,
@@ -2512,7 +2507,7 @@ function unwatchFile(filename, listener) {
   const stat = statWatchers.get(filename);
 
   if (stat === undefined) return;
-
+  const watchers = require('internal/fs/watchers');
   if (typeof listener === 'function') {
     const beforeListenerCount = stat.listenerCount('change');
     stat.removeListener('change', listener);
@@ -3116,8 +3111,6 @@ module.exports = fs = {
   mkdtempSync,
   open,
   openSync,
-  opendir,
-  opendirSync,
   readdir,
   readdirSync,
   read,
@@ -3157,7 +3150,6 @@ module.exports = fs = {
   writeSync,
   writev,
   writevSync,
-  Dir,
   Dirent,
   Stats,
 
@@ -3203,6 +3195,12 @@ module.exports = fs = {
   _toUnixTimestamp: toUnixTimestamp,
 };
 
+defineLazyProperties(
+  fs,
+  'internal/fs/dir',
+  ['Dir', 'opendir', 'opendirSync'],
+);
+
 ObjectDefineProperties(fs, {
   F_OK: { __proto__: null, enumerable: true, value: F_OK || 0 },
   R_OK: { __proto__: null, enumerable: true, value: R_OK || 0 },

lib/internal/async_hooks.js

@@ -8,8 +8,6 @@ const {
   Symbol,
 } = primordials;
 
-const promiseHooks = require('internal/promise_hooks');
-
 const async_wrap = internalBinding('async_wrap');
 const { setCallbackTrampoline } = async_wrap;
 /* async_hook_fields is a Uint32Array wrapping the uint32_t array of
@@ -382,6 +380,7 @@ function updatePromiseHookMode() {
     initHook = destroyTracking;
   }
   if (stopPromiseHook) stopPromiseHook();
+  const promiseHooks = require('internal/promise_hooks');
   stopPromiseHook = promiseHooks.createHook({
     init: initHook,
     before: promiseBeforeHook,

lib/internal/bootstrap/browser.js

@@ -9,6 +9,9 @@ const {
   defineOperation,
   exposeInterface,
   lazyDOMExceptionClass,
+  defineLazyProperties,
+  defineReplaceableLazyAttribute,
+  exposeLazyInterfaces,
 } = require('internal/util');
 const config = internalBinding('config');
 
@@ -28,56 +31,39 @@ exposeGetterAndSetter(globalThis,
                         exposeInterface(globalThis, 'DOMException', value);
                       });
 
-const {
-  TextEncoder,
-  TextDecoder,
-} = require('internal/encoding');
-// https://encoding.spec.whatwg.org/#textencoder
-exposeInterface(globalThis, 'TextEncoder', TextEncoder);
-// https://encoding.spec.whatwg.org/#textdecoder
-exposeInterface(globalThis, 'TextDecoder', TextDecoder);
-
-const {
-  AbortController,
-  AbortSignal,
-} = require('internal/abort_controller');
-exposeInterface(globalThis, 'AbortController', AbortController);
-exposeInterface(globalThis, 'AbortSignal', AbortSignal);
-
-const {
-  EventTarget,
-  Event,
-} = require('internal/event_target');
-exposeInterface(globalThis, 'EventTarget', EventTarget);
-exposeInterface(globalThis, 'Event', Event);
-const {
-  MessageChannel,
-  MessagePort,
-  MessageEvent,
-} = require('internal/worker/io');
-exposeInterface(globalThis, 'MessageChannel', MessageChannel);
-exposeInterface(globalThis, 'MessagePort', MessagePort);
-exposeInterface(globalThis, 'MessageEvent', MessageEvent);
-
 // https://html.spec.whatwg.org/multipage/webappapis.html#windoworworkerglobalscope
 const timers = require('timers');
 defineOperation(globalThis, 'clearInterval', timers.clearInterval);
 defineOperation(globalThis, 'clearTimeout', timers.clearTimeout);
 defineOperation(globalThis, 'setInterval', timers.setInterval);
 defineOperation(globalThis, 'setTimeout', timers.setTimeout);
 
-const buffer = require('buffer');
-defineOperation(globalThis, 'atob', buffer.atob);
-defineOperation(globalThis, 'btoa', buffer.btoa);
-
+// Lazy ones.
+exposeLazyInterfaces(globalThis, 'internal/abort_controller', [
+  'AbortController', 'AbortSignal',
+]);
+exposeLazyInterfaces(globalThis, 'internal/event_target', [
+  'EventTarget', 'Event',
+]);
+exposeLazyInterfaces(globalThis, 'internal/worker/io', [
+  'MessageChannel', 'MessagePort', 'MessageEvent',
+]);
+defineLazyProperties(globalThis, 'buffer', ['atob', 'btoa']);
 // https://www.w3.org/TR/FileAPI/#dfn-Blob
-exposeInterface(globalThis, 'Blob', buffer.Blob);
-
+exposeLazyInterfaces(globalThis, 'internal/blob', ['Blob']);
 // https://www.w3.org/TR/hr-time-2/#the-performance-attribute
-const perf_hooks = require('perf_hooks');
-exposeInterface(globalThis, 'Performance', perf_hooks.Performance);
-defineReplacableAttribute(globalThis, 'performance',
-                          perf_hooks.performance);
+
+exposeLazyInterfaces(globalThis, 'perf_hooks', [
+  'Performance',
+]);
+
+defineReplaceableLazyAttribute(globalThis, 'perf_hooks', ['performance']);
+
+// https://encoding.spec.whatwg.org/#textencoder
+// https://encoding.spec.whatwg.org/#textdecoder
+exposeLazyInterfaces(globalThis,
+                     'internal/encoding',
+                     ['TextEncoder', 'TextDecoder']);
 
 function createGlobalConsole() {
   const consoleFromNode =
@@ -115,67 +101,43 @@ function exposeGetterAndSetter(target, name, getter, setter = undefined) {
   });
 }
 
-// https://heycam.github.io/webidl/#Replaceable
-function defineReplacableAttribute(target, name, value) {
-  ObjectDefineProperty(target, name, {
-    __proto__: null,
-    writable: true,
-    enumerable: true,
-    configurable: true,
-    value,
-  });
-}
-
 // Web Streams API
-const {
-  TransformStream,
-  TransformStreamDefaultController,
-} = require('internal/webstreams/transformstream');
-
-const {
-  WritableStream,
-  WritableStreamDefaultController,
-  WritableStreamDefaultWriter,
-} = require('internal/webstreams/writablestream');
+exposeLazyInterfaces(
+  globalThis,
+  'internal/webstreams/transformstream',
+  ['TransformStream', 'TransformStreamDefaultController']);
 
-const {
-  ReadableStream,
-  ReadableStreamDefaultReader,
-  ReadableStreamBYOBReader,
-  ReadableStreamBYOBRequest,
-  ReadableByteStreamController,
-  ReadableStreamDefaultController,
-} = require('internal/webstreams/readablestream');
+exposeLazyInterfaces(
+  globalThis,
+  'internal/webstreams/writablestream',
+  ['WritableStream', 'WritableStreamDefaultController', 'WritableStreamDefaultWriter']);
 
-const {
-  ByteLengthQueuingStrategy,
-  CountQueuingStrategy,
-} = require('internal/webstreams/queuingstrategies');
+exposeLazyInterfaces(
+  globalThis,
+  'internal/webstreams/readablestream',
+  [
+    'ReadableStream', 'ReadableStreamDefaultReader',
+    'ReadableStreamBYOBReader', 'ReadableStreamBYOBRequest',
+    'ReadableByteStreamController', 'ReadableStreamDefaultController',
+  ]);
+
+exposeLazyInterfaces(
+  globalThis,
+  'internal/webstreams/queuingstrategies',
+  [
+    'ByteLengthQueuingStrategy', 'CountQueuingStrategy',
+  ]);
 
-const {
-  TextEncoderStream,
-  TextDecoderStream,
-} = require('internal/webstreams/encoding');
+exposeLazyInterfaces(
+  globalThis,
+  'internal/webstreams/encoding',
+  [
+    'TextEncoderStream', 'TextDecoderStream',
+  ]);
 
-const {
-  CompressionStream,
-  DecompressionStream,
-} = require('internal/webstreams/compression');
-
-exposeInterface(globalThis, 'ReadableStream', ReadableStream);
-exposeInterface(globalThis, 'ReadableStreamDefaultReader', ReadableStreamDefaultReader);
-exposeInterface(globalThis, 'ReadableStreamBYOBReader', ReadableStreamBYOBReader);
-exposeInterface(globalThis, 'ReadableStreamBYOBRequest', ReadableStreamBYOBRequest);
-exposeInterface(globalThis, 'ReadableByteStreamController', ReadableByteStreamController);
-exposeInterface(globalThis, 'ReadableStreamDefaultController', ReadableStreamDefaultController);
-exposeInterface(globalThis, 'TransformStream', TransformStream);
-exposeInterface(globalThis, 'TransformStreamDefaultController', TransformStreamDefaultController);
-exposeInterface(globalThis, 'WritableStream', WritableStream);
-exposeInterface(globalThis, 'WritableStreamDefaultWriter', WritableStreamDefaultWriter);
-exposeInterface(globalThis, 'WritableStreamDefaultController', WritableStreamDefaultController);
-exposeInterface(globalThis, 'ByteLengthQueuingStrategy', ByteLengthQueuingStrategy);
-exposeInterface(globalThis, 'CountQueuingStrategy', CountQueuingStrategy);
-exposeInterface(globalThis, 'TextEncoderStream', TextEncoderStream);
-exposeInterface(globalThis, 'TextDecoderStream', TextDecoderStream);
-exposeInterface(globalThis, 'CompressionStream', CompressionStream);
-exposeInterface(globalThis, 'DecompressionStream', DecompressionStream);
+exposeLazyInterfaces(
+  globalThis,
+  'internal/webstreams/compression',
+  [
+    'CompressionStream', 'DecompressionStream',
+  ]);