[WIP] allow snapshotting from the embedder API

Author: addaleax

src/api/embed_helpers.cc

@@ -14,6 +14,7 @@ using v8::Locker;
 using v8::Maybe;
 using v8::Nothing;
 using v8::SealHandleScope;
+using v8::SnapshotCreator;
 
 namespace node {
 
@@ -78,16 +79,18 @@ struct CommonEnvironmentSetup::Impl {
   MultiIsolatePlatform* platform = nullptr;
   uv_loop_t loop;
   std::shared_ptr<ArrayBufferAllocator> allocator;
+  std::optional<SnapshotCreator> snapshot_creator;
   Isolate* isolate = nullptr;
   DeleteFnPtr<IsolateData, FreeIsolateData> isolate_data;
   DeleteFnPtr<Environment, FreeEnvironment> env;
-  Global<Context> context;
+  Global<Context> main_context;
 };
 
 CommonEnvironmentSetup::CommonEnvironmentSetup(
     MultiIsolatePlatform* platform,
     std::vector<std::string>* errors,
     const EmbedderSnapshotData* snapshot_data,
+    bool is_snapshotting,
     std::function<Environment*(const CommonEnvironmentSetup*)> make_env)
     : impl_(new Impl()) {
   CHECK_NOT_NULL(platform);
@@ -105,28 +108,42 @@ CommonEnvironmentSetup::CommonEnvironmentSetup(
   }
   loop->data = this;
 
-  impl_->allocator = ArrayBufferAllocator::Create();
-  impl_->isolate =
-      NewIsolate(impl_->allocator, &impl_->loop, platform, snapshot_data);
-  Isolate* isolate = impl_->isolate;
+  Isolate* isolate;
+  if (is_snapshotting) {
+    const std::vector<intptr_t>& external_references =
+        SnapshotBuilder::CollectExternalReferences();
+    isolate = impl_->isolate = Isolate::Allocate();
+    // Must be done before the SnapshotCreator creation so  that the
+    // memory reducer can be initialized.
+    platform->RegisterIsolate(isolate, loop);
+    impl_->snapshot_creator.emplace(isolate, external_references.data());
+    isolate->SetCaptureStackTraceForUncaughtExceptions(
+        true, 10, v8::StackTrace::StackTraceOptions::kDetailed);
+    SetIsolateMiscHandlers(isolate, {});
+  } else {
+    impl_->allocator = ArrayBufferAllocator::Create();
+    isolate = impl_->isolate =
+        NewIsolate(impl_->allocator, &impl_->loop, platform, snapshot_data);
+  }
 
   {
     Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     impl_->isolate_data.reset(CreateIsolateData(
         isolate, loop, platform, impl_->allocator.get(), snapshot_data));
+    impl_->isolate_data->options()->build_snapshot = is_snapshotting;
 
     HandleScope handle_scope(isolate);
     if (snapshot_data) {
       impl_->env.reset(make_env(this));
       if (impl_->env) {
-        impl_->context.Reset(isolate, impl_->env->context());
+        impl_->main_context.Reset(isolate, impl_->env->context());
       }
       return;
     }
 
     Local<Context> context = NewContext(isolate);
-    impl_->context.Reset(isolate, context);
+    impl_->main_context.Reset(isolate, context);
     if (context.IsEmpty()) {
       errors->push_back("Failed to initialize V8 Context");
       return;
@@ -141,7 +158,34 @@ CommonEnvironmentSetup::CommonEnvironmentSetup(
     MultiIsolatePlatform* platform,
     std::vector<std::string>* errors,
     std::function<Environment*(const CommonEnvironmentSetup*)> make_env)
-    : CommonEnvironmentSetup(platform, errors, nullptr, make_env) {}
+    : CommonEnvironmentSetup(platform, errors, nullptr, false, make_env) {}
+
+std::unique_ptr<CommonEnvironmentSetup>
+CommonEnvironmentSetup::CreateForSnapshotting(
+    MultiIsolatePlatform* platform,
+    std::vector<std::string>* errors,
+    const std::vector<std::string>& args,
+    const std::vector<std::string>& exec_args) {
+  // It's not guaranteed that a context that goes through
+  // v8_inspector::V8Inspector::contextCreated() is runtime-independent,
+  // so do not start the inspector on the main context when building
+  // the default snapshot.
+  uint64_t env_flags = EnvironmentFlags::kDefaultFlags |
+                        EnvironmentFlags::kNoCreateInspector;
+
+  auto ret = std::unique_ptr<CommonEnvironmentSetup>(new CommonEnvironmentSetup(
+      platform, errors, nullptr, true,
+      [&](const CommonEnvironmentSetup* setup) -> Environment* {
+        return CreateEnvironment(
+            setup->isolate_data(),
+            setup->context(),
+            args,
+            exec_args,
+            static_cast<EnvironmentFlags::Flags>(env_flags));
+      }));
+  if (!errors->empty()) ret.reset();
+  return ret;
+}
 
 CommonEnvironmentSetup::~CommonEnvironmentSetup() {
   if (impl_->isolate != nullptr) {
@@ -150,7 +194,7 @@ CommonEnvironmentSetup::~CommonEnvironmentSetup() {
       Locker locker(isolate);
       Isolate::Scope isolate_scope(isolate);
 
-      impl_->context.Reset();
+      impl_->main_context.Reset();
       impl_->env.reset();
       impl_->isolate_data.reset();
     }
@@ -160,7 +204,10 @@ CommonEnvironmentSetup::~CommonEnvironmentSetup() {
       *static_cast<bool*>(data) = true;
     }, &platform_finished);
     impl_->platform->UnregisterIsolate(isolate);
-    isolate->Dispose();
+    if (impl_->snapshot_creator.has_value())
+      impl_->snapshot_creator.reset();
+    else
+      isolate->Dispose();
 
     // Wait until the platform has cleaned up all relevant resources.
     while (!platform_finished)
@@ -173,6 +220,20 @@ CommonEnvironmentSetup::~CommonEnvironmentSetup() {
   delete impl_;
 }
 
+EmbedderSnapshotData::Pointer CommonEnvironmentSetup::CreateSnapshot() {
+  CHECK_NOT_NULL(snapshot_creator());
+  SnapshotData* snapshot_data = new SnapshotData();
+  EmbedderSnapshotData::Pointer result{
+      new EmbedderSnapshotData(snapshot_data, true)};
+
+  auto exit_code = SnapshotBuilder::CreateSnapshot(
+      snapshot_data, this,
+      static_cast<uint8_t>(SnapshotMetadata::Type::kFullyCustomized));
+  if (exit_code != ExitCode::kNoFailure) return {};
+
+  return result;
+}
+
 Maybe<int> SpinEventLoop(Environment* env) {
   Maybe<ExitCode> result = SpinEventLoopInternal(env);
   if (result.IsNothing()) {
@@ -203,7 +264,11 @@ Environment* CommonEnvironmentSetup::env() const {
 }
 
 v8::Local<v8::Context> CommonEnvironmentSetup::context() const {
-  return impl_->context.Get(impl_->isolate);
+  return impl_->main_context.Get(impl_->isolate);
+}
+
+v8::SnapshotCreator* CommonEnvironmentSetup::snapshot_creator() {
+  return impl_->snapshot_creator ? &impl_->snapshot_creator.value() : nullptr;
 }
 
 void EmbedderSnapshotData::DeleteSnapshotData::operator()(
@@ -232,6 +297,10 @@ EmbedderSnapshotData::Pointer EmbedderSnapshotData::FromFile(FILE* in) {
   return result;
 }
 
+void EmbedderSnapshotData::ToFile(FILE* out) const {
+  impl_->ToBlob(out);
+}
+
 EmbedderSnapshotData::EmbedderSnapshotData(const SnapshotData* impl,
                                            bool owns_impl)
     : impl_(impl), owns_impl_(owns_impl) {}

src/node.h

@@ -511,11 +511,16 @@ class EmbedderSnapshotData {
   static Pointer BuiltinSnapshotData();
 
   // Return an EmbedderSnapshotData object that is based on an input file.
-  // Calling this method will not consume but not close the FILE* handle.
+  // Calling this method will consume but not close the FILE* handle.
   // The FILE* handle can be closed immediately following this call.
   // If the snapshot is invalid, this returns an empty pointer.
   static Pointer FromFile(FILE* in);
 
+  // Write this EmbedderSnapshotData object to an output file.
+  // Calling this method will not close the FILE* handle.
+  // The FILE* handle can be closed immediately following this call.
+  void ToFile(FILE* out) const;
+
   // Returns whether custom snapshots can be used. Currently, this means
   // that V8 was configured without the shared-readonly-heap feature.
   static bool CanUseCustomSnapshotPerIsolate();
@@ -532,6 +537,7 @@ class EmbedderSnapshotData {
   const SnapshotData* impl_;
   bool owns_impl_;
   friend struct SnapshotData;
+  friend class CommonEnvironmentSetup;
 };
 
 // Overriding IsolateSettings may produce unexpected behavior
@@ -823,7 +829,29 @@ class NODE_EXTERN CommonEnvironmentSetup {
       const EmbedderSnapshotData* snapshot_data,
       EnvironmentArgs&&... env_args);
 
+  // Create an embedding setup which will be used for creating a snapshot
+  // using CreateSnapshot().
+  //
+  // This will create and attach a v8::SnapshotCreator to this instance,
+  // and the same restrictions apply to this instance that also apply to
+  // other V8 snapshotting environments.
+  // Not all Node.js APIs are supported in this case. Currently, there is
+  // no support for native/host objects other than Node.js builtins
+  // in the snapshot.
+  //
+  // Snapshots are an *experimental* feature. In particular, the embedder API
+  // exposed through this class is subject to change or removal between Node.js
+  // versions, including possible API and ABI breakage.
+  static std::unique_ptr<CommonEnvironmentSetup> CreateForSnapshotting(
+      MultiIsolatePlatform* platform,
+      std::vector<std::string>* errors,
+      const std::vector<std::string>& args = {},
+      const std::vector<std::string>& exec_args = {});
+  EmbedderSnapshotData::Pointer CreateSnapshot();
+
   struct uv_loop_s* event_loop() const;
+  v8::SnapshotCreator* snapshot_creator();
+  // Empty for snapshotting environments.
   std::shared_ptr<ArrayBufferAllocator> array_buffer_allocator() const;
   v8::Isolate* isolate() const;
   IsolateData* isolate_data() const;
@@ -846,6 +874,7 @@ class NODE_EXTERN CommonEnvironmentSetup {
       MultiIsolatePlatform*,
       std::vector<std::string>*,
       const EmbedderSnapshotData*,
+      bool is_snapshotting,
       std::function<Environment*(const CommonEnvironmentSetup*)>);
 };
 
@@ -878,6 +907,7 @@ CommonEnvironmentSetup::CreateWithSnapshot(
       platform,
       errors,
       snapshot_data,
+      false,
       [&](const CommonEnvironmentSetup* setup) -> Environment* {
         return CreateEnvironment(setup->isolate_data(),
                                  setup->context(),

src/node_main_instance.cc

@@ -29,34 +29,6 @@ using v8::Isolate;
 using v8::Local;
 using v8::Locker;
 
-NodeMainInstance::NodeMainInstance(Isolate* isolate,
-                                   uv_loop_t* event_loop,
-                                   MultiIsolatePlatform* platform,
-                                   const std::vector<std::string>& args,
-                                   const std::vector<std::string>& exec_args)
-    : args_(args),
-      exec_args_(exec_args),
-      array_buffer_allocator_(nullptr),
-      isolate_(isolate),
-      platform_(platform),
-      isolate_data_(nullptr),
-      snapshot_data_(nullptr) {
-  isolate_data_ =
-      std::make_unique<IsolateData>(isolate_, event_loop, platform, nullptr);
-
-  SetIsolateMiscHandlers(isolate_, {});
-}
-
-std::unique_ptr<NodeMainInstance> NodeMainInstance::Create(
-    Isolate* isolate,
-    uv_loop_t* event_loop,
-    MultiIsolatePlatform* platform,
-    const std::vector<std::string>& args,
-    const std::vector<std::string>& exec_args) {
-  return std::unique_ptr<NodeMainInstance>(
-      new NodeMainInstance(isolate, event_loop, platform, args, exec_args));
-}
-
 NodeMainInstance::NodeMainInstance(const SnapshotData* snapshot_data,
                                    uv_loop_t* event_loop,
                                    MultiIsolatePlatform* platform,
@@ -88,13 +60,6 @@ NodeMainInstance::NodeMainInstance(const SnapshotData* snapshot_data,
       isolate_params_->constraints.max_young_generation_size_in_bytes();
 }
 
-void NodeMainInstance::Dispose() {
-  // This should only be called on a main instance that does not own its
-  // isolate.
-  CHECK_NULL(isolate_params_);
-  platform_->DrainTasks(isolate_);
-}
-
 NodeMainInstance::~NodeMainInstance() {
   if (isolate_params_ == nullptr) {
     return;

src/node_main_instance.h

@@ -22,33 +22,6 @@ struct SnapshotData;
 // We may be able to create an abstract class to reuse some of the routines.
 class NodeMainInstance {
  public:
-  // To create a main instance that does not own the isolate,
-  // The caller needs to do:
-  //
-  //   Isolate* isolate = Isolate::Allocate();
-  //   platform->RegisterIsolate(isolate, loop);
-  //   isolate->Initialize(...);
-  //   isolate->Enter();
-  //   std::unique_ptr<NodeMainInstance> main_instance =
-  //       NodeMainInstance::Create(isolate, loop, args, exec_args);
-  //
-  // When tearing it down:
-  //
-  //   main_instance->Cleanup();  // While the isolate is entered
-  //   isolate->Exit();
-  //   isolate->Dispose();
-  //   platform->UnregisterIsolate(isolate);
-  //
-  // After calling Dispose() the main_instance is no longer accessible.
-  static std::unique_ptr<NodeMainInstance> Create(
-      v8::Isolate* isolate,
-      uv_loop_t* event_loop,
-      MultiIsolatePlatform* platform,
-      const std::vector<std::string>& args,
-      const std::vector<std::string>& exec_args);
-
-  void Dispose();
-
   // Create a main instance that owns the isolate
   NodeMainInstance(const SnapshotData* snapshot_data,
                    uv_loop_t* event_loop,

src/node_snapshot_builder.h

@@ -31,10 +31,15 @@ class NODE_EXTERN_PRIVATE SnapshotBuilder {
   static void InitializeIsolateParams(const SnapshotData* data,
                                       v8::Isolate::CreateParams* params);
 
- private:
   static const std::vector<intptr_t>& CollectExternalReferences();
 
-  static std::unique_ptr<ExternalReferenceRegistry> registry_;
+  static ExitCode CreateSnapshot(
+      SnapshotData* out,
+      CommonEnvironmentSetup* setup,
+      /*SnapshotMetadata::Type*/uint8_t snapshot_type);
+
+ private:
+   static std::unique_ptr<ExternalReferenceRegistry> registry_;
 };
 }  // namespace node