bun-shared-memory 0.1.7 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-shared-memory",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Share data between Bun workers/threads using SharedArrayBuffer (zero-copy, 4-buffer architecture, Atomics-based synchronization).",
   "type": "module",
   "sideEffects": false,

package/src/growable-buffer.ts

@@ -102,7 +102,13 @@ export class GrowableBuffer {
   /** log2(chunkSize), used for O(1) offset resolution via bit shifts. */
   private readonly chunkShift: number;
   private readonly budget?: SharedBudget;
-  private used = 0;
+  /**
+   * Shared append cursor (used length). Stored in a SharedArrayBuffer so all
+   * workers that reconstruct this buffer from `fromBuffers()` see the same
+   * used length and append at the correct offset instead of overwriting
+   * existing data at offset 0.
+   */
+  private readonly cursor: BigInt64Array;
   /** Smallest chunk index that is not yet active (see `activate`). */
   private nextChunkToActivate = 0;
 
@@ -113,9 +119,13 @@ export class GrowableBuffer {
     chunkSize = 32 * 1024 * 1024, // 32 MiB per chunk
     singleBuffer = false,
     chargeInitial = true,
+    cursorBuffer?: SharedArrayBuffer,
   ) {
     this.singleBuffer = singleBuffer;
     this.budget = budget;
+    this.cursor = new BigInt64Array(
+      cursorBuffer ?? new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT),
+    );
     if (singleBuffer && typeof initialSizeOrBuffer !== "number") {
       const buffer = Array.isArray(initialSizeOrBuffer)
         ? initialSizeOrBuffer[0]
@@ -267,7 +277,12 @@ export class GrowableBuffer {
 
   /** Number of bytes written so far (used length, not buffer capacity). */
   get byteLength(): number {
-    return this.used;
+    return Number(Atomics.load(this.cursor, 0));
+  }
+
+  /** The shared cursor buffer (for export to workers). */
+  get cursorBuffer(): SharedArrayBuffer {
+    return this.cursor.buffer as SharedArrayBuffer;
   }
 
   /** Total logical capacity across all chunks (active or not). */
@@ -373,7 +388,7 @@ export class GrowableBuffer {
 
   /** Mark `n` bytes as used, after writing them at the current offset. */
   advance(n: number): void {
-    this.used += n;
+    Atomics.add(this.cursor, 0, BigInt(n));
   }
 
   /**
@@ -383,7 +398,7 @@ export class GrowableBuffer {
    * `releaseInactiveChunks()`.
    */
   reset(n: number): void {
-    this.used = n;
+    Atomics.store(this.cursor, 0, BigInt(n));
     if (this.singleBuffer) return;
     const neededChunks = Math.ceil(n / this.chunkSize);
     for (let i = 0; i < this.chunks.length; i++) {

package/src/memory.ts

@@ -211,6 +211,12 @@ export interface SharedMemoryOptions {
     layoutVersion?: SharedArrayBuffer;
     refCount?: SharedArrayBuffer;
     budget?: SharedArrayBuffer;
+    cursors?: {
+      indexTable?: SharedArrayBuffer;
+      dataTable?: SharedArrayBuffer;
+      stringTable?: SharedArrayBuffer;
+      arrayTable?: SharedArrayBuffer;
+    };
   };
 }
 
@@ -223,6 +229,7 @@ function makeBuffer(
   chunkSize?: number,
   singleBuffer = false,
   chargeInitial = true,
+  cursorBuffer?: SharedArrayBuffer,
 ): GrowableBuffer {
   if (buf === undefined) {
     return new GrowableBuffer(
@@ -232,6 +239,7 @@ function makeBuffer(
       chunkSize,
       singleBuffer,
       chargeInitial,
+      cursorBuffer,
     );
   }
   return new GrowableBuffer(
@@ -241,6 +249,7 @@ function makeBuffer(
     chunkSize,
     singleBuffer,
     chargeInitial,
+    cursorBuffer,
   );
 }
 
@@ -359,6 +368,8 @@ export class SharedMemory {
       undefined,
       chunkSize,
       true,
+      true,
+      buffers?.cursors?.indexTable,
     );
     this.dataTable = makeBuffer(
       buffers?.dataTable,
@@ -368,6 +379,7 @@ export class SharedMemory {
       chunkSize,
       false,
       chargeInitial,
+      buffers?.cursors?.dataTable,
     );
     this.stringTable = makeBuffer(
       buffers?.stringTable,
@@ -377,6 +389,7 @@ export class SharedMemory {
       chunkSize,
       false,
       chargeInitial,
+      buffers?.cursors?.stringTable,
     );
     this.arrayTable = makeBuffer(
       buffers?.arrayTable,
@@ -386,6 +399,7 @@ export class SharedMemory {
       chunkSize,
       false,
       chargeInitial,
+      buffers?.cursors?.arrayTable,
     );
     this.versionView = new Int32Array(this.indexTable.buffers[0]!);
     this.layoutVersion = new Int32Array(
@@ -453,6 +467,12 @@ export class SharedMemory {
     indexTableMaxByteLength: number;
     maxTotalBytes: number | null;
     budget: SharedArrayBuffer | null;
+    cursors: {
+      indexTable: SharedArrayBuffer;
+      dataTable: SharedArrayBuffer;
+      stringTable: SharedArrayBuffer;
+      arrayTable: SharedArrayBuffer;
+    };
   } {
     return {
       indexTable: this.indexTable.buffers,
@@ -466,6 +486,12 @@ export class SharedMemory {
       indexTableMaxByteLength: this.indexTableMaxByteLength,
       maxTotalBytes: this.maxTotalBytes,
       budget: this.budgetBuffer,
+      cursors: {
+        indexTable: this.indexTable.cursorBuffer,
+        dataTable: this.dataTable.cursorBuffer,
+        stringTable: this.stringTable.cursorBuffer,
+        arrayTable: this.arrayTable.cursorBuffer,
+      },
     };
   }
 
@@ -485,6 +511,12 @@ export class SharedMemory {
     indexTableMaxByteLength?: number;
     maxTotalBytes?: number | null;
     budget?: SharedArrayBuffer | null;
+    cursors?: {
+      indexTable?: SharedArrayBuffer;
+      dataTable?: SharedArrayBuffer;
+      stringTable?: SharedArrayBuffer;
+      arrayTable?: SharedArrayBuffer;
+    };
   }): SharedMemory {
     const indexBuffer = Array.isArray(buffers.indexTable)
       ? buffers.indexTable[0]
@@ -505,6 +537,7 @@ export class SharedMemory {
         layoutVersion: buffers.layoutVersion,
         refCount: buffers.refCount ?? undefined,
         budget: buffers.budget ?? undefined,
+        cursors: buffers.cursors,
       },
       lock: new Mutex(buffers.lock),
     });