什么是内存事务

The GPU never fetches a single byte by itself. It moves memory in fixed-size blocks called a memory transaction, even if you only asked for one value.

A warp of 32 threads issues its loads at the same time. The hardware gathers all 32 requests and tries to serve them with as few transactions as possible.

Global memory is carved into aligned segments, commonly 32 or 128 bytes wide. Each transaction pulls in one whole segment, never a partial slice.

A 128-byte line holds exactly 32 four-byte floats. That is one value for every thread in a warp, so a tidy warp can be served by a single transaction.

Segments start at fixed, aligned addresses. If your data begins mid-segment, a single warp can spill across two lines and force an extra transaction.

If a warp touches only a few bytes of a 128-byte line, the GPU still moves all 128. The unused bytes are wasted bandwidth you paid for anyway.

Performance often comes down to one number: how many transactions a warp needs. Fewer transactions means you read less and finish faster.

When 32 threads read 32 neighboring floats from an aligned address, the GPU answers with one clean 128-byte line. That is the ideal single transaction.

If each thread grabs a value far from its neighbors, the warp may trigger up to 32 separate transactions, dragging in 32 full lines for tiny use.

Most kernels are bound by how fast they move memory, not by math. Shrinking transaction count directly raises your effective bandwidth. 🚀

Now you know the unit of cost: the segment-sized transaction. Every coalescing trick ahead is really about packing warps into as few of these as you can.

Test your grasp of transaction size.

You learned that the GPU moves memory in fixed segments, and a warp is served by as few transactions as it can manage. Fewer transactions, faster kernel. 🎉