Die Host-Seite verdrahten

The kernel does the math, but the host CPU sets everything up. Its job is allocate, copy in, launch, copy back, and free. 🧩

You keep host pointers for CPU arrays and separate device pointers for GPU buffers. A common habit is naming them h_A and d_A.

First prepare your data in normal host memory. Here you just initialize h_A and h_B with values the GPU will add later.

The GPU needs its own buffers, so call cudaMalloc for each array. Note the size is in bytes, computed as count times sizeof(float).

Move your input arrays to the GPU with cudaMemcpy and the HostToDevice direction. The kernel can only see data that lives on the device.

Pick a thread count per block, then compute how many blocks cover all elements. Rounding up guarantees every element gets a thread.

Now fire the kernel with the triple-angle-bracket syntax, passing your device pointers. This call returns immediately while the GPU works.

When the kernel finishes, bring C back with cudaMemcpyDeviceToHost. This copy also waits for the launch to complete first.

GPU memory is not garbage collected, so release every buffer with cudaFree. Skipping this leaks memory that lasts until the process exits.

Always follow the same sequence: allocate, copy in, launch, copy back, free. Swap steps and the kernel reads stale or invalid data.

Notice the host side is ordinary C++ plus a handful of cuda calls. There is no special compiler magic beyond the kernel launch.

What must happen before you can launch the vecAdd kernel?

You wired the host side end to end: two pointer sets, cudaMalloc, copy up, launch, copy back, and cudaFree. The boilerplate that powers every kernel. ✅