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

common.gypi

@@ -79,7 +79,7 @@
 
     # Variables controlling external defines exposed in public headers.
     'v8_enable_map_packing%': 0,
-    'v8_enable_pointer_compression_shared_cage%': 0,
+    'v8_enable_pointer_compression_multiple_cages%': 0,
     'v8_enable_external_code_space%': 0,
     'v8_enable_sandbox%': 0,
     'v8_enable_v8_checks%': 0,
@@ -112,7 +112,7 @@
       # V8 pointer compression only supports 64bit architectures.
       ['target_arch in "arm ia32 mips mipsel"', {
         'v8_enable_pointer_compression': 0,
-        'v8_enable_pointer_compression_shared_cage': 0,
+        'v8_enable_pointer_compression_multiple_cages': 0,
         'v8_enable_31bit_smis_on_64bit_arch': 0,
         'v8_enable_external_code_space': 0,
         'v8_enable_sandbox': 0
@@ -443,10 +443,10 @@
       ['v8_enable_pointer_compression == 1', {
         'defines': ['V8_COMPRESS_POINTERS'],
       }],
-      ['v8_enable_pointer_compression_shared_cage == 1', {
-        'defines': ['V8_COMPRESS_POINTERS_IN_SHARED_CAGE'],
+      ['v8_enable_pointer_compression_multiple_cages == 1', {
+        'defines': ['V8_COMPRESS_POINTERS_IN_MULTIPLE_CAGES'],
       }],
-      ['v8_enable_pointer_compression == 1 and v8_enable_pointer_compression_shared_cage != 1', {
+      ['v8_enable_pointer_compression == 1 and v8_enable_pointer_compression_multiple_cages != 1', {
         'defines': ['V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE'],
       }],
       ['v8_enable_pointer_compression == 1 or v8_enable_31bit_smis_on_64bit_arch == 1', {

configure.py

@@ -1789,7 +1789,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_multiple_cages'] = 1 if options.enable_pointer_compression 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,6 +1,7 @@
 #include "debug_utils-inl.h"
 #include "env-inl.h"
 #include "node.h"
+#include "node_internals.h"
 #include "node_snapshot_builder.h"
 
 using v8::Context;
@@ -127,7 +128,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.cc

@@ -22,6 +22,7 @@
 #include "node.h"
 #include "node_config_file.h"
 #include "node_dotenv.h"
+#include "node_options.h"
 #include "node_task_runner.h"
 
 // ========== local headers ==========

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/node_options.cc

@@ -128,7 +128,12 @@ void PerIsolateOptions::HandleMaxOldSpaceSizePercentage(
   }
 
   // Get available memory in bytes
+#ifdef V8_COMPRESS_POINTERS
+  // When pointer compression is enabled, V8 uses a 4 GiB heap limit.
+  uint64_t total_memory = 4294967296;  // 4 GiB
+#else
   uint64_t total_memory = uv_get_total_memory();
+#endif
   uint64_t constrained_memory = uv_get_constrained_memory();
 
   // Use constrained memory if available, otherwise use total memory

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_;
 };
 

test/parallel/test-max-old-space-size-percentage.js

@@ -122,7 +122,9 @@ assert(
 );
 
 // Validate heap sizes against system memory
-const totalMemoryMB = Math.floor(os.totalmem() / 1024 / 1024);
+// When pointer compression is enabled, the maximum total memory is 4 GB
+const totalMemoryMB = process.config.variables.v8_enable_pointer_compression
+  ? 4096 : Math.floor(os.totalmem() / 1024 / 1024);
 const uint64Max = 2 ** 64 - 1;
 const constrainedMemory = process.constrainedMemory();
 const constrainedMemoryMB = Math.floor(constrainedMemory / 1024 / 1024);