GPU Occupancy Calculator

Topic Overview

What Occupancy Measures

Occupancy is the ratio of active warps on an SM to the maximum warps the SM can hold. Higher occupancy means more warps are available to hide memory latency, but it is not the only performance metric. A kernel with 100% occupancy can still be slow if every thread does redundant work.

The formula is straightforward:

cCopy
Loading…

For example, if an SM supports 48 warps and your kernel places 24 warps on it, occupancy is 50%.

Three Limits That Cap Block Count

Three resources compete to determine how many thread blocks fit on one SM:

1. Registers per thread: fixed register file divided by registers_per_thread * threads_per_block
2. Shared memory per block: fixed shared pool divided by bytes requested per block
3. Warps per block: threads_per_block / 32, capped by max warps per SM

If a kernel uses 128 registers per thread with 512 threads per block, register demand alone may allow only one block on a 64K-register SM. Shared memory can be the bottleneck too: four blocks at 24KB each fill a 96KB pool even when registers are plentiful.

• Memory-bound kernels usually need high occupancy to hide VRAM latency
• Compute-bound kernels may tolerate lower occupancy if each thread does heavy math
• Block size must be a multiple of 32 (warp size)

For This Exercise

You will read registers_per_thread, shared_memory_per_block, and threads_per_block from stdin and compute occupancy, identifying whether registers, shared memory, or warps is the limiting factor. This task asks you to test three configurations and explain whether higher occupancy would help. The calculator you build mirrors what nvcc --ptxas-options=-v reports when CUDA authors debug register pressure.

Your Task

Write the core of NVIDIA's occupancy calculator. Given a GPU architecture and a kernel's launch shape (threads per block, registers per thread, shared memory per block), compute how many blocks fit on one SM under each resource limit, the resulting occupancy (active warps / max warps), which resource is the limiter, and what change would fit one more block.

Architectures

All of them allow at most 1024 threads per block and 255 registers per thread. The default is sm_80.

Input

# starts a comment.

cCopy
Loading…

Formulas

• warps per block: ceil(THREADS / 32).
• by warps: floor(max_warps / wpb). by blocks: max_blocks.
• by registers: registers per warp = REGS × 32 rounded up to the reg unit; blocks = floor(floor(65536 / regs_per_warp) / wpb).
• by shared memory: bytes per block = SHARED + reserved rounded up to the shared unit; blocks = floor(shared_per_SM / bytes). With 0 bytes per block, there is no limit.
• Result: active blocks = the minimum of the four; active warps = blocks × wpb; occupancy = active warps / max warps, as a percentage rounded half up to 1 decimal.
• Limiters: every limit equal to the minimum, in the order warps, blocks per SM, registers, shared memory, joined with and.
• Hints: only when occupancy is below 100% and neither the warp nor the block limit binds.
  • If registers limit: the largest register count below REGS whose register limit exceeds the active blocks.
  • If shared memory limits (and SHARED > 0): floor(shared_per_SM / (active+1)) rounded down to the shared unit, minus the reserved bytes. Print it only if it is ≥ 0 and below SHARED.

Output

cCopy
Loading…

• Shared line: incl. N reserved appears only when the architecture reserves memory. unlimited (0 B per block) replaces the block count when no shared memory is used.
• Active line: when active is 0, it gets (the kernel cannot launch) before - limited by.
• Plurals: block/blocks everywhere.
• Errors:
  • gpu: sm_75, sm_80, sm_86 or sm_90
  • kernel: THREADS REGS SHARED_BYTES
  • kernel: threads per block must be 1-1024
  • kernel: registers per thread must be 1-255
  • kernel: shared memory per block must be 0-MAX bytes
  • unknown command X

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Apply the allocation granularities before dividing. Resources are handed out in units, so 33 registers cost as much as 40.
2. Report every tied limiter. Fixing only one of two binding limits does not raise occupancy.

Hidden tests cover an architecture without reserved shared memory, a 255-register kernel that cannot launch, a shared-memory-limited kernel with its hint, a block-count-limited small kernel, tied limiters, and every input error.