@simulatte/doppler 0.1.6 → 0.1.8

package/src/gpu/kernel-tuner/cache.js

@@ -8,11 +8,67 @@ export function getTunerConfig() {
   return getRuntimeConfig().shared.tuner;
 }
 
+function normalizeSignaturePart(value) {
+  return String(value ?? '')
+    .trim()
+    .replace(/[^a-zA-Z0-9]/g, '_');
+}
+
+function hasAdapterIdentity(info) {
+  if (!info || typeof info !== 'object') {
+    return false;
+  }
+  return ['vendor', 'architecture', 'device'].some((key) => {
+    const value = String(info[key] ?? '').trim().toLowerCase();
+    return value.length > 0 && value !== 'unknown';
+  });
+}
+
+function getFallbackSignature(capabilities) {
+  return [
+    capabilities?.hasF16 ? 'f16' : 'nof16',
+    capabilities?.hasSubgroups ? 'subgroups' : 'nosubgroups',
+    capabilities?.hasSubgroupsF16 ? 'subgroupsf16' : 'nosubgroupsf16',
+    capabilities?.hasTimestampQuery ? 'timestamp' : 'notimestamp',
+    `buf${Number.isFinite(capabilities?.maxBufferSize) ? capabilities.maxBufferSize : 'na'}`,
+    `wg${Number.isFinite(capabilities?.maxWorkgroupSize) ? capabilities.maxWorkgroupSize : 'na'}`,
+    `wgs${Number.isFinite(capabilities?.maxWorkgroupStorageSize) ? capabilities.maxWorkgroupStorageSize : 'na'}`,
+  ].join('_');
+}
+
+function isValidDeviceInfo(value) {
+  if (value == null) {
+    return true;
+  }
+  return typeof value === 'object';
+}
+
+function isValidTuneRecord(value) {
+  return !!value
+    && typeof value === 'object'
+    && Array.isArray(value.optimalWorkgroupSize)
+    && value.optimalWorkgroupSize.length === 3
+    && value.optimalWorkgroupSize.every((entry) => Number.isFinite(entry) && entry >= 0)
+    && Number.isFinite(value.optimalTileSize)
+    && value.optimalTileSize >= 0
+    && Number.isFinite(value.throughput)
+    && value.throughput >= 0
+    && Number.isFinite(value.timeMs)
+    && value.timeMs >= 0
+    && isValidDeviceInfo(value.deviceInfo);
+}
+
 
 export function getDeviceSignature(capabilities) {
-  
-  const info = capabilities?.adapterInfo || { vendor: '', architecture: '', device: '' };
-  return `${info.vendor}_${info.architecture}_${info.device}`.replace(/[^a-zA-Z0-9]/g, '_');
+  const info = capabilities?.adapterInfo;
+  if (hasAdapterIdentity(info)) {
+    return [
+      normalizeSignaturePart(info.vendor),
+      normalizeSignaturePart(info.architecture),
+      normalizeSignaturePart(info.device),
+    ].join('_');
+  }
+  return getFallbackSignature(capabilities);
 }
 
 
@@ -33,10 +89,21 @@ export function loadCache(capabilities) {
     const cached = localStorage.getItem(cacheKey);
     if (cached) {
       const data = JSON.parse(cached);
-      return new Map(Object.entries(data));
+      if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        throw new Error('Kernel tuner cache payload must be an object.');
+      }
+      const records = [];
+      for (const [key, value] of Object.entries(data)) {
+        if (!isValidTuneRecord(value)) {
+          throw new Error(`Kernel tuner cache record "${key}" is malformed.`);
+        }
+        records.push([key, value]);
+      }
+      return new Map(records);
     }
   } catch (e) {
     log.warn('KernelTuner', `Failed to load cache: ${e}`);
+    localStorage.removeItem(cacheKey);
   }
 
   return new Map();

package/src/gpu/kernel-tuner/tuner.js

@@ -1,6 +1,6 @@
 
 
-import { getDevice, getKernelCapabilities, getDeviceLimits } from '../device.js';
+import { getDevice, getKernelCapabilities, getDeviceLimits, getDeviceEpoch } from '../device.js';
 import { getKernelThresholds } from '../../config/schema/index.js';
 import { GPUProfiler } from '../profiler.js';
 import {
@@ -36,21 +36,33 @@ export class KernelTuner {
   
   #cache;
 
+  #deviceEpoch;
+
   constructor() {
     this.#device = null;
     this.#profiler = null;
     this.#limits = null;
     this.#capabilities = null;
     this.#cache = new Map();
+    this.#deviceEpoch = -1;
   }
 
   
   async init() {
-    this.#device = getDevice();
-    if (!this.#device) {
+    const device = getDevice();
+    if (!device) {
       throw new Error('GPU device not initialized');
     }
 
+    const deviceEpoch = getDeviceEpoch();
+    if (this.#device === device && this.#deviceEpoch === deviceEpoch && this.#profiler) {
+      return;
+    }
+
+    this.destroy();
+
+    this.#device = device;
+    this.#deviceEpoch = deviceEpoch;
     this.#profiler = new GPUProfiler(this.#device);
     this.#limits = getDeviceLimits();
     this.#capabilities = getKernelCapabilities();
@@ -203,6 +215,12 @@ export class KernelTuner {
     if (this.#profiler) {
       this.#profiler.destroy();
     }
+    this.#profiler = null;
+    this.#device = null;
+    this.#limits = null;
+    this.#capabilities = null;
+    this.#cache = new Map();
+    this.#deviceEpoch = -1;
   }
 }
 
@@ -214,8 +232,8 @@ let globalTuner = null;
 export async function getKernelTuner() {
   if (!globalTuner) {
     globalTuner = new KernelTuner();
-    await globalTuner.init();
   }
+  await globalTuner.init();
   return globalTuner;
 }
 

package/src/gpu/kernels/attention.js

@@ -18,48 +18,29 @@ import { logKernelSelectionOnce } from '../kernel-selection-log.js';
 // Track if we've logged the attention tier selection (avoid spam)
 let loggedAttentionTier = false;
 
-
-let _chunkedMaxKVLen = null;
-
-
-function getChunkedMaxKVLen() {
-  if (_chunkedMaxKVLen === null) {
-    const config = getKernelConfig('attention', 'decode_chunked_f16kv');
-    const maxKVLen = config.variantMetadata?.maxKVLen;
-    if (!Number.isFinite(maxKVLen)) {
-      throw new Error('Kernel config missing attention.decode_chunked_f16kv maxKVLen');
-    }
-    _chunkedMaxKVLen = maxKVLen;
+function getRequiredVariantMaxKVLen(operation, variant, errorLabel) {
+  const config = getKernelConfig(operation, variant);
+  const maxKVLen = config.variantMetadata?.maxKVLen;
+  if (!Number.isFinite(maxKVLen)) {
+    throw new Error(`Kernel config missing ${errorLabel} maxKVLen`);
   }
-  return _chunkedMaxKVLen;
+  return maxKVLen;
 }
 
-let _tieredMaxKVLen = null;
+function getChunkedMaxKVLen() {
+  return getRequiredVariantMaxKVLen('attention', 'decode_chunked_f16kv', 'attention.decode_chunked_f16kv');
+}
 
 function getTieredMaxKVLen() {
-  if (_tieredMaxKVLen === null) {
-    const config = getKernelConfig('attention_tiered', 'decode_tiered_f16');
-    const maxKVLen = config.variantMetadata?.maxKVLen;
-    if (!Number.isFinite(maxKVLen)) {
-      throw new Error('Kernel config missing attention_tiered.decode_tiered_f16 maxKVLen');
-    }
-    _tieredMaxKVLen = maxKVLen;
-  }
-  return _tieredMaxKVLen;
+  return getRequiredVariantMaxKVLen('attention_tiered', 'decode_tiered_f16', 'attention_tiered.decode_tiered_f16');
 }
 
-let _tieredQuantMaxKVLen = null;
-
 function getTieredQuantMaxKVLen() {
-  if (_tieredQuantMaxKVLen === null) {
-    const config = getKernelConfig('attention_tiered_quant', 'decode_tiered_int8_f16kv');
-    const maxKVLen = config.variantMetadata?.maxKVLen;
-    if (!Number.isFinite(maxKVLen)) {
-      throw new Error('Kernel config missing attention_tiered_quant.decode_tiered_int8_f16kv maxKVLen');
-    }
-    _tieredQuantMaxKVLen = maxKVLen;
-  }
-  return _tieredQuantMaxKVLen;
+  return getRequiredVariantMaxKVLen(
+    'attention_tiered_quant',
+    'decode_tiered_int8_f16kv',
+    'attention_tiered_quant.decode_tiered_int8_f16kv'
+  );
 }
 
 

package/src/gpu/kernels/backward/adam.js

@@ -25,60 +25,62 @@ async function runAdamChunked(device, pipeline, params, grads, moment1, moment2,
     const gradsChunkBuffer = acquireBuffer(chunkBytes, undefined, 'adam_grads_chunk');
     const mChunkBuffer = acquireBuffer(chunkBytes, undefined, 'adam_m_chunk');
     const vChunkBuffer = acquireBuffer(chunkBytes, undefined, 'adam_v_chunk');
-
-    const copyIn = device.createCommandEncoder();
-    copyIn.copyBufferToBuffer(params.buffer, chunkOffsetBytes, paramsChunkBuffer, 0, chunkBytes);
-    copyIn.copyBufferToBuffer(grads.buffer, chunkOffsetBytes, gradsChunkBuffer, 0, chunkBytes);
-    copyIn.copyBufferToBuffer(moment1.buffer, chunkOffsetBytes, mChunkBuffer, 0, chunkBytes);
-    copyIn.copyBufferToBuffer(moment2.buffer, chunkOffsetBytes, vChunkBuffer, 0, chunkBytes);
-    device.queue.submit([copyIn.finish()]);
-
-    const paramsChunk = createTensor(paramsChunkBuffer, params.dtype, [chunkCount], 'adam_params_chunk');
-    const gradsChunk = createTensor(gradsChunkBuffer, grads.dtype, [chunkCount], 'adam_grads_chunk');
-    const mChunk = createTensor(mChunkBuffer, moment1.dtype, [chunkCount], 'adam_m_chunk');
-    const vChunk = createTensor(vChunkBuffer, moment2.dtype, [chunkCount], 'adam_v_chunk');
-
-    const uniformBuffer = createUniformBufferWithView(
-      'adam_uniforms_chunk',
-      32,
-      (view) => {
-        view.setUint32(0, chunkCount, true);
-        view.setUint32(4, options.step, true);
-        view.setFloat32(8, options.lr, true);
-        view.setFloat32(12, options.beta1, true);
-        view.setFloat32(16, options.beta2, true);
-        view.setFloat32(20, options.eps, true);
-      },
-      null,
-      device
-    );
-
-    const bindGroup = device.createBindGroup({
-      label: 'adam_bind_group_chunk',
-      layout: pipeline.getBindGroupLayout(0),
-      entries: [
-        { binding: 0, resource: { buffer: uniformBuffer } },
-        { binding: 1, resource: { buffer: paramsChunk.buffer } },
-        { binding: 2, resource: { buffer: gradsChunk.buffer } },
-        { binding: 3, resource: { buffer: mChunk.buffer } },
-        { binding: 4, resource: { buffer: vChunk.buffer } },
-      ],
-    });
-
-    const workgroups = Math.ceil(chunkCount / WORKGROUP_SIZES.DEFAULT);
-    dispatch(device, pipeline, bindGroup, workgroups, 'adam_chunk');
-    uniformBuffer.destroy();
-
-    const copyOut = device.createCommandEncoder();
-    copyOut.copyBufferToBuffer(paramsChunk.buffer, 0, params.buffer, chunkOffsetBytes, chunkBytes);
-    copyOut.copyBufferToBuffer(mChunk.buffer, 0, moment1.buffer, chunkOffsetBytes, chunkBytes);
-    copyOut.copyBufferToBuffer(vChunk.buffer, 0, moment2.buffer, chunkOffsetBytes, chunkBytes);
-    device.queue.submit([copyOut.finish()]);
-
-    releaseBuffer(paramsChunkBuffer);
-    releaseBuffer(gradsChunkBuffer);
-    releaseBuffer(mChunkBuffer);
-    releaseBuffer(vChunkBuffer);
+    let uniformBuffer = null;
+    try {
+      const copyIn = device.createCommandEncoder();
+      copyIn.copyBufferToBuffer(params.buffer, chunkOffsetBytes, paramsChunkBuffer, 0, chunkBytes);
+      copyIn.copyBufferToBuffer(grads.buffer, chunkOffsetBytes, gradsChunkBuffer, 0, chunkBytes);
+      copyIn.copyBufferToBuffer(moment1.buffer, chunkOffsetBytes, mChunkBuffer, 0, chunkBytes);
+      copyIn.copyBufferToBuffer(moment2.buffer, chunkOffsetBytes, vChunkBuffer, 0, chunkBytes);
+      device.queue.submit([copyIn.finish()]);
+
+      const paramsChunk = createTensor(paramsChunkBuffer, params.dtype, [chunkCount], 'adam_params_chunk');
+      const gradsChunk = createTensor(gradsChunkBuffer, grads.dtype, [chunkCount], 'adam_grads_chunk');
+      const mChunk = createTensor(mChunkBuffer, moment1.dtype, [chunkCount], 'adam_m_chunk');
+      const vChunk = createTensor(vChunkBuffer, moment2.dtype, [chunkCount], 'adam_v_chunk');
+
+      uniformBuffer = createUniformBufferWithView(
+        'adam_uniforms_chunk',
+        32,
+        (view) => {
+          view.setUint32(0, chunkCount, true);
+          view.setUint32(4, options.step, true);
+          view.setFloat32(8, options.lr, true);
+          view.setFloat32(12, options.beta1, true);
+          view.setFloat32(16, options.beta2, true);
+          view.setFloat32(20, options.eps, true);
+        },
+        null,
+        device
+      );
+
+      const bindGroup = device.createBindGroup({
+        label: 'adam_bind_group_chunk',
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: uniformBuffer } },
+          { binding: 1, resource: { buffer: paramsChunk.buffer } },
+          { binding: 2, resource: { buffer: gradsChunk.buffer } },
+          { binding: 3, resource: { buffer: mChunk.buffer } },
+          { binding: 4, resource: { buffer: vChunk.buffer } },
+        ],
+      });
+
+      const workgroups = Math.ceil(chunkCount / WORKGROUP_SIZES.DEFAULT);
+      dispatch(device, pipeline, bindGroup, workgroups, 'adam_chunk');
+
+      const copyOut = device.createCommandEncoder();
+      copyOut.copyBufferToBuffer(paramsChunk.buffer, 0, params.buffer, chunkOffsetBytes, chunkBytes);
+      copyOut.copyBufferToBuffer(mChunk.buffer, 0, moment1.buffer, chunkOffsetBytes, chunkBytes);
+      copyOut.copyBufferToBuffer(vChunk.buffer, 0, moment2.buffer, chunkOffsetBytes, chunkBytes);
+      device.queue.submit([copyOut.finish()]);
+    } finally {
+      uniformBuffer?.destroy();
+      releaseBuffer(paramsChunkBuffer);
+      releaseBuffer(gradsChunkBuffer);
+      releaseBuffer(mChunkBuffer);
+      releaseBuffer(vChunkBuffer);
+    }
   }
 }
 
@@ -143,10 +145,12 @@ export async function runAdam(
     ],
   });
 
-  const workgroups = Math.ceil(inferredCount / WORKGROUP_SIZES.DEFAULT);
-  dispatch(device, pipeline, bindGroup, workgroups, 'adam');
-
-  uniformBuffer.destroy();
+  try {
+    const workgroups = Math.ceil(inferredCount / WORKGROUP_SIZES.DEFAULT);
+    dispatch(device, pipeline, bindGroup, workgroups, 'adam');
+  } finally {
+    uniformBuffer.destroy();
+  }
 
   return createTensor(params.buffer, params.dtype, [...params.shape], 'adam_params');
 }