Memoria constante y su caché

Constant memory is a small region built for data that every thread reads but none of them ever writes during a kernel.

You mark a global-scope array with the __constant__ qualifier. It lives outside any function, visible to all your kernels.

Total constant memory is only 64 KB on typical GPUs. It is meant for coefficients and parameters, not for large datasets.

You write to constant memory from the CPU using cudaMemcpyToSymbol, since kernels themselves cannot modify it.

Reads flow through a dedicated constant cache on each multiprocessor. A cached value comes back almost as fast as a register.

When a whole warp reads the same address, the hardware does one fetch and broadcasts it to all 32 threads in a single step. 📡

The win depends on uniform access. If threads in a warp read different constant addresses, those reads serialize and the speedup is lost.

Inside a kernel you read constant memory like any array. The compiler quietly routes the access through the fast constant cache.

Convolution kernels and lookup tables shine here, because every thread reuses the same small set of coefficients over and over.

You typically upload to constant memory a single time, then launch many kernels that all read those unchanging values cheaply.

Skip constant memory if your data is large or if threads read scattered addresses. In those cases plain global memory serves you better.

When does constant memory give its biggest speedup?

You learned constant memory is a tiny read-only space whose cache broadcasts uniform reads to a whole warp. Use it for small, shared values. ✨