Compute Shader

What is a Compute Shader

A compute shader is a programmable shader that allows developers to leverage the massive parallel computing power of the GPU for general-purpose tasks, not just graphics rendering. It runs on a separate compute pipeline and can read and write buffers and textures, making it suitable for data-parallel problems.

Core Concepts

Threads and Work Groups

Compute shaders use threads as the basic execution unit, and threads are organized into work groups. Threads within a work group can communicate and synchronize via shared memory. All work groups form a global dispatch space, typically identified by three-dimensional indices (x, y, z).

Shader Storage Objects

Compute shaders can access various resources:

• **Structured Buffer**: Stores custom data structures.
• **Raw Buffer**: Stores raw byte data.
• **RWTexture**: Read-write texture, directly accessible without the rendering pipeline.
• **Constant Buffer**: Passes constant parameters.

Synchronization Mechanisms

Threads within a work group can synchronize via barriers to ensure consistency of shared memory. Different work groups cannot synchronize directly; coordination often requires multiple dispatches or atomic operations.

Difference from Graphics Pipeline

Compute shaders are independent of the graphics pipeline, with no fixed input assembly, rasterization, etc. They are dispatched directly by the application without binding vertex buffers or render targets. Thus, they are more suitable for non-graphics tasks but can also optimize graphics-related computations (e.g., culling, LOD generation).

Application Scenarios

Post-processing and Image Processing

Compute shaders are commonly used for effects like blur, tone mapping, histogram calculation, offering more flexibility and efficiency than full-screen quad pixel shaders.

Particle Systems

Simulate massive particles' movement and collision, storing particle states in buffers, with compute shaders updating positions and velocities.

Physics Simulation

Cloth, fluids, soft bodies, etc., using parallelism to accelerate numerical computation.

Culling and Scene Management

Perform frustum culling and occlusion culling in compute shaders to reduce draw calls.

General-Purpose Computing

Sorting, matrix operations, neural network inference, similar to GPGPU.

Programming Model and APIs

In DirectX 11+, use HLSL to write compute shaders and call via `Dispatch`; in OpenGL 4.3+, use GLSL and call via `glDispatchCompute`. Shader code must declare `numthreads` to specify work group size. Typical workflow:

1. Create and compile the compute shader.
2. Bind input/output resources (UAV, SRV, etc.).
3. Call `Dispatch` specifying the number of work groups.
4. GPU executes the shader, results written back to resources.

Advantages and Challenges

**Advantages**:

• Highly parallel, suitable for data-parallel tasks.
• Bypasses graphics pipeline, reducing fixed-function overhead.
• Shared memory accelerates communication within work groups.

**Challenges**:

• Requires understanding GPU architecture, carefully arranging work group sizes and memory access patterns.
• Debugging is difficult, requiring tools like NVIDIA Nsight or RenderDoc.
• Performance varies significantly across hardware.

Practical Tips

• Coalesce memory accesses, avoid random reads/writes.
• Choose appropriate work group size, usually 64 or 128 threads, but test.
• Use shared memory to reduce global memory traffic.
• Use multiple small dispatches instead of one large dispatch for better load balancing.