feat: add experimental snapshot support MONGOSH-1333 (#40)

Author: addaleax

.github/workflows/nodejs.yml

@@ -36,7 +36,7 @@ jobs:
       fail-fast: false
       matrix:
         node-version: [14.x, 16.x, 18.x, 19.x]
-        shard: [1, 2, 3, 4]
+        shard: [1, 2, 3, 4, 5]
     runs-on: windows-latest
     steps:
       - uses: actions/checkout@v2
@@ -61,4 +61,4 @@ jobs:
       - name: Sharded tests
         run: npm test -- -g "shard ${{ matrix.shard }}"
       - name: Unsharded tests
-        run: npm test -- -g "shard [1-4]" -i
+        run: npm test -- -g "shard [1-5]" -i

bin/boxednode.js

@@ -33,6 +33,9 @@ const argv = require('yargs')
   .option('use-code-cache', {
     alias: 'H', type: 'boolean', desc: 'Use Node.js code cache support to speed up startup'
   })
+  .option('use-node-snapshot', {
+    alias: 'S', type: 'boolean', desc: 'Use experimental Node.js snapshot support'
+  })
   .example('$0 -s myProject.js -t myProject.exe -n ^14.0.0',
     'Create myProject.exe from myProject.js using Node.js v14')
   .help()
@@ -50,7 +53,8 @@ const argv = require('yargs')
       makeArgs: (argv.M || '').split(',').filter(Boolean),
       namespace: argv.N,
       useLegacyDefaultUvLoop: argv.useLegacyDefaultUvLoop,
-      useCodeCache: argv.H
+      useCodeCache: argv.H,
+      useNodeSnapshot: argv.S
     });
   } catch (err) {
     console.error(err);

resources/entry-point-trampoline.js

@@ -1,6 +1,7 @@
 'use strict';
 const Module = require('module');
 const vm = require('vm');
+const v8 = require('v8');
 const path = require('path');
 const assert = require('assert');
 const {
@@ -10,6 +11,8 @@ const {
 const hydatedRequireMappings =
   requireMappings.map(([re, reFlags, linked]) => [new RegExp(re, reFlags), linked]);
 
+if (process.argv[2] === '--') process.argv.splice(2, 1);
+
 if (enableBindingsPatch) {
   // Hack around various deficiencies in https://github.com/TooTallNate/node-bindings
   const fs = require('fs');
@@ -50,11 +53,24 @@ if (enableBindingsPatch) {
   });
 }
 
+const outerRequire = require;
 module.exports = (src, codeCacheMode, codeCache) => {
   const __filename = process.execPath;
   const __dirname = path.dirname(process.execPath);
-  const innerRequire = Module.createRequire(__filename);
+  let innerRequire;
   const exports = {};
+  const usesSnapshot = !!v8?.startupSnapshot?.isBuildingSnapshot();
+
+  if (usesSnapshot) {
+    innerRequire = outerRequire; // Node.js snapshots currently do not support userland require()
+    v8.startupSnapshot.addDeserializeCallback(() => {
+      if (process.argv[1] === '--boxednode-snapshot-argv-fixup') {
+        process.argv.splice(1, 1, process.execPath);
+      }
+    });
+  } else {
+    innerRequire = Module.createRequire(__filename);
+  }
 
   function require(module) {
     for (const [ re, linked ] of hydatedRequireMappings) {
@@ -69,7 +85,7 @@ module.exports = (src, codeCacheMode, codeCache) => {
   Object.setPrototypeOf(require, Object.getPrototypeOf(innerRequire));
 
   process.argv.unshift(__filename);
-  process.boxednode = {};
+  process.boxednode = { usesSnapshot };
 
   const module = {
     exports,
@@ -79,17 +95,23 @@ module.exports = (src, codeCacheMode, codeCache) => {
     path: __dirname,
     require
   };
-  const mainFunction = vm.compileFunction(src, [
-    '__filename', '__dirname', 'require', 'exports', 'module'
-  ], {
-    filename: __filename,
-    cachedData: codeCache.length > 0 ? codeCache : undefined,
-    produceCachedData: codeCacheMode === 'generate'
-  });
-  if (codeCacheMode === 'generate') {
-    assert.strictEqual(mainFunction.cachedDataProduced, true);
-    process.stdout.write(mainFunction.cachedData);
-    return;
+
+  let mainFunction;
+  if (usesSnapshot) {
+    mainFunction = eval(`(function(__filename, __dirname, require, exports, module) {\n${src}\n})`);
+  } else {
+    mainFunction = vm.compileFunction(src, [
+      '__filename', '__dirname', 'require', 'exports', 'module'
+    ], {
+      filename: __filename,
+      cachedData: codeCache.length > 0 ? codeCache : undefined,
+      produceCachedData: codeCacheMode === 'generate'
+    });
+    if (codeCacheMode === 'generate') {
+      assert.strictEqual(mainFunction.cachedDataProduced, true);
+      require('fs').writeFileSync('intermediate.out', mainFunction.cachedData);
+      return;
+    }
   }
 
   process.boxednode.hasCodeCache = codeCache.length > 0;

resources/main-template.cc

@@ -25,14 +25,21 @@ using namespace v8;
 #define USE_OWN_LEGACY_PROCESS_INITIALIZATION 1
 #endif
 
+// 20.0.0 will have https://github.com/nodejs/node/pull/45888, possibly the PR
+// will be backported to older versions but for now this is the one where we
+// can be sure of its presence.
+#if NODE_VERSION_AT_LEAST(20, 0, 0)
+#define NODE_VERSION_SUPPORTS_EMBEDDER_SNAPSHOT 1
+#endif
+
 // 18.1.0 is the current minimum version that has https://github.com/nodejs/node/pull/42809,
 // which introduced crashes when using workers, and later 18.9.0 is the current
 // minimum version to contain https://github.com/nodejs/node/pull/44252, which
 // introcued crashes when using the vm module.
 // We should be able to remove this restriction again once Node.js stops relying
 // on global state for determining whether snapshots are enabled or not
 // (after https://github.com/nodejs/node/pull/45888, hopefully).
-#if NODE_VERSION_AT_LEAST(18, 1, 0)
+#if NODE_VERSION_AT_LEAST(18, 1, 0) && !defined(NODE_VERSION_SUPPORTS_EMBEDDER_SNAPSHOT)
 #define PASS_NO_NODE_SNAPSHOT_OPTION 1
 #endif
 
@@ -45,6 +52,7 @@ void TearDownOncePerProcess();
 namespace boxednode {
 Local<String> GetBoxednodeMainScriptSource(Isolate* isolate);
 Local<Uint8Array> GetBoxednodeCodeCacheBuffer(Isolate* isolate);
+std::vector<char> GetBoxednodeSnapshotBlobVector();
 }
 
 extern "C" {
@@ -53,11 +61,86 @@ typedef void (*register_boxednode_linked_module)(const void**, const void**);
 REPLACE_DECLARE_LINKED_MODULES
 }
 
+#if __cplusplus >= 201703L
+[[maybe_unused]]
+#endif
 static register_boxednode_linked_module boxednode_linked_modules[] = {
   REPLACE_DEFINE_LINKED_MODULES
   nullptr  // Make sure the array is not empty, for MSVC
 };
 
+static MaybeLocal<Value> LoadBoxednodeEnvironment(Local<Context> context) {
+  Environment* env = GetCurrentEnvironment(context);
+  return LoadEnvironment(env,
+#ifdef BOXEDNODE_CONSUME_SNAPSHOT
+        node::StartExecutionCallback{}
+#else
+        [&](const StartExecutionCallbackInfo& info) -> MaybeLocal<Value> {
+          Isolate* isolate = context->GetIsolate();
+          HandleScope handle_scope(isolate);
+          Local<Value> entrypoint_name = String::NewFromUtf8(
+              isolate,
+              REPLACE_WITH_ENTRY_POINT)
+              .ToLocalChecked();
+          Local<Value> entrypoint_ret;
+          if (!info.native_require->Call(
+              context,
+              Null(isolate),
+              1,
+              &entrypoint_name
+            ).ToLocal(&entrypoint_ret)) {
+            return {}; // JS exception.
+          }
+          assert(entrypoint_ret->IsFunction());
+          Local<Value> trampoline_args[] = {
+            boxednode::GetBoxednodeMainScriptSource(isolate),
+            String::NewFromUtf8Literal(isolate, BOXEDNODE_CODE_CACHE_MODE),
+            boxednode::GetBoxednodeCodeCacheBuffer(isolate),
+          };
+          if (entrypoint_ret.As<Function>()->Call(
+              context,
+              Null(isolate),
+              sizeof(trampoline_args) / sizeof(trampoline_args[0]),
+              trampoline_args).IsEmpty()) {
+            return {}; // JS exception.
+          }
+          return Null(isolate);
+      }
+#endif
+    );
+}
+
+#ifdef BOXEDNODE_GENERATE_SNAPSHOT
+static int RunNodeInstance(MultiIsolatePlatform* platform,
+                           const std::vector<std::string>& args,
+                           const std::vector<std::string>& exec_args) {
+  int exit_code = 0;
+  std::vector<std::string> errors;
+  std::unique_ptr<CommonEnvironmentSetup> setup =
+      CommonEnvironmentSetup::CreateForSnapshotting(platform, &errors, args, exec_args);
+
+  Isolate* isolate = setup->isolate();
+
+  {
+    Locker locker(isolate);
+    Isolate::Scope isolate_scope(isolate);
+
+    HandleScope handle_scope(isolate);
+    Local<Context> context = setup->context();
+    Context::Scope context_scope(context);
+    if (LoadBoxednodeEnvironment(context).IsEmpty())
+      return 1;
+    exit_code = SpinEventLoop(setup->env()).FromMaybe(1);
+  }
+
+  {
+    FILE* fp = fopen("intermediate.out", "wb");
+    setup->CreateSnapshot()->ToFile(fp);
+    fclose(fp);
+  }
+  return exit_code;
+}
+#else // BOXEDNODE_GENERATE_SNAPSHOT
 static int RunNodeInstance(MultiIsolatePlatform* platform,
                            const std::vector<std::string>& args,
                            const std::vector<std::string>& exec_args) {
@@ -81,7 +164,13 @@ static int RunNodeInstance(MultiIsolatePlatform* platform,
   std::shared_ptr<ArrayBufferAllocator> allocator =
       ArrayBufferAllocator::Create();
 
-#if NODE_VERSION_AT_LEAST(14, 0, 0)
+#ifdef BOXEDNODE_CONSUME_SNAPSHOT
+  std::vector<char> snapshot_blob_vec = boxednode::GetBoxednodeSnapshotBlobVector();
+  assert(EmbedderSnapshotData::CanUseCustomSnapshotPerIsolate());
+  node::EmbedderSnapshotData::Pointer snapshot_blob =
+    EmbedderSnapshotData::FromBlob(snapshot_blob_vec);
+  Isolate* isolate = NewIsolate(allocator, loop, platform, snapshot_blob.get());
+#elif NODE_VERSION_AT_LEAST(14, 0, 0)
   Isolate* isolate = NewIsolate(allocator, loop, platform);
 #else
   Isolate* isolate = NewIsolate(allocator.get(), loop, platform);
@@ -98,12 +187,19 @@ static int RunNodeInstance(MultiIsolatePlatform* platform,
     // Create a node::IsolateData instance that will later be released using
     // node::FreeIsolateData().
     std::unique_ptr<IsolateData, decltype(&node::FreeIsolateData)> isolate_data(
-        node::CreateIsolateData(isolate, loop, platform, allocator.get()),
+        node::CreateIsolateData(isolate, loop, platform, allocator.get()
+#ifdef BOXEDNODE_CONSUME_SNAPSHOT
+        , snapshot_blob.get()
+#endif
+        ),
         node::FreeIsolateData);
 
-    // Set up a new v8::Context.
     HandleScope handle_scope(isolate);
-    Local<Context> context = node::NewContext(isolate);
+    Local<Context> context;
+#ifndef BOXEDNODE_CONSUME_SNAPSHOT
+    // Set up a new v8::Context.
+    context = node::NewContext(isolate);
+
     if (context.IsEmpty()) {
       fprintf(stderr, "%s: Failed to initialize V8 Context\n", args[0].c_str());
       return 1;
@@ -112,12 +208,20 @@ static int RunNodeInstance(MultiIsolatePlatform* platform,
     // The v8::Context needs to be entered when node::CreateEnvironment() and
     // node::LoadEnvironment() are being called.
     Context::Scope context_scope(context);
+#endif
 
     // Create a node::Environment instance that will later be released using
     // node::FreeEnvironment().
     std::unique_ptr<Environment, decltype(&node::FreeEnvironment)> env(
         node::CreateEnvironment(isolate_data.get(), context, args, exec_args),
         node::FreeEnvironment);
+#ifdef BOXEDNODE_CONSUME_SNAPSHOT
+    assert(context.IsEmpty());
+    context = GetMainContext(env.get());
+    assert(!context.IsEmpty());
+    Context::Scope context_scope(context);
+#endif
+    assert(isolate->InContext());
 
     const void* node_mod;
     const void* napi_mod;
@@ -144,27 +248,9 @@ static int RunNodeInstance(MultiIsolatePlatform* platform,
     // `module.createRequire()` is being used to create one that is able to
     // load files from the disk, and uses the standard CommonJS file loader
     // instead of the internal-only `require` function.
-    Local<Value> loadenv_ret;
-    if (!node::LoadEnvironment(
-        env.get(),
-        "const path = require('path');\n"
-        "if (process.argv[2] === '--') process.argv.splice(2, 1);\n"
-        "return require(" REPLACE_WITH_ENTRY_POINT ")").ToLocal(&loadenv_ret)) {
+    if (LoadBoxednodeEnvironment(context).IsEmpty()) {
       return 1; // There has been a JS exception.
     }
-    assert(loadenv_ret->IsFunction());
-    Local<Value> trampoline_args[] = {
-      boxednode::GetBoxednodeMainScriptSource(isolate),
-      String::NewFromUtf8Literal(isolate, BOXEDNODE_CODE_CACHE_MODE),
-      boxednode::GetBoxednodeCodeCacheBuffer(isolate),
-    };
-    if (loadenv_ret.As<Function>()->Call(
-        context,
-        Null(isolate),
-        sizeof(trampoline_args) / sizeof(trampoline_args[0]),
-        trampoline_args).IsEmpty()) {
-      return 1; // JS exception.
-    }
 
     {
       // SealHandleScope protects against handle leaks from callbacks.
@@ -221,13 +307,14 @@ static int RunNodeInstance(MultiIsolatePlatform* platform,
 
   return exit_code;
 }
+#endif // BOXEDNODE_GENERATE_SNAPSHOT
 
 static int BoxednodeMain(std::vector<std::string> args) {
   std::vector<std::string> exec_args;
   std::vector<std::string> errors;
 
   if (args.size() > 0) {
-    args.insert(args.begin() + 1, "--");
+      args.insert(args.begin() + 1, "--");
 #ifdef PASS_NO_NODE_SNAPSHOT_OPTION
     args.insert(args.begin() + 1, "--no-node-snapshot");
 #endif
@@ -260,6 +347,12 @@ static int BoxednodeMain(std::vector<std::string> args) {
   exec_args = result->exec_args();
 #endif
 
+#ifdef BOXEDNODE_CONSUME_SNAPSHOT
+  if (args.size() > 0) {
+    args.insert(args.begin() + 1, "--boxednode-snapshot-argv-fixup");
+  }
+#endif
+
   // Create a v8::Platform instance. `MultiIsolatePlatform::Create()` is a way
   // to create a v8::Platform instance that Node.js can use when creating
   // Worker threads. When no `MultiIsolatePlatform` instance is present,