quic: add aliased struct arenas

Every stream, session, and endpoint creates aliased
structs for stats and state. These were creating
v8::ArrayBuffer allocations and views for each instance,
which is expensive. This adds a new arena mechanism
for AliasedStructs that allocates in pages and allows
Streams and Sessions to share the same underlying
ArrayBuffer for their stats and state. Since these
are never exposed to users, this is safe and results
in a significant reduction in allocation counts.
Each arena maintains a freelist of pages, where each
page is a max of 16KB bytes. Pages are lazily allocated
and freed as needed. Each slot in the arena corresponds
to a single struct instance, and the slot index is
used to calculate the byte offset within the page for
that struct's view.
The perf improvement is modest but measurable. The
key benefit is in reduced memory fragmentation and GC
overhead.
Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: #63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

Author: jasnell

lib/internal/quic/quic.js

@@ -1472,8 +1472,10 @@ class QuicStream {
 this.#handle[kOwner]=this;
 this.#session =session;
 this.#direction =direction;
-this.#stats =newQuicStreamStats(kPrivateConstructor,this.#handle.stats);
-this.#state =newQuicStreamState(kPrivateConstructor,this.#handle.state);
+this.#stats =newQuicStreamStats(
+kPrivateConstructor,this.#handle.stats,this.#handle.statsByteOffset);
+this.#state =newQuicStreamState(
+kPrivateConstructor,this.#handle.state,this.#handle.stateByteOffset);
 this.#reader =this.#handle.getReader();
 
 if(hasObserver('quic')){
@@ -2656,8 +2658,10 @@ class QuicSession {
 this.#pendingQlog =handle._pendingQlog;
 handle._pendingQlog=undefined;
 }
-this.#stats =newQuicSessionStats(kPrivateConstructor,handle.stats);
-this.#state =newQuicSessionState(kPrivateConstructor,handle.state);
+this.#stats =newQuicSessionStats(
+kPrivateConstructor,handle.stats,handle.statsByteOffset);
+this.#state =newQuicSessionState(
+kPrivateConstructor,handle.state,handle.stateByteOffset);
 
 if(hasObserver('quic')){
 startPerf(this,kPerfEntry,{type: 'quic',name: 'QuicSession'});

lib/internal/quic/state.js

@@ -332,163 +332,168 @@ class QuicSessionStats {
  * @param {symbol} privateSymbol
  * @param {ArrayBuffer} buffer
  */
-constructor(privateSymbol,buffer){
+/** @type {number} */
+ #offset =0;
+
+constructor(privateSymbol,view,byteOffset=0){
 // We use the kPrivateConstructor symbol to restrict the ability to
 // create new instances of QuicSessionStats to internal code.
 if(privateSymbol!==kPrivateConstructor){
 thrownewERR_ILLEGAL_CONSTRUCTOR();
 }
-if(!isArrayBuffer(buffer)){
-thrownewERR_INVALID_ARG_TYPE('buffer',['ArrayBuffer'],buffer);
+if(isArrayBuffer(view)){
+this.#handle =newBigUint64Array(view);
+}else{
+this.#handle =view;
 }
-this.#handle=newBigUint64Array(buffer);
+this.#offset=byteOffset/8;
 }
 
 /** @type {bigint} */
 getcreatedAt(){
-returnthis.#handle[IDX_STATS_SESSION_CREATED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_CREATED_AT];
 }
 
 /** @type {bigint} */
 getdestroyedAt(){
-returnthis.#handle[IDX_STATS_SESSION_DESTROYED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_DESTROYED_AT];
 }
 
 /** @type {bigint} */
 getclosingAt(){
-returnthis.#handle[IDX_STATS_SESSION_CLOSING_AT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_CLOSING_AT];
 }
 
 /** @type {bigint} */
 gethandshakeCompletedAt(){
-returnthis.#handle[IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT];
 }
 
 /** @type {bigint} */
 gethandshakeConfirmedAt(){
-returnthis.#handle[IDX_STATS_SESSION_HANDSHAKE_CONFIRMED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_HANDSHAKE_CONFIRMED_AT];
 }
 
 /** @type {bigint} */
 getbytesReceived(){
-returnthis.#handle[IDX_STATS_SESSION_BYTES_RECEIVED];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BYTES_RECEIVED];
 }
 
 /** @type {bigint} */
 getbidiInStreamCount(){
-returnthis.#handle[IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT];
 }
 
 /** @type {bigint} */
 getbidiOutStreamCount(){
-returnthis.#handle[IDX_STATS_SESSION_BIDI_OUT_STREAM_COUNT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BIDI_OUT_STREAM_COUNT];
 }
 
 /** @type {bigint} */
 getuniInStreamCount(){
-returnthis.#handle[IDX_STATS_SESSION_UNI_IN_STREAM_COUNT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_UNI_IN_STREAM_COUNT];
 }
 
 /** @type {bigint} */
 getuniOutStreamCount(){
-returnthis.#handle[IDX_STATS_SESSION_UNI_OUT_STREAM_COUNT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_UNI_OUT_STREAM_COUNT];
 }
 
 /** @type {bigint} */
 getmaxBytesInFlight(){
-returnthis.#handle[IDX_STATS_SESSION_MAX_BYTES_IN_FLIGHT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_MAX_BYTES_IN_FLIGHT];
 }
 
 /** @type {bigint} */
 getbytesInFlight(){
-returnthis.#handle[IDX_STATS_SESSION_BYTES_IN_FLIGHT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BYTES_IN_FLIGHT];
 }
 
 /** @type {bigint} */
 getblockCount(){
-returnthis.#handle[IDX_STATS_SESSION_BLOCK_COUNT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BLOCK_COUNT];
 }
 
 /** @type {bigint} */
 getcwnd(){
-returnthis.#handle[IDX_STATS_SESSION_CWND];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_CWND];
 }
 
 /** @type {bigint} */
 getlatestRtt(){
-returnthis.#handle[IDX_STATS_SESSION_LATEST_RTT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_LATEST_RTT];
 }
 
 /** @type {bigint} */
 getminRtt(){
-returnthis.#handle[IDX_STATS_SESSION_MIN_RTT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_MIN_RTT];
 }
 
 /** @type {bigint} */
 getrttVar(){
-returnthis.#handle[IDX_STATS_SESSION_RTTVAR];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_RTTVAR];
 }
 
 /** @type {bigint} */
 getsmoothedRtt(){
-returnthis.#handle[IDX_STATS_SESSION_SMOOTHED_RTT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_SMOOTHED_RTT];
 }
 
 /** @type {bigint} */
 getssthresh(){
-returnthis.#handle[IDX_STATS_SESSION_SSTHRESH];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_SSTHRESH];
 }
 
 getpktSent(){
-returnthis.#handle[IDX_STATS_SESSION_PKT_SENT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_PKT_SENT];
 }
 
 getbytesSent(){
-returnthis.#handle[IDX_STATS_SESSION_BYTES_SENT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BYTES_SENT];
 }
 
 getpktRecv(){
-returnthis.#handle[IDX_STATS_SESSION_PKT_RECV];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_PKT_RECV];
 }
 
 getbytesRecv(){
-returnthis.#handle[IDX_STATS_SESSION_BYTES_RECV];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BYTES_RECV];
 }
 
 getpktLost(){
-returnthis.#handle[IDX_STATS_SESSION_PKT_LOST];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_PKT_LOST];
 }
 
 getbytesLost(){
-returnthis.#handle[IDX_STATS_SESSION_BYTES_LOST];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_BYTES_LOST];
 }
 
 getpingRecv(){
-returnthis.#handle[IDX_STATS_SESSION_PING_RECV];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_PING_RECV];
 }
 
 getpktDiscarded(){
-returnthis.#handle[IDX_STATS_SESSION_PKT_DISCARDED];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_PKT_DISCARDED];
 }
 
 /** @type {bigint} */
 getdatagramsReceived(){
-returnthis.#handle[IDX_STATS_SESSION_DATAGRAMS_RECEIVED];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_DATAGRAMS_RECEIVED];
 }
 
 /** @type {bigint} */
 getdatagramsSent(){
-returnthis.#handle[IDX_STATS_SESSION_DATAGRAMS_SENT];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_DATAGRAMS_SENT];
 }
 
 /** @type {bigint} */
 getdatagramsAcknowledged(){
-returnthis.#handle[IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED];
 }
 
 /** @type {bigint} */
 getdatagramsLost(){
-returnthis.#handle[IDX_STATS_SESSION_DATAGRAMS_LOST];
+returnthis.#handle[this.#offset +IDX_STATS_SESSION_DATAGRAMS_LOST];
 }
 
 toString(){
@@ -590,88 +595,99 @@ class QuicSessionStats {
 }
 
 [kFinishClose](){
-// Snapshot the stats into a new BigUint64Array since the underlying
-// buffer will be destroyed.
-this.#handle =newBigUint64Array(this.#handle);
+// Snapshot this session's stats slice into a standalone BigUint64Array.
+constcount=IDX_STATS_SESSION_DATAGRAMS_LOST+1;
+constsnapshot=newBigUint64Array(count);
+for(leti=0;i<count;i++){
+snapshot[i]=this.#handle[this.#offset +i];
+}
+this.#handle =snapshot;
+this.#offset =0;
 this.#disconnected =true;
 }
 }
 
 classQuicStreamStats{
 /** @type {BigUint64Array} */
  #handle;
+/** @type {number} */
+ #offset =0;
 /** type {boolean} */
  #disconnected =false;
 
 /**
  * @param {symbol} privateSymbol
- * @param {ArrayBuffer} buffer
+ * @param {BigUint64Array|ArrayBuffer} view
+ * @param {number} [byteOffset] - byte offset into the shared page view
  */
-constructor(privateSymbol,buffer){
+constructor(privateSymbol,view,byteOffset=0){
 // We use the kPrivateConstructor symbol to restrict the ability to
 // create new instances of QuicStreamStats to internal code.
 if(privateSymbol!==kPrivateConstructor){
 thrownewERR_ILLEGAL_CONSTRUCTOR();
 }
-if(!isArrayBuffer(buffer)){
-thrownewERR_INVALID_ARG_TYPE('buffer',['ArrayBuffer'],buffer);
+if(isArrayBuffer(view)){
+this.#handle =newBigUint64Array(view);
+}else{
+this.#handle =view;
 }
-this.#handle =newBigUint64Array(buffer);
+// Convert byte offset to element offset (8 bytes per uint64).
+this.#offset =byteOffset/8;
 }
 
 /** @type {bigint} */
 getcreatedAt(){
-returnthis.#handle[IDX_STATS_STREAM_CREATED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_CREATED_AT];
 }
 
 /** @type {bigint} */
 getopenedAt(){
-returnthis.#handle[IDX_STATS_STREAM_OPENED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_OPENED_AT];
 }
 
 /** @type {bigint} */
 getreceivedAt(){
-returnthis.#handle[IDX_STATS_STREAM_RECEIVED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_RECEIVED_AT];
 }
 
 /** @type {bigint} */
 getackedAt(){
-returnthis.#handle[IDX_STATS_STREAM_ACKED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_ACKED_AT];
 }
 
 /** @type {bigint} */
 getdestroyedAt(){
-returnthis.#handle[IDX_STATS_STREAM_DESTROYED_AT];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_DESTROYED_AT];
 }
 
 /** @type {bigint} */
 getbytesReceived(){
-returnthis.#handle[IDX_STATS_STREAM_BYTES_RECEIVED];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_BYTES_RECEIVED];
 }
 
 /** @type {bigint} */
 getbytesSent(){
-returnthis.#handle[IDX_STATS_STREAM_BYTES_SENT];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_BYTES_SENT];
 }
 
 /** @type {bigint} */
 getmaxOffset(){
-returnthis.#handle[IDX_STATS_STREAM_MAX_OFFSET];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_MAX_OFFSET];
 }
 
 /** @type {bigint} */
 getmaxOffsetAcknowledged(){
-returnthis.#handle[IDX_STATS_STREAM_MAX_OFFSET_ACK];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_MAX_OFFSET_ACK];
 }
 
 /** @type {bigint} */
 getmaxOffsetReceived(){
-returnthis.#handle[IDX_STATS_STREAM_MAX_OFFSET_RECV];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_MAX_OFFSET_RECV];
 }
 
 /** @type {bigint} */
 getfinalSize(){
-returnthis.#handle[IDX_STATS_STREAM_FINAL_SIZE];
+returnthis.#handle[this.#offset +IDX_STATS_STREAM_FINAL_SIZE];
 }
 
 toString(){
@@ -735,9 +751,14 @@ class QuicStreamStats {
 }
 
 [kFinishClose](){
-// Snapshot the stats into a new BigUint64Array since the underlying
-// buffer will be destroyed.
-this.#handle =newBigUint64Array(this.#handle);
+// Snapshot this stream's stats slice into a standalone BigUint64Array.
+constcount=IDX_STATS_STREAM_FINAL_SIZE+1;
+constsnapshot=newBigUint64Array(count);
+for(leti=0;i<count;i++){
+snapshot[i]=this.#handle[this.#offset +i];
+}
+this.#handle =snapshot;
+this.#offset =0;
 this.#disconnected =true;
 }
 }