Threads, blocs et grilles

A GPU runs your kernel as many tiny workers. Each single worker is a thread, and it usually handles one piece of data.

Threads are organized into a block. Threads in the same block can cooperate and share fast on-chip memory.

All the blocks for one kernel launch form the grid. The grid is the full set of workers handling your whole problem.

The model nests neatly: threads live in blocks, and blocks live in a grid. Three levels describe every launch.

Every thread can ask where it sits. Its index tells it which element of the data it is responsible for.

Blocks are numbered as well. A thread combines its block id with its local id to find a unique spot.

The classic formula maps each thread to one global element. This global index is how kernels split an array.

You pick how many threads sit in a block. A good size keeps the hardware busy without wasting resources.

The grid must cover all your data. You size it so threads times blocks reach every element you need.

The grid often launches a few extra threads. A simple bounds check stops them from touching memory past the end.

Blocks let groups share memory and sync, while the grid scales to any size. The structure maps work onto hardware cleanly.

A thread needs the position of its element across the whole array.

Threads group into blocks, blocks form the grid, and combining their ids gives each worker a unique global index. 🧵