WebGPU Compute Pipeline Memory Barrier & Worker Synchronization Standard

--- description: WebGPU Compute Pipeline Memory Barrier & Worker Synchronization Standard - Mandates deterministic execution ordering and explicit memory barrier synchronization for multi-stage compute passes and OffscreenCanvas frame transfers across Web Worker threads. Prevents Read-After-Write (RAW) tensor buffer hazards and cross-thread race conditions during client-side local LLM inference by enforcing explicit queue submission fencing, staging buffer lifecycle management, and synchronized buffer mapping. globs: src/**/*.{ts,tsx,worker.ts} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/webgpu-compute-worker-memory-barrier-sync" --- # WebGPU Compute Pipeline Memory Barrier & Worker Synchronization Standard > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Unfenced Cross-Worker Buffer Re-use and Asynchronous Compute Race Hazards ## System Constraints You are a Principal Software Architect enforcing WebGPU memory barriers and synchronization protocols for Web Worker-based compute pipelines. You must reject any code that assumes WebGPU queue submissions execute synchronously on the JavaScript thread, any concurrent staging-buffer mappings that lack explicit fence awaits (`onSubmittedWorkDone`), and any unsynchronized transfer of tensor buffers or OffscreenCanvas bitmaps across worker threads. ## Strict Guidelines - Engineers MUST ALWAYS await `device.queue.onSubmittedWorkDone()` before reading back tensor output buffers via `mapAsync` or signaling worker synchronization primitives. - Engineers MUST NOT dispatch subsequent compute passes that depend on mutating storage buffers across independent command buffers without explicit pipeline dependencies or queue fencing. - Code SHOULD consolidate dependent tensor operations (e.g., GEMM followed by Softmax) into a single `GPUCommandEncoder` pass sequence to leverage implicit hardware execution barriers within a single submission. - Services MUST explicitly call `buffer.unmap()` before submitting commands that bind mapped storage or staging buffers to prevent runtime GPU validation errors. - Components NEVER pass uncommitted `OffscreenCanvas` frames or in-flight compute buffers to another thread via `postMessage` without establishing a synchronized GPU timeline fence. ## Bad vs Good Implementations ### Compute Dispatch and Buffer Synchronization in Web Worker #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Calling `mapAsync` immediately following `queue.submit` without synchronizing via `onSubmittedWorkDone` or isolating mapping state can trigger map collisions, race conditions with ongoing GPU compute dispatches, or data corruption when consecutive tokens are generated in client-side LLM inference. ```typescript export async function runInferencePass(device: GPUDevice, computePipeline: GPUComputePipeline, inputBuffer: GPUBuffer, outputBuffer: GPUBuffer, stagingBuffer: GPUBuffer): Promise<Float32Array> { const encoder = device.createCommandEncoder(); const pass = encoder.beginComputePass(); pass.setPipeline(computePipeline); // Bind groups set here... pass.dispatchWorkgroups(64, 1, 1); pass.end(); // Copy compute output to staging buffer encoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, stagingBuffer.size); device.queue.submit([encoder.finish()]); // BUG: Attempting to map stagingBuffer immediately after submit without fence. // This triggers race conditions and potential GPU validation aborts during tensor readback. await stagingBuffer.mapAsync(GPUMapMode.READ); const data = new Float32Array(stagingBuffer.getMappedRange().slice(0)); stagingBuffer.unmap(); return data; } ``` #### Production Standard (Correct) > **Standard**: Ensures that all prior compute operations and copy dispatches are completely executed by the GPU device by awaiting `device.queue.onSubmittedWorkDone()` before calling `mapAsync`, providing deterministic memory reads and preventing data corruption. ```typescript export async function runInferencePass(device: GPUDevice, computePipeline: GPUComputePipeline, inputBuffer: GPUBuffer, outputBuffer: GPUBuffer, stagingBuffer: GPUBuffer): Promise<Float32Array> { const encoder = device.createCommandEncoder({ label: 'llm_tensor_compute_encoder' }); const pass = encoder.beginComputePass({ label: 'gemm_compute_pass' }); pass.setPipeline(computePipeline); // Bind groups set here... pass.dispatchWorkgroups(64, 1, 1); pass.end(); // Enforce memory transfer within the same deterministic queue submission encoder.copyBufferToBuffer(outputBuffer, 0, stagingBuffer, 0, stagingBuffer.size); const commandBuffer = encoder.finish(); device.queue.submit([commandBuffer]); // Deterministic synchronization barrier ensuring GPU execution is complete await device.queue.onSubmittedWorkDone(); await stagingBuffer.mapAsync(GPUMapMode.READ, 0, stagingBuffer.size); const copy = new Float32Array(stagingBuffer.getMappedRange().slice(0)); stagingBuffer.unmap(); return copy; } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: WebGPU Compute Pipeline Memory Barrier & Worker Synchronization Standard

WebGPU Compute Pipeline Memory Barrier & Worker Synchronization Standard defines an industrial-grade behavioral standard for frontend engineering. Mandates deterministic execution ordering and explicit memory barrier synchronization for multi-stage compute passes and OffscreenCanvas frame transfers across Web Worker threads. Prevents Read-After-Write (RAW) tensor buffer hazards and cross-thread race conditions during client-side local LLM inference by enforcing explicit queue submission fencing, staging buffer lifecycle management, and synchronized buffer mapping. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Unfenced Cross-Worker Buffer Re-use and Asynchronous Compute Race Hazards Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Unfenced Cross-Worker Buffer Re-use and Asynchronous Compute Race Hazards	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS await `device.queue.onSubmittedWorkDone()` before reading back tensor output buffers via `mapAsync` or signaling worker synchronization primitives.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.