@simulatte/doppler 0.1.6 → 0.1.8

package/src/gpu/command-recorder.js

@@ -3,7 +3,7 @@
 import { getDevice, hasFeature, FEATURES } from './device.js';
 import { allowReadback, trackAllocation } from './perf-guards.js';
 import { getUniformCache } from './uniform-cache.js';
-import { isBufferActive, releaseBuffer } from '../memory/buffer-pool.js';
+import { isBufferActive, releaseBuffer, discardBuffer } from '../memory/buffer-pool.js';
 import { log } from '../debug/index.js';
 import { getRuntimeConfig } from '../config/runtime.js';
 
@@ -93,6 +93,9 @@ export class CommandRecorder {
 
   
   #initProfiling() {
+    let querySet = null;
+    let queryBuffer = null;
+    let readbackBuffer = null;
     try {
       const runtimeProfiler = getRuntimeConfig().shared?.debug?.profiler;
       if (!runtimeProfiler) {
@@ -119,25 +122,31 @@ export class CommandRecorder {
         didLogQueryFallback = true;
       }
 
-      this.#querySet = this.device.createQuerySet({
+      querySet = this.device.createQuerySet({
         type: 'timestamp',
         count: this.#queryCapacity,
       });
 
       // Buffer to hold query results (8 bytes per timestamp = BigUint64)
-      this.#queryBuffer = this.device.createBuffer({
+      queryBuffer = this.device.createBuffer({
         label: `${this.label}_query_buffer`,
         size: this.#queryCapacity * 8,
         usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
       });
 
       // Readback buffer
-      this.#readbackBuffer = this.device.createBuffer({
+      readbackBuffer = this.device.createBuffer({
         label: `${this.label}_readback_buffer`,
         size: this.#queryCapacity * 8,
         usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
       });
+      this.#querySet = querySet;
+      this.#queryBuffer = queryBuffer;
+      this.#readbackBuffer = readbackBuffer;
     } catch (e) {
+      readbackBuffer?.destroy();
+      queryBuffer?.destroy();
+      querySet?.destroy();
       log.warn('CommandRecorder', `Failed to initialize profiling: ${e}`);
       this.#profilingEnabled = false;
     }
@@ -277,39 +286,57 @@ export class CommandRecorder {
     }
   }
 
+  #finalizeTrackedBuffers(buffersToDestroy, buffersToRelease, discardPooled) {
+    for (const buffer of buffersToDestroy) {
+      buffer.destroy();
+    }
+    for (const buffer of buffersToRelease) {
+      if (discardPooled) {
+        discardBuffer(buffer);
+      } else {
+        releaseBuffer(buffer);
+      }
+    }
+    getUniformCache().flushPendingDestruction();
+  }
+
+  #takeTrackedBuffers() {
+    const buffersToDestroy = this.#tempBuffers;
+    const buffersToRelease = this.#pooledBuffers;
+    this.#tempBuffers = [];
+    this.#pooledBuffers = [];
+    this.#tempBufferSet.clear();
+    this.#pooledBufferSet.clear();
+    return { buffersToDestroy, buffersToRelease };
+  }
+
   
   submit() {
     if (this.#submitted) {
       throw new Error('[CommandRecorder] Already submitted');
     }
 
-    // Submit commands
     const submitStart = performance.now();
-    this.device.queue.submit([this.#encoder.finish()]);
+    const { buffersToDestroy, buffersToRelease } = this.#takeTrackedBuffers();
+    try {
+      this.device.queue.submit([this.#encoder.finish()]);
+    } catch (error) {
+      this.#submitted = true;
+      this.#submitStartMs = submitStart;
+      this.#finalizeTrackedBuffers(buffersToDestroy, buffersToRelease, false);
+      this.#destroyProfilingResources();
+      throw error;
+    }
+
     this.#submitted = true;
     this.#submitStartMs = submitStart;
 
-    const buffersToDestroy = this.#tempBuffers;
-    const buffersToRelease = this.#pooledBuffers;
-    this.#tempBuffers = [];
-    this.#pooledBuffers = [];
-    this.#tempBufferSet.clear();
-    this.#pooledBufferSet.clear();
-
     this.#cleanupPromise = this.device.queue.onSubmittedWorkDone().then(() => {
       this.#submitLatencyMs = performance.now() - submitStart;
-      // Destroy buffers created directly by the recorder
-      for (const buffer of buffersToDestroy) {
-        buffer.destroy();
-      }
-      // Release pooled buffers back to the pool
-      for (const buffer of buffersToRelease) {
-        releaseBuffer(buffer);
-      }
-      // Safe to destroy evicted uniform buffers now that GPU work is complete
-      getUniformCache().flushPendingDestruction();
+      this.#finalizeTrackedBuffers(buffersToDestroy, buffersToRelease, false);
     }).catch((err) => {
       log.warn('CommandRecorder', `Deferred cleanup failed: ${ (err).message}`);
+      this.#finalizeTrackedBuffers(buffersToDestroy, buffersToRelease, true);
     });
   }
 
@@ -370,55 +397,53 @@ export class CommandRecorder {
     }
 
     if (this.#profileEntries.length === 0) {
+      this.#destroyProfilingResources();
       return {};
     }
 
-    // Wait for GPU work to complete
-    await this.device.queue.onSubmittedWorkDone();
+    let mapped = false;
 
-    // Resolve queries to buffer
-    const maxIndex = Math.max(...this.#profileEntries.map(e => e.endQueryIndex)) + 1;
-    const resolveEncoder = this.device.createCommandEncoder({ label: 'profile_resolve' });
-    resolveEncoder.resolveQuerySet(this.#querySet, 0, maxIndex, this.#queryBuffer, 0);
-    resolveEncoder.copyBufferToBuffer(this.#queryBuffer, 0, this.#readbackBuffer, 0, maxIndex * 8);
-    this.device.queue.submit([resolveEncoder.finish()]);
-
-    if (!allowReadback('CommandRecorder.resolveProfileTimings')) {
-      return null;
-    }
-
-    // Read back timestamps
-    await this.#readbackBuffer.mapAsync(GPUMapMode.READ);
-    const timestamps = new BigUint64Array(this.#readbackBuffer.getMappedRange());
+    try {
+      await this.device.queue.onSubmittedWorkDone();
 
-    // Aggregate timings by label
-    
-    const timings = {};
+      const maxIndex = Math.max(...this.#profileEntries.map(e => e.endQueryIndex)) + 1;
+      const resolveEncoder = this.device.createCommandEncoder({ label: 'profile_resolve' });
+      resolveEncoder.resolveQuerySet(this.#querySet, 0, maxIndex, this.#queryBuffer, 0);
+      resolveEncoder.copyBufferToBuffer(this.#queryBuffer, 0, this.#readbackBuffer, 0, maxIndex * 8);
+      this.device.queue.submit([resolveEncoder.finish()]);
 
-    for (const entry of this.#profileEntries) {
-      const startNs = timestamps[entry.startQueryIndex];
-      const endNs = timestamps[entry.endQueryIndex];
-      const durationMs = Number(endNs - startNs) / 1_000_000;
+      if (!allowReadback('CommandRecorder.resolveProfileTimings')) {
+        return null;
+      }
 
-      // Skip invalid timings
-      if (durationMs < 0 || durationMs > 60000) {
-        continue;
+      await this.#readbackBuffer.mapAsync(GPUMapMode.READ);
+      mapped = true;
+      const timestamps = new BigUint64Array(this.#readbackBuffer.getMappedRange());
+      const timings = {};
+
+      for (const entry of this.#profileEntries) {
+        const startNs = timestamps[entry.startQueryIndex];
+        const endNs = timestamps[entry.endQueryIndex];
+        const durationMs = Number(endNs - startNs) / 1_000_000;
+
+        if (durationMs < 0 || durationMs > 60000) {
+          continue;
+        }
+
+        if (timings[entry.label] !== undefined) {
+          timings[entry.label] += durationMs;
+        } else {
+          timings[entry.label] = durationMs;
+        }
       }
 
-      // Aggregate by label
-      if (timings[entry.label] !== undefined) {
-        timings[entry.label] += durationMs;
-      } else {
-        timings[entry.label] = durationMs;
+      return timings;
+    } finally {
+      if (mapped && this.#readbackBuffer) {
+        this.#readbackBuffer.unmap();
       }
+      this.#destroyProfilingResources();
     }
-
-    this.#readbackBuffer.unmap();
-
-    // Clean up profiling resources after use
-    this.#destroyProfilingResources();
-
-    return timings;
   }
 
   

package/src/gpu/device.d.ts

@@ -82,6 +82,7 @@ export function initDevice(): Promise<GPUDevice>;
 
 /**
  * Register an externally created GPU device for pipeline use.
+ * The active device epoch advances and loss handling is attached to the device.
  */
 export function setDevice(
   device: GPUDevice | null,

package/src/gpu/device.js

@@ -28,16 +28,47 @@ function advanceDeviceEpoch() {
   deviceEpoch += 1;
 }
 
+function clearActiveDeviceState() {
+  gpuDevice = null;
+  kernelCapabilities = null;
+  resolvedPlatformConfig = null;
+  platformInitialized = false;
+}
+
 function isValidGPUBuffer(value) {
   if (!value) {
     return false;
   }
+  if (value.__dopplerFakeGPUBuffer === true) {
+    return true;
+  }
+  if (
+    typeof value === 'object'
+    && value.constructor?.name === 'FakeBuffer'
+    && typeof value.size === 'number'
+    && typeof value.usage === 'number'
+    && typeof value.destroy === 'function'
+  ) {
+    return true;
+  }
   if (typeof GPUBuffer === 'undefined') {
     return true;
   }
   return value instanceof GPUBuffer;
 }
 
+function isUsableGPUDevice(device) {
+  return !!(
+    device
+    && typeof device.createBuffer === 'function'
+    && typeof device.createBindGroup === 'function'
+    && typeof device.createCommandEncoder === 'function'
+    && typeof device.createShaderModule === 'function'
+    && device.queue
+    && typeof device.queue.submit === 'function'
+  );
+}
+
 function describeBindGroupBufferValue(value) {
   if (value === null) return 'null';
   if (value === undefined) return 'undefined';
@@ -84,6 +115,39 @@ function wrapDeviceCreateBindGroup(device) {
   return device;
 }
 
+function registerDeviceLostHandler(device) {
+  if (!device || device.__dopplerLossHandlerRegistered) {
+    return device;
+  }
+
+  if (device.lost && typeof device.lost.then === 'function') {
+    const trackedDevice = device;
+    device.lost.then((info) => {
+      if (gpuDevice !== trackedDevice) {
+        return;
+      }
+      log.error('GPU', 'Device lost: ' + info.message + ', Reason: ' + info.reason);
+      clearActiveDeviceState();
+      advanceDeviceEpoch();
+    }).catch((error) => {
+      if (gpuDevice !== trackedDevice) {
+        return;
+      }
+      log.warn('GPU', 'Device lost handler failed: ' + (error?.message ?? error));
+      clearActiveDeviceState();
+      advanceDeviceEpoch();
+    });
+  }
+
+  Object.defineProperty(device, '__dopplerLossHandlerRegistered', {
+    value: true,
+    configurable: true,
+    enumerable: false,
+    writable: false,
+  });
+  return device;
+}
+
 
 export const FEATURES =  ({
   SHADER_F16: 'shader-f16',
@@ -219,7 +283,11 @@ async function initializePlatformAndRegistry(adapter) {
 export async function initDevice() {
   // Return cached device if available
   if (gpuDevice) {
-    return gpuDevice;
+    if (isUsableGPUDevice(gpuDevice)) {
+      return gpuDevice;
+    }
+    clearActiveDeviceState();
+    advanceDeviceEpoch();
   }
 
   if (!isWebGPUAvailable()) {
@@ -258,18 +326,9 @@ export async function initDevice() {
     throw createDopplerError(ERROR_CODES.GPU_DEVICE_FAILED, 'Failed to create WebGPU device');
   }
   wrapDeviceCreateBindGroup(gpuDevice);
+  registerDeviceLostHandler(gpuDevice);
   advanceDeviceEpoch();
 
-  // Set up device lost handler
-  gpuDevice.lost.then((info) => {
-    log.error('GPU', 'Device lost: ' + info.message + ', Reason: ' + info.reason);
-    gpuDevice = null;
-    kernelCapabilities = null;
-    resolvedPlatformConfig = null;
-    platformInitialized = false;
-    advanceDeviceEpoch();
-  });
-
   // Wrap queue for submit tracking (when enabled)
   wrapQueueForTracking(gpuDevice.queue);
 
@@ -301,16 +360,14 @@ export async function initDevice() {
 
 export function setDevice(device, options = {}) {
   if (!device) {
-    gpuDevice = null;
-    kernelCapabilities = null;
-    resolvedPlatformConfig = null;
-    platformInitialized = false;
+    clearActiveDeviceState();
     advanceDeviceEpoch();
     return;
   }
 
   gpuDevice = device;
   wrapDeviceCreateBindGroup(gpuDevice);
+  registerDeviceLostHandler(gpuDevice);
   advanceDeviceEpoch();
   wrapQueueForTracking(gpuDevice.queue);
 
@@ -372,10 +429,7 @@ export function isPlatformInitialized() {
 export function destroyDevice() {
   if (gpuDevice) {
     gpuDevice.destroy();
-    gpuDevice = null;
-    kernelCapabilities = null;
-    resolvedPlatformConfig = null;
-    platformInitialized = false;
+    clearActiveDeviceState();
     advanceDeviceEpoch();
   }
 }