深入理解 Node.js 的 Buffer

时间:2022-11-10 19:47:53

深入理解 Node.js 的 Buffer

Buffer 模块是 Node.js 非常重要的模块,很多模块都依赖它,本文介绍一下 Buffer 模块底层的原理,包括 Buffer 的核心实现和 V8 堆外内存等内容。

1 Buffer 的实现

1.1 Buffer 的 JS 层实现

Buffer 模块的实现虽然非常复杂,代码也非常多,但是很多都是编码解码以及内存分配管理的逻辑,我们从常用的使用方式 Buffer.from 来看看 Buffer 的核心实现。

  1. Buffer.from = function from(value, encodingOrOffset, length) { 
  2.   return fromString(value, encodingOrOffset); 
  3. }; 
  4.  
  5. function fromString(string, encoding) { 
  6.   return fromStringFast(string, ops); 
  7.  
  8. function fromStringFast(string, ops) { 
  9.   const length = ops.byteLength(string); 
  10.   // 长度太长,从 C++ 层分配 
  11.   if (length >= (Buffer.poolSize >>> 1)) 
  12.     return createFromString(string, ops.encodingVal); 
  13.   // 剩下的不够了,扩容  
  14.   if (length > (poolSize - poolOffset)) 
  15.     createPool(); 
  16.   // 从 allocPool (ArrayBuffer)中分配内存 
  17.   let b = new FastBuffer(allocPool, poolOffset, length); 
  18.   const actual = ops.write(b, string, 0, length); 
  19.   poolOffset += actual; 
  20.   alignPool(); 
  21.   return b; 

from 的逻辑如下:1. 如果长度大于 Node.js 设置的阈值,则调用 createFromString 通过 C++ 层直接分配内存。2. 否则判断之前剩下的内存是否足够,足够则直接分配。Node.js 初始化时会首先分配一大块内存由 JS 管理,每次从这块内存了切分一部分给使用方,如果不够则扩容。我们看看 createPool。

  1. // 分配一个内存池 
  2. function createPool() { 
  3.   poolSize = Buffer.poolSize; 
  4.   // 拿到底层的 ArrayBuffer 
  5.   allocPool = createUnsafeBuffer(poolSize).buffer; 
  6.   poolOffset = 0; 
  7.  
  8. function createUnsafeBuffer(size) { 
  9.   zeroFill[0] = 0; 
  10.   try { 
  11.     return new FastBuffer(size); 
  12.   } finally { 
  13.     zeroFill[0] = 1; 
  14.   } 
  15.  
  16. class FastBuffer extends Uint8Array {} 

我们看到最终调用 Uint8Array 实现了内存分配。3. 通过 new FastBuffer(allocPool, poolOffset, length) 从内存池中分配一块内存。如下图所示。

深入理解 Node.js 的 Buffer

1.2 Buffer 的 C++ 层实现

分析 C++ 层之前我们先看一下 V8 里下面几个对象的关系图。

深入理解 Node.js 的 Buffer

接着来看看通过 createFromString 直接从 C++ 申请内存的实现。

  1. void CreateFromString(const FunctionCallbackInfo<Value>& args) { 
  2.   enum encoding enc = static_cast<enum encoding>(args[1].As<Int32>()->Value()); 
  3.   Local<Object> buf; 
  4.   if (New(args.GetIsolate(), args[0].As<String>(), enc).ToLocal(&buf)) 
  5.     args.GetReturnValue().Set(buf); 
  6.  
  7. MaybeLocal<Object> New(Isolate* isolate, 
  8.                        Local<String> string, 
  9.                        enum encoding enc) { 
  10.   EscapableHandleScope scope(isolate); 
  11.  
  12.   size_t length; 
  13.   // 计算长度 
  14.   if (!StringBytes::Size(isolate, string, enc).To(&length)) 
  15.     return Local<Object>(); 
  16.   size_t actual = 0; 
  17.   char* data = nullptr; 
  18.   // 直接通过 realloc 在进程堆上申请一块内存 
  19.   data = UncheckedMalloc(length); 
  20.   // 按照编码转换数据 
  21.   actual = StringBytes::Write(isolate, data, length, string, enc); 
  22.   return scope.EscapeMaybe(New(isolate, data, actual)); 
  23.  
  24. MaybeLocal<Object> New(Isolate* isolate, char* data, size_t length) { 
  25.   EscapableHandleScope handle_scope(isolate); 
  26.   Environment* env = Environment::GetCurrent(isolate); 
  27.   Local<Object> obj; 
  28.   if (Buffer::New(env, data, length).ToLocal(&obj)) 
  29.     return handle_scope.Escape(obj); 
  30.   return Local<Object>(); 
  31.  
  32. MaybeLocal<Object> New(Environment* env, 
  33.                        char* data, 
  34.                        size_t length) { 
  35.   // JS 层变量释放后使得这块内存没人用了,GC 时在回调里释放这块内存                
  36.   auto free_callback = [](char* data, void* hint) { free(data); }; 
  37.   return New(env, data, length, free_callback, nullptr); 
  38.  
  39. MaybeLocal<Object> New(Environment* env, 
  40.                        char* data, 
  41.                        size_t length, 
  42.                        FreeCallback callback, 
  43.                        void* hint) { 
  44.   EscapableHandleScope scope(env->isolate()); 
  45.   // 创建一个 ArrayBuffer 
  46.   Local<ArrayBuffer> ab = 
  47.       CallbackInfo::CreateTrackedArrayBuffer(env, data, length, callback, hint); 
  48.   /*  
  49.     创建一个 Uint8Array  
  50.     Buffer::New => Local<Uint8Array> ui = Uint8Array::New(ab, byte_offset, length) 
  51.   */ 
  52.   MaybeLocal<Uint8Array> maybe_ui = Buffer::New(env, ab, 0, length); 
  53.  
  54.   Local<Uint8Array> ui; 
  55.   if (!maybe_ui.ToLocal(&ui)) 
  56.     return MaybeLocal<Object>(); 
  57.  
  58.   return scope.Escape(ui); 

通过一系列的调用,最后通过 CreateTrackedArrayBuffer 创建了一个 ArrayBuffer,再通过 ArrayBuffer 创建了一个 Uint8Array。接着看一下 CreateTrackedArrayBuffer 的实现。

  1. Local<ArrayBuffer> CallbackInfo::CreateTrackedArrayBuffer( 
  2.     Environment* env, 
  3.     char* data, 
  4.     size_t length, 
  5.     FreeCallback callback, 
  6.     void* hint) { 
  7.   // 管理回调 
  8.   CallbackInfo* self = new CallbackInfo(env, callback, data, hint); 
  9.   // 用自己申请的内存创建一个 BackingStore,并设置 GC 回调 
  10.   std::unique_ptr<BackingStore> bs = 
  11.       ArrayBuffer::NewBackingStore(data, length, [](void*, size_t, void* arg) { 
  12.         static_cast<CallbackInfo*>(arg)->OnBackingStoreFree(); 
  13.       }, self); 
  14.   // 通过 BackingStore 创建 ArrayBuffer 
  15.   Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs)); 
  16.   return ab; 

看一下 NewBackingStore 的实现。

  1. std::unique_ptr<v8::BackingStore> v8::ArrayBuffer::NewBackingStore( 
  2.     void* data, size_t byte_length, v8::BackingStore::DeleterCallback deleter, 
  3.     void* deleter_data) { 
  4.   std::unique_ptr<i::BackingStoreBase> backing_store = i::BackingStore::WrapAllocation(data, byte_length, deleter, deleter_data, 
  5.                                       i::SharedFlag::kNotShared); 
  6.   return std::unique_ptr<v8::BackingStore>( 
  7.       static_cast<v8::BackingStore*>(backing_store.release())); 
  8.  
  9. std::unique_ptr<BackingStore> BackingStore::WrapAllocation( 
  10.     void* allocation_base, size_t allocation_length, 
  11.     v8::BackingStore::DeleterCallback deleter, void* deleter_data, 
  12.     SharedFlag shared) { 
  13.   bool is_empty_deleter = (deleter == v8::BackingStore::EmptyDeleter); 
  14.   // 新建一个 BackingStore  
  15.   auto result = new BackingStore(allocation_base,    // start 
  16.                                  allocation_length,  // length 
  17.                                  allocation_length,  // capacity 
  18.                                  shared,             // shared 
  19.                                  false,              // is_wasm_memory 
  20.                                  true,               // free_on_destruct 
  21.                                  false,              // has_guard_regions 
  22.                                  // 说明释放内存由调用方执行 
  23.                                  true,               // custom_deleter 
  24.                                  is_empty_deleter);  // empty_deleter 
  25.   // 保存回调需要的信息                                
  26.   result->type_specific_data_.deleter = {deleter, deleter_data}; 
  27.   return std::unique_ptr<BackingStore>(result); 

NewBackingStore 最终是创建了一个 BackingStore 对象。我们再看一下 GC 时 BackingStore 的析构函数里都做了什么。

  1. BackingStore::~BackingStore() { 
  2.   if (custom_deleter_) { 
  3.     type_specific_data_.deleter.callback(buffer_start_, byte_length_, 
  4.                                          type_specific_data_.deleter.data); 
  5.     Clear(); 
  6.     return
  7.   } 

析构的时候会执行创建 BackingStore 时保存的回调。我们看一下管理回调的 CallbackInfo 的实现。

  1. CallbackInfo::CallbackInfo(Environment* env, 
  2.                            FreeCallback callback, 
  3.                            char* data, 
  4.                            void* hint) 
  5.     : callback_(callback), 
  6.       data_(data), 
  7.       hint_(hint), 
  8.       env_(env) { 
  9.   env->AddCleanupHook(CleanupHook, this); 
  10.   env->isolate()->AdjustAmountOfExternalAllocatedMemory(sizeof(*this)); 

CallbackInfo 的实现很简单,主要的地方是 AdjustAmountOfExternalAllocatedMemory。该函数告诉 V8 堆外内存增加了多少个字节,V8 会根据内存的数据做适当的 GC。CallbackInfo 主要是保存了回调和内存地址。接着在 GC 的时候会回调 CallbackInfo 的 OnBackingStoreFree。

  1. void CallbackInfo::OnBackingStoreFree() { 
  2.   std::unique_ptr<CallbackInfo> self { this }; 
  3.   Mutex::ScopedLock lock(mutex_); 
  4.   // check 阶段执行 CallAndResetCallback 
  5.   env_->SetImmediateThreadsafe([self = std::move(self)](Environment* env) { 
  6.     self->CallAndResetCallback(); 
  7.   });}void CallbackInfo::CallAndResetCallback() { 
  8.   FreeCallback callback; 
  9.   { 
  10.     Mutex::ScopedLock lock(mutex_); 
  11.     callback = callback_; 
  12.     callback_ = nullptr; 
  13.   } 
  14.   if (callback != nullptr) { 
  15.     // 堆外内存减少了这么多个字节 
  16.     int64_t change_in_bytes = -static_cast<int64_t>(sizeof(*this)); 
  17.     env_->isolate()->AdjustAmountOfExternalAllocatedMemory(change_in_bytes); 
  18.     // 执行回调,通常是释放内存 
  19.     callback(data_, hint_); 
  20.   } 

1.3 Buffer C++ 层的另一种实现

刚才介绍的 C++ 实现中内存是由自己分配并释放的,下面介绍另一种内存的分配和释放由 V8 管理的场景。以 Buffer 的提供的 EncodeUtf8String 函数为例,该函数实现字符串的编码。

  1. static void EncodeUtf8String(const FunctionCallbackInfo<Value>& args) { 
  2.   Environment* env = Environment::GetCurrent(args); 
  3.   Isolate* isolate = env->isolate(); 
  4.   // 被编码的字符串 
  5.   Local<String> str = args[0].As<String>(); 
  6.   size_t length = str->Utf8Length(isolate); 
  7.   // 分配内存 
  8.   AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, length); 
  9.   // 编码 
  10.   str->WriteUtf8(isolate, 
  11.                  buf.data(), 
  12.                  -1,  // We are certain that `data` is sufficiently large 
  13.                  nullptr, 
  14.                  String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8); 
  15.   // 基于上面申请的 buf 内存新建一个 Uint8Array               
  16.   auto array = Uint8Array::New(buf.ToArrayBuffer(), 0, length); 
  17.   args.GetReturnValue().Set(array); 

我们重点分析 AllocatedBuffer::AllocateManaged。

  1. AllocatedBuffer AllocatedBuffer::AllocateManaged( 
  2.     Environment* env, 
  3.     size_t size) { 
  4.   NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data()); 
  5.   std::unique_ptr<v8::BackingStore> bs = v8::ArrayBuffer::NewBackingStore(env->isolate(), size); 
  6.   return AllocatedBuffer(env, std::move(bs)); 

AllocateManaged 调用 NewBackingStore 申请了内存。

  1. std::unique_ptr<v8::BackingStore> v8::ArrayBuffer::NewBackingStore( 
  2.     Isolate* isolate, size_t byte_length) { 
  3.  
  4.   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); 
  5.   std::unique_ptr<i::BackingStoreBase> backing_store = 
  6.       i::BackingStore::Allocate(i_isolate, byte_length, 
  7.                                 i::SharedFlag::kNotShared, 
  8.                                 i::InitializedFlag::kZeroInitialized); 
  9.  
  10.   return std::unique_ptr<v8::BackingStore>( 
  11.       static_cast<v8::BackingStore*>(backing_store.release())); 

继续看 BackingStore::Allocate。

  1. std::unique_ptr<BackingStore> BackingStore::Allocate( 
  2.     Isolate* isolate, size_t byte_length, SharedFlag shared, 
  3.     InitializedFlag initialized) { 
  4.   void* buffer_start = nullptr; 
  5.   // ArrayBuffer 内存分配器,可以自定义,V8 默认提供的是使用平台相关的堆内存分析函数,比如 malloc 
  6.   auto allocator = isolate->array_buffer_allocator(); 
  7.   if (byte_length != 0) { 
  8.     auto allocate_buffer = [allocator, initialized](size_t byte_length) { 
  9.       // 分配内存 
  10.       void* buffer_start = allocator->Allocate(byte_length); 
  11.       return buffer_start; 
  12.     }; 
  13.     // 同步执行 allocate_buffer 分配内存 
  14.     buffer_start = isolate->heap()->AllocateExternalBackingStore(allocate_buffer, byte_length); 
  15.   } 
  16.   // 新建 BackingStore 管理内存 
  17.   auto result = new BackingStore(buffer_start,  // start 
  18.                                  byte_length,   // length 
  19.                                  byte_length,   // capacity 
  20.                                  shared,        // shared 
  21.                                  false,         // is_wasm_memory 
  22.                                  true,          // free_on_destruct 
  23.                                  false,         // has_guard_regions 
  24.                                  false,         // custom_deleter 
  25.                                  false);        // empty_deleter 
  26.  
  27.   return std::unique_ptr<BackingStore>(result); 

BackingStore::Allocate 分配一块内存并新建 BackingStore 对象管理这块内存,内存分配器是在初始化 V8 的时候设置的。这里我们再看一下 AllocateExternalBackingStore 函数的逻辑。

  1. void* Heap::AllocateExternalBackingStore( 
  2.     const std::function<void*(size_t)>& allocate, size_t byte_length) { 
  3.    // 可能需要触发 GC 
  4.    if (!always_allocate()) { 
  5.     size_t new_space_backing_store_bytes = 
  6.         new_space()->ExternalBackingStoreBytes(); 
  7.     if (new_space_backing_store_bytes >= 2 * kMaxSemiSpaceSize && 
  8.         new_space_backing_store_bytes >= byte_length) { 
  9.       CollectGarbage(NEW_SPACE, 
  10.                      GarbageCollectionReason::kExternalMemoryPressure); 
  11.     } 
  12.   } 
  13.   // 分配内存 
  14.   void* result = allocate(byte_length); 
  15.   // 成功则返回 
  16.   if (result) return result; 
  17.   // 失败则进行 GC 
  18.   if (!always_allocate()) { 
  19.     for (int i = 0; i < 2; i++) { 
  20.       CollectGarbage(OLD_SPACE, 
  21.                      GarbageCollectionReason::kExternalMemoryPressure); 
  22.       result = allocate(byte_length); 
  23.       if (result) return result; 
  24.     } 
  25.     isolate()->counters()->gc_last_resort_from_handles()->Increment(); 
  26.     CollectAllAvailableGarbage( 
  27.         GarbageCollectionReason::kExternalMemoryPressure); 
  28.   } 
  29.   // 再次分配,失败则返回失败 
  30.   return allocate(byte_length); 

我们看到通过 BackingStore 申请内存失败时会触发 GC 来腾出更多的可用内存。分配完内存后,最终以 BackingStore 对象为参数,返回一个 AllocatedBuffer 对象。

  1. AllocatedBuffer::AllocatedBuffer( 
  2.     Environment* env, std::unique_ptr<v8::BackingStore> bs) 
  3.     : env_(env), backing_store_(std::move(bs)) {} 

接着把 AllocatedBuffer 对象转成 ArrayBuffer 对象。

  1. v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() { 
  2.   return v8::ArrayBuffer::New(env_->isolate(), std::move(backing_store_)); 

最后把 ArrayBuffer 对象传入 Uint8Array 返回一个 Uint8Array 对象返回给调用方。

2 Uint8Array 的使用和实现

从前面的实现中可以看到 C++ 层的实现中,内存都是从进程的堆中分配的,那么 JS 层通过 Uint8Array 申请的内存是否也是在进程堆中申请的呢?下面我们看看 V8 中 Uint8Array 的实现。Uint8Array 有多种创建方式,我们只看 new Uint8Array(length) 的实现。

  1. transitioning macro ConstructByLength(implicit context: Context)( 
  2.     map: Map, lengthObj: JSAny, 
  3.     elementsInfo: typed_array::TypedArrayElementsInfo): JSTypedArray { 
  4.   try { 
  5.     // 申请的内存大小 
  6.     const length: uintptr = ToIndex(lengthObj); 
  7.     // 拿到创建 ArrayBuffer 的函数 
  8.     const defaultConstructor: Constructor = GetArrayBufferFunction(); 
  9.     const initialize: constexpr bool = true
  10.     return TypedArrayInitialize( 
  11.         initialize, map, length, elementsInfo, defaultConstructor) 
  12.         otherwise RangeError; 
  13.   } 
  14.  
  15. transitioning macro TypedArrayInitialize(implicit context: Context)( 
  16.     initialize: constexpr bool, map: Map, length: uintptr, 
  17.     elementsInfo: typed_array::TypedArrayElementsInfo, 
  18.     bufferConstructor: JSReceiver): JSTypedArray labels IfRangeError { 
  19.  
  20.   const byteLength = elementsInfo.CalculateByteLength(length); 
  21.   const byteLengthNum = Convert<Number>(byteLength); 
  22.   const defaultConstructor = GetArrayBufferFunction(); 
  23.   const byteOffset: uintptr = 0; 
  24.  
  25.   try { 
  26.     // 创建 JSArrayBuffer 
  27.     const buffer = AllocateEmptyOnHeapBuffer(byteLength); 
  28.     const isOnHeap: constexpr bool = true
  29.     // 通过 buffer 创建 TypedArray 
  30.     const typedArray = AllocateTypedArray( 
  31.         isOnHeap, map, buffer, byteOffset, byteLength, length); 
  32.     // 内存置 0 
  33.     if constexpr (initialize) { 
  34.       const backingStore = typedArray.data_ptr; 
  35.       typed_array::CallCMemset(backingStore, 0, byteLength); 
  36.     } 
  37.  
  38.     return typedArray; 
  39.   } 

主要逻辑分为两步,首先通过 AllocateEmptyOnHeapBuffer 申请一个 JSArrayBuffer,然后以 JSArrayBuffer 创建一个 TypedArray。我们先看一下 AllocateEmptyOnHeapBuffer。

  1. TNode<JSArrayBuffer> TypedArrayBuiltinsAssembler::AllocateEmptyOnHeapBuffer( 
  2.     TNode<Context> context, TNode<UintPtrT> byte_length) { 
  3.  
  4.   TNode<NativeContext> native_context = LoadNativeContext(context); 
  5.   TNode<Map> map = CAST(LoadContextElement(native_context, Context::ARRAY_BUFFER_MAP_INDEX)); 
  6.   TNode<FixedArray> empty_fixed_array = EmptyFixedArrayConstant(); 
  7.   // 申请一个 JSArrayBuffer 对象所需要的内存 
  8.   TNode<JSArrayBuffer> buffer = UncheckedCast<JSArrayBuffer>(Allocate(JSArrayBuffer::kSizeWithEmbedderFields)); 
  9.   // 初始化对象的属性 
  10.   StoreMapNoWriteBarrier(buffer, map); 
  11.   StoreObjectFieldNoWriteBarrier(buffer, JSArray::kPropertiesOrHashOffset, empty_fixed_array); 
  12.   StoreObjectFieldNoWriteBarrier(buffer, JSArray::kElementsOffset, empty_fixed_array); 
  13.   int32_t bitfield_value = (1 << JSArrayBuffer::IsExternalBit::kShift) | 
  14.                            (1 << JSArrayBuffer::IsDetachableBit::kShift); 
  15.   StoreObjectFieldNoWriteBarrier(buffer, JSArrayBuffer::kBitFieldOffset, Int32Constant(bitfield_value)); 
  16.   StoreObjectFieldNoWriteBarrier(buffer, JSArrayBuffer::kByteLengthOffset, byte_length); 
  17.   // 设置 buffer 为 nullptr                                
  18.   StoreJSArrayBufferBackingStore(buffer, EncodeExternalPointer(ReinterpretCast<RawPtrT>(IntPtrConstant(0)))); 
  19.   StoreObjectFieldNoWriteBarrier(buffer, JSArrayBuffer::kExtensionOffset, IntPtrConstant(0)); 
  20.   for (int offset = JSArrayBuffer::kHeaderSize; offset < JSArrayBuffer::kSizeWithEmbedderFields; offset += kTaggedSize) { 
  21.     StoreObjectFieldNoWriteBarrier(buffer, offset, SmiConstant(0)); 
  22.   } 
  23.   return buffer; 

AllocateEmptyOnHeapBuffer 申请了一个空的 JSArrayBuffer 对象,空的意思是说没有存储数据的内存。接着看基于 JSArrayBuffer 对象 通过 AllocateTypedArray 创建一个 TypedArray。

  1. transitioning macro AllocateTypedArray(implicit context: Context)( 
  2.     isOnHeap: constexpr bool, map: Map, buffer: JSArrayBuffer, 
  3.     byteOffset: uintptr, byteLength: uintptr, length: uintptr): JSTypedArray { 
  4.   // 从 V8 堆中申请存储数据的内存 
  5.   let elements: ByteArray = AllocateByteArray(byteLength); 
  6.   // 申请一个 JSTypedArray 对象 
  7.   const typedArray = UnsafeCast<JSTypedArray>(AllocateFastOrSlowJSObjectFromMap(map)); 
  8.   // 初始化属性 
  9.   typedArray.elements = elements; 
  10.   typedArray.buffer = buffer; 
  11.   typedArray.byte_offset = byteOffset; 
  12.   typedArray.byte_length = byteLength; 
  13.   typedArray.length = length; 
  14.   typed_array::SetJSTypedArrayOnHeapDataPtr(typedArray, elements, byteOffset); 
  15.   SetupTypedArrayEmbedderFields(typedArray); 
  16.   return typedArray; 

我们发现 Uint8Array 申请的内存是基于 V8 堆的,而不是 V8 的堆外内存,这难道和 C++ 层的实现不一样?Uint8Array 的内存的确是基于 V8 堆的,比如我像下面这样使用的时候。

  1. const arr = new Uint8Array(1); 
  2. arr[0] = 65; 

但是如果我们使用 arr.buffer 的时候,情况就不一样了。我们看看具体的实现。

  1. BUILTIN(TypedArrayPrototypeBuffer) { 
  2.   HandleScope scope(isolate); 
  3.   CHECK_RECEIVER(JSTypedArray, typed_array, 
  4.                  "get %TypedArray%.prototype.buffer"); 
  5.   return *typed_array->GetBuffer(); 

接着看 GetBuffer 的实现。

  1. Handle<JSArrayBuffer> JSTypedArray::GetBuffer() { 
  2.   Isolate* isolate = GetIsolate(); 
  3.   Handle<JSTypedArray> self(*this, isolate); 
  4.   // 拿到 TypeArray 对应的 JSArrayBuffer 对象 
  5.   Handle<JSArrayBuffer> array_buffer(JSArrayBuffer::cast(self->buffer()), isolate); 
  6.   // 分配过了直接返回 
  7.   if (!is_on_heap()) { 
  8.    return array_buffer; 
  9.   } 
  10.   size_t byte_length = self->byte_length(); 
  11.   // 申请 byte_length 字节内存存储数据 
  12.   auto backing_store = BackingStore::Allocate(isolate, byte_length, SharedFlag::kNotShared, InitializedFlag::kUninitialized); 
  13.   // 关联 backing_store 到 array_buffer 
  14.   array_buffer->Setup(SharedFlag::kNotShared, std::move(backing_store)); 
  15.   return array_buffer; 

我们看到当使用 buffer 的时候,V8 会在 V8 堆外申请内存来替代初始化 Uint8Array 时在 V8 堆内分配的内存,并且把原来的数据复制过来。看一下下面的例子。

  1. console.log(process.memoryUsage().arrayBuffers) 
  2. let a = new Uint8Array(10); 
  3. a[0] = 65; 
  4. console.log(process.memoryUsage().arrayBuffers) 

我们会发现 arrayBuffers 的值是一样的,说明 Uint8Array 初始化时没有通过 arrayBuffers 申请堆外内存。接着再看下一个例子。

  1. console.log(process.memoryUsage().arrayBuffers) 
  2. let a = new Uint8Array(1); 
  3. a[0] = 65; 
  4. a.buffer 
  5. console.log(process.memoryUsage().arrayBuffers) 
  6. console.log(new Uint8Array(a.buffer)) 

我们看到输出的内存增加了一个字节,输出的 a.buffer 是 [ 65 ](申请内存超 64 时会从堆外申请)。

3 堆外内存的管理

从之前的分析中我们看到,Node.js Buffer 是基于堆外内存实现的(自己申请进程堆内存或者使用 V8 默认的内存分配器),我们知道,平时使用的变量都是由 V8 负责管理内存的,那么 Buffer 所代表的堆外内存是怎么管理的呢?Buffer 的内存释放也是由 V8 跟踪的,不过释放的逻辑和堆内内存不太一样。我们通过一些例子来分析一下。

  1. function forceGC() { 
  2.     new ArrayBuffer(1024 * 1024 * 1024); 
  3.  
  4. setTimeout(() => { 
  5.     /* 
  6.         从 C++ 层调用 V8 对象创建内存 
  7.         let a = process.binding('buffer').createFromString("你好", 1); 
  8.     */  
  9.     /* 
  10.         直接使用 V8 内置对象 
  11.         let a = new ArrayBuffer(10); 
  12.     */ 
  13.     // 从 C++ 层自己管理内存 
  14.     let a = process.binding('buffer').encodeUtf8String("你好"); 
  15.     // 置空等待 GC 
  16.     a = null
  17.     // 分配一块大内存触发 GC 
  18.     process.nextTick(forceGC); 
  19. }, 1000); 
  20.  
  21. const net = require('net'); 
  22. net.createServer((socket) => {}).listen() 

在 V8 的代码打断点,然后调试以上代码。

深入理解 Node.js 的 Buffer

我们看到在超时回调里 V8 分配了一个 ArrayBufferExtension 对象并记录到 ArrayBufferSweeper 中。接着看一下触发 GC 时的逻辑。

深入理解 Node.js 的 Buffer

深入理解 Node.js 的 Buffer

V8 在 GC 中会调用

heap_->array_buffer_sweeper()->RequestSweepYoung() 回收堆外内存,另外 Node.js 本身似乎也使用线程去回收 堆外内存。我们再看一下自己管理内存的情况下回调的触发。

深入理解 Node.js 的 Buffer

如果这样写是不会触发 BackingStore::~BackingStore 执行的,再次验证了 Uint8Array 初始化时没有使用 BackingStore。

  1. setTimeout(() => { 
  2.    let a = new Uint8Array(1); 
  3.    // a.buffer; 
  4.    a = null
  5.    process.nextTick(forceGC); 
  6. }); 

但是如果把注释打开就可以。

4 总结

Buffer 平时用起来可能比较简单,但是如果深入研究它的实现就会发现涉及的内容不仅多,而且还复杂,不过深入理解了它的底层实现后,会有种豁然开朗的感觉,另外 Buffer 的内存是堆外内存,如果我们发现进程的内存不断增长但是 V8 堆快照大小变化不大,那可能是 Buffer 变量没有释放,理解实现能帮助我们更好地思考问题和解决问题。

原文链接:https://mp.weixin.qq.com/s/ln2ReI-2aF4_Ubxn1EGg7Q