bun-shared-memory 0.1.5 → 0.1.7

package/src/refcount.ts

@@ -161,6 +161,13 @@ export class RefCountCoordinator {
   /** Free-space threshold (fraction of maxByteLength) that triggers defrag. */
   private readonly defragThreshold: number;
   private maintenanceTimer: ReturnType<typeof setInterval> | null = null;
+  /** Called after a defragmentation pass with the new chunk lists. */
+  private readonly onDefragment?: (buffers: {
+    indexTable: SharedArrayBuffer[];
+    dataTable: SharedArrayBuffer[];
+    stringTable: SharedArrayBuffer[];
+    arrayTable: SharedArrayBuffer[];
+  }) => void;
 
   constructor(
     mem: SharedMemory,
@@ -169,9 +176,16 @@ export class RefCountCoordinator {
       defragThreshold?: number;
       autoMaintenance?: boolean;
       maintenanceInterval?: number;
+      onDefragment?: (buffers: {
+        indexTable: SharedArrayBuffer[];
+        dataTable: SharedArrayBuffer[];
+        stringTable: SharedArrayBuffer[];
+        arrayTable: SharedArrayBuffer[];
+      }) => void;
     } = {},
   ) {
     this.mem = mem;
+    this.onDefragment = opts.onDefragment;
     // Reuse the memory's shared refCount buffer if present, so the same SAB is
     // exported to workers; otherwise create a fresh one and attach it to the
     // memory so it can be shared.
@@ -286,9 +300,9 @@ export class RefCountCoordinator {
 
   /** Whether any table has less than `defragThreshold` free space. */
   needsDefrag(): boolean {
-    const max = this.mem.dataTable.buffer.maxByteLength;
-    const free = (b: { buffer: SharedArrayBuffer; byteLength: number }) =>
-      (b.buffer.byteLength - b.byteLength) / max;
+    const max = this.mem.dataTable.capacity;
+    const free = (b: { capacity: number; byteLength: number }) =>
+      (b.capacity - b.byteLength) / max;
     return (
       free(this.mem.dataTable) < this.defragThreshold ||
       free(this.mem.arrayTable) < this.defragThreshold ||
@@ -313,7 +327,8 @@ export class RefCountCoordinator {
     this.maintenanceTimer = setInterval(() => {
       this.drainEvents();
       if (this.needsDefrag()) {
-        this.mem.withLock(() => this.mem.defragment());
+        const buffers = this.mem.withLock(() => this.mem.defragment());
+        this.onDefragment?.(buffers);
       }
     }, intervalMs);
     // Unref the timer so it does not keep the process alive. The coordinator

package/src/shared.ts

@@ -178,7 +178,7 @@ function isTrackable(value: unknown): boolean {
 function getTopLevelObjectId(mem: SharedMemory, key: string): number | null {
   const offset = getOffset(mem, key);
   if (offset === null) return null;
-  const type = mem.dataTable.getView().getInt32(offset, true);
+  const type = mem.dataTable.getInt32(offset);
   if (type === 5) {
     return mem.getObjectId(offset);
   }
@@ -517,7 +517,7 @@ function createSharedRef<T>(
       enumerable: false,
       configurable: false,
       get() {
-        return mem.dataTable.buffer;
+        return mem.dataTable.buffers[0];
       },
     });
     const ref = Object.create(proto) as Record<string | symbol, unknown>;
@@ -564,7 +564,7 @@ function createSharedRef<T>(
       if (prop === "write") return t.write;
       if (prop === "update") return t.update;
       if (prop === "key") return t.key;
-      if (prop === "buffer") return mem.dataTable.buffer;
+      if (prop === "buffer") return mem.dataTable.buffers[0];
       if (prop === Symbol.toPrimitive) return () => t.read();
 
       // push/pop on a top-level array: operate directly on the array ref
@@ -635,7 +635,7 @@ function readValue(
     if (offset === null) {
       throw new Error(`No shared value found for key "${key}"`);
     }
-    const type = mem.dataTable.getView().getInt32(offset, true);
+    const type = mem.dataTable.getInt32(offset);
     if (type === 5) {
       // Object block.
       const properties = mem.readObject(offset);
@@ -665,7 +665,7 @@ function writeValue(
   mem.withLock(() => {
     const existing = getOffset(mem, key);
     if (existing !== null) {
-      const type = mem.dataTable.getView().getInt32(existing, true);
+      const type = mem.dataTable.getInt32(existing);
       if (type === 5) {
         // Update existing object's property slots in place.
         const properties = mem.readObject(existing);

package/src/worker.ts

@@ -130,7 +130,9 @@ export function getDefaultTracker(): RefCountTracker | null {
 function startCoordinator(): void {
   if (coordinator !== null) return;
   const mem = getDefaultMemory();
-  coordinator = new RefCountCoordinator(mem);
+  coordinator = new RefCountCoordinator(mem, undefined, {
+    onDefragment: (buffers) => broadcastChunkUpdate(buffers),
+  });
   unregisterWorkers = coordinator.autoRegister();
 }
 
@@ -144,6 +146,7 @@ function stopCoordinator(): void {
   }
 }
 
+// ---------------------------------------------------------------------------
 /** The main-thread worker listener, so it can be removed by `stopInit()`. */
 let mainListener:
   | ((worker: {
@@ -155,6 +158,12 @@ let mainListener:
     }) => void)
   | null = null;
 
+/** Live workers on the main thread, for broadcasting chunk updates. */
+const liveWorkers = new Set<{
+  postMessage: (msg: unknown) => void;
+  addEventListener: (type: string, fn: (e: { data: unknown }) => void) => void;
+}>();
+
 /** Main thread: answer each worker's buffer request. */
 function initMain(): void {
   const listener = (worker: {
@@ -164,14 +173,20 @@ function initMain(): void {
       fn: (e: { data: unknown }) => void,
     ) => void;
   }) => {
+    liveWorkers.add(worker);
     worker.addEventListener("message", (e) => {
       const msg = e.data as { __sharedMemoryRequest?: boolean } | undefined;
-      if (msg && msg.__sharedMemoryRequest) {
+      if (
+        msg !== null &&
+        typeof msg === "object" &&
+        "__sharedMemoryRequest" in msg
+      ) {
         const mem = getDefaultMemory();
         worker.postMessage({
           __sharedMemoryInit: true,
           buffers: mem.exportBuffers(),
         });
+        return;
       }
     });
   };
@@ -185,6 +200,22 @@ function stopMain(): void {
     process.off("worker", mainListener);
     mainListener = null;
   }
+  liveWorkers.clear();
+}
+
+/**
+ * Broadcast a chunk update (new chunk lists after a defragmentation pass) to
+ * all live workers. Workers apply it via `applyChunkUpdate()`.
+ */
+function broadcastChunkUpdate(buffers: {
+  indexTable: SharedArrayBuffer[];
+  dataTable: SharedArrayBuffer[];
+  stringTable: SharedArrayBuffer[];
+  arrayTable: SharedArrayBuffer[];
+}): void {
+  for (const worker of liveWorkers) {
+    worker.postMessage({ __chunkUpdate: true, buffers });
+  }
 }
 
 /** Worker: request the buffers from the main thread and await the reply. */
@@ -233,8 +264,22 @@ function installMessageWrapper(): void {
           __sharedMemoryInit?: boolean;
           buffers?: Parameters<typeof SharedMemory.fromBuffers>[0];
         }
+      | {
+          __chunkUpdate?: boolean;
+          buffers?: {
+            indexTable: SharedArrayBuffer[];
+            dataTable: SharedArrayBuffer[];
+            stringTable: SharedArrayBuffer[];
+            arrayTable: SharedArrayBuffer[];
+          };
+        }
       | undefined;
-    if (msg && msg.__sharedMemoryInit && msg.buffers) {
+    if (
+      msg !== null &&
+      typeof msg === "object" &&
+      "__sharedMemoryInit" in msg &&
+      msg.buffers
+    ) {
       const mem = SharedMemory.fromBuffers(msg.buffers);
       setDefaultMemory(mem);
       // Create the worker-side refcount tracker from the shared refcount
@@ -253,6 +298,18 @@ function installMessageWrapper(): void {
       flush();
       return;
     }
+    if (
+      msg !== null &&
+      typeof msg === "object" &&
+      "__chunkUpdate" in msg &&
+      msg.buffers &&
+      hasDefaultMemory()
+    ) {
+      // The main thread replaced inactive chunks after a defragmentation
+      // pass; apply the new chunk lists so this worker sees the replacement.
+      getDefaultMemory().applyChunkUpdate(msg.buffers);
+      return;
+    }
     if (hasDefaultMemory() && hasHandler) {
       messageHandler(e);
     } else {