[v24.x backport] v8: adding total_allocated_bytes to HeapStatistics

common.gypi

@@ -38,7 +38,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.31',
+    'v8_embedder_string': '-node.32',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/include/v8-isolate.h

@@ -950,6 +950,13 @@ class V8_EXPORT Isolate {
    */
   void GetHeapStatistics(HeapStatistics* heap_statistics);
 
+  /**
+   * Get total allocated bytes since isolate creation.
+   * This should be used only by Node.JS, since it's a temporary method
+   * to avoid breaking ABI on HeapStatistics.
+   */
+  uint64_t GetTotalAllocatedBytes();
+
   /**
    * Returns the number of spaces in the heap.
    */

deps/v8/src/api/api.cc

@@ -10363,6 +10363,11 @@ void Isolate::GetHeapStatistics(HeapStatistics* heap_statistics) {
 #endif  // V8_ENABLE_WEBASSEMBLY
 }
 
+uint64_t Isolate::GetTotalAllocatedBytes() {
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(this);
+  return i_isolate->heap()->GetTotalAllocatedBytes();
+}
+
 size_t Isolate::NumberOfHeapSpaces() {
   return i::LAST_SPACE - i::FIRST_SPACE + 1;
 }

deps/v8/src/heap/heap-allocator.cc

@@ -65,24 +65,42 @@ AllocationResult HeapAllocator::AllocateRawLargeInternal(
     int size_in_bytes, AllocationType allocation, AllocationOrigin origin,
     AllocationAlignment alignment) {
   DCHECK_GT(size_in_bytes, heap_->MaxRegularHeapObjectSize(allocation));
+  AllocationResult allocation_result;
   switch (allocation) {
     case AllocationType::kYoung:
-      return new_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      allocation_result =
+          new_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      break;
     case AllocationType::kOld:
-      return lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      allocation_result =
+          lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      break;
     case AllocationType::kCode:
-      return code_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      allocation_result =
+          code_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      break;
     case AllocationType::kSharedOld:
-      return shared_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      allocation_result =
+          shared_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      break;
     case AllocationType::kTrusted:
-      return trusted_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      allocation_result =
+          trusted_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      break;
     case AllocationType::kSharedTrusted:
-      return shared_trusted_lo_space()->AllocateRaw(local_heap_, size_in_bytes);
+      allocation_result = shared_trusted_lo_space()->AllocateRaw(
+          local_heap_, size_in_bytes);
+      break;
     case AllocationType::kMap:
     case AllocationType::kReadOnly:
     case AllocationType::kSharedMap:
       UNREACHABLE();
   }
+  if (!allocation_result.IsFailure()) {
+    int allocated_size = ALIGN_TO_ALLOCATION_ALIGNMENT(size_in_bytes);
+    heap_->AddTotalAllocatedBytes(allocated_size);
+  }
+  return allocation_result;
 }
 
 namespace {

deps/v8/src/heap/heap.cc

@@ -7446,6 +7446,10 @@ int Heap::NextStackTraceId() {
   return last_id;
 }
 
+uint64_t Heap::GetTotalAllocatedBytes() {
+  return total_allocated_bytes_.load(std::memory_order_relaxed);
+}
+
 EmbedderStackStateScope::EmbedderStackStateScope(
     Heap* heap, EmbedderStackStateOrigin origin, StackState stack_state)
     : heap_(heap),

deps/v8/src/heap/heap.h

@@ -1635,6 +1635,11 @@ class Heap final {
   bool ShouldUseBackgroundThreads() const;
   bool ShouldUseIncrementalMarking() const;
 
+  void AddTotalAllocatedBytes(size_t size) {
+    total_allocated_bytes_.fetch_add(size, std::memory_order_relaxed);
+  }
+  uint64_t GetTotalAllocatedBytes();
+
   HeapAllocator* allocator() { return heap_allocator_; }
   const HeapAllocator* allocator() const { return heap_allocator_; }
 
@@ -2409,6 +2414,8 @@ class Heap final {
   // actually finished.
   bool is_full_gc_during_loading_ = false;
 
+  std::atomic<uint64_t> total_allocated_bytes_ = 0;
+
   // Classes in "heap" can be friends.
   friend class ActivateMemoryReducerTask;
   friend class AlwaysAllocateScope;

deps/v8/src/heap/main-allocator.cc

@@ -298,6 +298,12 @@ void MainAllocator::ResetLab(Address start, Address end, Address extended_end) {
     MemoryChunkMetadata::UpdateHighWaterMark(top());
   }
 
+  // This is going to overestimate a bit of the total allocated bytes, since the
+  // LAB was not used yet. However the leftover compared to the LAB itself is
+  // quite small, so it seems tolerable.
+  if (local_heap_) {
+    local_heap_->heap()->AddTotalAllocatedBytes(end - start);
+  }
   allocation_info().Reset(start, end);
 
   if (SupportsPendingAllocation()) {

doc/api/v8.md

@@ -197,6 +197,7 @@ Returns an object with the following properties:
 * `total_global_handles_size` {number}
 * `used_global_handles_size` {number}
 * `external_memory` {number}
+* `total_allocated_bytes` {number}
 
 `total_heap_size` The value of total\_heap\_size is the number of bytes V8 has
 allocated for the heap. This can grow if used\_heap needs more memory.
@@ -250,6 +251,9 @@ used memory size of V8 global handles.
 `external_memory` The value of external\_memory is the memory size of array
 buffers and external strings.
 
+`total_allocated_bytes` The value of total allocated bytes since the Isolate
+creation.
+
 <!-- eslint-skip -->
 
 ```js
@@ -267,7 +271,8 @@ buffers and external strings.
   number_of_detached_contexts: 0,
   total_global_handles_size: 8192,
   used_global_handles_size: 3296,
-  external_memory: 318824
+  external_memory: 318824,
+  total_allocated_bytes: 24970208
 }
 ```
 

lib/v8.js

@@ -117,6 +117,7 @@ const {
   stopCpuProfile: _stopCpuProfile,
   isStringOneByteRepresentation: _isStringOneByteRepresentation,
   updateHeapStatisticsBuffer,
+  getTotalAllocatedBytes,
   updateHeapSpaceStatisticsBuffer,
   updateHeapCodeStatisticsBuffer,
   setHeapSnapshotNearHeapLimit: _setHeapSnapshotNearHeapLimit,
@@ -246,6 +247,7 @@ function getHeapStatistics() {
     total_global_handles_size: buffer[kTotalGlobalHandlesSizeIndex],
     used_global_handles_size: buffer[kUsedGlobalHandlesSizeIndex],
     external_memory: buffer[kExternalMemoryIndex],
+    total_allocated_bytes: getTotalAllocatedBytes(),
   };
 }
 

src/node_v8.cc

@@ -212,6 +212,12 @@ void UpdateHeapStatisticsBuffer(const FunctionCallbackInfo<Value>& args) {
 #undef V
 }
 
+void GetTotalAllocatedBytes(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  uint64_t allocated_bytes = isolate->GetTotalAllocatedBytes();
+  args.GetReturnValue().Set(Number::New(isolate, allocated_bytes));
+}
+
 
 void UpdateHeapSpaceStatisticsBuffer(const FunctionCallbackInfo<Value>& args) {
   BindingData* data = Realm::GetBindingData<BindingData>(args);
@@ -692,6 +698,11 @@ void Initialize(Local<Object> target,
             "updateHeapStatisticsBuffer",
             UpdateHeapStatisticsBuffer);
 
+  SetMethod(context,
+            target,
+            "getTotalAllocatedBytes",
+            GetTotalAllocatedBytes);
+
   SetMethod(context,
             target,
             "updateHeapCodeStatisticsBuffer",
@@ -773,6 +784,7 @@ void Initialize(Local<Object> target,
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(CachedDataVersionTag);
   registry->Register(UpdateHeapStatisticsBuffer);
+  registry->Register(GetTotalAllocatedBytes);
   registry->Register(UpdateHeapCodeStatisticsBuffer);
   registry->Register(UpdateHeapSpaceStatisticsBuffer);
   registry->Register(SetFlagsFromString);

src/node_worker.cc

@@ -1263,6 +1263,7 @@ void Worker::GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
                 "total_global_handles_size",
                 "used_global_handles_size",
                 "external_memory",
+                "total_allocated_bytes",
             };
             tmpl = DictionaryTemplate::New(isolate, heap_stats_names);
             env->set_heap_statistics_template(tmpl);
@@ -1283,7 +1284,8 @@ void Worker::GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
               Number::New(isolate, heap_stats->number_of_detached_contexts()),
               Number::New(isolate, heap_stats->total_global_handles_size()),
               Number::New(isolate, heap_stats->used_global_handles_size()),
-              Number::New(isolate, heap_stats->external_memory())};
+              Number::New(isolate, heap_stats->external_memory()),
+              Number::New(isolate, isolate->GetTotalAllocatedBytes())};
 
           Local<Object> obj;
           if (!NewDictionaryInstanceNullProto(

test/parallel/test-v8-stats.js

@@ -12,6 +12,7 @@ const keys = [
   'number_of_detached_contexts',
   'number_of_native_contexts',
   'peak_malloced_memory',
+  'total_allocated_bytes',
   'total_available_size',
   'total_global_handles_size',
   'total_heap_size',

test/parallel/test-worker-heap-statistics.js

@@ -40,6 +40,7 @@ if (isMainThread) {
       `total_global_handles_size`,
       `used_global_handles_size`,
       `external_memory`,
+      `total_allocated_bytes`,
     ].sort();
     assert.deepStrictEqual(keys, Object.keys(stats).sort());
     for (const key of keys) {