wgblas 2.0.0 → 2.1.0

package/src/init.mjs

@@ -1,10 +1,27 @@
 import { benchmarkMode } from "./util/benchmark.mjs";
 
-let _device = null;
-let _adapter = null;
-let _gpu = null; // eslint-disable-line no-unused-vars
-let _benchmarkEnabled = false;
-
+// One WebGPU instance for the whole process, never released. A GPUAdapter
+// yields at most one working device, so a second device needs a second
+// adapter — but creating a second *instance* aborts Dawn during native
+// teardown (std::system_error), whether the instances overlap or are made one
+// after another. So the instance is built once and every adapter comes from
+// it; cleanup() releases devices, not this.
+let _gpu = null;
+let _dumpShaders = false; // instance-level Dawn toggle, fixed when _gpu is made
+
+// Resolved-options key -> GPUDevice. init() returns the cached device for a
+// given option set and creates one per distinct set, so a process can drive
+// several GPUs at once (e.g. discrete via "high-performance", integrated via
+// "low-power").
+const _devices = new Map();
+// GPUDevice -> { adapter, benchmark, options }. Benchmark support is a
+// property of the device (its requiredFeatures), not of the library.
+const _meta = new WeakMap();
+// The device from the first init(); what getDevice() returns for callers that
+// never mention one (GpuVector.from(data), GpuMatrix.from(data, ...)).
+let _primary = null;
+
+const optionsKey = ({ powerPreference, benchmark }) => `${powerPreference}::${benchmark}`;
 
 // ── Public API ───────────────────────────────────────────────────────────────
 
@@ -13,103 +30,144 @@ export async function init({
   benchmark = false,
   dumpShaders = false,
 } = {}) {
-  if (_device) {
-    return _device;
-  }
+  const options = { powerPreference, benchmark, dumpShaders };
+  const key = optionsKey(options);
+
+  // Same options: idempotent, hand back the device already built for them.
+  const cached = _devices.get(key);
+  if (cached) return cached;
 
-  let gpu;
   // Browser exposes WebGPU natively via navigator.gpu.
   // Node.js has no navigator, so we polyfill using the "webgpu" npm package which also
   // injects WebGPU globals (GPUBufferUsage, GPUShaderStage, etc.) into globalThis.
-  if (typeof window === "undefined") {
-    const { create, globals } = await import("webgpu");
-    Object.assign(globalThis, globals);
-    // dumpShaders forwards Dawn's own debug toggle — prints each pipeline's
-    // WGSL and compiled backend IR to stderr. Node-only; see index.d.mts.
-    const toggles = dumpShaders
-      ? ["enable-dawn-features=dump_shaders,disable_symbol_renaming"]
-      : [];
-    gpu = create(toggles);
-    _gpu = gpu;
-  } else {
-    if (dumpShaders)
-      console.warn("dumpShaders has no effect in the browser — see init()'s docs.");
-    gpu = navigator.gpu;
+  if (!_gpu) {
+    if (typeof window === "undefined") {
+      const { create, globals } = await import("webgpu");
+      Object.assign(globalThis, globals);
+      // dumpShaders forwards Dawn's own debug toggle — prints each pipeline's
+      // WGSL and compiled backend IR to stderr. Node-only; see index.d.mts.
+      const toggles = dumpShaders
+        ? ["enable-dawn-features=dump_shaders,disable_symbol_renaming"]
+        : [];
+      _gpu = create(toggles);
+      _dumpShaders = dumpShaders;
+    } else {
+      if (dumpShaders)
+        console.warn("dumpShaders has no effect in the browser — see init()'s docs.");
+      _gpu = navigator.gpu;
+    }
+  } else if (dumpShaders !== _dumpShaders && typeof window === "undefined") {
+    // Unlike powerPreference and benchmark, dumpShaders is a toggle on the Dawn
+    // instance rather than the device, and the instance is shared, so a later
+    // init() cannot change it.
+    console.warn(
+      `dumpShaders: ${dumpShaders} was requested, but the WebGPU instance was already created with ` +
+      `dumpShaders: ${_dumpShaders}. The first init() call fixes this for the process.`,
+    );
   }
 
-  if (!gpu) {
+  if (!_gpu) {
     throw new Error("WebGPU not supported in this environment.");
   }
 
-  _adapter =
-    (await gpu.requestAdapter({ powerPreference })) ??
-    (await gpu.requestAdapter());
-  if (!_adapter) {
+  // A fresh adapter per device: requesting a device consumes its adapter, so
+  // reusing one would hand back an already-lost device.
+  const adapter =
+    (await _gpu.requestAdapter({ powerPreference })) ??
+    (await _gpu.requestAdapter());
+  if (!adapter) {
     throw new Error("No WebGPU adapter found.");
   }
 
-  _benchmarkEnabled = benchmark;
-  const bmConfig = benchmarkMode(_adapter, benchmark);
+  const bmConfig = benchmarkMode(adapter, benchmark);
   const features = [...(bmConfig.requiredFeatures ?? [])];
-  _device = await _adapter.requestDevice({ requiredFeatures: features });
+  const device = await adapter.requestDevice({ requiredFeatures: features });
   // Fires for any GPU error not caught by a pushErrorScope/popErrorScope pair — surfaces silent GPU failures to the console.
   // See: https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/uncapturederror_event
-  _device.addEventListener("uncapturederror", (e) => {
+  device.addEventListener("uncapturederror", (e) => {
     console.error("Uncaptured GPU error:", e.error.message);
   });
 
-  return _device;
+  // benchmarkMode() drops the feature when the adapter can't do timestamp
+  // queries, so record what was actually granted rather than what was asked
+  // for — otherwise beginTimestamp() would build a query set on a device that
+  // never requested the feature.
+  const benchmarkGranted = features.includes("timestamp-query");
+  _meta.set(device, { adapter, benchmark: benchmarkGranted, options });
+  _devices.set(key, device);
+  if (!_primary) _primary = device;
+
+  return device;
 }
 
-export function cleanup() {
-  if (_device) {
-    _device.destroy();
-    _device = null;
+export function cleanup(device) {
+  if (device === undefined) {
+    for (const d of _devices.values()) d.destroy();
+    _devices.clear();
+    _primary = null;
+    return;
   }
-  _adapter = null;
-  _gpu = null;
-  _benchmarkEnabled = false;
+
+  // Releasing one device of several. Unknown or already-released devices are a
+  // no-op so teardown paths can call this unguarded.
+  const meta = _meta.get(device);
+  if (!meta) return;
+  _devices.delete(optionsKey(meta.options));
+  _meta.delete(device);
+  device.destroy();
+
+  // getDevice() must keep answering while any device is left, so promote a
+  // survivor when the primary is the one being released.
+  if (_primary === device) _primary = _devices.values().next().value ?? null;
 }
 
-export function gpuName() {
-  if (!_adapter) {
+export function gpuName(device = _primary) {
+  const meta = device && _meta.get(device);
+  if (!meta) {
     throw new Error("WebGPU adapter not initialized — call init() first.");
   }
-  const { device, description } = _adapter.info;
+  const { device: deviceName, description } = meta.adapter.info;
   return {
     description: description || "unknown",
-    device: device || "unknown",
+    device: deviceName || "unknown",
   };
 }
 
 // ── Library internals (not part of the public API) ───────────────────────────
 
-/** @returns {boolean} whether benchmark mode was enabled in the last `init()` call */
-export function isBenchmarkEnabled() {
-  return _benchmarkEnabled;
+/**
+ * Whether benchmark mode is active for `device` — i.e. it was created with
+ * `benchmark: true` *and* its adapter actually supports timestamp queries.
+ * @param {GPUDevice} [device] - defaults to the first-initialized device
+ * @returns {boolean}
+ */
+export function isBenchmarkEnabled(device = _primary) {
+  return _meta.get(device)?.benchmark ?? false;
 }
 
 /**
- * Returns the active `GPUDevice`. Throws if `init()` has not been called.
+ * Returns the device from the first `init()` call — the default for callers
+ * that don't name one. Throws if `init()` has not been called.
  * @returns {GPUDevice}
- * @throws {Error} if the device is not initialized
+ * @throws {Error} if no device is initialized
  */
 export function getDevice() {
-  if (!_device) {
+  if (!_primary) {
     throw new Error("WebGPU device not initialized — call init() first.");
   }
-  return _device;
+  return _primary;
 }
 
 /**
- * Returns the active `GPUAdapter`. Throws if `init()` has not been called.
+ * Returns the `GPUAdapter` backing `device`. Throws if it isn't initialized.
+ * @param {GPUDevice} [device] - defaults to the first-initialized device
  * @returns {GPUAdapter}
  * @throws {Error} if the adapter is not initialized
  */
-export function getAdapter() {
-  if (!_adapter) {
+export function getAdapter(device = _primary) {
+  const meta = device && _meta.get(device);
+  if (!meta) {
     throw new Error("WebGPU adapter not initialized — call init() first.");
   }
-  return _adapter;
+  return meta.adapter;
 }
-

package/src/isamax/isamax.d.mts

@@ -1,9 +1,18 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Returns the 0-based index of the element with the largest absolute value.
+ * Returns the 0-based index of the element with the largest absolute value:
+ * $$\text{index} = \arg\max_{i} |x_i|$$
  * Ties are broken in favour of the lower index, matching CBLAS behaviour.
  *
+ * **NaN handling.** The search compares with `>`, which is false for NaN, so
+ * NaN elements are skipped rather than selected: a vector of all NaN returns
+ * `0`. This matches CBLAS except when `x[0]` itself is NaN — CBLAS seeds its
+ * running maximum from `x[0]`, and since no comparison against NaN succeeds it
+ * returns `0` however large the later elements are, whereas this returns the
+ * index of the largest non-NaN element. `+-Infinity` compares normally and is
+ * selected as the maximum.
+ *
  * {@includeCode ../../examples/isamax/isamax.js}
  *
  * **Browser (standalone HTML):**
@@ -25,9 +34,18 @@ export declare function isamax(
 ): Promise<{ index: number } | { index: number; gpuTimeMs: number }>;
 
 /**
- * Returns the 0-based index of the element with the largest absolute value.
+ * Returns the 0-based index of the element with the largest absolute value:
+ * $$\text{index} = \arg\max_{i} |x_i|$$
  * Ties are broken in favour of the lower index, matching CBLAS behaviour.
  *
+ * **NaN handling.** The search compares with `>`, which is false for NaN, so
+ * NaN elements are skipped rather than selected: a vector of all NaN returns
+ * `0`. This matches CBLAS except when `x[0]` itself is NaN — CBLAS seeds its
+ * running maximum from `x[0]`, and since no comparison against NaN succeeds it
+ * returns `0` however large the later elements are, whereas this returns the
+ * index of the largest non-NaN element. `+-Infinity` compares normally and is
+ * selected as the maximum.
+ *
  * {@includeCode ../../examples/isamax/gpu.isamax.js}
  *
  * @param device - GPUDevice from `init()`

package/src/isamax/isamax.mjs

@@ -12,14 +12,16 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
-const WGS = 64;
 
 export async function isamax(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "isamax", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
   if (incx <= 0) throw new Error("incx must be positive.");
@@ -42,17 +44,17 @@ export async function isamax(device, n, x, incx) {
   let readBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "isamax-x", false);
-    partialsValBuffer = createStorageBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "isamax-x", false);
+    partialsValBuffer = createStorageBuffer(device,
       2 * WGS * 4,
       "isamax-partials-val",
     ); //to hold 2*WGS partial max values of f32
-    partialsIdxBuffer = createStorageBuffer(
+    partialsIdxBuffer = createStorageBuffer(device,
       2 * WGS * 4,
       "isamax-partials-idx",
     ); //to hold 2*WGS partial max indices of u32
-    resultBuffer = createResultBuffer(4, "isamax-result"); // u32 index
-    paramsBuffer = createParamsBuffer(
+    resultBuffer = createResultBuffer(device, 4, "isamax-result"); // u32 index
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -60,33 +62,33 @@ export async function isamax(device, n, x, incx) {
       "isamax-params",
     );
 
-    const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
       xBuffer,
       partialsValBuffer,
       partialsIdxBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
       pipelineMain,
       bgMain,
       2 * WGS,
     ); //dispatch 2*WGS workgroups
 
-    submit(enc1);
+    submit(device, enc1);
 
-    const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
+    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
       partialsValBuffer,
       partialsIdxBuffer,
       resultBuffer,
     ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
       pipelineReduce,
       bgReduce,
       1,
     ); // dispatch 1 workgroup to reduce the partial sums to a single result
-    readBuffer = stageReadback(enc2, resultBuffer);
+    readBuffer = stageReadback(device, enc2, resultBuffer);
 
-    submit(enc2);
+    submit(device, enc2);
 
     const resultPromise = extractResult(readBuffer, Uint32Array);
     readBuffer = null; // ownership transferred — extractResult's own finally destroys it
@@ -108,7 +110,7 @@ export async function isamax(device, n, x, incx) {
     if (partialsIdxBuffer) destroyBuffers(partialsIdxBuffer);
     if (resultBuffer) destroyBuffers(resultBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);
-    // Only reached if submit(enc2) threw before ownership was transferred above.
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
     if (readBuffer) destroyBuffers(readBuffer);
   }
 }

package/src/random/random.d.mts

@@ -83,6 +83,7 @@ export declare function randomFloat64Array(
  *
  * const n = 4, lda = n;
  * const A = randomTriangularFloat32Array(n, lda, "lower");
+ * console.log(A);
  * ```
  * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/random/random.mjs#L13">Source code: random.mjs (L13)</a>
  * @category Utilities

package/src/sasum/sasum.d.mts

@@ -1,7 +1,7 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Computes the sum of absolute values of a vector: result = sum(|x[i]|)
+ * Computes the sum of absolute values of a vector: $$\text{result} = \sum_{i} |x_i|$$
  *
  * {@includeCode ../../examples/sasum/sasum.js}
  *
@@ -24,7 +24,7 @@ export declare function sasum(
 ): Promise<{ asum: number } | { asum: number; gpuTimeMs: number }>;
 
 /**
- * Computes the sum of absolute values of a vector: result = sum(|x[i]|)
+ * Computes the sum of absolute values of a vector: $$\text{result} = \sum_{i} |x_i|$$
  *
  * {@includeCode ../../examples/sasum/gpu.sasum.js}
  *

package/src/sasum/sasum.mjs

@@ -12,14 +12,16 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
-const WGS = 64; // workgroup size
 
 export async function sasum(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "sasum", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
   if (incx <= 0) throw new Error("incx must be positive.");
@@ -41,10 +43,10 @@ export async function sasum(device, n, x, incx) {
   let readBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sasum-x", false);
-    partialsBuffer = createStorageBuffer(2 * WGS * 4, "sasum-partials"); // 2*WGS partial sums of f32
-    resultBuffer = createResultBuffer(4, "sasum-result"); // final f32 scalar
-    paramsBuffer = createParamsBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sasum-x", false);
+    partialsBuffer = createStorageBuffer(device, 2 * WGS * 4, "sasum-partials"); // 2*WGS partial sums of f32
+    resultBuffer = createResultBuffer(device, 4, "sasum-result"); // final f32 scalar
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -52,31 +54,31 @@ export async function sasum(device, n, x, incx) {
       "sasum-params",
     );
 
-    const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
       xBuffer,
       partialsBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
       pipelineMain,
       bgMain,
       2 * WGS,
     ); // dispatch 2*WGS workgroups
 
-    submit(enc1);
+    submit(device, enc1);
 
-    const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
+    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
       partialsBuffer,
       resultBuffer,
     ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
       pipelineReduce,
       bgReduce,
       1,
     ); // dispatch 1 workgroup to reduce the partial sums to a single result
-    readBuffer = stageReadback(enc2, resultBuffer);
+    readBuffer = stageReadback(device, enc2, resultBuffer);
 
-    submit(enc2);
+    submit(device, enc2);
 
     const resultPromise = extractResult(readBuffer, Float32Array);
     readBuffer = null; // ownership transferred — extractResult's own finally destroys it
@@ -96,7 +98,7 @@ export async function sasum(device, n, x, incx) {
     if (partialsBuffer) destroyBuffers(partialsBuffer);
     if (resultBuffer) destroyBuffers(resultBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);
-    // Only reached if submit(enc2) threw before ownership was transferred above.
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
     if (readBuffer) destroyBuffers(readBuffer);
   }
 }

package/src/saxpy/saxpy.d.mts

@@ -1,7 +1,7 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Performs the operation y = alpha * x + y
+ * Performs the operation $$y \leftarrow \alpha x + y$$
  *
  * {@includeCode ../../examples/saxpy/saxpy.js}
  *
@@ -29,7 +29,7 @@ export declare function saxpy(
 ): Promise<{ y: Float32Array } | { y: Float32Array; gpuTimeMs: number }>;
 
 /**
- * Performs the operation y = alpha * x + y
+ * Performs the operation $$y \leftarrow \alpha x + y$$
  *
  * {@includeCode ../../examples/saxpy/gpu.saxpy.js}
  *

package/src/saxpy/saxpy.mjs

@@ -11,6 +11,7 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { calcWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
 export async function saxpy(device, n, alpha, x, incx, y, incy) {
   const xIsGpu = x instanceof GpuVector;
@@ -18,6 +19,7 @@ export async function saxpy(device, n, alpha, x, incx, y, incy) {
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "saxpy", { x, y });
   if (
     !Number.isInteger(n) ||
     !Number.isInteger(incx) ||
@@ -56,9 +58,9 @@ export async function saxpy(device, n, alpha, x, incx, y, incy) {
   let readBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "saxpy-x", false);
-    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "saxpy-y", true);
-    paramsBuffer = createParamsBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "saxpy-x", false);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "saxpy-y", true);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: alpha, type: "f32" },
@@ -68,19 +70,19 @@ export async function saxpy(device, n, alpha, x, incx, y, incy) {
       "saxpy-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       xBuffer,
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(
+    const { commandEncoder, ts } = runComputePass(device,
       pipeline,
       bindGroup,
-      calcWorkgroups(n),
+      calcWorkgroups(device, n),
     );
-    readBuffer = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+    readBuffer = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
 
-    submit(commandEncoder);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 

package/src/scopy/scopy.d.mts

@@ -1,7 +1,7 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Performs the operation y = x
+ * Performs the operation $$y \leftarrow x$$
  *
  * {@includeCode ../../examples/scopy/scopy.js}
  *
@@ -27,7 +27,7 @@ export declare function scopy(
 ): Promise<{ y: Float32Array } | { y: Float32Array; gpuTimeMs: number }>;
 
 /**
- * Performs the operation y = x
+ * Performs the operation $$y \leftarrow x$$
  *
  * {@includeCode ../../examples/scopy/gpu.scopy.js}
  *

package/src/scopy/scopy.mjs

@@ -11,6 +11,7 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { calcWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
 export async function scopy(device, n, x, incx, y, incy) {
   const xIsGpu = x instanceof GpuVector;
@@ -18,6 +19,7 @@ export async function scopy(device, n, x, incx, y, incy) {
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "scopy", { x, y });
   if (
     !Number.isInteger(n) ||
     !Number.isInteger(incx) ||
@@ -52,9 +54,9 @@ export async function scopy(device, n, x, incx, y, incy) {
   let readBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "scopy-x", false);
-    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "scopy-y", true);
-    paramsBuffer = createParamsBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "scopy-x", false);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "scopy-y", true);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -63,19 +65,19 @@ export async function scopy(device, n, x, incx, y, incy) {
       "scopy-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       xBuffer,
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(
+    const { commandEncoder, ts } = runComputePass(device,
       pipeline,
       bindGroup,
-      calcWorkgroups(n),
+      calcWorkgroups(device, n),
     );
-    readBuffer = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+    readBuffer = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
 
-    submit(commandEncoder);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 

package/src/sdot/sdot.d.mts

@@ -1,7 +1,7 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Computes the dot product of two vectors: result = sum(x[i] * y[i])
+ * Computes the dot product of two vectors: $$\text{result} = \sum_{i} x_i y_i$$
  *
  * {@includeCode ../../examples/sdot/sdot.js}
  *
@@ -28,7 +28,7 @@ export declare function sdot(
 ): Promise<{ dot: number } | { dot: number; gpuTimeMs: number }>;
 
 /**
- * Computes the dot product of two vectors: result = sum(x[i] * y[i])
+ * Computes the dot product of two vectors: $$\text{result} = \sum_{i} x_i y_i$$
  *
  * {@includeCode ../../examples/sdot/gpu.sdot.js}
  *