@simulatte/webgpu 0.2.3 → 0.3.0

package/src/bun-ffi.js

@@ -4,6 +4,7 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createDoeRuntime, runDawnVsDoeCompare } from "./runtime_cli.js";
 import { loadDoeBuildMetadata } from "./build_metadata.js";
+import { inferAutoBindGroupLayouts } from "./auto_bind_group_layout.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = resolve(__dirname, "..");
@@ -120,7 +121,7 @@ let wgpu = null;
 // ---------------------------------------------------------------------------
 
 function openLibrary(path) {
-    return dlopen(path, {
+    const symbols = {
         // Instance
         wgpuCreateInstance:       { args: [FFIType.ptr], returns: FFIType.ptr },
         wgpuInstanceRelease:      { args: [FFIType.ptr], returns: FFIType.void },
@@ -157,7 +158,6 @@ function openLibrary(path) {
         wgpuDeviceCreateComputePipeline: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
         wgpuComputePipelineRelease: { args: [FFIType.ptr], returns: FFIType.void },
         wgpuComputePipelineGetBindGroupLayout: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.ptr },
-        doeNativeComputePipelineGetBindGroupLayout: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.ptr },
 
         // Bind group layout / bind group / pipeline layout
         wgpuDeviceCreateBindGroupLayout: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
@@ -203,7 +203,14 @@ function openLibrary(path) {
         wgpuRenderPassEncoderDraw: { args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u32, FFIType.u32], returns: FFIType.void },
         wgpuRenderPassEncoderEnd: { args: [FFIType.ptr], returns: FFIType.void },
         wgpuRenderPassEncoderRelease: { args: [FFIType.ptr], returns: FFIType.void },
-    });
+    };
+    if (process.platform === "darwin") {
+        symbols.doeNativeComputePipelineGetBindGroupLayout = {
+            args: [FFIType.ptr, FFIType.u32],
+            returns: FFIType.ptr,
+        };
+    }
+    return dlopen(path, symbols);
 }
 
 // ---------------------------------------------------------------------------
@@ -626,6 +633,36 @@ function bufferMapSync(instancePtr, bufferPtr, mode, offset, size) {
     }
 }
 
+function waitForSubmittedWorkDoneSync(instancePtr, queuePtr) {
+    let queueStatus = null;
+    let done = false;
+    const cb = new JSCallback(
+        (status, _msgData, _msgLen, _ud1, _ud2) => {
+            queueStatus = status;
+            done = true;
+        },
+        { args: [FFIType.u32, FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.void },
+    );
+    try {
+        const futureId = wgpu.symbols.doeQueueOnSubmittedWorkDoneFlat(
+            queuePtr,
+            CALLBACK_MODE_ALLOW_PROCESS_EVENTS,
+            cb.ptr,
+            null,
+            null,
+        );
+        if (futureId === 0 || futureId === 0n) {
+            throw new Error("[fawn-webgpu] queue work-done future unavailable");
+        }
+        processEventsUntilDone(instancePtr, () => done);
+        if (queueStatus !== REQUEST_DEVICE_STATUS_SUCCESS) {
+            throw new Error(`[fawn-webgpu] queue work-done failed (status=${queueStatus})`);
+        }
+    } finally {
+        cb.close();
+    }
+}
+
 // ---------------------------------------------------------------------------
 // WebGPU wrapper classes — matches index.js surface exactly
 // ---------------------------------------------------------------------------
@@ -640,6 +677,10 @@ class DoeGPUBuffer {
     }
 
     async mapAsync(mode, offset = 0, size = this.size) {
+        if (this._queue?.hasPendingSubmissions()) {
+            waitForSubmittedWorkDoneSync(this._instance, this._queue._native);
+            this._queue.markSubmittedWorkDone();
+        }
         bufferMapSync(this._instance, this._native, mode, offset, size);
         this._mapMode = mode;
     }
@@ -727,6 +768,15 @@ class DoeGPUQueue {
     constructor(native, instance) {
         this._native = native;
         this._instance = instance;
+        this._pendingSubmissions = 0;
+    }
+
+    hasPendingSubmissions() {
+        return this._pendingSubmissions > 0;
+    }
+
+    markSubmittedWorkDone() {
+        this._pendingSubmissions = 0;
     }
 
     submit(commandBuffers) {
@@ -735,6 +785,9 @@ class DoeGPUQueue {
             ptrs[i] = BigInt(commandBuffers[i]._native);
         }
         wgpu.symbols.wgpuQueueSubmit(this._native, BigInt(commandBuffers.length), ptrs);
+        if (commandBuffers.length > 0) {
+            this._pendingSubmissions += commandBuffers.length;
+        }
     }
 
     writeBuffer(buffer, bufferOffset, data, dataOffset = 0, size) {
@@ -750,8 +803,9 @@ class DoeGPUQueue {
     }
 
     async onSubmittedWorkDone() {
-        // Match the Node provider contract: Doe submit commits synchronously,
-        // and mapAsync flushes when readback synchronization is required.
+        if (!this.hasPendingSubmissions()) return;
+        waitForSubmittedWorkDoneSync(this._instance, this._native);
+        this.markSubmittedWorkDone();
     }
 }
 
@@ -798,15 +852,38 @@ class DoeGPURenderPipeline {
 }
 
 class DoeGPUShaderModule {
-    constructor(native) { this._native = native; }
+    constructor(native, code) {
+        this._native = native;
+        this._code = code;
+    }
 }
 
 class DoeGPUComputePipeline {
-    constructor(native) { this._native = native; }
+    constructor(native, device, explicitLayout, autoLayoutEntriesByGroup) {
+        this._native = native;
+        this._device = device;
+        this._explicitLayout = explicitLayout;
+        this._autoLayoutEntriesByGroup = autoLayoutEntriesByGroup;
+        this._cachedLayouts = new Map();
+    }
 
     getBindGroupLayout(index) {
-        const layout = wgpu.symbols.doeNativeComputePipelineGetBindGroupLayout(this._native, index);
-        return new DoeGPUBindGroupLayout(layout);
+        if (this._explicitLayout) return this._explicitLayout;
+        if (this._cachedLayouts.has(index)) return this._cachedLayouts.get(index);
+
+        let layout;
+        if (this._autoLayoutEntriesByGroup && process.platform === "darwin") {
+            const entries = this._autoLayoutEntriesByGroup.get(index) ?? [];
+            layout = this._device.createBindGroupLayout({ entries });
+        } else {
+            const native = process.platform === "darwin"
+                ? wgpu.symbols.doeNativeComputePipelineGetBindGroupLayout(this._native, index)
+                : wgpu.symbols.wgpuComputePipelineGetBindGroupLayout(this._native, index);
+            layout = new DoeGPUBindGroupLayout(native);
+        }
+
+        this._cachedLayouts.set(index, layout);
+        return layout;
     }
 }
 
@@ -835,7 +912,7 @@ class DoeGPUDevice {
     createBuffer(descriptor) {
         const descBytes = buildBufferDescriptor(descriptor);
         const buf = wgpu.symbols.wgpuDeviceCreateBuffer(this._native, descBytes);
-        return new DoeGPUBuffer(buf, this._instance, descriptor.size, descriptor.usage, this.queue._native);
+        return new DoeGPUBuffer(buf, this._instance, descriptor.size, descriptor.usage, this.queue);
     }
 
     createShaderModule(descriptor) {
@@ -844,18 +921,22 @@ class DoeGPUDevice {
         const { desc, _refs } = buildShaderModuleDescriptor(code);
         const mod = wgpu.symbols.wgpuDeviceCreateShaderModule(this._native, desc);
         void _refs;
-        return new DoeGPUShaderModule(mod);
+        return new DoeGPUShaderModule(mod, code);
     }
 
     createComputePipeline(descriptor) {
         const shader = descriptor.compute?.module;
         const entryPoint = descriptor.compute?.entryPoint || "main";
         const layout = descriptor.layout === "auto" ? null : descriptor.layout;
+        const autoLayoutEntriesByGroup = layout ? null : inferAutoBindGroupLayouts(
+            shader?._code || "",
+            globals.GPUShaderStage.COMPUTE,
+        );
         const { desc, _refs } = buildComputePipelineDescriptor(
             shader._native, entryPoint, layout?._native ?? null);
         const native = wgpu.symbols.wgpuDeviceCreateComputePipeline(this._native, desc);
         void _refs;
-        return new DoeGPUComputePipeline(native);
+        return new DoeGPUComputePipeline(native, this, layout, autoLayoutEntriesByGroup);
     }
 
     async createComputePipelineAsync(descriptor) {

package/src/bun.js

@@ -1,2 +1,23 @@
-export * from "./index.js";
-export { default } from "./index.js";
+import * as ffi from "./bun-ffi.js";
+import * as full from "./full.js";
+import { createDoeNamespace } from "./doe.js";
+
+const runtime = process.platform === "linux" ? ffi : full;
+
+export const doe = createDoeNamespace({
+  requestDevice: runtime.requestDevice,
+});
+
+export const create = runtime.create;
+export const globals = runtime.globals;
+export const setupGlobals = runtime.setupGlobals;
+export const requestAdapter = runtime.requestAdapter;
+export const requestDevice = runtime.requestDevice;
+export const providerInfo = runtime.providerInfo;
+export const createDoeRuntime = runtime.createDoeRuntime;
+export const runDawnVsDoeCompare = runtime.runDawnVsDoeCompare;
+
+export default {
+  ...runtime,
+  doe,
+};

package/src/compute.d.ts

@@ -0,0 +1,162 @@
+import type {
+  BoundDoeNamespace,
+  DoeKernelDispatchOptions,
+  DoeNamespace,
+  DoeRunComputeOptions,
+} from "./doe.js";
+import type {
+  DoeRuntime,
+  DoeRuntimeRunResult,
+  ProviderInfo,
+} from "./full.js";
+
+export interface ComputeGPUBuffer {
+  readonly size: number;
+  readonly usage: number;
+  mapAsync(mode: number, offset?: number, size?: number): Promise<void>;
+  getMappedRange(offset?: number, size?: number): ArrayBuffer;
+  assertMappedPrefixF32?(expected: number[], count: number): boolean;
+  unmap(): void;
+  destroy(): void;
+}
+
+export interface ComputeBindGroupLayout {}
+
+export interface ComputeBindGroup {}
+
+export interface ComputePipelineLayout {}
+
+export interface ComputeQuerySet {
+  destroy(): void;
+}
+
+export interface ComputeComputePipeline {
+  getBindGroupLayout(index: number): ComputeBindGroupLayout;
+}
+
+export interface ComputePassEncoder {
+  setPipeline(pipeline: ComputeComputePipeline): void;
+  setBindGroup(index: number, bindGroup: ComputeBindGroup): void;
+  dispatchWorkgroups(x: number, y?: number, z?: number): void;
+  dispatchWorkgroupsIndirect(indirectBuffer: ComputeGPUBuffer, indirectOffset?: number): void;
+  writeTimestamp?(querySet: ComputeQuerySet, queryIndex: number): void;
+  end(): void;
+}
+
+export interface ComputeCommandEncoder {
+  beginComputePass(descriptor?: GPUComputePassDescriptor): ComputePassEncoder;
+  copyBufferToBuffer(
+    source: ComputeGPUBuffer,
+    sourceOffset: number,
+    target: ComputeGPUBuffer,
+    targetOffset: number,
+    size: number
+  ): void;
+  resolveQuerySet?(
+    querySet: ComputeQuerySet,
+    firstQuery: number,
+    queryCount: number,
+    destination: ComputeGPUBuffer,
+    destinationOffset: number
+  ): void;
+  finish(): GPUCommandBuffer;
+}
+
+export interface ComputeQueue {
+  submit(commandBuffers: GPUCommandBuffer[]): void;
+  writeBuffer(
+    buffer: ComputeGPUBuffer,
+    bufferOffset: number,
+    data: BufferSource,
+    dataOffset?: number,
+    size?: number
+  ): void;
+  onSubmittedWorkDone(): Promise<void>;
+}
+
+export interface ComputeGPUDevice {
+  readonly queue: ComputeQueue;
+  readonly limits: GPUSupportedLimits;
+  readonly features: GPUSupportedFeatures;
+  createBuffer(descriptor: GPUBufferDescriptor): ComputeGPUBuffer;
+  createShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule;
+  createComputePipeline(descriptor: GPUComputePipelineDescriptor): ComputeComputePipeline;
+  createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise<ComputeComputePipeline>;
+  createBindGroupLayout(descriptor: GPUBindGroupLayoutDescriptor): ComputeBindGroupLayout;
+  createBindGroup(descriptor: GPUBindGroupDescriptor): ComputeBindGroup;
+  createPipelineLayout(descriptor: GPUPipelineLayoutDescriptor): ComputePipelineLayout;
+  createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): ComputeCommandEncoder;
+  createQuerySet?(descriptor: GPUQuerySetDescriptor): ComputeQuerySet;
+  destroy(): void;
+}
+
+export interface ComputeGPUAdapter {
+  readonly limits: GPUSupportedLimits;
+  readonly features: GPUSupportedFeatures;
+  requestDevice(descriptor?: GPUDeviceDescriptor): Promise<ComputeGPUDevice>;
+  destroy(): void;
+}
+
+export interface ComputeGPU {
+  requestAdapter(options?: GPURequestAdapterOptions): Promise<ComputeGPUAdapter | null>;
+}
+
+export interface RequestDeviceOptions {
+  adapterOptions?: GPURequestAdapterOptions;
+  deviceDescriptor?: GPUDeviceDescriptor;
+  createArgs?: string[] | null;
+}
+
+export interface ComputeDoeRunComputeOptions extends DoeRunComputeOptions<ComputeGPUBuffer> {}
+
+export interface ComputeDoeKernelDispatchOptions extends DoeKernelDispatchOptions<ComputeGPUBuffer> {}
+
+export interface ComputeDoeKernel {
+  readonly device: ComputeGPUDevice;
+  readonly entryPoint: string;
+  dispatch(options: ComputeDoeKernelDispatchOptions): Promise<void>;
+}
+
+export interface ComputeBoundDoeNamespace
+  extends BoundDoeNamespace<ComputeGPUDevice, ComputeGPUBuffer, ComputeDoeKernel, ComputeDoeRunComputeOptions> {}
+
+export interface ComputeDoeNamespace
+  extends DoeNamespace<
+    ComputeGPUDevice,
+    ComputeGPUBuffer,
+    ComputeDoeKernel,
+    ComputeBoundDoeNamespace,
+    ComputeDoeRunComputeOptions,
+    RequestDeviceOptions
+  > {}
+
+export const globals: Record<string, unknown>;
+export function create(createArgs?: string[] | null): ComputeGPU;
+export function setupGlobals(target?: object, createArgs?: string[] | null): ComputeGPU;
+export function requestAdapter(
+  adapterOptions?: GPURequestAdapterOptions,
+  createArgs?: string[] | null
+): Promise<ComputeGPUAdapter | null>;
+export function requestDevice(options?: RequestDeviceOptions): Promise<ComputeGPUDevice>;
+export function providerInfo(): ProviderInfo;
+export function createDoeRuntime(options?: {
+  binPath?: string;
+  libPath?: string;
+}): DoeRuntime;
+export function runDawnVsDoeCompare(options: Record<string, unknown>): DoeRuntimeRunResult;
+
+export const doe: ComputeDoeNamespace;
+
+declare const _default: {
+  create: typeof create;
+  globals: typeof globals;
+  setupGlobals: typeof setupGlobals;
+  requestAdapter: typeof requestAdapter;
+  requestDevice: typeof requestDevice;
+  providerInfo: typeof providerInfo;
+  createDoeRuntime: typeof createDoeRuntime;
+  runDawnVsDoeCompare: typeof runDawnVsDoeCompare;
+  doe: ComputeDoeNamespace;
+};
+
+export default _default;