@aztec/bb.js 0.5.0 → 0.5.1

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -0,0 +1,105 @@
+import { type Worker } from 'worker_threads';
+import createDebug from 'debug';
+import { Remote } from 'comlink';
+import { getNumCpu, getRemoteBarretenbergWasm, getSharedMemoryAvailable } from '../helpers/index.js';
+import { fetchCode } from '../fetch_code/index.js';
+import { createThreadWorker } from '../barretenberg_wasm_thread/factory/node/index.js';
+import { type BarretenbergWasmThreadWorker } from '../barretenberg_wasm_thread/index.js';
+import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
+
+const debug = createDebug('bb.js:wasm');
+
+export class BarretenbergWasmMain extends BarretenbergWasmBase {
+  static MAX_THREADS = 32;
+  private workers: Worker[] = [];
+  private remoteWasms: BarretenbergWasmThreadWorker[] = [];
+  private nextWorker = 0;
+  private nextThreadId = 1;
+
+  public getNumThreads() {
+    return this.workers.length + 1;
+  }
+
+  /**
+   * Init as main thread. Spawn child threads.
+   */
+  public async init(
+    threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
+    logger: (msg: string) => void = debug,
+    initial = 25,
+    maximum = 2 ** 16,
+  ) {
+    this.logger = logger;
+
+    const initialMb = (initial * 2 ** 16) / (1024 * 1024);
+    const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
+    const shared = getSharedMemoryAvailable();
+
+    if (!shared) {
+      threads = 1;
+    }
+
+    this.logger(
+      `initial mem: ${initial} pages, ${initialMb}MiB. ` +
+        `max mem: ${maximum} pages, ${maxMb}MiB. ` +
+        `threads: ${threads}, shared: ${shared}`,
+    );
+
+    this.memory = new WebAssembly.Memory({ initial, maximum, shared });
+
+    const code = await fetchCode(shared);
+    const { instance, module } = await WebAssembly.instantiate(code, this.getImportObj(this.memory));
+
+    this.instance = instance;
+
+    // Init all global/static data.
+    this.call('_initialize');
+
+    // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
+    if (threads > 1) {
+      this.logger(`creating ${threads} worker threads...`);
+      this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createThreadWorker));
+      this.remoteWasms = await Promise.all(this.workers.map(getRemoteBarretenbergWasm<BarretenbergWasmThreadWorker>));
+      await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));
+    }
+    this.logger('init complete.');
+  }
+
+  /**
+   * Called on main thread. Signals child threads to gracefully exit.
+   */
+  public async destroy() {
+    await Promise.all(this.workers.map(w => w.terminate()));
+  }
+
+  protected getImportObj(memory: WebAssembly.Memory) {
+    const baseImports = super.getImportObj(memory);
+
+    /* eslint-disable camelcase */
+    return {
+      ...baseImports,
+      wasi: {
+        'thread-spawn': (arg: number) => {
+          arg = arg >>> 0;
+          const id = this.nextThreadId++;
+          const worker = this.nextWorker++ % this.remoteWasms.length;
+          // this.logger(`spawning thread ${id} on worker ${worker} with arg ${arg >>> 0}`);
+          this.remoteWasms[worker].call('wasi_thread_start', id, arg).catch(this.logger);
+          // this.remoteWasms[worker].postMessage({ msg: 'thread', data: { id, arg } });
+          return id;
+        },
+      },
+      env: {
+        ...baseImports.env,
+        env_hardware_concurrency: () => {
+          // If there are no workers (we're already running as a worker, or the main thread requested no workers)
+          // then we return 1, which should cause any algos using threading to just not create a thread.
+          return this.remoteWasms.length + 1;
+        },
+      },
+    };
+    /* eslint-enable camelcase */
+  }
+}
+
+export type BarretenbergWasmMainWorker = Remote<BarretenbergWasmMain>;

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

@@ -0,0 +1,10 @@
+import debug from 'debug';
+import ThreadWorker from './thread.worker.js';
+
+export function createThreadWorker() {
+  const worker = new ThreadWorker();
+  const debugStr = debug.disable();
+  debug.enable(debugStr);
+  worker.postMessage({ debug: debugStr });
+  return worker;
+}

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

@@ -0,0 +1,15 @@
+import { expose } from 'comlink';
+import { BarretenbergWasmThread } from '../../index.js';
+import debug from 'debug';
+
+self.onmessage = function (e) {
+  if (e.data.debug) {
+    debug.enable(e.data.debug);
+  }
+};
+
+expose(new BarretenbergWasmThread());
+
+self.postMessage({ ready: true });
+
+export default null as any;

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

@@ -0,0 +1,8 @@
+import { Worker } from 'worker_threads';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+export function createThreadWorker() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return new Worker(__dirname + `/thread.worker.js`);
+}

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

@@ -0,0 +1,10 @@
+import { parentPort } from 'worker_threads';
+import { expose } from 'comlink';
+import { BarretenbergWasmThread } from '../../index.js';
+import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
+
+if (!parentPort) {
+  throw new Error('No parentPort');
+}
+
+expose(new BarretenbergWasmThread(), nodeEndpoint(parentPort));

package/src/barretenberg_wasm/barretenberg_wasm_thread/index.ts

@@ -0,0 +1,47 @@
+import { Remote } from 'comlink';
+import { killSelf, threadLogger } from '../helpers/index.js';
+import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
+
+export class BarretenbergWasmThread extends BarretenbergWasmBase {
+  /**
+   * Init as worker thread.
+   */
+  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory) {
+    this.logger = threadLogger() || this.logger;
+    this.memory = memory;
+    this.instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
+  }
+
+  public destroy() {
+    killSelf();
+  }
+
+  protected getImportObj(memory: WebAssembly.Memory) {
+    const baseImports = super.getImportObj(memory);
+
+    /* eslint-disable camelcase */
+    return {
+      ...baseImports,
+      wasi: {
+        'thread-spawn': () => {
+          this.logger('PANIC: threads cannot spawn threads!');
+          this.logger(new Error().stack!);
+          killSelf();
+        },
+      },
+
+      // These are functions implementations for imports we've defined are needed.
+      // The native C++ build defines these in a module called "env". We must implement TypeScript versions here.
+      env: {
+        ...baseImports.env,
+        env_hardware_concurrency: () => {
+          // We return 1, which should cause any algos using threading to just not create a thread.
+          return 1;
+        },
+      },
+    };
+    /* eslint-enable camelcase */
+  }
+}
+
+export type BarretenbergWasmThreadWorker = Remote<BarretenbergWasmThread>;

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

@@ -0,0 +1,9 @@
+import barretenbergModule from '../../../barretenberg.wasm';
+import barretenbergThreadsModule from '../../../barretenberg-threads.wasm';
+
+// Annoyingly the wasm declares if it's memory is shared or not. So now we need two wasms if we want to be
+// able to fallback on "non shared memory" situations.
+export async function fetchCode(multithreaded: boolean) {
+  const res = await fetch(multithreaded ? barretenbergThreadsModule : barretenbergModule);
+  return await res.arrayBuffer();
+}

package/src/barretenberg_wasm/fetch_code/browser/wasm-module.d.ts

@@ -0,0 +1,4 @@
+declare module '*.wasm' {
+  const content: string;
+  export default content;
+}

package/src/barretenberg_wasm/fetch_code/index.ts

@@ -0,0 +1 @@
+export * from './node/index.js';

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

@@ -0,0 +1,9 @@
+import { readFile } from 'fs/promises';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function fetchCode(multithreaded: boolean) {
+  const path = dirname(fileURLToPath(import.meta.url)) + '/../../../barretenberg-threads.wasm';
+  return await readFile(path);
+}

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

@@ -0,0 +1,22 @@
+import { wrap } from 'comlink';
+
+export function getSharedMemoryAvailable() {
+  const globalScope = typeof window !== 'undefined' ? window : self;
+  return typeof SharedArrayBuffer !== 'undefined' && globalScope.crossOriginIsolated;
+}
+
+export function getRemoteBarretenbergWasm<T>(worker: Worker) {
+  return wrap(worker) as T;
+}
+
+export function getNumCpu() {
+  return navigator.hardwareConcurrency;
+}
+
+export function threadLogger(): ((msg: string) => void) | undefined {
+  return undefined;
+}
+
+export function killSelf() {
+  self.close();
+}

package/src/barretenberg_wasm/helpers/index.ts

@@ -0,0 +1 @@
+export * from './node/index.js';

package/src/barretenberg_wasm/{node → helpers/node}/index.ts

@@ -1,25 +1,20 @@
 import { Worker } from 'worker_threads';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { readFile } from 'fs/promises';
 import os from 'os';
-import { type BarretenbergWasm, type BarretenbergWasmWorker } from '../barretenberg_wasm.js';
 import { wrap } from 'comlink';
 import { nodeEndpoint } from './node_endpoint.js';
 import { writeSync } from 'fs';
 
-export async function fetchCode(multithreading: boolean) {
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  return await readFile(__dirname + `/../../${multithreading ? 'barretenberg-threads.wasm' : 'barretenberg.wasm'}`);
+export function getSharedMemoryAvailable() {
+  return true;
 }
 
-export function createWorker() {
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  return new Worker(__dirname + `/worker.js`);
-}
-
-export function getRemoteBarretenbergWasm(worker: Worker): BarretenbergWasmWorker {
-  return wrap<BarretenbergWasm>(nodeEndpoint(worker)) as BarretenbergWasmWorker;
+/**
+ * Comlink allows you to produce a Proxy to the worker, enabling you to call methods as if it were a normal class.
+ * Note we give it the type information it needs so the returned Proxy object looks like that type.
+ * Node has a different implementation, needing this nodeEndpoint wrapper, hence this function exists here.
+ */
+export function getRemoteBarretenbergWasm<T>(worker: Worker): T {
+  return wrap(nodeEndpoint(worker)) as T;
 }
 
 export function getNumCpu() {

package/src/barretenberg_wasm/{barretenberg_wasm.test.ts → index.test.ts}

@@ -1,48 +1,36 @@
 import { type Worker } from 'worker_threads';
-import { BarretenbergWasm, BarretenbergWasmWorker } from './barretenberg_wasm.js';
+import { BarretenbergWasm, BarretenbergWasmWorker } from './index.js';
 
 describe('barretenberg wasm', () => {
-  let wasm!: BarretenbergWasm;
+  let worker!: Worker;
+  let wasm!: BarretenbergWasmWorker;
 
   beforeAll(async () => {
-    wasm = await BarretenbergWasm.new();
-  });
+    ({ wasm, worker } = await BarretenbergWasm.new(2));
+  }, 20000);
 
   afterAll(async () => {
     await wasm.destroy();
+    await worker.terminate();
   });
 
-  it('should new malloc, transfer and slice mem', () => {
+  it('should new malloc, transfer and slice mem', async () => {
     const length = 1024;
-    const ptr = wasm.call('bbmalloc', length);
+    const ptr = await wasm.call('bbmalloc', length);
     const buf = Buffer.alloc(length, 128);
-    wasm.writeMemory(ptr, buf);
-    const result = Buffer.from(wasm.getMemorySlice(ptr, ptr + length));
-    wasm.call('bbfree', ptr);
+    await wasm.writeMemory(ptr, buf);
+    const result = Buffer.from(await wasm.getMemorySlice(ptr, ptr + length));
+    await wasm.call('bbfree', ptr);
     expect(result).toStrictEqual(buf);
   });
 
-  it('test abort', () => {
-    expect(() => wasm.call('test_abort')).toThrow();
+  it('test abort', async () => {
+    await expect(() => wasm.call('test_abort')).rejects.toThrow();
   });
 
-  it('test c/c++ stdout/stderr', () => {
+  it('test c/c++ stdout/stderr', async () => {
     // We're checking we don't crash, but you can manually confirm you see log lines handled by logstr.
-    wasm.call('test_stdout_stderr');
-  });
-});
-
-describe('barretenberg wasm worker', () => {
-  let worker!: Worker;
-  let wasm!: BarretenbergWasmWorker;
-
-  beforeAll(async () => {
-    ({ wasm, worker } = (await BarretenbergWasm.newWorker(2)) as any);
-  }, 20000);
-
-  afterAll(async () => {
-    await wasm.destroy();
-    await worker.terminate();
+    await wasm.call('test_stdout_stderr');
   });
 
   it('should new malloc, transfer and slice mem', async () => {

package/src/barretenberg_wasm/index.ts

@@ -1 +1,22 @@
-export * from './barretenberg_wasm.js';
+import { proxy } from 'comlink';
+import createDebug from 'debug';
+import { createMainWorker } from './barretenberg_wasm_main/factory/node/index.js';
+import { getRemoteBarretenbergWasm } from './helpers/node/index.js';
+import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from './barretenberg_wasm_main/index.js';
+
+const debug = createDebug('bb.js:wasm');
+
+export class BarretenbergWasm extends BarretenbergWasmMain {
+  /**
+   * Construct and initialise BarretenbergWasm within a Worker. Return both the worker and the wasm proxy.
+   * Used when running in the browser, because we can't block the main thread.
+   */
+  public static async new(threads?: number) {
+    const worker = createMainWorker();
+    const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
+    await wasm.init(threads, proxy(debug));
+    return { worker, wasm };
+  }
+}
+
+export type BarretenbergWasmWorker = BarretenbergWasmMainWorker;

package/src/bindgen/typescript.ts

@@ -48,44 +48,7 @@ export class BarretenbergApi {
     }
   }
 
-  output += `}
-
-export class BarretenbergApiSync {
-  constructor(public binder: BarretenbergBinderSync) {}
-
-  async destroy() {
-    await this.binder.wasm.destroy();
-  }
-`;
-
-  for (const { functionName, inArgs, outArgs } of functionDeclarations) {
-    try {
-      const parameters = inArgs.map(({ name, type }) => `${toCamelCase(name)}: ${mapType(type)}`).join(', ');
-      const inArgsVar = `[${inArgs.map(arg => toCamelCase(arg.name)).join(', ')}]`;
-      const outTypesVar = `[${outArgs.map(arg => mapDeserializer(arg.type)).join(', ')}]`;
-      const wasmCall = `const result = this.binder.callWasmExport('${functionName}', ${inArgsVar}, ${outTypesVar});`;
-
-      const n = outArgs.length;
-      const returnStmt = n === 0 ? 'return;' : n === 1 ? 'return result[0];' : 'return result as any;';
-      const returnType =
-        outArgs.length === 0
-          ? 'void'
-          : outArgs.length === 1
-          ? `${mapType(outArgs[0].type)}`
-          : `[${outArgs.map(a => mapType(a.type)).join(', ')}]`;
-
-      output += `
-  ${toCamelCase(functionName)}(${parameters}): ${returnType} {
-    ${wasmCall}
-    ${returnStmt}
-  }
-`;
-    } catch (err: any) {
-      throw new Error(`Function ${functionName}: ${err.message}`);
-    }
-  }
-
-  output += '}';
+  output += `}`;
 
   return output;
 }

package/src/crs/browser/cached_net_crs.ts

@@ -10,9 +10,7 @@ export class CachedNetCrs {
 
   constructor(public readonly numPoints: number) {}
 
-  // This is to keep signrature equal with the node version of CRS
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  static async new(numPoints: number, _?: string) {
+  static async new(numPoints: number) {
     const crs = new CachedNetCrs(numPoints);
     await crs.init();
     return crs;

package/src/crs/index.ts

@@ -1 +1 @@
-export { Crs } from 'dynamic/crs';
+export { Crs } from './node/index.js';

package/src/examples/simple.rawtest.ts

@@ -0,0 +1,37 @@
+import { Crs } from '../crs/index.js';
+import createDebug from 'debug';
+import { Barretenberg } from '../barretenberg/index.js';
+import { RawBuffer } from '../types/index.js';
+
+createDebug.enable('*');
+const debug = createDebug('simple_test');
+
+async function main() {
+  const CIRCUIT_SIZE = 2 ** 19;
+
+  debug('starting test...');
+  const api = await Barretenberg.new();
+
+  // Important to init slab allocator as first thing, to ensure maximum memory efficiency.
+  await api.commonInitSlabAllocator(CIRCUIT_SIZE);
+
+  // Plus 1 needed!
+  const crs = await Crs.new(CIRCUIT_SIZE + 1);
+  await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+
+  const iterations = 10;
+  let totalTime = 0;
+  for (let i = 0; i < iterations; ++i) {
+    const start = new Date().getTime();
+    debug(`iteration ${i} starting...`);
+    await api.examplesSimpleCreateAndVerifyProof();
+    totalTime += new Date().getTime() - start;
+  }
+
+  await api.destroy();
+
+  debug(`avg iteration time: ${totalTime / iterations}ms`);
+  debug('test complete.');
+}
+
+void main();

package/src/examples/simple.test.ts

@@ -1,12 +1,12 @@
-import { Crs } from '../index.js';
-import { BarretenbergApiAsync, newBarretenbergApiAsync } from '../factory/index.js';
+import { Crs } from '../crs/index.js';
+import { Barretenberg } from '../barretenberg/index.js';
 import { RawBuffer } from '../types/index.js';
 
 describe('simple', () => {
-  let api: BarretenbergApiAsync;
+  let api: Barretenberg;
 
   beforeAll(async () => {
-    api = await newBarretenbergApiAsync();
+    api = await Barretenberg.new();
 
     // Important to init slab allocator as first thing, to ensure maximum memory efficiency.
     const CIRCUIT_SIZE = 2 ** 19;
@@ -23,5 +23,5 @@ describe('simple', () => {
   it('should construct 512k gate proof', async () => {
     const valid = await api.examplesSimpleCreateAndVerifyProof();
     expect(valid).toBe(true);
-  }, 90000);
+  }, 300000);
 });

package/src/index.ts

@@ -1,5 +1,3 @@
-export * from './crs/index.js';
-export * from './barretenberg_wasm/index.js';
-export * from './barretenberg_api/index.js';
-export * from './factory/index.js';
+export { Crs } from './crs/index.js';
+export { Barretenberg } from './barretenberg/index.js';
 export { RawBuffer } from './types/index.js';

package/src/info.json

@@ -0,0 +1,22 @@
+{
+  "language": {
+    "name": "PLONK-CSAT",
+    "width": 3
+  },
+  "opcodes_supported": ["arithmetic", "directive", "brillig", "memory_init", "memory_op"],
+  "black_box_functions_supported": [
+    "and",
+    "xor",
+    "range",
+    "sha256",
+    "blake2s",
+    "keccak256",
+    "schnorr_verify",
+    "pedersen",
+    "hash_to_field_128_security",
+    "ecdsa_secp256k1",
+    "ecdsa_secp256r1",
+    "fixed_base_scalar_mul",
+    "recursive_aggregation"
+  ]
+}