Compromis de la mémoire globale

Global memory is the GPU's main DRAM, often many gigabytes. It is where your big input and output arrays naturally live during a kernel.

Every thread in every block can read and write global memory. That shared visibility is exactly why you copy your data there before launching. 🌍

You reserve global memory from the host with cudaMalloc, which hands you a device pointer to that DRAM region.

The catch is latency. A single global memory read can cost hundreds of clock cycles, far more than a register access ever would.

Many kernels are bound not by math but by how fast bytes flow from DRAM. We call these memory-bound kernels.

The GPU hides slow reads by switching to other ready warps while one waits. This latency hiding is why having many threads matters so much.

Data in global memory stays put between kernel launches until you free it. You can run several kernels over the same buffers.

A unified L2 cache sits in front of global memory for the whole GPU. Reused addresses can be served from it instead of slow DRAM.

How threads map to addresses hugely affects throughput. Neighboring threads touching neighboring addresses is what later lessons call coalescing.

The core strategy is simple: touch global memory as few times as possible. Read once, reuse on-chip, then write once.

Because global memory is a finite resource, release it with cudaFree when you are done to avoid leaking device memory.

Which statement best captures the tradeoff of global memory?

You now know global memory is the GPU's large, all-visible DRAM that trades capacity for high latency. Touch it rarely and reuse data on-chip. 🚀