oidn-web 0.3.4 → 0.4.0

package/benchmarks/leak.mjs

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import { createServer } from 'node:http';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { chromium } from 'playwright-core';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function options(argv) {
+  const result = { cycles: 6, engine: 'wgsl' };
+  for (let index = 0; index < argv.length; index += 2) {
+    const name = argv[index];
+    const value = argv[index + 1];
+    if (name === '--cycles') result.cycles = Number(value);
+    else if (name === '--engine') result.engine = value;
+    else if (name === '--chrome') result.chrome = value;
+    else throw new Error(`Unknown option ${name}`);
+  }
+  if (!Number.isInteger(result.cycles) || result.cycles < 2) {
+    throw new Error('--cycles must be an integer of at least 2');
+  }
+  if (!['wgsl', 'webnn'].includes(result.engine)) {
+    throw new Error('--engine must be wgsl or webnn');
+  }
+  return result;
+}
+
+function defaultChrome() {
+  return [
+    process.env.CHROME_PATH,
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/usr/bin/google-chrome',
+    '/usr/bin/chromium'
+  ].find((candidate) => candidate && existsSync(candidate));
+}
+
+async function server() {
+  const files = new Map([
+    ['/oidn.js', path.join(root, 'dist/oidn.js')],
+    ['/model.tza', path.join(root, 'weights/rt_hdr.tza')]
+  ]);
+  const instance = createServer(async (request, response) => {
+    const pathname = new URL(request.url, 'http://127.0.0.1').pathname;
+    if (pathname === '/') {
+      response.writeHead(200, { 'content-type': 'text/html' });
+      response.end(
+        '<!doctype html><meta charset="utf-8"><title>OIDN resource stress</title>'
+      );
+      return;
+    }
+    if (pathname === '/favicon.ico') {
+      response.writeHead(204).end();
+      return;
+    }
+    const file = files.get(pathname);
+    if (!file) {
+      response.writeHead(404).end();
+      return;
+    }
+    response.writeHead(200, {
+      'content-type': pathname.endsWith('.js')
+        ? 'text/javascript'
+        : 'application/octet-stream',
+      'cache-control': 'no-store'
+    });
+    response.end(await readFile(file));
+  });
+  await new Promise((resolve, reject) => {
+    instance.once('error', reject);
+    instance.listen(0, '127.0.0.1', resolve);
+  });
+  return {
+    origin: `http://127.0.0.1:${instance.address().port}`,
+    close: () =>
+      new Promise((resolve, reject) =>
+        instance.close((error) => (error ? reject(error) : resolve()))
+      )
+  };
+}
+
+async function main() {
+  const config = options(process.argv.slice(2));
+  const chrome = config.chrome || defaultChrome();
+  if (!chrome) throw new Error('Chrome not found; pass --chrome <path>');
+
+  const { spawn } = await import('node:child_process');
+  await new Promise((resolve, reject) => {
+    const child = spawn('npm', ['run', 'build'], {
+      cwd: root,
+      stdio: 'inherit'
+    });
+    child.once('error', reject);
+    child.once('exit', (code) =>
+      code === 0
+        ? resolve()
+        : reject(new Error(`OIDN build exited with ${code}`))
+    );
+  });
+
+  const host = await server();
+  let browser;
+  try {
+    browser = await chromium.launch({
+      executablePath: chrome,
+      headless: true,
+      args: [
+        '--enable-unsafe-webgpu',
+        '--enable-precise-memory-info',
+        '--js-flags=--expose-gc',
+        '--enable-features=Vulkan,UseSkiaRenderer,WebMachineLearningNeuralNetwork'
+      ]
+    });
+    const page = await browser.newPage();
+    const browserErrors = [];
+    page.on('pageerror', (error) => browserErrors.push(error.message));
+    page.on('console', (message) => {
+      if (message.type() === 'error') browserErrors.push(message.text());
+    });
+    await page.goto(host.origin);
+    const result = await page.evaluate(
+      async ({ cycles, engine, origin }) => {
+        if (!navigator.gpu) throw new Error('WebGPU is unavailable');
+        if (engine === 'webnn' && !navigator.ml) {
+          throw new Error('WebNN is unavailable in this Chrome configuration');
+        }
+        const module = await import(`${origin}/oidn.js`);
+        const model = await fetch(`${origin}/model.tza`).then((response) =>
+          response.arrayBuffer()
+        );
+        const adapter = await navigator.gpu.requestAdapter({
+          powerPreference: 'high-performance'
+        });
+        if (!adapter) throw new Error('No WebGPU adapter');
+        const requiredFeatures = adapter.features.has('shader-f16')
+          ? ['shader-f16']
+          : [];
+        const device = await adapter.requestDevice({ requiredFeatures });
+        const adapterInfo = adapter.info ?? {};
+        const shapes = [
+          { width: 32, height: 32 },
+          { width: 48, height: 48 },
+          { width: 80, height: 64 }
+        ];
+        const heap = [];
+        const resources = [];
+
+        for (let cycle = 0; cycle < cycles; cycle++) {
+          device.pushErrorScope('validation');
+          const unet = await module.initUNetFromBuffer(
+            model.slice(0),
+            { device, adapterInfo },
+            {
+              aux: false,
+              hdr: true,
+              engine,
+              precision: requiredFeatures.length ? 'fp16' : 'fp32',
+              maxTileSize: 128,
+              dynamicTile: false
+            }
+          );
+          for (const shape of shapes) {
+            const values = new Float32Array(shape.width * shape.height * 4);
+            values.fill(0.25 + cycle * 0.001);
+            const input = device.createBuffer({
+              size: values.byteLength,
+              usage:
+                GPUBufferUsage.STORAGE |
+                GPUBufferUsage.COPY_SRC |
+                GPUBufferUsage.COPY_DST,
+              mappedAtCreation: true
+            });
+            new Float32Array(input.getMappedRange()).set(values);
+            input.unmap();
+            await new Promise((resolve, reject) => {
+              try {
+                unet.tileExecute({
+                  color: { data: input, ...shape },
+                  done: resolve
+                });
+              } catch (error) {
+                reject(error);
+              }
+            });
+            await device.queue.onSubmittedWorkDone();
+            input.destroy();
+          }
+          const beforeDispose = unet.getRuntimeInfo().resources;
+          unet.dispose();
+          await device.queue.onSubmittedWorkDone();
+          const afterDispose = unet.getRuntimeInfo().resources;
+          const validationError = await device.popErrorScope();
+          if (validationError) throw new Error(validationError.message);
+          if (
+            afterDispose.live !== 0 ||
+            afterDispose.pending !== 0 ||
+            afterDispose.created !== afterDispose.destroyed
+          ) {
+            throw new Error(
+              `cycle ${cycle}: resources did not return to zero: ` +
+                JSON.stringify(afterDispose)
+            );
+          }
+          resources.push({ beforeDispose, afterDispose });
+          globalThis.gc?.();
+          heap.push(performance.memory?.usedJSHeapSize ?? null);
+        }
+        device.destroy();
+        return { heap, resources, adapter: adapterInfo };
+      },
+      { ...config, origin: host.origin }
+    );
+
+    if (browserErrors.length) {
+      throw new Error(`Browser errors:\n${browserErrors.join('\n')}`);
+    }
+    const measuredHeap = result.heap.filter(Number.isFinite).slice(2);
+    const retainedHeapBytes =
+      measuredHeap.length > 1
+        ? measuredHeap.at(-1) - Math.min(...measuredHeap)
+        : null;
+    if (retainedHeapBytes !== null && retainedHeapBytes > 32 * 1024 * 1024) {
+      throw new Error(
+        `JS heap retained ${(retainedHeapBytes / 1024 / 1024).toFixed(1)} MiB`
+      );
+    }
+    console.log(
+      JSON.stringify(
+        {
+          status: 'passed',
+          engine: config.engine,
+          cycles: config.cycles,
+          retainedHeapBytes,
+          peakOwnedResources: Math.max(
+            ...result.resources.map((entry) => entry.beforeDispose.peakLive)
+          ),
+          adapter: result.adapter
+        },
+        null,
+        2
+      )
+    );
+  } finally {
+    await browser?.close();
+    await host.close();
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack : error);
+  process.exitCode = 1;
+});

package/benchmarks/results/before-spatial.json

@@ -0,0 +1,391 @@
+{
+  "generatedAt": "2026-08-20T04:41:13.388Z",
+  "currentCommit": "e6b8577b1c69cc8ce979022717984aec5b9ea881",
+  "baselineCommit": "136c00c34aa5cf4561b4137034dbd643177f0a5f",
+  "settings": {
+    "width": 512,
+    "height": 512,
+    "tileSize": 512,
+    "warmup": 2,
+    "runs": 5,
+    "model": "rt_hdr_calb_cnrm_large.tza",
+    "gpuQueueCompletionIncluded": true
+  },
+  "browser": "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "adapter": {
+    "vendor": "apple",
+    "architecture": "metal-3",
+    "device": "",
+    "description": ""
+  },
+  "results": [
+    {
+      "label": "TFJS (136c00c)",
+      "bundle": "baseline",
+      "baseline": true,
+      "initializationMs": 8.5,
+      "timesMs": [
+        37.29999999701977,
+        37.100000001490116,
+        37.5,
+        36.899999998509884,
+        37.399999998509884
+      ],
+      "supportsFP16": true,
+      "adapter": {
+        "vendor": "apple",
+        "architecture": "metal-3",
+        "device": "",
+        "description": ""
+      },
+      "summary": {
+        "minMs": 36.899999998509884,
+        "medianMs": 37.29999999701977,
+        "meanMs": 37.23999999910593,
+        "p95Ms": 37.5,
+        "maxMs": 37.5
+      },
+      "messages": []
+    },
+    {
+      "label": "WGSL FP32",
+      "bundle": "current",
+      "baseline": false,
+      "precision": "fp32",
+      "initializationMs": 39.399999998509884,
+      "timesMs": [
+        38.19999999552965,
+        38.100000001490116,
+        37.79999999701977,
+        38.20000000298023,
+        38.100000001490116
+      ],
+      "executionProfile": {
+        "totalMs": 36.714113,
+        "layers": [
+          {
+            "id": "input-pack",
+            "durationMs": 0.051164
+          },
+          {
+            "id": "enc_conv1a",
+            "durationMs": 0.840212
+          },
+          {
+            "id": "enc_conv1b",
+            "durationMs": 3.694748
+          },
+          {
+            "id": "pool1",
+            "durationMs": 0.413064
+          },
+          {
+            "id": "enc_conv2a",
+            "durationMs": 1.403019
+          },
+          {
+            "id": "enc_conv2b",
+            "durationMs": 2.701085
+          },
+          {
+            "id": "pool2",
+            "durationMs": 0.072955
+          },
+          {
+            "id": "enc_conv3a",
+            "durationMs": 0.770299
+          },
+          {
+            "id": "enc_conv3b",
+            "durationMs": 0.98883
+          },
+          {
+            "id": "pool3",
+            "durationMs": 0.017833
+          },
+          {
+            "id": "enc_conv4a",
+            "durationMs": 0.399939
+          },
+          {
+            "id": "enc_conv4b",
+            "durationMs": 0.609888
+          },
+          {
+            "id": "pool4",
+            "durationMs": 0.008625
+          },
+          {
+            "id": "enc_conv5a",
+            "durationMs": 0.25828
+          },
+          {
+            "id": "enc_conv5b",
+            "durationMs": 0.336652
+          },
+          {
+            "id": "dec_conv4a",
+            "durationMs": 1.243235
+          },
+          {
+            "id": "dec_conv4b",
+            "durationMs": 0.670344
+          },
+          {
+            "id": "dec_conv3a",
+            "durationMs": 2.621255
+          },
+          {
+            "id": "dec_conv3b",
+            "durationMs": 0.990622
+          },
+          {
+            "id": "dec_conv2a",
+            "durationMs": 4.373216
+          },
+          {
+            "id": "dec_conv2b",
+            "durationMs": 2.320394
+          },
+          {
+            "id": "dec_conv1a",
+            "durationMs": 7.416744
+          },
+          {
+            "id": "dec_conv1b",
+            "durationMs": 4.014733
+          },
+          {
+            "id": "dec_conv1c",
+            "durationMs": 0.496977
+          }
+        ]
+      },
+      "runtimeInfo": {
+        "configuredEngine": "wgsl",
+        "gpuEngine": "wgsl",
+        "precision": "fp32",
+        "model": "oidn-unet-large-v1",
+        "modelFamily": "oidn-unet-large",
+        "inputChannels": 9,
+        "dynamicTile": {
+          "enabled": false,
+          "currentTileSize": 512,
+          "minTileSize": 256,
+          "maxTileSize": 512,
+          "targetTileTimeMs": 16
+        },
+        "lastExecution": {
+          "width": 512,
+          "height": 512,
+          "tileWidth": 512,
+          "tileHeight": 512,
+          "tileCount": 1,
+          "durationMs": 38.5,
+          "tileTimeMs": {
+            "min": 38.5,
+            "median": 38.5,
+            "mean": 38.5,
+            "max": 38.5
+          }
+        }
+      },
+      "supportsFP16": true,
+      "adapter": {
+        "vendor": "apple",
+        "architecture": "metal-3",
+        "device": "",
+        "description": ""
+      },
+      "summary": {
+        "minMs": 37.79999999701977,
+        "medianMs": 38.100000001490116,
+        "meanMs": 38.079999999701975,
+        "p95Ms": 38.20000000298023,
+        "maxMs": 38.20000000298023
+      },
+      "messages": [],
+      "validation": {
+        "sampleCount": 6144,
+        "meanAbsoluteError": 0.0000011096847932397698,
+        "rootMeanSquaredError": 0.0000018071588418628667,
+        "maxAbsoluteError": 0.000013589859008789062,
+        "passed": true,
+        "thresholds": {
+          "maxMeanError": 0.0001,
+          "maxAbsoluteError": 0.001
+        }
+      }
+    },
+    {
+      "label": "WGSL FP16",
+      "bundle": "current",
+      "baseline": false,
+      "precision": "fp16",
+      "initializationMs": 31.399999998509884,
+      "timesMs": [
+        30.399999998509884,
+        29.399999998509884,
+        30.30000000447035,
+        29.600000001490116,
+        30.399999998509884
+      ],
+      "executionProfile": {
+        "totalMs": 29.073979,
+        "layers": [
+          {
+            "id": "input-pack",
+            "durationMs": 0.044457
+          },
+          {
+            "id": "enc_conv1a",
+            "durationMs": 0.617963
+          },
+          {
+            "id": "enc_conv1b",
+            "durationMs": 3.851724
+          },
+          {
+            "id": "pool1",
+            "durationMs": 0.355894
+          },
+          {
+            "id": "enc_conv2a",
+            "durationMs": 1.278839
+          },
+          {
+            "id": "enc_conv2b",
+            "durationMs": 1.971796
+          },
+          {
+            "id": "pool2",
+            "durationMs": 0.049789
+          },
+          {
+            "id": "enc_conv3a",
+            "durationMs": 0.680792
+          },
+          {
+            "id": "enc_conv3b",
+            "durationMs": 0.844449
+          },
+          {
+            "id": "pool3",
+            "durationMs": 0.146366
+          },
+          {
+            "id": "enc_conv4a",
+            "durationMs": 0.782577
+          },
+          {
+            "id": "enc_conv4b",
+            "durationMs": 0.628628
+          },
+          {
+            "id": "pool4",
+            "durationMs": 0.01
+          },
+          {
+            "id": "enc_conv5a",
+            "durationMs": 0.184988
+          },
+          {
+            "id": "enc_conv5b",
+            "durationMs": 0.237694
+          },
+          {
+            "id": "dec_conv4a",
+            "durationMs": 0.961274
+          },
+          {
+            "id": "dec_conv4b",
+            "durationMs": 0.539551
+          },
+          {
+            "id": "dec_conv3a",
+            "durationMs": 1.739311
+          },
+          {
+            "id": "dec_conv3b",
+            "durationMs": 0.836199
+          },
+          {
+            "id": "dec_conv2a",
+            "durationMs": 3.206554
+          },
+          {
+            "id": "dec_conv2b",
+            "durationMs": 2.382521
+          },
+          {
+            "id": "dec_conv1a",
+            "durationMs": 4.440979
+          },
+          {
+            "id": "dec_conv1b",
+            "durationMs": 3.088521
+          },
+          {
+            "id": "dec_conv1c",
+            "durationMs": 0.193113
+          }
+        ]
+      },
+      "runtimeInfo": {
+        "configuredEngine": "wgsl",
+        "gpuEngine": "wgsl",
+        "precision": "fp16",
+        "model": "oidn-unet-large-v1",
+        "modelFamily": "oidn-unet-large",
+        "inputChannels": 9,
+        "dynamicTile": {
+          "enabled": false,
+          "currentTileSize": 512,
+          "minTileSize": 256,
+          "maxTileSize": 512,
+          "targetTileTimeMs": 16
+        },
+        "lastExecution": {
+          "width": 512,
+          "height": 512,
+          "tileWidth": 512,
+          "tileHeight": 512,
+          "tileCount": 1,
+          "durationMs": 30.799999997019768,
+          "tileTimeMs": {
+            "min": 30.799999997019768,
+            "median": 30.799999997019768,
+            "mean": 30.799999997019768,
+            "max": 30.799999997019768
+          }
+        }
+      },
+      "supportsFP16": true,
+      "adapter": {
+        "vendor": "apple",
+        "architecture": "metal-3",
+        "device": "",
+        "description": ""
+      },
+      "summary": {
+        "minMs": 29.399999998509884,
+        "medianMs": 30.30000000447035,
+        "meanMs": 30.020000000298023,
+        "p95Ms": 30.399999998509884,
+        "maxMs": 30.399999998509884
+      },
+      "messages": [],
+      "validation": {
+        "sampleCount": 6144,
+        "meanAbsoluteError": 0.0010210334021394374,
+        "rootMeanSquaredError": 0.001609680379854656,
+        "maxAbsoluteError": 0.012395620346069336,
+        "passed": true,
+        "thresholds": {
+          "maxMeanError": 0.005,
+          "maxAbsoluteError": 0.05
+        }
+      }
+    }
+  ]
+}

package/benchmarks/results/before-spatial.md

@@ -0,0 +1,47 @@
+# oidn-web benchmark
+
+- Current: `e6b8577b1c69cc8ce979022717984aec5b9ea881`
+- TFJS baseline: `136c00c34aa5cf4561b4137034dbd643177f0a5f`
+- Input: 512x512, fixed tile 512, 5 runs after 2 warmup(s)
+- Adapter: apple
+
+| Runtime | Init ms | Median ms | P95 ms | Speedup | Precision |
+| --- | ---: | ---: | ---: | ---: | --- |
+| TFJS (136c00c) | 8.50 | 37.30 | 37.50 | 1.00x | fp32 |
+| WGSL FP32 | 39.40 | 38.10 | 38.20 | 0.98x | fp32 |
+| WGSL FP16 | 31.40 | 30.30 | 30.40 | 1.23x | fp16 |
+
+## Output validation
+
+Compared against sampled TFJS FP32 output.
+
+| Runtime | Status | MAE | RMSE | Max error | Samples |
+| --- | --- | ---: | ---: | ---: | ---: |
+| WGSL FP32 | pass | 1.11e-6 | 1.81e-6 | 1.36e-5 | 6144 |
+| WGSL FP16 | pass | 1.02e-3 | 1.61e-3 | 1.24e-2 | 6144 |
+
+## GPU hot layers
+
+### WGSL FP32
+
+Profiled GPU total: 36.71 ms
+
+| Node | GPU ms |
+| --- | ---: |
+| dec_conv1a | 7.42 |
+| dec_conv2a | 4.37 |
+| dec_conv1b | 4.01 |
+| enc_conv1b | 3.69 |
+| enc_conv2b | 2.70 |
+
+### WGSL FP16
+
+Profiled GPU total: 29.07 ms
+
+| Node | GPU ms |
+| --- | ---: |
+| dec_conv1a | 4.44 |
+| enc_conv1b | 3.85 |
+| dec_conv2a | 3.21 |
+| dec_conv1b | 3.09 |
+| dec_conv2b | 2.38 |