当我调用异步CUDA内核时，它的参数是如何复制的？

Question

Say I want to invoke a CUDA kernel, like this:

struct foo { int a; int b; float c; double d; }
foo arg;
// fill in elements of `arg` here
my_kernel<<<grid_size, block_size, 0, stream>>>(arg);

Assume that stream was previously created using a call to cudaStreamCreate() , so the above will execute asynchronously. I'm concerned about the required lifetime of arg .

Are the arguments to the kernel copied synchronously when I invoke it (so it would be safe for arg to go out of scope immediately), or are they copied asynchronously (so I need to ensure that it stays alive until the kernel runs)?

Answer 1

Arguments are copied synchronously at launch. The API exposes a call stack onto which execution parameters and function arguments are pushed in order, then a call finalises those arguments into a CUDA kernel launch on the drivers internal streams/command queues.

This process isn't documented, but as of CUDA 7.5, a runtime API kernel launch like this:

dot_product<<<1,n>>>(n, d_a, d_b);

becomes this:

(cudaConfigureCall(1, n)) ? (void)0 : (dot_product)(n, d_a, d_b);

where the host stub function dot_product is expanded into this:

void __device_stub__Z11dot_productiPfS_(int __par0, float *__par1, float *__par2)
{
    if (cudaSetupArgument((void *)(char *)&__par0, sizeof(__par0), (size_t)0UL) != cudaSuccess) return;
    if (cudaSetupArgument((void *)(char *)&__par1, sizeof(__par1), (size_t)8UL) != cudaSuccess) return;
    if (cudaSetupArgument((void *)(char *)&__par2, sizeof(__par2), (size_t)16UL) != cudaSuccess) return;
    {
        volatile static char *__f __attribute__((unused)); __f = ((char *)((void ( *)(int, float *, float *))dot_product)); 
        (void)cudaLaunch(((char *)((void ( *)(int, float *, float *))dot_product))); 
    };
}

void dot_product( int __cuda_0,float *__cuda_1,float *__cuda_2)
{
    __device_stub__Z11dot_productiPfS_( __cuda_0,__cuda_1,__cuda_2);
}

cudaSetupArgument is the API call which is pushing arguments onto the call stack. Interestingly, this is actually deprecated in the API documentation for CUDA 7.5, even though the compiler is using it. I would, therefore, expect this to change in the future, but the idea will be the same.

Answer 2

The parameters of the kernel call are copied prior to execution, so the scope schould be of no concern. But please note that the size of all kernel parameters cannot exceed a maximum size in bytes. If you want larger structs or blobs of data you need to allocate the used memory on the device using cudaMalloc, then copy the content of the host struct to the device struct using cudaMemcpy and call the kernel with a pointer to the new device struct.

Your code would look something like this:

struct foo { int a; int b; float c; double d; }
foo arg;
foo *arg_d;
// fill in elements of `arg` here

cudaMalloc(&arg_d, sizeof(foo));
// check the allocation here
cudaMemcpy(arg_d, &arg, sizeof(foo), cudaMemcpyHostToDevice);
my_kernel<<<grid_size, block_size, 0, stream>>>(arg_d);