@simulatte/webgpu 0.2.1 → 0.2.4

package/src/compute.d.ts

@@ -0,0 +1,161 @@
+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
+  > {}
+
+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;

package/src/compute.js

@@ -0,0 +1,277 @@
+import * as full from './index.js';
+import { doe } from './doe.js';
+
+function unwrap(value) {
+  return value && typeof value === 'object' && '_raw' in value ? value._raw : value;
+}
+
+function wrap_buffer(raw) {
+  return {
+    _raw: raw,
+    size: raw.size,
+    usage: raw.usage,
+    async mapAsync(mode, offset, size) {
+      return raw.mapAsync(mode, offset, size);
+    },
+    getMappedRange(offset, size) {
+      return raw.getMappedRange(offset, size);
+    },
+    assertMappedPrefixF32(expected, count) {
+      return raw.assertMappedPrefixF32(expected, count);
+    },
+    unmap() {
+      return raw.unmap();
+    },
+    destroy() {
+      return raw.destroy();
+    },
+  };
+}
+
+function wrap_bind_group_layout(raw) {
+  return { _raw: raw };
+}
+
+function wrap_bind_group(raw) {
+  return { _raw: raw };
+}
+
+function wrap_pipeline_layout(raw) {
+  return { _raw: raw };
+}
+
+function wrap_compute_pipeline(raw) {
+  return {
+    _raw: raw,
+    getBindGroupLayout(index) {
+      return wrap_bind_group_layout(raw.getBindGroupLayout(index));
+    },
+  };
+}
+
+function wrap_compute_pass(raw) {
+  return {
+    _raw: raw,
+    setPipeline(pipeline) {
+      return raw.setPipeline(unwrap(pipeline));
+    },
+    setBindGroup(index, bind_group) {
+      return raw.setBindGroup(index, unwrap(bind_group));
+    },
+    dispatchWorkgroups(x, y = 1, z = 1) {
+      return raw.dispatchWorkgroups(x, y, z);
+    },
+    dispatchWorkgroupsIndirect(indirect_buffer, indirect_offset = 0) {
+      return raw.dispatchWorkgroupsIndirect(unwrap(indirect_buffer), indirect_offset);
+    },
+    writeTimestamp(query_set, query_index) {
+      if (typeof raw.writeTimestamp !== 'function') {
+        throw new Error('timestamp query writes are unsupported on the compute surface');
+      }
+      return raw.writeTimestamp(unwrap(query_set), query_index);
+    },
+    end() {
+      return raw.end();
+    },
+  };
+}
+
+function wrap_command_encoder(raw) {
+  return {
+    _raw: raw,
+    beginComputePass(descriptor) {
+      return wrap_compute_pass(raw.beginComputePass(descriptor));
+    },
+    copyBufferToBuffer(source, source_offset, target, target_offset, size) {
+      return raw.copyBufferToBuffer(
+        unwrap(source),
+        source_offset,
+        unwrap(target),
+        target_offset,
+        size,
+      );
+    },
+    resolveQuerySet(query_set, first_query, query_count, destination, destination_offset) {
+      if (typeof raw.resolveQuerySet !== 'function') {
+        throw new Error('query resolution is unsupported on the compute surface');
+      }
+      return raw.resolveQuerySet(
+        unwrap(query_set),
+        first_query,
+        query_count,
+        unwrap(destination),
+        destination_offset,
+      );
+    },
+    finish() {
+      return raw.finish();
+    },
+  };
+}
+
+function wrap_queue(raw) {
+  return {
+    _raw: raw,
+    submit(command_buffers) {
+      return raw.submit(command_buffers.map(unwrap));
+    },
+    writeBuffer(buffer, buffer_offset, data, data_offset, size) {
+      return raw.writeBuffer(unwrap(buffer), buffer_offset, data, data_offset, size);
+    },
+    async onSubmittedWorkDone() {
+      if (typeof raw.onSubmittedWorkDone === 'function') {
+        return raw.onSubmittedWorkDone();
+      }
+    },
+  };
+}
+
+function wrap_query_set(raw) {
+  return {
+    _raw: raw,
+    destroy() {
+      return raw.destroy();
+    },
+  };
+}
+
+function wrap_device(raw) {
+  return {
+    _raw: raw,
+    queue: wrap_queue(raw.queue),
+    limits: raw.limits,
+    features: raw.features,
+    createBuffer(descriptor) {
+      return wrap_buffer(raw.createBuffer(descriptor));
+    },
+    createShaderModule(descriptor) {
+      return raw.createShaderModule(descriptor);
+    },
+    createComputePipeline(descriptor) {
+      return wrap_compute_pipeline(raw.createComputePipeline(descriptor));
+    },
+    async createComputePipelineAsync(descriptor) {
+      return wrap_compute_pipeline(await raw.createComputePipelineAsync(descriptor));
+    },
+    createBindGroupLayout(descriptor) {
+      return wrap_bind_group_layout(raw.createBindGroupLayout(descriptor));
+    },
+    createBindGroup(descriptor) {
+      const entries = (descriptor.entries ?? []).map((entry) => ({
+        ...entry,
+        resource: entry.resource && typeof entry.resource === 'object' && 'buffer' in entry.resource
+          ? { ...entry.resource, buffer: unwrap(entry.resource.buffer) }
+          : entry.resource,
+      }));
+      return wrap_bind_group(raw.createBindGroup({
+        ...descriptor,
+        layout: unwrap(descriptor.layout),
+        entries,
+      }));
+    },
+    createPipelineLayout(descriptor) {
+      return wrap_pipeline_layout(raw.createPipelineLayout({
+        ...descriptor,
+        bindGroupLayouts: (descriptor.bindGroupLayouts ?? []).map(unwrap),
+      }));
+    },
+    createCommandEncoder(descriptor) {
+      return wrap_command_encoder(raw.createCommandEncoder(descriptor));
+    },
+    createQuerySet(descriptor) {
+      if (typeof raw.createQuerySet !== 'function') {
+        throw new Error('query sets are unsupported on the compute surface');
+      }
+      return wrap_query_set(raw.createQuerySet(descriptor));
+    },
+    destroy() {
+      return raw.destroy();
+    },
+  };
+}
+
+function wrap_adapter(raw) {
+  return {
+    _raw: raw,
+    features: raw.features,
+    limits: raw.limits,
+    async requestDevice(descriptor) {
+      return wrap_device(await raw.requestDevice(descriptor));
+    },
+    destroy() {
+      return raw.destroy();
+    },
+  };
+}
+
+function wrap_gpu(raw) {
+  return {
+    _raw: raw,
+    async requestAdapter(options) {
+      return wrap_adapter(await raw.requestAdapter(options));
+    },
+  };
+}
+
+export const globals = full.globals;
+
+export function create(create_args = null) {
+  return wrap_gpu(full.create(create_args));
+}
+
+export function setupGlobals(target = globalThis, create_args = null) {
+  for (const [name, value] of Object.entries(globals)) {
+    if (target[name] === undefined) {
+      Object.defineProperty(target, name, {
+        value,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      });
+    }
+  }
+  const gpu = create(create_args);
+  if (typeof target.navigator === 'undefined') {
+    Object.defineProperty(target, 'navigator', {
+      value: { gpu },
+      writable: true,
+      configurable: true,
+      enumerable: false,
+    });
+  } else if (!target.navigator.gpu) {
+    Object.defineProperty(target.navigator, 'gpu', {
+      value: gpu,
+      writable: true,
+      configurable: true,
+      enumerable: false,
+    });
+  }
+  return gpu;
+}
+
+export async function requestAdapter(adapter_options = undefined, create_args = null) {
+  return create(create_args).requestAdapter(adapter_options);
+}
+
+export async function requestDevice(options = {}) {
+  const adapter = await requestAdapter(options?.adapterOptions, options?.createArgs ?? null);
+  return adapter.requestDevice(options?.deviceDescriptor);
+}
+
+export const providerInfo = full.providerInfo;
+export const createDoeRuntime = full.createDoeRuntime;
+export const runDawnVsDoeCompare = full.runDawnVsDoeCompare;
+
+export default {
+  create,
+  globals,
+  setupGlobals,
+  requestAdapter,
+  requestDevice,
+  providerInfo,
+  createDoeRuntime,
+  runDawnVsDoeCompare,
+  doe,
+};
+
+export { doe };

package/src/doe.d.ts

@@ -0,0 +1,84 @@
+export type DoeBufferUsage =
+  | "upload"
+  | "readback"
+  | "uniform"
+  | "storage-read"
+  | "storage-readwrite";
+
+export type DoeWorkgroups = number | [number, number, number];
+
+export type DoeBindingAccess =
+  | "uniform"
+  | "storage-read"
+  | "storage-readwrite";
+
+export interface DoeCreateBufferOptions {
+  size: number;
+  usage: DoeBufferUsage | DoeBufferUsage[] | number;
+  label?: string;
+  mappedAtCreation?: boolean;
+}
+
+export interface DoeCreateBufferFromDataOptions {
+  usage?: DoeBufferUsage | DoeBufferUsage[] | number;
+  label?: string;
+}
+
+export interface DoeReadBufferOptions {
+  size?: number;
+  offset?: number;
+  label?: string;
+}
+
+export interface DoeBindingBuffer<TBuffer> {
+  buffer: TBuffer;
+  access?: DoeBindingAccess;
+}
+
+export interface DoeRunComputeOptions<TBuffer> {
+  code: string;
+  entryPoint?: string;
+  bindings?: Array<TBuffer | DoeBindingBuffer<TBuffer>>;
+  workgroups: DoeWorkgroups;
+  label?: string;
+}
+
+export interface DoeKernelDispatchOptions<TBuffer> {
+  bindings?: Array<TBuffer | DoeBindingBuffer<TBuffer>>;
+  workgroups: DoeWorkgroups;
+  label?: string;
+}
+
+export interface BoundDoeNamespace<TDevice, TBuffer, TKernel, TRunComputeOptions> {
+  readonly device: TDevice;
+  createBuffer(options: DoeCreateBufferOptions): TBuffer;
+  createBufferFromData<T extends ArrayBufferView>(
+    data: T | ArrayBuffer,
+    options?: DoeCreateBufferFromDataOptions
+  ): TBuffer;
+  readBuffer<T extends ArrayBufferView>(
+    buffer: TBuffer,
+    type: { new(buffer: ArrayBuffer): T },
+    options?: DoeReadBufferOptions
+  ): Promise<T>;
+  runCompute(options: TRunComputeOptions): Promise<void>;
+  compileCompute(options: TRunComputeOptions): TKernel;
+}
+
+export interface DoeNamespace<TDevice, TBuffer, TKernel, TBoundDoe, TRunComputeOptions> {
+  bind(device: TDevice): TBoundDoe;
+  createBuffer(device: TDevice, options: DoeCreateBufferOptions): TBuffer;
+  createBufferFromData<T extends ArrayBufferView>(
+    device: TDevice,
+    data: T | ArrayBuffer,
+    options?: DoeCreateBufferFromDataOptions
+  ): TBuffer;
+  readBuffer<T extends ArrayBufferView>(
+    device: TDevice,
+    buffer: TBuffer,
+    type: { new(buffer: ArrayBuffer): T },
+    options?: DoeReadBufferOptions
+  ): Promise<T>;
+  runCompute(device: TDevice, options: TRunComputeOptions): Promise<void>;
+  compileCompute(device: TDevice, options: TRunComputeOptions): TKernel;
+}