@aztec/bb.js 0.0.1-commit.24de95ac → 0.0.1-commit.2e2504e2

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -5,7 +5,6 @@ import { createThreadWorker } from '../barretenberg_wasm_thread/factory/node/ind
 import { type BarretenbergWasmThreadWorker } from '../barretenberg_wasm_thread/index.js';
 import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
 import { HeapAllocator } from './heap_allocator.js';
-import { createDebugLogger } from '../../log/index.js';
 
 /**
  * This is the "main thread" implementation of BarretenbergWasm.
@@ -18,6 +17,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   private remoteWasms: BarretenbergWasmThreadWorker[] = [];
   private nextWorker = 0;
   private nextThreadId = 1;
+  private useCustomLogger = false;
 
   // Pre-allocated scratch buffers for msgpack I/O to avoid malloc/free overhead
   private msgpackInputScratch: number = 0; // 8MB input buffer
@@ -34,11 +34,13 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   public async init(
     module: WebAssembly.Module,
     threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
-    logger: (msg: string) => void = createDebugLogger('bb_wasm'),
-    initial = 33,
+    logger?: (msg: string) => void,
+    initial = 35,
     maximum = this.getDefaultMaximumMemoryPages(),
   ) {
-    this.logger = logger;
+    // Track whether a custom logger was provided so workers know whether to postMessage logs
+    this.useCustomLogger = logger !== undefined;
+    this.logger = logger ?? (() => {});
 
     const initialMb = (initial * 2 ** 16) / (1024 * 1024);
     const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
@@ -71,8 +73,14 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     if (threads > 1) {
       this.logger(`Creating ${threads} worker threads`);
       this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createThreadWorker));
+
+      // Set up log message forwarding from workers to our logger (only if custom logger provided)
+      if (this.useCustomLogger) {
+        this.workers.forEach(worker => this.setupWorkerLogForwarding(worker));
+      }
+
       this.remoteWasms = await Promise.all(this.workers.map(getRemoteBarretenbergWasm<BarretenbergWasmThreadWorker>));
-      await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));
+      await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory, this.useCustomLogger)));
     }
   }
 
@@ -85,6 +93,31 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     return 2 ** 16;
   }
 
+  /**
+   * Set up forwarding of log messages from worker threads to our logger.
+   * Workers post messages with { type: 'log', msg: string } which we intercept here.
+   */
+  private setupWorkerLogForwarding(worker: Worker) {
+    const handler = (data: unknown) => {
+      if (data && typeof data === 'object' && 'type' in data && data.type === 'log' && 'msg' in data) {
+        this.logger(data.msg as string);
+      }
+    };
+
+    // Node Workers use 'on' method, browser Workers use 'addEventListener'
+    // The 'worker' variable is typed as Node's Worker, but at runtime in browser
+    // it will be a browser Worker (due to browser_postprocess.sh import rewriting)
+    if ('on' in worker && typeof worker.on === 'function') {
+      // Node.js worker_threads Worker
+      worker.on('message', handler);
+    } else if ('addEventListener' in worker) {
+      // Browser Web Worker
+      (worker as unknown as globalThis.Worker).addEventListener('message', (event: MessageEvent) => {
+        handler(event.data);
+      });
+    }
+  }
+
   /**
    * Called on main thread. Signals child threads to gracefully exit.
    */

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.ts

@@ -1,11 +1,9 @@
-import { logOptions } from '../../../../log/index.js';
 import { readinessListener } from '../../../helpers/browser/index.js';
 
 export async function createThreadWorker() {
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
   const worker = new Worker(new URL('./thread.worker.js', import.meta.url), { type: 'module' });
-  worker.postMessage({ log: logOptions });
   await new Promise<void>(resolve => readinessListener(worker, resolve));
   return worker;
 }

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/thread.worker.ts

@@ -1,13 +1,6 @@
 import { expose } from 'comlink';
 import { BarretenbergWasmThread } from '../../index.js';
 import { Ready } from '../../../helpers/browser/index.js';
-import { initLogger } from '../../../../log/browser/index.js';
-
-addEventListener('message', e => {
-  if (e.data.log) {
-    initLogger(e.data.log);
-  }
-});
 
 expose(new BarretenbergWasmThread());
 postMessage(Ready);

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/node/index.ts

@@ -1,7 +1,6 @@
 import { Worker } from 'worker_threads';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { logOptions } from '../../../../log/index.js';
 
 function getCurrentDir() {
   if (typeof __dirname !== 'undefined') {
@@ -16,6 +15,5 @@ function getCurrentDir() {
 export function createThreadWorker() {
   const __dirname = getCurrentDir();
   const worker = new Worker(__dirname + `/thread.worker.js`);
-  worker.postMessage({ log: logOptions });
   return Promise.resolve(worker);
 }

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/node/thread.worker.ts

@@ -2,7 +2,6 @@ import { parentPort } from 'worker_threads';
 import { expose } from 'comlink';
 import { BarretenbergWasmThread } from '../../index.js';
 import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
-import { initLogger } from '../../../../log/node/index.js';
 
 if (!parentPort) {
   throw new Error('No parentPort');
@@ -10,10 +9,4 @@ if (!parentPort) {
 
 const endpoint = nodeEndpoint(parentPort);
 
-endpoint.addEventListener('message', (e: any) => {
-  if (e.data.log) {
-    initLogger(e.data.log);
-  }
-});
-
 expose(new BarretenbergWasmThread(), endpoint);

package/src/barretenberg_wasm/barretenberg_wasm_thread/index.ts

@@ -5,9 +5,10 @@ import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
 export class BarretenbergWasmThread extends BarretenbergWasmBase {
   /**
    * Init as worker thread.
+   * @param useCustomLogger - If true, logs will be posted back to main thread for custom logger routing
    */
-  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory) {
-    this.logger = threadLogger() || this.logger;
+  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory, useCustomLogger = false) {
+    this.logger = threadLogger(useCustomLogger) || this.logger;
     this.memory = memory;
     this.instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
   }

package/src/barretenberg_wasm/helpers/browser/index.ts

@@ -13,7 +13,14 @@ export function getNumCpu() {
   return navigator.hardwareConcurrency;
 }
 
-export function threadLogger(): ((msg: string) => void) | undefined {
+export function threadLogger(useCustomLogger: boolean): ((msg: string) => void) | undefined {
+  if (useCustomLogger) {
+    // Post log messages back to main thread for routing through user-provided logger
+    return (msg: string) => {
+      postMessage({ type: 'log', msg });
+    };
+  }
+  // Use console.log directly when no custom logger is provided
   return console.log;
 }
 

package/src/barretenberg_wasm/helpers/node/index.ts

@@ -1,4 +1,4 @@
-import { Worker } from 'worker_threads';
+import { Worker, parentPort } from 'worker_threads';
 import os from 'os';
 import { wrap } from 'comlink';
 import { nodeEndpoint } from './node_endpoint.js';
@@ -25,12 +25,19 @@ export function getNumCpu() {
 }
 
 /**
- * In node, the message passing is different to the browser. When using 'debug' in the browser, we seemingly always
- * get our logs, but in node it looks like it's dependent on the chain of workers from child to main thread be
- * unblocked. If one of our threads aborts, we can't see it as the parent is blocked waiting on threads to join.
- * To work around this in node, threads will by default write directly to stdout.
+ * Returns a logger function for worker threads.
+ * When a custom logger is provided, posts messages back to the main thread.
+ * Otherwise, writes directly to stdout.
  */
-export function threadLogger(): ((msg: string) => void) | undefined {
+export function threadLogger(useCustomLogger: boolean): ((msg: string) => void) | undefined {
+  if (useCustomLogger) {
+    return (msg: string) => {
+      if (parentPort) {
+        parentPort.postMessage({ type: 'log', msg });
+      }
+    };
+  }
+  // Write directly to stdout when no custom logger is provided
   return (msg: string) => {
     writeSync(1, msg + '\n');
   };

package/src/barretenberg_wasm/index.ts

@@ -1,11 +1,10 @@
 import { getSharedMemoryAvailable, getAvailableThreads } from './helpers/node/index.js';
 import { fetchCode } from './fetch_code/index.js';
-import { createDebugLogger } from '../log/index.js';
 
 export async function fetchModuleAndThreads(
   desiredThreads = 32,
   wasmPath?: string,
-  logger: (msg: string) => void = createDebugLogger('fetch_mat'),
+  logger: (msg: string) => void = () => {},
 ) {
   const shared = getSharedMemoryAvailable();
 

package/src/bb_backends/browser/platform.ts

@@ -0,0 +1,11 @@
+export function findPackageRoot(): string | null {
+  throw new Error('Not implemented in browser environment.');
+}
+
+export function findBbBinary(customPath?: string): string | null {
+  throw new Error('Not implemented in browser environment.');
+}
+
+export function findNapiBinary(customPath?: string): string | null {
+  throw new Error('Not implemented in browser environment.');
+}

package/src/bb_backends/index.ts

@@ -3,13 +3,13 @@
  */
 export enum BackendType {
   /** WASM direct execution (no worker) */
-  Wasm = 'wasm',
+  Wasm = 'Wasm',
   /** WASM with worker threads */
-  WasmWorker = 'wasm-worker',
+  WasmWorker = 'WasmWorker',
   /** Native via Unix domain socket (async only) */
-  NativeUnixSocket = 'native-unix-socket',
-  /** Native via shared memory (sync only currently) */
-  NativeSharedMemory = 'native-shared-mem',
+  NativeUnixSocket = 'NativeUnixSocket',
+  /** Native via shared memory */
+  NativeSharedMemory = 'NativeSharedMemory',
 }
 
 export type BackendOptions = {
@@ -28,7 +28,13 @@ export type BackendOptions = {
   /** @description Custom path to bb binary for native backend (overrides automatic detection) */
   bbPath?: string;
 
-  /** @description Logging function */
+  /** @description Custom path to bb NAPI module for native backend (overrides automatic detection) */
+  napiPath?: string;
+
+  /**
+   * @description Logging function
+   * Warning: Attaching a logger can prevent nodejs from exiting without explicitly destroying the backend.
+   */
   logger?: (msg: string) => void;
 
   /**

package/src/bb_backends/node/index.ts

@@ -1,7 +1,7 @@
 import { BarretenbergNativeSocketAsyncBackend } from './native_socket.js';
 import { BarretenbergWasmSyncBackend, BarretenbergWasmAsyncBackend } from '../wasm.js';
 import { BarretenbergNativeShmSyncBackend } from './native_shm.js';
-import { SyncToAsyncAdapter } from '../sync_to_async_adapter.js';
+import { BarretenbergNativeShmAsyncBackend } from './native_shm_async.js';
 import { findBbBinary, findNapiBinary } from './platform.js';
 import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
 import { BackendOptions, BackendType } from '../index.js';
@@ -14,6 +14,11 @@ export async function createAsyncBackend(
   options: BackendOptions,
   logger: (msg: string) => void,
 ): Promise<Barretenberg> {
+  options = {
+    ...options,
+    wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+  };
+
   switch (type) {
     case BackendType.NativeUnixSocket: {
       const bbPath = findBbBinary(options.bbPath);
@@ -21,7 +26,7 @@ export async function createAsyncBackend(
         throw new Error('Native backend requires bb binary.');
       }
       logger(`Using native Unix socket backend: ${bbPath}`);
-      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads);
+      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads, options.logger);
       return new Barretenberg(socket, options);
     }
 
@@ -30,14 +35,17 @@ export async function createAsyncBackend(
       if (!bbPath) {
         throw new Error('Native backend requires bb binary.');
       }
-      const napiPath = findNapiBinary();
+      const napiPath = findNapiBinary(options.napiPath);
       if (!napiPath) {
-        throw new Error('Native sync backend requires napi client stub.');
+        throw new Error('Native async backend requires napi client stub.');
       }
-      logger(`Using native shared memory backend (via sync adapter): ${bbPath}`);
-      // Use sync backend with adapter to provide async interface
-      const syncBackend = await BarretenbergNativeShmSyncBackend.new(bbPath, options.threads, options.maxClients);
-      const asyncBackend = new SyncToAsyncAdapter(syncBackend);
+      logger(`Using native shared memory async backend: ${bbPath}`);
+      const asyncBackend = await BarretenbergNativeShmAsyncBackend.new(
+        bbPath,
+        napiPath,
+        options.threads,
+        options.logger,
+      );
       return new Barretenberg(asyncBackend, options);
     }
 
@@ -68,18 +76,23 @@ export async function createSyncBackend(
   options: BackendOptions,
   logger: (msg: string) => void,
 ): Promise<BarretenbergSync> {
+  options = {
+    ...options,
+    wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+  };
+
   switch (type) {
     case BackendType.NativeSharedMemory: {
       const bbPath = findBbBinary(options.bbPath);
       if (!bbPath) {
         throw new Error('Native backend requires bb binary.');
       }
-      const napiPath = findNapiBinary();
+      const napiPath = findNapiBinary(options.napiPath);
       if (!napiPath) {
         throw new Error('Native sync backend requires napi client stub.');
       }
       logger(`Using native shared memory backend: ${bbPath}`);
-      const shm = await BarretenbergNativeShmSyncBackend.new(bbPath, options.threads, options.maxClients);
+      const shm = await BarretenbergNativeShmSyncBackend.new(bbPath, napiPath, options.threads, options.logger);
       return new BarretenbergSync(shm);
     }
 

package/src/bb_backends/node/native_shm.ts

@@ -1,22 +1,11 @@
 import { createRequire } from 'module';
 import { spawn, ChildProcess } from 'child_process';
+import { openSync, closeSync, unlinkSync } from 'fs';
 import { IMsgpackBackendSync } from '../interface.js';
 import { findNapiBinary, findPackageRoot } from './platform.js';
+import { threadId } from 'worker_threads';
 
-// Import the NAPI module
-// The addon is built to the nodejs_module directory
-const addonPath = findNapiBinary();
-// Try loading, but don't throw if it doesn't exist (will be caught in constructor)
-let addon: any = null;
-try {
-  if (addonPath) {
-    const require = createRequire(findPackageRoot()!);
-    addon = require(addonPath);
-  }
-} catch (err) {
-  // Addon not built yet or not available
-  addon = null;
-}
+let instanceCounter = 0;
 
 /**
  * Synchronous shared memory backend that communicates with bb binary via shared memory.
@@ -32,49 +21,89 @@ try {
 export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
   private process: ChildProcess;
   private client: any; // NAPI MsgpackClient instance
+  private logFd?: number; // File descriptor for logs
 
-  private constructor(process: ChildProcess, client: any) {
+  private constructor(process: ChildProcess, client: any, logFd?: number) {
     this.process = process;
     this.client = client;
+    this.logFd = logFd;
   }
 
   /**
    * Create and initialize a shared memory backend.
    * @param bbBinaryPath Path to bb binary
+   * @param napiPath Path to NAPI binary
    * @param threads Optional number of threads
-   * @param maxClients Optional maximum concurrent clients (default: 1)
    */
   static async new(
     bbBinaryPath: string,
+    napiPath: string,
     threads?: number,
-    maxClients?: number,
+    logger?: (msg: string) => void,
   ): Promise<BarretenbergNativeShmSyncBackend> {
-    if (!addon || !addon.MsgpackClient) {
-      throw new Error('Shared memory NAPI not available.');
+    // Import the NAPI module
+    // The addon is built to the nodejs_module directory
+    const addonPath = findNapiBinary(napiPath);
+    // Try loading
+    let addon: any = null;
+    try {
+      const require = createRequire(findPackageRoot()!);
+      addon = require(addonPath!);
+    } catch (err) {
+      // Addon not built yet or not available
+      throw new Error('Shared memory sync NAPI not available.');
     }
 
     // Create a unique shared memory name
-    const shmName = `bb-${process.pid}-${Date.now()}`;
+    const shmName = `bb-sync-${process.pid}-${threadId}-${instanceCounter++}`;
+
+    // If threads not set use 1 thread. We're not expected to do long lived work on sync backends.
+    const hwc = threads ? threads.toString() : '1';
+    const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
+
+    // Set up file logging if logger is provided.
+    // Direct file redirection bypasses Node event loop - logs are written even if process hangs.
+    let logFd: number | undefined;
+    let logPath: string | undefined;
+    if (logger) {
+      logPath = `/tmp/${shmName}.log`;
+      logFd = openSync(logPath, 'w');
+      logger(`BB process logs redirected to: ${logPath}`);
+    }
 
-    // Default maxClients to 1 if not specified
-    const clientCount = maxClients ?? 1;
+    // Clean up any stale shared memory files from previous runs
+    // This handles the case where a previous process crashed without cleanup
+    const shmRequestPath = `/dev/shm/${shmName}_request`;
+    const shmResponsePath = `/dev/shm/${shmName}_response`;
+    try {
+      unlinkSync(shmRequestPath);
+    } catch (err) {
+      const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+      if (!isNotFound) {
+        throw new Error(`Failed to clean up stale shared memory file ${shmRequestPath}: ${err}`);
+      }
+    }
 
-    // Set HARDWARE_CONCURRENCY if threads specified
-    const env = threads !== undefined ? { ...process.env, HARDWARE_CONCURRENCY: threads.toString() } : process.env;
+    try {
+      unlinkSync(shmResponsePath);
+    } catch (err) {
+      const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+      if (!isNotFound) {
+        throw new Error(`Failed to clean up stale shared memory file ${shmResponsePath}: ${err}`);
+      }
+    }
 
-    // Spawn bb process with shared memory mode
-    const args = [bbBinaryPath, 'msgpack', 'run', '--input', `${shmName}.shm`, '--max-clients', clientCount.toString()];
-    const bbProcess = spawn(findPackageRoot() + '/scripts/kill_wrapper.sh', args, {
-      stdio: ['ignore', 'ignore', 'ignore'],
+    // Spawn bb process with shared memory mode (SPSC-only, no max-clients needed)
+    const args = ['msgpack', 'run', '--input', `${shmName}.shm`, '--request-ring-size', `${1024 * 1024 * 4}`];
+    const bbProcess = spawn(bbBinaryPath, args, {
+      stdio: ['ignore', logFd ?? 'ignore', logFd ?? 'ignore'],
       env,
     });
-    // Disconnect from event loop so process can exit. The kill wrapper will reap bb once parent (node) dies.
-    bbProcess.unref();
 
-    // Capture stderr for error diagnostics
-    // bbProcess.stderr?.on('data', (data: Buffer) => {
-    //   stderrOutput += data.toString();
-    // });
+    // Disconnect from event loop so process can exit without waiting for bb
+    // The bb process has parent death monitoring (prctl on Linux, kqueue on macOS)
+    // so it will automatically exit when Node.js exits
+    bbProcess.unref();
 
     // Track if process has exited
     let processExited = false;
@@ -114,8 +143,8 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
         }
 
         try {
-          // Create NAPI client with matching max_clients value
-          client = new addon.MsgpackClient(shmName, clientCount);
+          // Create NAPI client (SPSC-only, no max_clients needed)
+          client = new addon.MsgpackClient(shmName);
           break; // Success!
         } catch (err: any) {
           // Connection failed, will retry
@@ -133,12 +162,19 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
         throw new Error('Failed to create client connection');
       }
 
-      return new BarretenbergNativeShmSyncBackend(bbProcess, client);
+      return new BarretenbergNativeShmSyncBackend(bbProcess, client, logFd);
     } finally {
-      // If we failed to connect, ensure the process is killed
+      // If we failed to connect, ensure the process is killed and log file closed
       // kill() returns false if process already exited, but doesn't throw
       if (!client) {
         bbProcess.kill('SIGKILL');
+        if (logFd !== undefined) {
+          try {
+            closeSync(logFd);
+          } catch (e) {
+            // Ignore errors during cleanup
+          }
+        }
       }
     }
   }
@@ -160,6 +196,13 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
         // Ignore errors during cleanup
       }
     }
+    if (this.logFd !== undefined) {
+      try {
+        closeSync(this.logFd);
+      } catch (e) {
+        // Ignore errors during cleanup
+      }
+    }
   }
 
   destroy(): void {