src: initial enablement of IsolateGroups

This lays the initial groundwork for enabling the
use of IsolateGroups.

Every isolate in V8 is created within a group. When pointer
compression is enabled, all isolates within a single group
are limited to a 4 GB shared pointer cage. By default, all
isolates in the process share the same group, which means
that when running with pointer compression, the entire
process would be limited to a single 4 GB shared pointer
cage. But, we can create as many IsolateGroups as we want,
limited only by the amount of virtual memory available on
the machine.

Author: jasnell

configure.py

@@ -646,6 +646,12 @@
     default=None,
     help='[Experimental] Enable V8 pointer compression (limits max heap to 4GB and breaks ABI compatibility)')
 
+parser.add_argument('--experimental-enable-pointer-compression-multicage',
+    action='store_true',
+    dest='enable_pointer_compression_multicage',
+    default=None,
+    help='[Experimental] When pointer compression is enabled, turns on multi cage mode')
+
 parser.add_argument('--v8-options',
     action='store',
     dest='v8_options',
@@ -1789,7 +1795,7 @@ def configure_v8(o, configs):
   # Note that enabling pointer compression without enabling sandbox is unsupported by V8,
   # so this can be broken at any time.
   o['variables']['v8_enable_sandbox'] = 0
-  o['variables']['v8_enable_pointer_compression_shared_cage'] = 1 if options.enable_pointer_compression else 0
+  o['variables']['v8_enable_pointer_compression_shared_cage'] = 1 if options.enable_pointer_compression and not options.enable_pointer_compression_multicage else 0
   o['variables']['v8_enable_external_code_space'] = 1 if options.enable_pointer_compression else 0
   o['variables']['v8_enable_31bit_smis_on_64bit_arch'] = 1 if options.enable_pointer_compression else 0
   o['variables']['v8_enable_extensible_ro_snapshot'] = 0

src/api/embed_helpers.cc

@@ -1,13 +1,15 @@
 #include "debug_utils-inl.h"
 #include "env-inl.h"
 #include "node.h"
+#include "node_internals.h"
 #include "node_snapshot_builder.h"
 
 using v8::Context;
 using v8::Function;
 using v8::Global;
 using v8::HandleScope;
 using v8::Isolate;
+using v8::IsolateGroup;
 using v8::Just;
 using v8::Local;
 using v8::Locker;
@@ -127,7 +129,7 @@ CommonEnvironmentSetup::CommonEnvironmentSetup(
   if (flags & Flags::kIsForSnapshotting) {
     // The isolate must be registered before the SnapshotCreator initializes the
     // isolate, so that the memory reducer can be initialized.
-    isolate = impl_->isolate = Isolate::Allocate();
+    isolate = impl_->isolate = Isolate::Allocate(GetOrCreateIsolateGroup());
     platform->RegisterIsolate(isolate, loop);
 
     impl_->snapshot_creator.emplace(isolate, params);

src/api/environment.cc

@@ -37,6 +37,7 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
 using v8::Isolate;
+using v8::IsolateGroup;
 using v8::Just;
 using v8::JustVoid;
 using v8::Local;
@@ -304,14 +305,26 @@ void SetIsolateUpForNode(v8::Isolate* isolate) {
   SetIsolateUpForNode(isolate, settings);
 }
 
+//
+IsolateGroup GetOrCreateIsolateGroup() {
+  // When pointer compression is disabled, we cannot create new groups,
+  // in which case we'll always return the default.
+  if (IsolateGroup::CanCreateNewGroups()) {
+    return IsolateGroup::Create();
+  }
+
+  return IsolateGroup::GetDefault();
+}
+
 // TODO(joyeecheung): we may want to expose this, but then we need to be
 // careful about what we override in the params.
 Isolate* NewIsolate(Isolate::CreateParams* params,
                     uv_loop_t* event_loop,
                     MultiIsolatePlatform* platform,
                     const SnapshotData* snapshot_data,
                     const IsolateSettings& settings) {
-  Isolate* isolate = Isolate::Allocate();
+  IsolateGroup group = GetOrCreateIsolateGroup();
+  Isolate* isolate = Isolate::Allocate(group);
   if (isolate == nullptr) return nullptr;
 
   if (snapshot_data != nullptr) {

src/node_internals.h

@@ -342,6 +342,20 @@ void TraceEnvVar(Environment* env,
                  v8::Local<v8::String> key);
 
 void DefineZlibConstants(v8::Local<v8::Object> target);
+
+// If creating new v8::IsolateGroup instance is supported, this returns a
+// new instance. Otherwise, it returns the default instance.
+//
+// An IsolateGroup is a collection of Isolates that share the same underlying
+// pointer cage when pointer compression is enabled. When pointer compression is
+// disabled, there is a default IsolateGroup that is used for all isolates, and
+// when pointer compression is enabled, all isolates in the app share the
+// same pointer cage by default that is limited a maximum of 4GB, not counting
+// array buffers and off-heap storage. Multiple IsolateGroups can be used to
+// work around the 4GB limit, but each group reserves a range of virtual memory
+// addresses, so this should be used with care.
+v8::IsolateGroup GetOrCreateIsolateGroup();
+
 v8::Isolate* NewIsolate(v8::Isolate::CreateParams* params,
                         uv_loop_t* event_loop,
                         MultiIsolatePlatform* platform,

src/util.cc

@@ -736,8 +736,9 @@ Local<String> UnionBytes::ToStringChecked(Isolate* isolate) const {
 }
 
 RAIIIsolateWithoutEntering::RAIIIsolateWithoutEntering(const SnapshotData* data)
-    : allocator_{ArrayBuffer::Allocator::NewDefaultAllocator()} {
-  isolate_ = Isolate::Allocate();
+    : allocator_{ArrayBuffer::Allocator::NewDefaultAllocator()},
+      isolate_group_(GetOrCreateIsolateGroup()) {
+  isolate_ = Isolate::Allocate(isolate_group_);
   CHECK_NOT_NULL(isolate_);
   per_process::v8_platform.Platform()->RegisterIsolate(isolate_,
                                                        uv_default_loop());

src/util.h

@@ -990,6 +990,7 @@ class RAIIIsolateWithoutEntering {
 
  private:
   std::unique_ptr<v8::ArrayBuffer::Allocator> allocator_;
+  v8::IsolateGroup isolate_group_;
   v8::Isolate* isolate_;
 };