@simulatte/doppler 0.1.9 → 0.2.0

package/src/gpu/kernels/pipeline-cache.js

@@ -1,305 +0,0 @@
-
-
-import { getDevice, getDeviceEpoch, getKernelCapabilities } from '../device.js';
-import { getKernelConfig } from './kernel-configs.js';
-import { getShaderModule } from './shader-cache.js';
-import { hasRequiredFeatures } from './feature-check.js';
-import { trace } from '../../debug/index.js';
-
-// ============================================================================
-// Caches
-// ============================================================================
-
-
-const pipelineCache = new Map();
-
-
-const bindGroupLayoutCache = new Map();
-
-
-const pipelineLayoutCache = new Map();
-
-let pipelineCacheEpoch = -1;
-const deviceIds = new WeakMap();
-let nextDeviceId = 1;
-
-function getDeviceId(device) {
-  let id = deviceIds.get(device);
-  if (id == null) {
-    id = nextDeviceId++;
-    deviceIds.set(device, id);
-  }
-  return id;
-}
-
-function ensureCacheEpoch() {
-  const epoch = getDeviceEpoch();
-  if (epoch !== pipelineCacheEpoch) {
-    pipelineCache.clear();
-    bindGroupLayoutCache.clear();
-    pipelineLayoutCache.clear();
-    pipelineCacheEpoch = epoch;
-  }
-}
-
-// ============================================================================
-// Bind Group Layout
-// ============================================================================
-
-
-export function getOrCreateBindGroupLayout(
-  label,
-  entries,
-  deviceOverride = null
-) {
-  ensureCacheEpoch();
-
-  const device = deviceOverride || getDevice();
-  if (!device) {
-    throw new Error('Device not initialized');
-  }
-  const scopedLabel = `${getDeviceId(device)}:${label}`;
-  const cached = bindGroupLayoutCache.get(scopedLabel);
-  if (cached) {
-    return cached;
-  }
-
-  const layout = device.createBindGroupLayout({ label, entries });
-  bindGroupLayoutCache.set(scopedLabel, layout);
-  return layout;
-}
-
-// ============================================================================
-// Pipeline Layout
-// ============================================================================
-
-
-export function getOrCreatePipelineLayout(
-  label,
-  bindGroupLayouts,
-  deviceOverride = null
-) {
-  ensureCacheEpoch();
-
-  const device = deviceOverride || getDevice();
-  if (!device) {
-    throw new Error('Device not initialized');
-  }
-  const scopedLabel = `${getDeviceId(device)}:${label}`;
-  const cached = pipelineLayoutCache.get(scopedLabel);
-  if (cached) {
-    return cached;
-  }
-
-  const layout = device.createPipelineLayout({
-    label,
-    bindGroupLayouts,
-  });
-
-  pipelineLayoutCache.set(scopedLabel, layout);
-  return layout;
-}
-
-// ============================================================================
-// Pipeline Creation
-// ============================================================================
-
-
-function buildPipelineCacheKey(operation, variant, constants, bindGroupLayout, device) {
-  const constantsKey = constants
-    ? Object.entries(constants).sort().map(([k, v]) => `${k}=${v}`).join('|')
-    : '';
-  const layoutKey = bindGroupLayout ? `:${bindGroupLayout.label || 'layout'}` : '';
-  const deviceKey = `dev:${getDeviceId(device)}`;
-  return `${deviceKey}:${operation}:${variant}${constants ? ':' + constantsKey : ''}${layoutKey}`;
-}
-
-function resolveConstants(operation, variant, constants) {
-  const config = getKernelConfig(operation, variant);
-  const overrides = config.wgslOverrides;
-  if (!overrides || Object.keys(overrides).length === 0) {
-    return constants;
-  }
-  if (!constants || Object.keys(constants).length === 0) {
-    return { ...overrides };
-  }
-  return { ...constants, ...overrides };
-}
-
-function normalizePipelineConstants(constants) {
-  if (!constants) return null;
-  const normalized = {};
-  for (const [key, value] of Object.entries(constants)) {
-    if (typeof value === 'boolean') {
-      normalized[key] = value ? 1 : 0;
-      continue;
-    }
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-      throw new Error(
-        `Kernel pipeline constant "${key}" must be a finite number or boolean, got ${typeof value}.`
-      );
-    }
-    normalized[key] = value;
-  }
-  return normalized;
-}
-
-function isPowerOfTwo(value) {
-  return Number.isInteger(value) && value > 0 && (value & (value - 1)) === 0;
-}
-
-function assertWorkgroupPowerOfTwo(operation, variant, workgroupSize, constants) {
-  if (Array.isArray(workgroupSize)) {
-    for (const dim of workgroupSize) {
-      if (!isPowerOfTwo(dim)) {
-        throw new Error(
-          `Kernel ${operation}/${variant} requires power-of-two workgroup size, got [${workgroupSize.join(', ')}]`
-        );
-      }
-    }
-  }
-
-  if (!constants) return;
-  for (const [key, value] of Object.entries(constants)) {
-    if (!Number.isFinite(value)) continue;
-    if (!key.includes('WORKGROUP_SIZE')) continue;
-    if (!isPowerOfTwo(value)) {
-      throw new Error(
-        `Kernel ${operation}/${variant} requires power-of-two ${key}, got ${value}`
-      );
-    }
-  }
-}
-
-export function getCachedPipeline(
-  operation,
-  variant,
-  constants = null
-) {
-  ensureCacheEpoch();
-  const device = getDevice();
-  if (!device) {
-    return null;
-  }
-  const resolvedConstants = normalizePipelineConstants(
-    resolveConstants(operation, variant, constants)
-  );
-  const cacheKey = buildPipelineCacheKey(operation, variant, resolvedConstants, null, device);
-  return pipelineCache.get(cacheKey) || null;
-}
-
-
-export async function getPipelineFast(
-  operation,
-  variant,
-  bindGroupLayout = null,
-  constants = null
-) {
-  ensureCacheEpoch();
-  const device = getDevice();
-  if (!device) {
-    throw new Error('Device not initialized');
-  }
-  const resolvedConstants = normalizePipelineConstants(
-    resolveConstants(operation, variant, constants)
-  );
-  if (bindGroupLayout) {
-    const layoutKey = buildPipelineCacheKey(operation, variant, resolvedConstants, bindGroupLayout, device);
-    const cached = pipelineCache.get(layoutKey);
-    if (cached) return cached;
-    return createPipeline(operation, variant, bindGroupLayout, constants);
-  }
-  const cacheKey = buildPipelineCacheKey(operation, variant, resolvedConstants, null, device);
-  const cached = pipelineCache.get(cacheKey);
-  if (cached) return cached;
-  return createPipeline(operation, variant, null, constants);
-}
-
-
-export async function createPipeline(
-  operation,
-  variant,
-  bindGroupLayout = null,
-  constants = null
-) {
-  ensureCacheEpoch();
-  const device = getDevice();
-  if (!device) {
-    throw new Error('Device not initialized');
-  }
-
-  const config = getKernelConfig(operation, variant);
-  const resolvedConstants = normalizePipelineConstants(
-    resolveConstants(operation, variant, constants)
-  );
-  const constantsKey = resolvedConstants
-    ? Object.entries(resolvedConstants).sort().map(([k, v]) => `${k}=${v}`).join('|')
-    : '';
-  const cacheKey = buildPipelineCacheKey(operation, variant, resolvedConstants, bindGroupLayout, device);
-
-  // Return cached pipeline if available
-  if (pipelineCache.has(cacheKey)) {
-    return pipelineCache.get(cacheKey);
-  }
-  const capabilities = getKernelCapabilities();
-
-  // Verify requirements
-  if (!hasRequiredFeatures(config.requires, capabilities)) {
-    throw new Error(
-      `Kernel ${operation}/${variant} requires features: ${config.requires.join(', ')}`
-    );
-  }
-
-  assertWorkgroupPowerOfTwo(operation, variant, config.workgroupSize, resolvedConstants);
-
-  trace.kernels(
-    `KernelLayout: ${operation}/${variant} file=${config.shaderFile} entry=${config.entryPoint} ` +
-    `workgroup=[${config.workgroupSize.join(',')}] requires=` +
-    `${config.requires.length > 0 ? config.requires.join('|') : 'none'}` +
-    `${resolvedConstants ? ' constants=' + constantsKey : ''}`
-  );
-
-  // Compile or reuse shader module
-  const shaderModule = await getShaderModule(device, config.shaderFile, `${operation}_${variant}`);
-
-  // Create pipeline
-  const layoutLabel = bindGroupLayout?.label || `${operation}_${variant}_layout`;
-
-  const pipelineDescriptor = {
-    label: `${operation}_${variant}_pipeline${constants ? '_' + constantsKey : ''}`,
-    layout: bindGroupLayout
-      ? getOrCreatePipelineLayout(layoutLabel, [bindGroupLayout], device)
-      : 'auto',
-    compute: {
-      module: shaderModule,
-      entryPoint: config.entryPoint,
-      constants: resolvedConstants || undefined,
-    },
-  };
-
-  const pipeline = await device.createComputePipelineAsync(pipelineDescriptor);
-  pipelineCache.set(cacheKey, pipeline);
-
-  return pipeline;
-}
-
-// ============================================================================
-// Cache Management
-// ============================================================================
-
-
-export function clearPipelineCaches() {
-  pipelineCache.clear();
-  bindGroupLayoutCache.clear();
-  pipelineLayoutCache.clear();
-  pipelineCacheEpoch = getDeviceEpoch();
-}
-
-
-export function getPipelineCacheStats() {
-  return {
-    pipelines: pipelineCache.size,
-    bindGroupLayouts: bindGroupLayoutCache.size,
-    pipelineLayouts: pipelineLayoutCache.size,
-  };
-}

package/src/gpu/kernels/pixel_shuffle.d.ts

@@ -1,27 +0,0 @@
-/**
- * @module gpu/kernels/pixel_shuffle
- */
-
-import type { Tensor } from '../tensor.js';
-
-export interface PixelShuffleOptions {
-  outChannels: number;
-  outHeight: number;
-  outWidth: number;
-  gridWidth: number;
-  gridHeight: number;
-  patchSize: number;
-  patchChannels?: number;
-  outputBuffer?: GPUBuffer | null;
-}
-
-export declare function runPixelShuffle(
-  input: Tensor,
-  options: PixelShuffleOptions
-): Promise<Tensor>;
-
-export declare function recordPixelShuffle(
-  recorder: any,
-  input: Tensor,
-  options: PixelShuffleOptions
-): Promise<Tensor>;

package/src/gpu/kernels/pixel_shuffle.js

@@ -1,57 +0,0 @@
-import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
-import { createTensor, dtypeBytes } from '../tensor.js';
-import { unifiedKernelWrapper } from './utils.js';
-import { selectRuleValue } from './rule-registry.js';
-import { WORKGROUP_SIZES } from './constants.js';
-
-function selectPixelShuffleVariant(dtype) {
-  return selectRuleValue('pixel_shuffle', 'variant', { dtype });
-}
-
-async function _pixelShuffle(target, input, options = {}) {
-  const {
-    outChannels, outHeight, outWidth,
-    gridWidth, gridHeight, patchSize,
-    patchChannels, outputBuffer = null,
-  } = options;
-
-  if (!Number.isFinite(outChannels) || !Number.isFinite(outHeight) || !Number.isFinite(outWidth) ||
-      !Number.isFinite(gridWidth) || !Number.isFinite(gridHeight) || !Number.isFinite(patchSize)) {
-    throw new Error('PixelShuffle requires explicit dimensions.');
-  }
-
-  const inferredPatchChannels = patchChannels ?? outChannels * patchSize * patchSize;
-  const variant = selectPixelShuffleVariant(input.dtype);
-  const bytesPerElement = dtypeBytes(input.dtype);
-  const outputSize = outChannels * outHeight * outWidth * bytesPerElement;
-  const output = outputBuffer || acquireBuffer(outputSize, undefined, 'pixel_shuffle_output');
-  const ownedOutput = outputBuffer ? null : output;
-
-  try {
-    await unifiedKernelWrapper(
-      'pixel_shuffle', target, variant,
-      [input, output],
-      {
-        out_channels: outChannels, out_height: outHeight, out_width: outWidth,
-        grid_width: gridWidth, grid_height: gridHeight, patch_size: patchSize,
-        patch_channels: inferredPatchChannels, _pad0: 0,
-      },
-      [Math.ceil((outHeight * outWidth) / WORKGROUP_SIZES.DEFAULT), outChannels, 1]
-    );
-
-    return createTensor(output, input.dtype, [outChannels, outHeight, outWidth], 'pixel_shuffle_output');
-  } catch (error) {
-    if (ownedOutput) {
-      releaseBuffer(ownedOutput);
-    }
-    throw error;
-  }
-}
-
-export async function runPixelShuffle(input, options = {}) {
-  return _pixelShuffle(null, input, options);
-}
-
-export async function recordPixelShuffle(recorder, input, options = {}) {
-  return _pixelShuffle(recorder, input, options);
-}

package/src/gpu/kernels/pixel_shuffle.wgsl

@@ -1,43 +0,0 @@
-// Pixel shuffle (tokens -> CHW)
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    out_channels: u32,
-    out_height: u32,
-    out_width: u32,
-    grid_width: u32,
-    grid_height: u32,
-    patch_size: u32,
-    patch_channels: u32,
-    _pad0: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f32>;
-@group(0) @binding(2) var<storage, read_write> output: array<f32>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let spatial_size = u.out_height * u.out_width;
-    let spatial = gid.x;
-    let c = gid.y;
-    if (c >= u.out_channels || spatial >= spatial_size) {
-        return;
-    }
-
-    let y = spatial / u.out_width;
-    let x = spatial - y * u.out_width;
-    let idx = c * spatial_size + spatial;
-
-    let grid_y = y / u.patch_size;
-    let grid_x = x / u.patch_size;
-    let sub_y = y - grid_y * u.patch_size;
-    let sub_x = x - grid_x * u.patch_size;
-
-    let token_idx = grid_y * u.grid_width + grid_x;
-    let patch_idx = (sub_y * u.patch_size + sub_x) * u.out_channels + c;
-    let input_idx = token_idx * u.patch_channels + patch_idx;
-
-    output[idx] = input[input_idx];
-}

package/src/gpu/kernels/pixel_shuffle_f16.wgsl

@@ -1,46 +0,0 @@
-// AUTO-GENERATED from src/gpu/kernels/pixel_shuffle.wgsl.
-// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
-// Pixel shuffle (tokens -> CHW) f16
-
-enable f16;
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    out_channels: u32,
-    out_height: u32,
-    out_width: u32,
-    grid_width: u32,
-    grid_height: u32,
-    patch_size: u32,
-    patch_channels: u32,
-    _pad0: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f16>;
-@group(0) @binding(2) var<storage, read_write> output: array<f16>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let spatial_size = u.out_height * u.out_width;
-    let spatial = gid.x;
-    let c = gid.y;
-    if (c >= u.out_channels || spatial >= spatial_size) {
-        return;
-    }
-
-    let y = spatial / u.out_width;
-    let x = spatial - y * u.out_width;
-    let idx = c * spatial_size + spatial;
-
-    let grid_y = y / u.patch_size;
-    let grid_x = x / u.patch_size;
-    let sub_y = y - grid_y * u.patch_size;
-    let sub_x = x - grid_x * u.patch_size;
-
-    let token_idx = grid_y * u.grid_width + grid_x;
-    let patch_idx = (sub_y * u.patch_size + sub_x) * u.out_channels + c;
-    let input_idx = token_idx * u.patch_channels + patch_idx;
-
-    output[idx] = input[input_idx];
-}

package/src/gpu/kernels/relu.d.ts

@@ -1,18 +0,0 @@
-import type { Tensor } from '../tensor.js';
-import type { CommandRecorder } from '../command-recorder.js';
-import type { OutputBufferOptions } from './types.js';
-
-export interface ReLUOptions extends OutputBufferOptions {
-  count?: number | null;
-}
-
-export declare function runReLU(
-  input: Tensor,
-  options?: ReLUOptions
-): Promise<Tensor>;
-
-export declare function recordReLU(
-  recorder: CommandRecorder,
-  input: Tensor,
-  options?: ReLUOptions
-): Promise<Tensor>;

package/src/gpu/kernels/relu.js

@@ -1,66 +0,0 @@
-import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
-import { createTensor, dtypeBytes } from '../tensor.js';
-import { unifiedKernelWrapper } from './utils.js';
-import { selectRuleValue } from './rule-registry.js';
-import { WORKGROUP_SIZES } from './constants.js';
-
-function selectReluVariant(dtype) {
-  return selectRuleValue('relu', 'variant', { dtype });
-}
-
-function resolveCount(input, countOverride) {
-  if (Number.isFinite(countOverride) && countOverride > 0) {
-    return Math.floor(countOverride);
-  }
-  if (Array.isArray(input.shape) && input.shape.length > 0) {
-    return input.shape.reduce((acc, value) => acc * value, 1);
-  }
-  return Math.floor(input.buffer.size / dtypeBytes(input.dtype));
-}
-
-function planReluDispatch(target, size) {
-  const device = target?.device;
-  const maxPerDim = Number.isFinite(device?.limits?.maxComputeWorkgroupsPerDimension)
-    ? device.limits.maxComputeWorkgroupsPerDimension
-    : 65535;
-  const dispatchStride = Math.min(size, maxPerDim * WORKGROUP_SIZES.DEFAULT);
-  return {
-    dispatchStride,
-    workgroups: [Math.ceil(dispatchStride / WORKGROUP_SIZES.DEFAULT), 1, 1],
-  };
-}
-
-async function _relu(target, input, options = {}) {
-  const { count = null, outputBuffer = null } = options;
-  const size = resolveCount(input, count);
-  const variant = selectReluVariant(input.dtype);
-  const output = outputBuffer || acquireBuffer(size * dtypeBytes(input.dtype), undefined, 'relu_output');
-  const ownedOutput = outputBuffer ? null : output;
-  const dispatchPlan = planReluDispatch(target, size);
-
-  try {
-    await unifiedKernelWrapper(
-      'relu',
-      target,
-      variant,
-      [input, output],
-      { size, _pad0: dispatchPlan.dispatchStride, _pad1: 0, _pad2: 0 },
-      dispatchPlan.workgroups
-    );
-
-    return createTensor(output, input.dtype, [...input.shape], 'relu_output');
-  } catch (error) {
-    if (ownedOutput) {
-      releaseBuffer(ownedOutput);
-    }
-    throw error;
-  }
-}
-
-export async function runReLU(input, options = {}) {
-  return _relu(null, input, options);
-}
-
-export async function recordReLU(recorder, input, options = {}) {
-  return _relu(recorder, input, options);
-}

package/src/gpu/kernels/relu.wgsl

@@ -1,22 +0,0 @@
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    size: u32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f32>;
-@group(0) @binding(2) var<storage, read_write> output: array<f32>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let dispatch_stride = max(u._pad0, 1u);
-    let idx = gid.y * dispatch_stride + gid.x;
-    if (idx >= u.size) {
-        return;
-    }
-    output[idx] = max(input[idx], 0.0);
-}

package/src/gpu/kernels/relu_f16.wgsl

@@ -1,24 +0,0 @@
-enable f16;
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    size: u32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f16>;
-@group(0) @binding(2) var<storage, read_write> output: array<f16>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let dispatch_stride = max(u._pad0, 1u);
-    let idx = gid.y * dispatch_stride + gid.x;
-    if (idx >= u.size) {
-        return;
-    }
-    output[idx] = max(input[idx], 0.0h);
-}

package/src/gpu/kernels/repeat_channels.d.ts

@@ -1,21 +0,0 @@
-import type { Tensor } from '../tensor.js';
-import type { CommandRecorder } from '../command-recorder.js';
-import type { OutputBufferOptions } from './types.js';
-
-export interface RepeatChannelsOptions extends OutputBufferOptions {
-  inChannels: number;
-  height: number;
-  width: number;
-  repeats: number;
-}
-
-export declare function runRepeatChannels(
-  input: Tensor,
-  options: RepeatChannelsOptions
-): Promise<Tensor>;
-
-export declare function recordRepeatChannels(
-  recorder: CommandRecorder,
-  input: Tensor,
-  options: RepeatChannelsOptions
-): Promise<Tensor>;