src: use v8::ExternalMemoryAccounter

`Isolate::AdjustAmountOfExternalAllocatedMemory` is deprecated.

Refs: v8/v8@7dc4c18
PR-URL: #58070
Reviewed-By: Antoine du Hamel <[email protected]>
Reviewed-By: Darshan Sen <[email protected]>
Reviewed-By: Joyee Cheung <[email protected]>
Reviewed-By: Rafael Gonzaga <[email protected]>

Author: targos

src/crypto/crypto_bio.h

@@ -156,15 +156,15 @@ class NodeBIO : public MemoryRetainer {
                                            len_(len),
                                            next_(nullptr) {
       data_ = new char[len];
-      if (env_ != nullptr)
-        env_->isolate()->AdjustAmountOfExternalAllocatedMemory(len);
+      if (env_ != nullptr) {
+        env_->external_memory_accounter()->Increase(env_->isolate(), len);
+      }
     }
 
     ~Buffer() {
       delete[] data_;
       if (env_ != nullptr) {
-        const int64_t len = static_cast<int64_t>(len_);
-        env_->isolate()->AdjustAmountOfExternalAllocatedMemory(-len);
+        env_->external_memory_accounter()->Decrease(env_->isolate(), len_);
       }
     }
 

src/crypto/crypto_context.cc

@@ -1104,12 +1104,13 @@ SecureContext* SecureContext::Create(Environment* env) {
 SecureContext::SecureContext(Environment* env, Local<Object> wrap)
     : BaseObject(env, wrap) {
   MakeWeak();
-  env->isolate()->AdjustAmountOfExternalAllocatedMemory(kExternalSize);
+  env->external_memory_accounter()->Increase(env->isolate(), kExternalSize);
 }
 
 inline void SecureContext::Reset() {
   if (ctx_ != nullptr) {
-    env()->isolate()->AdjustAmountOfExternalAllocatedMemory(-kExternalSize);
+    env()->external_memory_accounter()->Decrease(env()->isolate(),
+                                                 kExternalSize);
   }
   ctx_.reset();
   cert_.reset();

src/crypto/crypto_tls.cc

@@ -431,7 +431,7 @@ TLSWrap::TLSWrap(Environment* env,
   StreamBase::AttachToObject(GetObject());
   stream->PushStreamListener(this);
 
-  env_->isolate()->AdjustAmountOfExternalAllocatedMemory(kExternalSize);
+  env_->external_memory_accounter()->Increase(env_->isolate(), kExternalSize);
 
   InitSSL();
   Debug(this, "Created new TLSWrap");
@@ -1317,7 +1317,7 @@ void TLSWrap::Destroy() {
   // And destroy
   InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
 
-  env()->isolate()->AdjustAmountOfExternalAllocatedMemory(-kExternalSize);
+  env()->external_memory_accounter()->Decrease(env()->isolate(), kExternalSize);
   ssl_.reset();
 
   enc_in_ = nullptr;

src/env-inl.h

@@ -205,6 +205,11 @@ inline v8::Isolate* Environment::isolate() const {
   return isolate_;
 }
 
+inline v8::ExternalMemoryAccounter* Environment::external_memory_accounter()
+    const {
+  return external_memory_accounter_;
+}
+
 inline Environment* Environment::from_timer_handle(uv_timer_t* handle) {
   return ContainerOf(&Environment::timer_handle_, handle);
 }

src/env.cc

@@ -48,6 +48,7 @@ using v8::CppHeap;
 using v8::CppHeapCreateParams;
 using v8::EmbedderGraph;
 using v8::EscapableHandleScope;
+using v8::ExternalMemoryAccounter;
 using v8::Function;
 using v8::HandleScope;
 using v8::HeapProfiler;
@@ -803,6 +804,7 @@ Environment::Environment(IsolateData* isolate_data,
                          EnvironmentFlags::Flags flags,
                          ThreadId thread_id)
     : isolate_(isolate),
+      external_memory_accounter_(new ExternalMemoryAccounter()),
       isolate_data_(isolate_data),
       async_hooks_(isolate, MAYBE_FIELD_PTR(env_info, async_hooks)),
       immediate_info_(isolate, MAYBE_FIELD_PTR(env_info, immediate_info)),
@@ -1056,6 +1058,8 @@ Environment::~Environment() {
       addon.Close();
     }
   }
+
+  delete external_memory_accounter_;
 }
 
 void Environment::InitializeLibuv() {

src/env.h

@@ -48,6 +48,7 @@
 #include "req_wrap.h"
 #include "util.h"
 #include "uv.h"
+#include "v8-external-memory-accounter.h"
 #include "v8.h"
 
 #if HAVE_OPENSSL
@@ -696,6 +697,7 @@ class Environment final : public MemoryRetainer {
   void StartProfilerIdleNotifier();
 
   inline v8::Isolate* isolate() const;
+  inline v8::ExternalMemoryAccounter* external_memory_accounter() const;
   inline uv_loop_t* event_loop() const;
   void TryLoadAddon(const char* filename,
                     int flags,
@@ -1078,6 +1080,7 @@ class Environment final : public MemoryRetainer {
 
   std::list<binding::DLib> loaded_addons_;
   v8::Isolate* const isolate_;
+  v8::ExternalMemoryAccounter* const external_memory_accounter_;
   IsolateData* const isolate_data_;
 
   bool env_handle_initialized_ = false;

src/node_buffer.cc

@@ -154,7 +154,7 @@ CallbackInfo::CallbackInfo(Environment* env,
       hint_(hint),
       env_(env) {
   env->cleanable_queue()->PushFront(this);
-  env->isolate()->AdjustAmountOfExternalAllocatedMemory(sizeof(*this));
+  env->external_memory_accounter()->Increase(env->isolate(), sizeof(*this));
 }
 
 void CallbackInfo::Clean() {
@@ -182,8 +182,7 @@ void CallbackInfo::CallAndResetCallback() {
   if (callback != nullptr) {
     // Clean up all Environment-related state and run the callback.
     cleanable_queue_.Remove();
-    int64_t change_in_bytes = -static_cast<int64_t>(sizeof(*this));
-    env_->isolate()->AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
+    env_->external_memory_accounter()->Decrease(env_->isolate(), sizeof(*this));
 
     callback(data_, hint_);
   }

src/node_mem-inl.h

@@ -54,19 +54,19 @@ void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr,
   if (mem != nullptr) {
     // Adjust the memory info counter.
     // TODO(addaleax): Avoid the double bookkeeping we do with
-    // current_nghttp2_memory_ + AdjustAmountOfExternalAllocatedMemory
+    // current_nghttp2_memory_ + ExternalMemoryAccounter
     // and provide versions of our memory allocation utilities that take an
     // Environment*/Isolate* parameter and call the V8 method transparently.
     const int64_t new_size = size - previous_size;
     manager->IncreaseAllocatedSize(new_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        new_size);
+    manager->env()->external_memory_accounter()->Increase(
+        manager->env()->isolate(), new_size);
     *reinterpret_cast<size_t*>(mem) = size;
     mem += sizeof(size_t);
   } else if (size == 0) {
     manager->DecreaseAllocatedSize(previous_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        -static_cast<int64_t>(previous_size));
+    manager->env()->external_memory_accounter()->Decrease(
+        manager->env()->isolate(), previous_size);
   }
   return mem;
 }
@@ -99,8 +99,8 @@ void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) {
       static_cast<char*>(ptr) - sizeof(size_t));
   Class* manager = static_cast<Class*>(this);
   manager->DecreaseAllocatedSize(*original_ptr);
-  manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-      -static_cast<int64_t>(*original_ptr));
+  manager->env()->external_memory_accounter()->Decrease(
+      manager->env()->isolate(), *original_ptr);
   *original_ptr = 0;
 }
 

src/node_zlib.cc

@@ -642,7 +642,8 @@ class CompressionStream : public AsyncWrap, public ThreadPoolWork {
     if (report == 0) return;
     CHECK_IMPLIES(report < 0, zlib_memory_ >= static_cast<size_t>(-report));
     zlib_memory_ += report;
-    AsyncWrap::env()->isolate()->AdjustAmountOfExternalAllocatedMemory(report);
+    AsyncWrap::env()->external_memory_accounter()->Increase(
+        AsyncWrap::env()->isolate(), report);
   }
 
   struct AllocScope {

src/string_bytes.cc

@@ -27,6 +27,7 @@
 #include "node_errors.h"
 #include "simdutf.h"
 #include "util.h"
+#include "v8-external-memory-accounter.h"
 
 #include <climits>
 #include <cstring>  // memcpy
@@ -40,6 +41,7 @@
 
 namespace node {
 
+using v8::ExternalMemoryAccounter;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Just;
@@ -57,7 +59,8 @@ class ExternString: public ResourceType {
  public:
   ~ExternString() override {
     free(const_cast<TypeName*>(data_));
-    isolate()->AdjustAmountOfExternalAllocatedMemory(-byte_length());
+    external_memory_accounter_->Decrease(isolate(), byte_length());
+    delete external_memory_accounter_;
   }
 
   const TypeName* data() const override {
@@ -68,9 +71,7 @@ class ExternString: public ResourceType {
     return length_;
   }
 
-  int64_t byte_length() const {
-    return length() * sizeof(*data());
-  }
+  size_t byte_length() const { return length() * sizeof(*data()); }
 
   static MaybeLocal<Value> NewFromCopy(Isolate* isolate,
                                        const TypeName* data,
@@ -117,16 +118,19 @@ class ExternString: public ResourceType {
       return MaybeLocal<Value>();
     }
 
-    isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
-
     return str;
   }
 
   inline Isolate* isolate() const { return isolate_; }
 
  private:
   ExternString(Isolate* isolate, const TypeName* data, size_t length)
-    : isolate_(isolate), data_(data), length_(length) { }
+      : isolate_(isolate),
+        external_memory_accounter_(new ExternalMemoryAccounter()),
+        data_(data),
+        length_(length) {
+    external_memory_accounter_->Increase(isolate, byte_length());
+  }
   static MaybeLocal<Value> NewExternal(Isolate* isolate,
                                        ExternString* h_str);
 
@@ -136,6 +140,7 @@ class ExternString: public ResourceType {
                                              size_t length);
 
   Isolate* isolate_;
+  ExternalMemoryAccounter* external_memory_accounter_;
   const TypeName* data_;
   size_t length_;
 };