@simulatte/doppler 0.1.9 → 0.2.0

package/src/gpu/kernels/energy_quintel_reduce.wgsl

@@ -1,112 +0,0 @@
-// energy_quintel_reduce.wgsl
-// Reduces quintel energy components and state sum per workgroup.
-
-const WORKGROUP_SIZE: u32 = 256u;
-
-const FLAG_MIRROR_X: u32 = 1u;
-const FLAG_MIRROR_Y: u32 = 2u;
-const FLAG_DIAGONAL: u32 = 4u;
-const FLAG_CENTER: u32 = 16u;
-const FLAG_BINARIZE: u32 = 32u;
-
-struct Uniforms {
-    count: u32,
-    size: u32,
-    flags: u32,
-    _pad0: u32,
-    symmetryWeight: f32,
-    centerWeight: f32,
-    binarizeWeight: f32,
-    centerTarget: f32,
-    _pad1: f32,
-    _pad2: f32,
-    _pad3: f32,
-    _pad4: f32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> state: array<f32>;
-@group(0) @binding(2) var<storage, read_write> output: array<vec4<f32>>;
-
-var<workgroup> sharedAccum: array<vec4<f32>, WORKGROUP_SIZE>;
-
-fn hasFlag(mask: u32) -> bool {
-    return (u.flags & mask) != 0u;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(global_invocation_id) gid: vec3<u32>,
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wid: vec3<u32>
-) {
-    let idx = gid.x;
-    var accum = vec4<f32>(0.0);
-
-    if (idx < u.count) {
-        let size = u.size;
-        let i = idx / size;
-        let j = idx - i * size;
-        let value = state[idx];
-
-        accum.x = value;
-
-        var symmetryEnergy: f32 = 0.0;
-        if (hasFlag(FLAG_MIRROR_X)) {
-            let mirrorJ = size - 1u - j;
-            if (j < mirrorJ) {
-                let mirrorIdx = i * size + mirrorJ;
-                let diff = value - state[mirrorIdx];
-                symmetryEnergy += u.symmetryWeight * diff * diff;
-            }
-        }
-        if (hasFlag(FLAG_MIRROR_Y)) {
-            let mirrorI = size - 1u - i;
-            if (i < mirrorI) {
-                let mirrorIdx = mirrorI * size + j;
-                let diff = value - state[mirrorIdx];
-                symmetryEnergy += u.symmetryWeight * diff * diff;
-            }
-        }
-        if (hasFlag(FLAG_DIAGONAL)) {
-            if (i < j) {
-                let mirrorIdx = j * size + i;
-                let diff = value - state[mirrorIdx];
-                symmetryEnergy += u.symmetryWeight * diff * diff;
-            }
-        }
-        accum.y = symmetryEnergy;
-
-        if (hasFlag(FLAG_BINARIZE)) {
-            accum.z = u.binarizeWeight * value * (1.0 - value);
-        }
-
-        if (hasFlag(FLAG_CENTER)) {
-            let center = size / 2u;
-            let centerIdx = center * size + center;
-            if (idx == centerIdx) {
-                let diff = value - u.centerTarget;
-                accum.w = u.centerWeight * diff * diff;
-            }
-        }
-    }
-
-    sharedAccum[lid.x] = accum;
-    workgroupBarrier();
-
-    var stride = WORKGROUP_SIZE / 2u;
-    loop {
-        if (stride == 0u) {
-            break;
-        }
-        if (lid.x < stride) {
-            sharedAccum[lid.x] = sharedAccum[lid.x] + sharedAccum[lid.x + stride];
-        }
-        workgroupBarrier();
-        stride = stride / 2u;
-    }
-
-    if (lid.x == 0u) {
-        output[wid.x] = sharedAccum[0];
-    }
-}

package/src/gpu/kernels/energy_quintel_reduce_f16.wgsl

@@ -1,116 +0,0 @@
-// AUTO-GENERATED from src/gpu/kernels/energy_quintel_reduce.wgsl.
-// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
-// energy_quintel_reduce_f16.wgsl
-// Reduces quintel energy components and state sum per workgroup for f16 state.
-
-enable f16;
-
-const WORKGROUP_SIZE: u32 = 256u;
-
-const FLAG_MIRROR_X: u32 = 1u;
-const FLAG_MIRROR_Y: u32 = 2u;
-const FLAG_DIAGONAL: u32 = 4u;
-const FLAG_CENTER: u32 = 16u;
-const FLAG_BINARIZE: u32 = 32u;
-
-struct Uniforms {
-    count: u32,
-    size: u32,
-    flags: u32,
-    _pad0: u32,
-    symmetryWeight: f32,
-    centerWeight: f32,
-    binarizeWeight: f32,
-    centerTarget: f32,
-    _pad1: f32,
-    _pad2: f32,
-    _pad3: f32,
-    _pad4: f32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> state: array<f16>;
-@group(0) @binding(2) var<storage, read_write> output: array<vec4<f32>>;
-
-var<workgroup> sharedAccum: array<vec4<f32>, WORKGROUP_SIZE>;
-
-fn hasFlag(mask: u32) -> bool {
-    return (u.flags & mask) != 0u;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(global_invocation_id) gid: vec3<u32>,
-    @builtin(local_invocation_id) lid: vec3<u32>,
-    @builtin(workgroup_id) wid: vec3<u32>
-) {
-    let idx = gid.x;
-    var accum = vec4<f32>(0.0);
-
-    if (idx < u.count) {
-        let size = u.size;
-        let i = idx / size;
-        let j = idx - i * size;
-        let value = f32(state[idx]);
-
-        accum.x = value;
-
-        var symmetryEnergy: f32 = 0.0;
-        if (hasFlag(FLAG_MIRROR_X)) {
-            let mirrorJ = size - 1u - j;
-            if (j < mirrorJ) {
-                let mirrorIdx = i * size + mirrorJ;
-                let diff = value - f32(state[mirrorIdx]);
-                symmetryEnergy += u.symmetryWeight * diff * diff;
-            }
-        }
-        if (hasFlag(FLAG_MIRROR_Y)) {
-            let mirrorI = size - 1u - i;
-            if (i < mirrorI) {
-                let mirrorIdx = mirrorI * size + j;
-                let diff = value - f32(state[mirrorIdx]);
-                symmetryEnergy += u.symmetryWeight * diff * diff;
-            }
-        }
-        if (hasFlag(FLAG_DIAGONAL)) {
-            if (i < j) {
-                let mirrorIdx = j * size + i;
-                let diff = value - f32(state[mirrorIdx]);
-                symmetryEnergy += u.symmetryWeight * diff * diff;
-            }
-        }
-        accum.y = symmetryEnergy;
-
-        if (hasFlag(FLAG_BINARIZE)) {
-            accum.z = u.binarizeWeight * value * (1.0 - value);
-        }
-
-        if (hasFlag(FLAG_CENTER)) {
-            let center = size / 2u;
-            let centerIdx = center * size + center;
-            if (idx == centerIdx) {
-                let diff = value - u.centerTarget;
-                accum.w = u.centerWeight * diff * diff;
-            }
-        }
-    }
-
-    sharedAccum[lid.x] = accum;
-    workgroupBarrier();
-
-    var stride = WORKGROUP_SIZE / 2u;
-    loop {
-        if (stride == 0u) {
-            break;
-        }
-        if (lid.x < stride) {
-            sharedAccum[lid.x] = sharedAccum[lid.x] + sharedAccum[lid.x + stride];
-        }
-        workgroupBarrier();
-        stride = stride / 2u;
-    }
-
-    if (lid.x == 0u) {
-        output[wid.x] = sharedAccum[0];
-    }
-}

package/src/gpu/kernels/energy_quintel_update.wgsl

@@ -1,92 +0,0 @@
-// energy_quintel_update.wgsl
-// Quintel update kernel: apply symmetry/count/center/binarize gradients.
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-const FLAG_MIRROR_X: u32 = 1u;
-const FLAG_MIRROR_Y: u32 = 2u;
-const FLAG_DIAGONAL: u32 = 4u;
-const FLAG_COUNT: u32 = 8u;
-const FLAG_CENTER: u32 = 16u;
-const FLAG_BINARIZE: u32 = 32u;
-
-struct Uniforms {
-    count: u32,
-    size: u32,
-    flags: u32,
-    _pad0: u32,
-    stepSize: f32,
-    gradientScale: f32,
-    countDiff: f32,
-    centerTarget: f32,
-    symmetryWeight: f32,
-    countWeight: f32,
-    centerWeight: f32,
-    binarizeWeight: f32,
-    clampMin: f32,
-    clampMax: f32,
-    _pad1: f32,
-    _pad2: f32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read_write> state: array<f32>;
-
-fn hasFlag(mask: u32) -> bool {
-    return (u.flags & mask) != 0u;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    if (idx >= u.count) {
-        return;
-    }
-
-    let size = u.size;
-    let i = idx / size;
-    let j = idx - i * size;
-    let value = state[idx];
-    var grad: f32 = 0.0;
-
-    if (hasFlag(FLAG_MIRROR_X)) {
-        let mirrorJ = size - 1u - j;
-        let mirrorIdx = i * size + mirrorJ;
-        let diff = value - state[mirrorIdx];
-        grad = grad + (2.0 * u.symmetryWeight * diff);
-    }
-
-    if (hasFlag(FLAG_MIRROR_Y)) {
-        let mirrorI = size - 1u - i;
-        let mirrorIdx = mirrorI * size + j;
-        let diff = value - state[mirrorIdx];
-        grad = grad + (2.0 * u.symmetryWeight * diff);
-    }
-
-    if (hasFlag(FLAG_DIAGONAL)) {
-        let mirrorIdx = j * size + i;
-        let diff = value - state[mirrorIdx];
-        grad = grad + (2.0 * u.symmetryWeight * diff);
-    }
-
-    if (hasFlag(FLAG_COUNT)) {
-        grad = grad + (2.0 * u.countWeight * u.countDiff);
-    }
-
-    if (hasFlag(FLAG_CENTER)) {
-        let center = size / 2u;
-        let centerIdx = center * size + center;
-        if (idx == centerIdx) {
-            let diff = value - u.centerTarget;
-            grad = grad + (2.0 * u.centerWeight * diff);
-        }
-    }
-
-    if (hasFlag(FLAG_BINARIZE)) {
-        grad = grad + (u.binarizeWeight * (1.0 - 2.0 * value));
-    }
-
-    let stepScale = u.stepSize * u.gradientScale;
-    let next = clamp(value - stepScale * grad, u.clampMin, u.clampMax);
-    state[idx] = next;
-}

package/src/gpu/kernels/energy_quintel_update_f16.wgsl

@@ -1,96 +0,0 @@
-// AUTO-GENERATED from src/gpu/kernels/energy_quintel_update.wgsl.
-// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
-// energy_quintel_update_f16.wgsl
-// Quintel update kernel for f16 state.
-
-enable f16;
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-const FLAG_MIRROR_X: u32 = 1u;
-const FLAG_MIRROR_Y: u32 = 2u;
-const FLAG_DIAGONAL: u32 = 4u;
-const FLAG_COUNT: u32 = 8u;
-const FLAG_CENTER: u32 = 16u;
-const FLAG_BINARIZE: u32 = 32u;
-
-struct Uniforms {
-    count: u32,
-    size: u32,
-    flags: u32,
-    _pad0: u32,
-    stepSize: f32,
-    gradientScale: f32,
-    countDiff: f32,
-    centerTarget: f32,
-    symmetryWeight: f32,
-    countWeight: f32,
-    centerWeight: f32,
-    binarizeWeight: f32,
-    clampMin: f32,
-    clampMax: f32,
-    _pad1: f32,
-    _pad2: f32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read_write> state: array<f16>;
-
-fn hasFlag(mask: u32) -> bool {
-    return (u.flags & mask) != 0u;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    if (idx >= u.count) {
-        return;
-    }
-
-    let size = u.size;
-    let i = idx / size;
-    let j = idx - i * size;
-    let value = f32(state[idx]);
-    var grad: f32 = 0.0;
-
-    if (hasFlag(FLAG_MIRROR_X)) {
-        let mirrorJ = size - 1u - j;
-        let mirrorIdx = i * size + mirrorJ;
-        let diff = value - f32(state[mirrorIdx]);
-        grad = grad + (2.0 * u.symmetryWeight * diff);
-    }
-
-    if (hasFlag(FLAG_MIRROR_Y)) {
-        let mirrorI = size - 1u - i;
-        let mirrorIdx = mirrorI * size + j;
-        let diff = value - f32(state[mirrorIdx]);
-        grad = grad + (2.0 * u.symmetryWeight * diff);
-    }
-
-    if (hasFlag(FLAG_DIAGONAL)) {
-        let mirrorIdx = j * size + i;
-        let diff = value - f32(state[mirrorIdx]);
-        grad = grad + (2.0 * u.symmetryWeight * diff);
-    }
-
-    if (hasFlag(FLAG_COUNT)) {
-        grad = grad + (2.0 * u.countWeight * u.countDiff);
-    }
-
-    if (hasFlag(FLAG_CENTER)) {
-        let center = size / 2u;
-        let centerIdx = center * size + center;
-        if (idx == centerIdx) {
-            let diff = value - u.centerTarget;
-            grad = grad + (2.0 * u.centerWeight * diff);
-        }
-    }
-
-    if (hasFlag(FLAG_BINARIZE)) {
-        grad = grad + (u.binarizeWeight * (1.0 - 2.0 * value));
-    }
-
-    let stepScale = u.stepSize * u.gradientScale;
-    let next = clamp(value - stepScale * grad, u.clampMin, u.clampMax);
-    state[idx] = f16(next);
-}

package/src/gpu/kernels/energy_update.wgsl

@@ -1,25 +0,0 @@
-// energy_update.wgsl
-// Gradient step on state towards target: state -= stepSize * gradientScale * (state - target).
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    count: u32,
-    stepSize: f32,
-    gradientScale: f32,
-    _pad0: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read_write> state: array<f32>;
-@group(0) @binding(2) var<storage, read> targetBuf: array<f32>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    if (idx >= u.count) {
-        return;
-    }
-    let diff = state[idx] - targetBuf[idx];
-    state[idx] = state[idx] - (u.stepSize * u.gradientScale * diff);
-}

package/src/gpu/kernels/energy_update_f16.wgsl

@@ -1,30 +0,0 @@
-// AUTO-GENERATED from src/gpu/kernels/energy_update.wgsl.
-// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
-// energy_update_f16.wgsl
-// Gradient step on f16 state towards f16 target.
-
-enable f16;
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    count: u32,
-    stepSize: f32,
-    gradientScale: f32,
-    _pad0: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read_write> state: array<f16>;
-@group(0) @binding(2) var<storage, read> targetBuf: array<f16>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    if (idx >= u.count) {
-        return;
-    }
-    let diff = f32(state[idx] - targetBuf[idx]);
-    let next = f32(state[idx]) - (u.stepSize * u.gradientScale * diff);
-    state[idx] = f16(next);
-}

package/src/gpu/kernels/feature-check.d.ts

@@ -1,42 +0,0 @@
-/**
- * Feature Check - GPU capability checking utilities
- *
- * Provides utilities for checking device feature requirements.
- *
- * @module gpu/kernels/feature-check
- */
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/** Minimum capabilities interface for feature checking */
-export interface FeatureCapabilities {
-  hasF16: boolean;
-  hasSubgroups: boolean;
-}
-
-// ============================================================================
-// Feature Checking
-// ============================================================================
-
-/**
- * Check if all required features are available
- */
-export declare function hasRequiredFeatures(
-  required: string[],
-  capabilities: FeatureCapabilities
-): boolean;
-
-// ============================================================================
-// Attention Validation
-// ============================================================================
-
-/**
- * Validate that attention parameters are within device limits
- */
-export declare function validateAttentionLimits(
-  seqLen: number,
-  numHeads: number,
-  headDim: number
-): void;

package/src/gpu/kernels/feature-check.js

@@ -1,70 +0,0 @@
-
-
-import { getDeviceLimits } from '../device.js';
-import { TILE_SIZES } from './constants.js';
-import { log } from '../../debug/index.js';
-
-// ============================================================================
-// Feature Checking
-// ============================================================================
-
-
-export function hasRequiredFeatures(
-  required,
-  capabilities
-) {
-  for (const feature of required) {
-    if (feature === 'shader-f16' && !capabilities.hasF16) return false;
-    if (feature === 'subgroups' && !capabilities.hasSubgroups) return false;
-    if (feature === 'subgroups-f16' && !capabilities.hasSubgroupsF16) return false;
-  }
-  return true;
-}
-
-// ============================================================================
-// Attention Validation
-// ============================================================================
-
-
-export function validateAttentionLimits(
-  seqLen,
-  numHeads,
-  headDim
-) {
-  const limits = getDeviceLimits();
-  if (!limits) return; // No device, validation will fail later
-
-  // Check workgroup invocations limit
-  const workgroupInvocations = seqLen * numHeads;
-  if (workgroupInvocations > limits.maxComputeWorkgroupsPerDimension) {
-    throw new Error(
-      `Attention parameters exceed device limits: ${workgroupInvocations} workgroups ` +
-      `> ${limits.maxComputeWorkgroupsPerDimension} max per dimension. ` +
-      `Try reducing seqLen (${seqLen}) or numHeads (${numHeads}).`
-    );
-  }
-
-  // Check buffer size limits for KV cache
-  const kvCacheSize = seqLen * numHeads * headDim * 4; // float32
-  if (kvCacheSize > limits.maxStorageBufferBindingSize) {
-    throw new Error(
-      `KV cache size ${(kvCacheSize / 1e9).toFixed(2)}GB exceeds device limit ` +
-      `${(limits.maxStorageBufferBindingSize / 1e9).toFixed(2)}GB. ` +
-      `Reduce sequence length or use paged attention.`
-    );
-  }
-
-  // Check shared memory requirements for attention tile
-  const blockSize = TILE_SIZES.ATTENTION_LARGE_BLOCK_SIZE;
-  const headTile = TILE_SIZES.ATTENTION_LARGE_HEAD_TILE;
-  const sharedMemRequired =
-    blockSize * headTile * 4 * 2 +  // K/V tiles
-    blockSize * blockSize * 4;      // score tile
-  if (sharedMemRequired > limits.maxComputeWorkgroupStorageSize) {
-    log.warn(
-      'FeatureCheck',
-      `Attention may be slow: tile requires ${sharedMemRequired} bytes but device has ` +
-      `${limits.maxComputeWorkgroupStorageSize} bytes shared memory.`
-    );
-  }
-}

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

@@ -1,65 +0,0 @@
-/**
- * Fused FFN Kernel (Tier 2 P0)
- *
- * EXPERIMENTAL: Not currently wired into layer.ts.
- * Complete gate+up fusion kernel, kept for future integration.
- */
-
-import type { Tensor } from '../tensor.js';
-import type { CommandRecorder } from '../command-recorder.js';
-import type { WeightBuffer } from '../weight-buffer.js';
-import type { OutputBufferOptions } from './types.js';
-
-/** FFN activation type */
-export type FFNActivation = 'silu' | 'gelu';
-
-/** Fused FFN options */
-export interface FusedFFNOptions extends OutputBufferOptions {
-  /** Batch size (default: 1) */
-  batchSize?: number;
-  /** Activation function (default: 'silu') */
-  activation?: FFNActivation;
-  /** Scale factor (default: 1.0) */
-  alpha?: number;
-  /** Clamp SwiGLU output (null = disabled) */
-  swigluLimit: number | null;
-}
-
-/**
- * Run fused FFN forward pass
- */
-export declare function runFusedFFN(
-  input: Tensor,
-  W_gate: GPUBuffer | WeightBuffer,
-  W_up: GPUBuffer | WeightBuffer,
-  hiddenSize: number,
-  intermediateSize: number,
-  options?: FusedFFNOptions
-): Promise<Tensor>;
-
-/**
- * Record fused FFN forward pass (batched, no submit)
- */
-export declare function recordFusedFFN(
-  recorder: CommandRecorder,
-  input: Tensor,
-  W_gate: GPUBuffer | WeightBuffer,
-  W_up: GPUBuffer | WeightBuffer,
-  hiddenSize: number,
-  intermediateSize: number,
-  options?: FusedFFNOptions
-): Promise<Tensor>;
-
-/**
- * Calculate memory savings from using fused FFN
- */
-export declare function calculateFusedFFNSavings(
-  batchSize: number,
-  hiddenSize: number,
-  intermediateSize: number
-): {
-  separateBytes: number;
-  fusedBytes: number;
-  savingsBytes: number;
-  savingsPct: number;
-};