python - 为什么我的代码(与 CUDA 链接)偶尔会导致 Python 中的段错误？

Question

我正在为 python 创建一个 GPU 加速卷积例程，它后端为 C，它利用 Cuda 来访问 GPU。为此，请使用以下 C 代码:

#include <cuda.h>
#include <cuda_runtime_api.h>


/* 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
GPU device functions for GPU modules 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
__global__ void d_VectorConvolve(float *a, float *b, float *c, size_t n_a, size_t n_b, size_t half)
{
    size_t idx = blockIdx.x * blockDim.x + threadIdx.x;
    float val = 0.0;

    if (idx < n_a)
    {
        for (int j = 0; j < n_b; j++)
        {
            int check = idx - half + j; // this is needed to ensure we dont attempt to index
                        // a value outsize the size of a.
            if (check > 0 && check < n_a)
            {
                val = val + a[idx - half + j]*b[j];
            }   
        }
        c[idx] = val;
    }
}
extern "C" {
void VectorConvolve(float *a, float *b, float *c, size_t n_a, size_t n_b, size_t half)
{
    float *d_a, *d_b, *d_c;

    cudaMalloc( &d_a, n_a*sizeof(float));
    cudaMalloc( &d_b, n_b*sizeof(float));
    cudaMalloc( &d_c, n_a*sizeof(float));

    cudaMemcpy( d_a, a, n_a*sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy( d_b, b, n_b*sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy( d_c, c, n_a*sizeof(float), cudaMemcpyHostToDevice);

    d_VectorConvolve <<< ceil(n_a / 256.0), 256 >>> (d_a, d_b, d_c, n_a, n_b, half);

    cudaMemcpy( c, d_c, n_a*sizeof(float), cudaMemcpyDeviceToHost);

    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);
}
}

此文件保存为 vector_functions.cu，我使用 nvcc 对其进行编译以生成 .so :

nvcc -Xcompiler -fPIC -shared -o vector_functions.so vector_functions.cu 

这一切都工作正常，并且代码在 C 中工作。我创建了一个 init.py 文件，该文件使用创建的 .so 文件:

def get_vector_functions():
    dll = ctypes.CDLL(current_dir + '/vector_functions.so', mode=ctypes.RTLD_GLOBAL)

    # convolve funtion
    vector_convolve = dll.VectorConvolve
    vector_convolve.argtypes = [POINTER(c_float), POINTER(c_float), POINTER(c_float), c_size_t, c_size_t, c_size_t]

    return vector_convolve

# create __cuda_sum function with get_cuda_sum()
__vector_convolve = get_vector_functions()

def cuda_convolve(a,b):
    a = a.astype('float32')
    b = b.astype('float32')

    a_shape = a.shape[0]
    b_shape = b.shape[0]

    half = int(b_shape/2.)

    a_p = a.ctypes.data_as(POINTER(c_float))
    b_p = b.ctypes.data_as(POINTER(c_float))
    c_p = np.zeros(a_shape).ctypes.data_as(POINTER(c_float))

    __vector_convolve(a_p, b_p, c_p, a_shape, b_shape,  half)
    c = make_nd_array(c_p, [a_shape], dtype=np.float32, order='C', own_data=True)
    return c

现在效果很好，我可以加载我的模块来快速进行大型卷积。问题是，有时我会遇到段错误，但我不知道为什么。一旦我得到这个，我就不能再次使用这个模块，直到我重新启动计算机。

我认为我没有正确管理我的内存？但奇怪的是，有时它运行得很好，然后突然就失败了。我还觉得链接 .so 文件可能是一个坏主意，并且可能与此有关，但这是将 python 链接到 C 的快速解决方案。

我对Python和C语言比较有经验。我这里的大部分代码都是改编自在线教程和其他人的代码。我欢迎所有关于为什么会出现这种情况以及可以采取哪些措施来避免此问题的建议。

<小时/>

编辑 2017 年 10 月 31 日

如果我使用 python 解释器运行一些预热命令，问题似乎就会消失:

cuda_convolve(np.ones(2**5), np.ones(100))
cuda_convolve(np.ones(2**10), np.ones(100))
cuda_convolve(np.ones(2**15), np.ones(100))
cuda_convolve(np.ones(2**18), np.ones(100))

在此之后，我可以毫无问题地将它用于大型数组。但是，如果我在不进行“预热”的情况下加载模块，则会出现段错误。

Answer 1

这实际上并不是段错误问题的解决方案，而是找到段错误背后的真正罪魁祸首的一种方法。

您的代码中没有错误检查。您希望如何找到错误？

使用以下函数来包装所有 CUDA 调用:

#define gpuErrchk(ans) { gpuAssert((ans), __FILE__, __LINE__); }
inline void gpuAssert(cudaError_t code, const char *file, int line, bool abort=true)
{
   if (code != cudaSuccess) 
   {
      fprintf(stderr,"GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line);
      if (abort) exit(code);
   }
}

现在修改您的代码:

extern "C" {
void VectorConvolve(float *a, float *b, float *c, size_t n_a, size_t n_b, size_t half)
{
    float *d_a, *d_b, *d_c;

    gpuErrchk(cudaMalloc( &d_a, n_a*sizeof(float)));
    gpuErrchk(cudaMalloc( &d_b, n_b*sizeof(float)));
    gpuErrchk(cudaMalloc( &d_c, n_a*sizeof(float)));

    gpuErrchk(cudaMemcpy( d_a, a, n_a*sizeof(float), cudaMemcpyHostToDevice));
    gpuErrchk(cudaMemcpy( d_b, b, n_b*sizeof(float), cudaMemcpyHostToDevice));
    gpuErrchk(cudaMemcpy( d_c, c, n_a*sizeof(float), cudaMemcpyHostToDevice));

    d_VectorConvolve <<< ceil(n_a / 256.0), 256 >>> (d_a, d_b, d_c, n_a, n_b, half);

    // check if cuda kernel executed correctly
    gpuErrchk(cudaPeekAtLastError())
    // make sure kernel execution has ended
    gpuErrchk(cudaDeviceSynchronize())

    gpuErrchk(cudaMemcpy( c, d_c, n_a*sizeof(float), cudaMemcpyDeviceToHost));

    gpuErrchk(cudaFree(d_a));
    gpuErrchk(cudaFree(d_b));
    gpuErrchk(cudaFree(d_c));
}
}