quic: use arena allocation for packets

Previously Packets were ReqWrap objects with a shared
free-list. This commit changes to a per-Endpoint arena
with no v8 involvement. This is the design I originally
had in mind but I initially went with the simpler
freelist approach to get something working. There's
too much overhead in the reqrap/freelist approach and
individual packets do not really need to be observable
via async hooks.

This design should eliminate the risk of memory fragmentation
and eliminate a significant bottleneck in the hot path.

Summary of improvements:

**Memory Comparison**

| Metric | Before | After | Delta |
| ------ | ------ | ----- | ----- |
| Per-packet memory | ~2,140 bytes | 1,712 bytes | -20% |
| Heap allocations per acquire | 3-4 (Packet, Data, shared_ptr control, V8 object) | 0 (pre-allocated in block) | eliminated |
| Heap allocations per reuse (freelist hit) | 2 (Data, shared_ptr control) | 0 | eliminated |
| V8 heap per packet | ~200-400 bytes (JS object) | 0 | eliminated |
| Block allocation (128 slots) | N/A | 214 KB (one new char[]) | amortized across 128 acquires |
| Per-packet allocator overhead | ~48-96 bytes (malloc headers × 3-4 allocs) | 0 (inline in block) | eliminated |

**Fragmentation**

**Before**: Each packet reuse from the freelist still called
std::make_shared<Data>(length, label) — a new heap allocation
for the Data object + its shared_ptr control block + the std::string
diagnostic label. These are small, variably-sized allocations
scattered across the heap.

**After**: All slots are identical 1,712-byte regions within
contiguous 214 KB blocks. Zero per-packet heap allocations
during steady-state operation. The only allocations happen
when a new block is grown.

**Performance Comparison**

**Acquire (hot path — called up to 32× per SendPendingData)**

**Before** (freelist hit):
1. BindingData::Get(env) — resolve binding data from environment
2. packet_freelist.front() / pop_front() — std::list dereference
   (random memory access)
3. std::make_shared<Data>(length, label) — heap allocate Data +
   control block
4. std::string constructor for diagnostic label — potential heap
   allocation
5. Set listener, destination, data pointer on Packet

**Before** (freelist miss):
1. JS_NEW_INSTANCE_OR_RETURN — allocate V8 JS object (GC pressure,
   potentially triggers GC)
2. MakeBaseObject<Packet>(...) — heap allocate Packet
3. std::make_shared<Data>(...) — heap allocate Data + control block
4. ClearWeak() — modify V8 weak handle state

**After** (always):
1. Pop from intrusive free list — slot = free_list_; free_list_ =
   slot->next_free; (2 pointer ops)
2. Increment in_use_count_ on block and pool (2 increments)
3. Placement new Packet in pre-allocated memory (zero-initializes
   uv_udp_send_t, copies SocketAddress)

The new acquire is essentially 2 pointer operations + a placement
new. No heap allocation, no V8 involvement, no atomic operations
(shared_ptr control block had atomics).

**Release (send callback — every completed packet)**

**Before**:
1. BaseObjectPtr<Packet> construction from raw pointer — atomic
   increment
2. MakeWeak() — modify V8 weak handle
3. Check IsDispatched(), call listener
4. data_.reset() — atomic decrement on shared_ptr, may free Data
5. Reset() — reset uv_udp_send_t state
6. packet_freelist.push_back(std::move(self)) — std::list node
   allocation (!)
7. Or if freelist full: destroy Packet → V8 GC eventually collects
   JS object

**After**:
1. Packet::FromReq(req) — ContainerOf pointer arithmetic
   (compile-time offset)
2. Call listener
3. ArenaPool::Release(p) — ~Packet() (trivial), then ReleaseSlot:
   - Pointer arithmetic to recover SlotHeader
   - slot->next_free = free_list_; free_list_ = slot; (2 pointer ops)
   - Decrement 2 counters
   - MaybeGC() check (branch, rarely taken)

The new release is pointer arithmetic + 2 pointer operations + 2
decrements. No atomic operations, no heap free, no V8 interaction.

**Send path (UDP::Send)**

**Before**: ClearWeak() + Dispatched() + uv_udp_send() + on
error: Done() + MakeWeak()

**After**: Ptr::release() (1 pointer swap) + uv_udp_send() + on
error: ArenaPool::Release()

**SendPendingData loop (up to 32 packets per call)**

**Before**: Each iteration potentially triggered
JS_NEW_INSTANCE_OR_RETURN (V8 object allocation) on freelist miss,
plus std::make_shared<Data> on every iteration.

**After**: Each iteration is just a free list pop + placement new.
For a full 32-packet burst from a warm pool, this is ~32 × (2 pointer
ops + a memset/memcpy for the Packet fields) — essentially zero
allocation cost.

**GC pressure**

**Before**: Each Packet had a persistent V8 JS object. When the
freelist was full (>100 packets), excess packets were destroyed,
leaving their V8 objects for the garbage collector. Under high
throughput, this created ongoing GC pressure proportional to
packet churn.

**After**: Zero V8 objects. Zero GC pressure from packets. The
ArenaPool::MaybeGC() only runs when >50% of total slots are free
and only frees entire blocks — a rare bulk operation, not per-packet
work.

**Summary**
| Aspect | Improvement |
| Per-packet memory | ~20% smaller (1,712 vs ~2,140 bytes) |
| Heap fragmentation | Eliminated (contiguous block allocation) |
| Heap allocations per acquire | 0 (was 2-4) |
| V8 GC pressure | Eliminated entirely |
| Atomic operations per acquire/release | 0 (was 2+ from shared_ptr) |
| Cache locality | Improved (sequential slots in contiguous blocks) |
| Acquire cost | ~2 pointer ops (was: conditional heap alloc + V8 object + shared_ptr) |
| Release cost | ~4 pointer ops + 2 decrements (was: atomic decrement + V8 weak handle + list node alloc) |
| SendPendingData 32-packet burst | ~32 × pointer swap (was: 32 × potential heap alloc + V8 alloc) |
| Steady-state memory overhead | Fixed: 1 block = 214 KB for 128 slots (was: unbounded individual allocations) |

The biggest wins are eliminating the per-packet V8 object
allocation (which could trigger GC) and the shared_ptr atomic
operations on every acquire/release. For a high-throughput QUIC
session sending 32 packets per SendPendingData call, the new path
is essentially allocation-free after the first block is populated.

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6

Author: jasnell

node.gyp

@@ -354,6 +354,7 @@
       'src/quic/tlscontext.cc',
       'src/quic/transportparams.cc',
       'src/quic/quic.cc',
+      'src/quic/arena.h',
       'src/quic/bindingdata.h',
       'src/quic/cid.h',
       'src/quic/data.h',
@@ -440,6 +441,7 @@
       'test/cctest/test_node_crypto_env.cc',
     ],
     'node_cctest_quic_sources': [
+      'test/cctest/test_quic_arena.cc',
       'test/cctest/test_quic_cid.cc',
       'test/cctest/test_quic_error.cc',
       'test/cctest/test_quic_preferredaddress.cc',

src/quic/application.cc

@@ -1,7 +1,6 @@
 #if HAVE_OPENSSL && HAVE_QUIC
 #include "guard.h"
 #ifndef OPENSSL_NO_QUIC
-#include "application.h"
 #include <async_wrap-inl.h>
 #include <debug_utils-inl.h>
 #include <nghttp3/nghttp3.h>
@@ -10,6 +9,7 @@
 #include <node_sockaddr-inl.h>
 #include <uv.h>
 #include <v8.h>
+#include "application.h"
 #include "defs.h"
 #include "endpoint.h"
 #include "http3.h"
@@ -207,12 +207,9 @@ StreamPriority Session::Application::GetStreamPriority(const Stream& stream) {
   return StreamPriority::DEFAULT;
 }
 
-BaseObjectPtr<Packet> Session::Application::CreateStreamDataPacket() {
-  return Packet::Create(env(),
-                        session_->endpoint(),
-                        session_->remote_address(),
-                        session_->max_packet_size(),
-                        "stream data");
+Packet::Ptr Session::Application::CreateStreamDataPacket() {
+  return session_->endpoint().CreatePacket(
+      session_->remote_address(), session_->max_packet_size(), "stream data");
 }
 
 void Session::Application::StreamClose(Stream* stream, QuicError&& error) {
@@ -264,7 +261,7 @@ void Session::Application::SendPendingData() {
   // The number of packets that have been sent in this call to SendPendingData.
   size_t packet_send_count = 0;
 
-  BaseObjectPtr<Packet> packet;
+  Packet::Ptr packet;
   uint8_t* pos = nullptr;
   uint8_t* begin = nullptr;
 
@@ -273,7 +270,7 @@ void Session::Application::SendPendingData() {
       packet = CreateStreamDataPacket();
       if (!packet) [[unlikely]]
         return false;
-      pos = begin = ngtcp2_vec(*packet).base;
+      pos = begin = packet->data();
     }
     DCHECK(packet);
     DCHECK_NOT_NULL(pos);
@@ -299,7 +296,6 @@ void Session::Application::SendPendingData() {
     // The stream_data is the next block of data from the application stream.
     if (GetStreamData(&stream_data) < 0) {
       Debug(session_, "Application failed to get stream data");
-      packet->CancelPacket();
       session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
       closed = true;
       return session_->Close(CloseMethod::SILENT);
@@ -367,7 +363,6 @@ void Session::Application::SendPendingData() {
           if (ndatalen >= 0 && !StreamCommit(&stream_data, ndatalen)) {
             Debug(session_,
                   "Failed to commit stream data while writing packets");
-            packet->CancelPacket();
             session_->SetLastError(
                 QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
             closed = true;
@@ -380,7 +375,6 @@ void Session::Application::SendPendingData() {
           // ngtcp2 callback failed for some reason. This would be a
           // bug in our code.
           Debug(session_, "Internal failure with ngtcp2 callback");
-          packet->CancelPacket();
           session_->SetLastError(
               QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
           closed = true;
@@ -393,12 +387,10 @@ void Session::Application::SendPendingData() {
       Debug(session_,
             "Application encountered error while writing packet: %s",
             ngtcp2_strerror(nwrite));
-      packet->CancelPacket();
       session_->SetLastError(QuicError::ForNgtcp2Error(nwrite));
       closed = true;
       return session_->Close(CloseMethod::SILENT);
     } else if (ndatalen >= 0 && !StreamCommit(&stream_data, ndatalen)) {
-      packet->CancelPacket();
       session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
       closed = true;
       return session_->Close(CloseMethod::SILENT);
@@ -416,10 +408,9 @@ void Session::Application::SendPendingData() {
       if (datalen) {
         Debug(session_, "Sending packet with %zu bytes", datalen);
         packet->Truncate(datalen);
-        session_->Send(packet, path);
-      } else {
-        packet->CancelPacket();
+        session_->Send(std::move(packet), path);
       }
+      // If no data, Ptr destructor releases the packet.
 
       return;
     }
@@ -429,15 +420,15 @@ void Session::Application::SendPendingData() {
     size_t datalen = pos - begin;
     Debug(session_, "Sending packet with %zu bytes", datalen);
     packet->Truncate(datalen);
-    session_->Send(packet, path);
+    session_->Send(std::move(packet), path);
 
     // If we have sent the maximum number of packets, we're done.
     if (++packet_send_count == max_packet_count) {
       return;
     }
 
     // Prepare to loop back around to prepare a new packet.
-    packet.reset();
+    // packet is already empty from the std::move above.
     pos = begin = nullptr;
   }
 }

src/quic/application.h

@@ -132,7 +132,7 @@ class Session::Application : public MemoryRetainer {
   }
 
  private:
-  BaseObjectPtr<Packet> CreateStreamDataPacket();
+  Packet::Ptr CreateStreamDataPacket();
 
   // Write the given stream_data into the buffer.
   ssize_t WriteVStream(PathStorage* path,