src: refactor grow_async_ids_stack

src/aliased_buffer.h

@@ -4,7 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "v8.h"
-#include "util-inl.h"
+#include "util.h"
 
 namespace node {
 
@@ -22,7 +22,9 @@ namespace node {
  * The encapsulation herein provides a placeholder where such writes can be
  * observed. Any notification APIs will be left as a future exercise.
  */
-template <class NativeT, class V8T>
+template <class NativeT, class V8T,
+ // SFINAE NativeT to be scalar
+ typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
 class AliasedBuffer {
  public:
  AliasedBuffer(v8::Isolate* isolate, const size_t count)
@@ -33,14 +35,14 @@ class AliasedBuffer {
  CHECK_GT(count, 0);
  const v8::HandleScope handle_scope(isolate_);
 
- const size_t sizeInBytes = sizeof(NativeT) * count;
+ const size_t size_in_bytes = sizeof(NativeT) * count;
 
  // allocate native buffer
  buffer_ = Calloc<NativeT>(count);
 
  // allocate v8 ArrayBuffer
  v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
- isolate_, buffer_, sizeInBytes);
+ isolate_, buffer_, size_in_bytes);
 
  // allocate v8 TypedArray
  v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
@@ -55,6 +57,7 @@ class AliasedBuffer {
  *
  * Note that byte_offset must by aligned by sizeof(NativeT).
  */
+ // TODO(refack): refactor into a non-owning `AliasedBufferView`
  AliasedBuffer(v8::Isolate* isolate,
  const size_t byte_offset,
  const size_t count,
@@ -96,7 +99,7 @@ class AliasedBuffer {
  js_array_.Reset();
  }
 
- AliasedBuffer& operator=(AliasedBuffer&& that) {
+ AliasedBuffer& operator=(AliasedBuffer&& that) noexcept {
  this->~AliasedBuffer();
  isolate_ = that.isolate_;
  count_ = that.count_;
@@ -226,6 +229,41 @@ class AliasedBuffer {
  return count_;
  }
 
+ // Should only be used to extend the array.
+ // Should only be used on an owning array, not one created as a sub array of
+ // an owning `AliasedBuffer`.
+ void reserve(size_t new_capacity) {
+#if defined(DEBUG) && DEBUG
+ CHECK_GE(new_capacity, count_);
+ CHECK_EQ(byte_offset_, 0);
+ CHECK(free_buffer_);
+#endif
+ const v8::HandleScope handle_scope(isolate_);
+
+ const size_t old_size_in_bytes = sizeof(NativeT) * count_;
+ const size_t new_size_in_bytes = sizeof(NativeT) * new_capacity;
+
+ // allocate new native buffer
+ NativeT* new_buffer = Calloc<NativeT>(new_capacity);
+ // copy old content
+ memcpy(new_buffer, buffer_, old_size_in_bytes);
+
+ // allocate v8 new ArrayBuffer
+ v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
+ isolate_, new_buffer, new_size_in_bytes);
+
+ // allocate v8 TypedArray
+ v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, new_capacity);
+
+ // move over old v8 TypedArray
+ js_array_ = std::move(v8::Global<V8T>(isolate_, js_array));
+
+ // Free old buffer and set new values
+ free(buffer_);
+ buffer_ = new_buffer;
+ count_ = new_capacity;
+ }
+
  private:
  v8::Isolate* isolate_;
  size_t count_;

src/env.cc

@@ -826,14 +826,7 @@ void Environment::CollectUVExceptionInfo(v8::Local<v8::Value> object,
 
 
 void Environment::AsyncHooks::grow_async_ids_stack() {
- const uint32_t old_capacity = async_ids_stack_.Length() / 2;
- const uint32_t new_capacity = old_capacity * 1.5;
- AliasedBuffer<double, v8::Float64Array> new_buffer(
- env()->isolate(), new_capacity * 2);
-
- for (uint32_t i = 0; i < old_capacity * 2; ++i)
- new_buffer[i] = async_ids_stack_[i];
- async_ids_stack_ = std::move(new_buffer);
+ async_ids_stack_.reserve(async_ids_stack_.Length() * 3);
 
  env()->async_hooks_binding()->Set(
  env()->context(),

src/inspector/main_thread_interface.cc

@@ -5,6 +5,7 @@
 
 #include <functional>
 #include <unicode/unistr.h>
+#include "util-inl.h"
 
 namespace node {
 namespace inspector {

src/util-inl.h

@@ -160,8 +160,8 @@ ContainerOfHelper<Inner, Outer>::operator TypeName*() const {
 }
 
 template <typename Inner, typename Outer>
-inline ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
- Inner* pointer) {
+constexpr ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
+Inner* pointer) {
  return ContainerOfHelper<Inner, Outer>(field, pointer);
 }
 

src/util.h

@@ -198,8 +198,8 @@ class ContainerOfHelper {
 // Calculate the address of the outer (i.e. embedding) struct from
 // the interior pointer to a data member.
 template <typename Inner, typename Outer>
-inline ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
- Inner* pointer);
+constexpr ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
+Inner* pointer);
 
 // If persistent.IsWeak() == false, then do not call persistent.Reset()
 // while the returned Local<T> is still in scope, it will destroy the