src: snapshot Environment upon instantiation

Author: joyeecheung

src/aliased_buffer.h

@@ -10,6 +10,8 @@
 
 namespace node {
 
+typedef size_t AliasedBufferInfo;
+
 /**
  * Do not use this class directly when creating instances of it - use the
  * Aliased*Array defined at the end of this file instead.
@@ -28,7 +30,14 @@ namespace node {
  * observed. Any notification APIs will be left as a future exercise.
  */
 
-enum class AliasedBufferType { kNew, kCopy, kShared, kAssigned };
+enum class AliasedBufferType {
+  kNew,
+  kCopy,
+  kShared,
+  kAssigned,
+  kToBeDeserialized,
+  kDeserialized
+};
 
 template <class NativeT,
           class V8T,
@@ -38,25 +47,51 @@ class AliasedBufferBase {
  public:
   static std::unordered_set<AliasedBufferBase*> buffers;
 
-  inline AliasedBufferBase(v8::Isolate* isolate, const size_t count)
+  inline AliasedBufferBase(v8::Isolate* isolate,
+                           const size_t count,
+                           const AliasedBufferInfo* info = nullptr)
       : isolate_(isolate),
         count_(count),
         byte_offset_(0),
         type_(AliasedBufferType::kNew) {
     buffers.insert(this);
-    CHECK_GT(count, 0);
     const v8::HandleScope handle_scope(isolate_);
-    const size_t size_in_bytes =
-        MultiplyWithOverflowCheck(sizeof(NativeT), count);
+    if (info == nullptr) {
+      CHECK_GT(count, 0);
+      const size_t size_in_bytes =
+          MultiplyWithOverflowCheck(sizeof(NativeT), count);
+
+      // allocate v8 ArrayBuffer
+      v8::Local<v8::ArrayBuffer> ab =
+          v8::ArrayBuffer::New(isolate_, size_in_bytes);
+      buffer_ = static_cast<NativeT*>(ab->GetBackingStore()->Data());
+
+      // allocate v8 TypedArray
+      v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
+      js_array_ = v8::Global<V8T>(isolate, js_array);
+    } else {
+      // To be deserialized later when context is available
+      type_ = AliasedBufferType::kToBeDeserialized;
+      info_ = info;
+      buffer_ = nullptr;
+    }
+  }
 
-    // allocate v8 ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, size_in_bytes);
-    buffer_ = static_cast<NativeT*>(ab->GetBackingStore()->Data());
+  AliasedBufferInfo Serialize(v8::Local<v8::Context> context,
+                              v8::SnapshotCreator* creator) {
+    return creator->AddData(context, GetJSArray());
+  }
 
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
+  inline void Deserialize(v8::Local<v8::Context> context) {
+    DCHECK_EQ(type_, AliasedBufferType::kToBeDeserialized);
+    v8::Local<V8T> arr =
+        context->GetDataFromSnapshotOnce<V8T>(*info_).ToLocalChecked();
+    DCHECK_EQ(count_, arr->Length());
+    byte_offset_ = arr->ByteOffset();
+    buffer_ = static_cast<NativeT*>(arr->Buffer()->GetBackingStore()->Data());
+    js_array_.Reset(isolate_, arr);
+    info_ = nullptr;
+    type_ = AliasedBufferType::kDeserialized;
   }
 
   /**
@@ -80,19 +115,34 @@ class AliasedBufferBase {
     buffers.insert(this);
     const v8::HandleScope handle_scope(isolate_);
 
+    if (backing_buffer.type() == AliasedBufferType::kToBeDeserialized) {
+      type_ = AliasedBufferType::kToBeDeserialized;
+      buffer_ = nullptr;
+      return;
+    }
+    CreateView(backing_buffer);
+  }
+
+  inline void CreateView(
+      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer) {
     v8::Local<v8::ArrayBuffer> ab = backing_buffer.GetArrayBuffer();
 
     // validate that the byte_offset is aligned with sizeof(NativeT)
-    CHECK_EQ(byte_offset & (sizeof(NativeT) - 1), 0);
+    CHECK_EQ(byte_offset_ & (sizeof(NativeT) - 1), 0);
     // validate this fits inside the backing buffer
-    CHECK_LE(MultiplyWithOverflowCheck(sizeof(NativeT), count),
-             ab->ByteLength() - byte_offset);
+    CHECK_LE(MultiplyWithOverflowCheck(sizeof(NativeT), count_),
+             ab->ByteLength() - byte_offset_);
 
     buffer_ = reinterpret_cast<NativeT*>(
-        const_cast<uint8_t*>(backing_buffer.GetNativeBuffer() + byte_offset));
+        const_cast<uint8_t*>(backing_buffer.GetNativeBuffer() + byte_offset_));
+
+    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count_);
+    js_array_ = v8::Global<V8T>(isolate_, js_array);
 
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
+    if (type_ == AliasedBufferType::kToBeDeserialized) {
+      type_ = AliasedBufferType::kShared;
+      info_ = nullptr;
+    }
   }
 
   AliasedBufferBase(const AliasedBufferBase& that)
@@ -102,12 +152,14 @@ class AliasedBufferBase {
         buffer_(that.buffer_),
         type_(AliasedBufferType::kCopy) {
     buffers.insert(this);
+    DCHECK_NE(type_, AliasedBufferType::kToBeDeserialized);
     js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
   }
 
   inline ~AliasedBufferBase() { buffers.erase(this); }
 
   AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {
+    DCHECK_NE(type_, AliasedBufferType::kToBeDeserialized);
     this->~AliasedBufferBase();
     isolate_ = that.isolate_;
     count_ = that.count_;
@@ -174,6 +226,7 @@ class AliasedBufferBase {
    *  Get the underlying v8 TypedArray overlayed on top of the native buffer
    */
   v8::Local<V8T> GetJSArray() const {
+    DCHECK_NE(type_, AliasedBufferType::kToBeDeserialized);
     return js_array_.Get(isolate_);
   }
 
@@ -190,6 +243,7 @@ class AliasedBufferBase {
    *  through the GetValue/SetValue/operator[] methods
    */
   inline const NativeT* GetNativeBuffer() const {
+    DCHECK_NE(type_, AliasedBufferType::kToBeDeserialized);
     return buffer_;
   }
 
@@ -205,13 +259,15 @@ class AliasedBufferBase {
    */
   inline void SetValue(const size_t index, NativeT value) {
     DCHECK_LT(index, count_);
+    DCHECK_NE(type_, AliasedBufferType::kToBeDeserialized);
     buffer_[index] = value;
   }
 
   /**
    *  Get value at position index
    */
   inline const NativeT GetValue(const size_t index) const {
+    DCHECK_NE(type_, AliasedBufferType::kToBeDeserialized);
     DCHECK_LT(index, count_);
     return buffer_[index];
   }
@@ -220,6 +276,7 @@ class AliasedBufferBase {
    *  Effectively, a synonym for GetValue/SetValue
    */
   Reference operator[](size_t index) {
+    DCHECK_NE(type_, AliasedBufferType::kToBeDeserialized);
     return Reference(this, index);
   }
 
@@ -279,6 +336,7 @@ class AliasedBufferBase {
   NativeT* buffer_;
   v8::Global<V8T> js_array_;
   AliasedBufferType type_;
+  const AliasedBufferInfo* info_ = nullptr;
 };
 
 template <class NativeT, class V8T, typename Trait>

src/api/environment.cc

@@ -369,15 +369,7 @@ Environment* CreateEnvironment(
   // TODO(addaleax): This is a much better place for parsing per-Environment
   // options than the global parse call.
   Environment* env = new Environment(
-      isolate_data,
-      context,
-      args,
-      exec_args,
-      flags,
-      thread_id);
-  if (flags & EnvironmentFlags::kOwnsProcessState) {
-    env->set_abort_on_uncaught_exception(false);
-  }
+      isolate_data, context, args, exec_args, nullptr, flags, thread_id);
 
 #if HAVE_INSPECTOR
   if (inspector_parent_handle) {

src/base_object.h

@@ -30,6 +30,8 @@
 
 namespace node {
 
+enum class InternalFieldType { kDefault = 0, kNoBindingData };
+
 class Environment;
 template <typename T, bool kIsWeak>
 class BaseObjectPtrImpl;
@@ -98,10 +100,14 @@ class BaseObject : public MemoryRetainer {
   // a BaseObjectPtr to this object.
   inline void Detach();
 
+  InternalFieldType type() { return type_; }
+  void set_type(InternalFieldType type) { type_ = type; }
+
  protected:
   virtual inline void OnGCCollect();
 
  private:
+  InternalFieldType type_ = InternalFieldType::kDefault;
   v8::Local<v8::Object> WrappedObject() const override;
   static void DeleteMe(void* data);
 

src/debug_utils.h

@@ -45,7 +45,8 @@ void FWrite(FILE* file, const std::string& str);
   V(INSPECTOR_SERVER)                                                          \
   V(INSPECTOR_PROFILER)                                                        \
   V(CODE_CACHE)                                                                \
-  V(WASI)
+  V(WASI)                                                                      \
+  V(MKSNAPSHOT)
 
 enum class DebugCategory {
 #define V(name) name,

src/env-inl.h

@@ -77,29 +77,6 @@ inline v8::Local<v8::String> IsolateData::async_wrap_provider(int index) const {
   return async_wrap_providers_[index].Get(isolate_);
 }
 
-inline AsyncHooks::AsyncHooks()
-    : async_ids_stack_(env()->isolate(), 16 * 2),
-      fields_(env()->isolate(), kFieldsCount),
-      async_id_fields_(env()->isolate(), kUidFieldsCount) {
-  clear_async_id_stack();
-
-  // Always perform async_hooks checks, not just when async_hooks is enabled.
-  // TODO(AndreasMadsen): Consider removing this for LTS releases.
-  // See discussion in https://github.com/nodejs/node/pull/15454
-  // When removing this, do it by reverting the commit. Otherwise the test
-  // and flag changes won't be included.
-  fields_[kCheck] = 1;
-
-  // kDefaultTriggerAsyncId should be -1, this indicates that there is no
-  // specified default value and it should fallback to the executionAsyncId.
-  // 0 is not used as the magic value, because that indicates a missing context
-  // which is different from a default context.
-  async_id_fields_[AsyncHooks::kDefaultTriggerAsyncId] = -1;
-
-  // kAsyncIdCounter should start at 1 because that'll be the id the execution
-  // context during bootstrap (code that runs before entering uv_run()).
-  async_id_fields_[AsyncHooks::kAsyncIdCounter] = 1;
-}
 inline AliasedUint32Array& AsyncHooks::fields() {
   return fields_;
 }
@@ -238,9 +215,6 @@ inline void Environment::PopAsyncCallbackScope() {
   async_callback_scope_depth_--;
 }
 
-inline ImmediateInfo::ImmediateInfo(v8::Isolate* isolate)
-    : fields_(isolate, kFieldsCount) {}
-
 inline AliasedUint32Array& ImmediateInfo::fields() {
   return fields_;
 }
@@ -265,9 +239,6 @@ inline void ImmediateInfo::ref_count_dec(uint32_t decrement) {
   fields_[kRefCount] -= decrement;
 }
 
-inline TickInfo::TickInfo(v8::Isolate* isolate)
-    : fields_(isolate, kFieldsCount) {}
-
 inline AliasedUint8Array& TickInfo::fields() {
   return fields_;
 }
@@ -365,16 +336,22 @@ inline v8::Local<v8::Uint32> BindingDataBase::New(
     Environment* env,
     v8::Local<v8::Context> context,
     v8::Local<v8::Object> target) {
-  T* data = new T(env, target);
+  return Initialize(context, new T(env, target));
+}
+
+template <typename T>
+inline v8::Local<v8::Uint32> BindingDataBase::Initialize(
+    v8::Local<v8::Context> context, T* binding) {
   // This won't compile if T is not a BindingDataBase subclass.
-  BindingDataBase* item = static_cast<BindingDataBase*>(data);
+  BindingDataBase* item = static_cast<BindingDataBase*>(binding);
   std::vector<BindingDataBase*>* list =
       static_cast<std::vector<BindingDataBase*>*>(
           context->GetAlignedPointerFromEmbedderData(
               ContextEmbedderIndex::KBindingListIndex));
   size_t index = list->size();
   list->push_back(item);
-  return v8::Integer::NewFromUnsigned(env->isolate(), index).As<v8::Uint32>();
+  return v8::Integer::NewFromUnsigned(context->GetIsolate(), index)
+      .As<v8::Uint32>();
 }
 
 template <typename T>
@@ -384,7 +361,7 @@ Environment::BindingScope<T>::BindingScope(Environment* env,
     : env(env) {
   v8::Local<v8::Uint32> index = BindingDataBase::New<T>(env, context, target);
   data = BindingDataBase::Unwrap<T>(context, index);
-  env->set_current_callback_data(index);
+  env->set_current_callback_data(index.As<v8::Uint32>());
 }
 
 template <typename T>