nodejs
diff --git a/‎src/env.cc‎
Lines changed: 17 additions & 4 deletions b/‎src/env.cc‎
Lines changed: 17 additions & 4 deletions
diff --git a/‎src/env.h‎
Lines changed: 3 additions & 0 deletions b/‎src/env.h‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎src/stream_base.cc‎
Lines changed: 2 additions & 0 deletions b/‎src/stream_base.cc‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎test/cctest/test_environment.cc‎
Lines changed: 21 additions & 0 deletions b/‎test/cctest/test_environment.cc‎
Lines changed: 21 additions & 0 deletions
@@ -77,6 +77,8 @@ using v8::Undefined;
 using v8::Value;
 using worker::Worker;
 
+constexpr size_t kManagedBufferCacheSize = 64 * 1024;
+
 int const ContextEmbedderTag::kNodeContextTag = 0x6e6f64;
 void* const ContextEmbedderTag::kNodeContextTagPtr = const_cast<void*>(
     static_cast<const void*>(&ContextEmbedderTag::kNodeContextTag));
@@ -782,10 +784,16 @@ void Environment::add_refs(int64_t diff) {
 }
 
 uv_buf_t Environment::allocate_managed_buffer(const size_t suggested_size) {
-  std::unique_ptr<BackingStore> bs = ArrayBuffer::NewBackingStore(
-      isolate(),
-      suggested_size,
-      BackingStoreInitializationMode::kUninitialized);
+  std::unique_ptr<BackingStore> bs;
+  if (suggested_size == kManagedBufferCacheSize &&
+      managed_buffer_cache_ != nullptr) {
+    bs = std::move(managed_buffer_cache_);
+  } else {
+    bs = ArrayBuffer::NewBackingStore(
+        isolate(),
+        suggested_size,
+        BackingStoreInitializationMode::kUninitialized);
+  }
   uv_buf_t buf = uv_buf_init(static_cast<char*>(bs->Data()), bs->ByteLength());
   released_allocated_buffers_.emplace(buf.base, std::move(bs));
   return buf;
@@ -803,6 +811,11 @@ std::unique_ptr<BackingStore> Environment::release_managed_buffer(
   return bs;
 }
 
+void Environment::recycle_managed_buffer(std::unique_ptr<BackingStore> bs) {
+  if (bs != nullptr && bs->ByteLength() == kManagedBufferCacheSize)
+    managed_buffer_cache_ = std::move(bs);
+}
+
 std::string Environment::GetExecPath(const std::vector<std::string>& argv) {
   char exec_path_buf[2 * PATH_MAX];
   size_t exec_path_len = sizeof(exec_path_buf);
 
@@ -1063,6 +1063,8 @@ class Environment final : public MemoryRetainer {
 
   uv_buf_t allocate_managed_buffer(const size_t suggested_size);
   std::unique_ptr<v8::BackingStore> release_managed_buffer(const uv_buf_t& buf);
+  // Only buffers that were not exposed externally may be recycled.
+  void recycle_managed_buffer(std::unique_ptr<v8::BackingStore> bs);
 
   void AddUnmanagedFd(int fd);
   void RemoveUnmanagedFd(int fd);
@@ -1279,6 +1281,7 @@ class Environment final : public MemoryRetainer {
   // track of the BackingStore for a given pointer.
   std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
       released_allocated_buffers_;
+  std::unique_ptr<v8::BackingStore> managed_buffer_cache_;
 
   v8::CpuProfiler* cpu_profiler_ = nullptr;
   std::vector<v8::ProfilerId> pending_profiles_;
 
@@ -697,6 +697,7 @@ void EmitToJSStreamListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
   std::unique_ptr<BackingStore> bs = env->release_managed_buffer(buf_);
 
   if (nread <= 0)  {
+    env->recycle_managed_buffer(std::move(bs));
     if (nread < 0)
       stream->CallJSOnreadMethod(nread, Local<ArrayBuffer>());
     return;
@@ -708,6 +709,7 @@ void EmitToJSStreamListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
     bs = ArrayBuffer::NewBackingStore(
         isolate, nread, BackingStoreInitializationMode::kUninitialized);
     memcpy(bs->Data(), old_bs->Data(), nread);
+    env->recycle_managed_buffer(std::move(old_bs));
   }
 
   stream->CallJSOnreadMethod(nread, ArrayBuffer::New(isolate, std::move(bs)));
 
@@ -39,6 +39,27 @@ class EnvironmentTest : public EnvironmentTestFixture {
   }
 };
 
+TEST_F(EnvironmentTest, ManagedBufferCache) {
+  constexpr size_t kCacheSize = 64 * 1024;
+  constexpr size_t kOtherSize = 1024;
+  const v8::HandleScope handle_scope(isolate_);
+  Argv argv;
+  Env env{handle_scope, argv};
+
+  (*env)->recycle_managed_buffer(nullptr);
+
+  uv_buf_t buffer = (*env)->allocate_managed_buffer(kCacheSize);
+  char* cached_data = buffer.base;
+  (*env)->recycle_managed_buffer((*env)->release_managed_buffer(buffer));
+
+  buffer = (*env)->allocate_managed_buffer(kOtherSize);
+  (*env)->recycle_managed_buffer((*env)->release_managed_buffer(buffer));
+
+  buffer = (*env)->allocate_managed_buffer(kCacheSize);
+  EXPECT_EQ(buffer.base, cached_data);
+  (*env)->release_managed_buffer(buffer);
+}
+
 TEST_F(EnvironmentTest, EnvironmentWithoutBrowserGlobals) {
   const v8::HandleScope handle_scope(isolate_);
   Argv argv;