cudaMemcpy不起作用

Question

In the following code there's the cudaMemcpy not working, it returns an error, and the program exits. What can be the problem? It doesn't seem to me I'm doing something illegal, and the size of the vectors seem fine to me.

It might be possible the algorithm does something wrong at some point but the idea is correct I guess. The code is to sum n numbers by doing some partial sums in parallel, and then re-iterate.

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include <iostream>

__device__ int aug_vec(int *vec, const int& i, const int& size) {
    return (i >= size) ? 0 : vec[i];
}

__global__ void sumVectorElements(int *vec,const int& size) {
    const int i = (blockDim.x*blockIdx.x + threadIdx.x);
    vec[i] = aug_vec(vec, 2*i, size) + aug_vec(vec, 2 * i + 1, size);
}

__host__ int parallel_sum(int *vec,const int& size) {

    cudaError_t err;
    int *d_vec, *cp_vec;
    int n_threads = (size >> 1) + (size & 1);

    cp_vec = new int[size];
    err = cudaMalloc((void**)&d_vec, size * sizeof(int));

    if (err != cudaSuccess) {
        std::cout << "error in cudaMalloc!" << std::endl;
        exit(1);
    }

    err = cudaMemcpy(d_vec, vec, size*sizeof(int), cudaMemcpyHostToDevice);

    if (err != cudaSuccess) {
        std::cout << "error in cudaMemcpy!" << std::endl;
        exit(1);
    }

    int curr_size = size;
    while (curr_size > 1) {
        std::cout << "size = " << curr_size << std::endl;
        sumVectorElements<<<1,n_threads>>>(d_vec, curr_size);
        curr_size = (curr_size >> 1) + (curr_size & 1);
    }

    err = cudaMemcpy(cp_vec, d_vec, size*sizeof(int), cudaMemcpyDeviceToHost); //THIS LINE IS THE PROBLEM!

    if (err != cudaSuccess) {
        std::cout << "error in cudaMemcpy" << std::endl;
        exit(1);
    }

    err = cudaFree(d_vec);

    if (err != cudaSuccess) {
        std::cout << "error in cudaFree" << std::endl;
        exit(1);
    }

    int rval = cp_vec[0];

    delete[] cp_vec;

    return rval;
}

int main(int argc, char **argv) {
    const int n_blocks = 1;
    const int n_threads_per_block = 12;

    int vec[12] = { 0 };
    for (auto i = 0; i < n_threads_per_block; ++i) vec[i] = i + 1;
    int sum = parallel_sum(vec, n_threads_per_block);
    std::cout << "Sum = " << sum << std::endl;

    system("pause");

    return 0;
}

Answer 1

The cudaMemcpy operation after the kernel is actually asynchronously reporting an error that is due to the kernel execution. Your error reporting is primitive. If you have an error code, you may get more useful information by printing out the result of passing that error code to cudaGetErrorString() .

The error is occurring in the kernel due to use of the reference argument:

__global__ void sumVectorElements(int *vec,const int& size) {
                                           ^^^^^^^^^^^^^^^

Any argument you pass to a kernel and expect to be usable in kernel code must refer to data that is passed by value, or else data that is accessible/referenceable from device code. For example, passing a host pointer to device code is generally not legal in CUDA, because an attempt to dereference a host pointer in device code will fail.

The exceptions to the above would be data/pointers/references that are accessible in device code. Unified memory and pinned/mapped data are two examples, neither of which are being used here.

As a result, the reference parameter involves a reference (an address, basically) for a an item ( size ) in host memory. When the kernel code attempts to use this item, it must first de-reference it. The dereferenceing of a host item in device code is illegal in CUDA (unless using UM or pinned memory).

The solution in this case is simple: convert to an ordinary pass-by-value situation:

__global__ void sumVectorElements(int *vec,const int size) ...
                                                    ^
                                                 remove ampersand