error-handling

GPU代码错误处理

概述

良好的错误处理是生产级GPU代码的关键，包括编译时检查、运行时检查和调试支持。

CUDA错误检查

基础宏定义

#define CUDA_CHECK(call) \
do { \
    cudaError_t error = call; \
    if (error != cudaSuccess) { \
        fprintf(stderr, "CUDA Error: %s:%d, ", __FILE__, __LINE__); \
        fprintf(stderr, "code: %d, reason: %s\n", error, \
                cudaGetErrorString(error)); \
        exit(1); \
    } \
} while(0)

// 使用示例
CUDA_CHECK(cudaMalloc(&d_data, size));
CUDA_CHECK(cudaMemcpy(d_data, h_data, size, cudaMemcpyHostToDevice));

Kernel启动错误检查

// Kernel启动
my_kernel<<<grid, block>>>(args);

// 检查启动错误
CUDA_CHECK(cudaGetLastError());

// 检查执行错误
CUDA_CHECK(cudaDeviceSynchronize());

C++异常封装

class CUDAException : public std::runtime_exception {
public:
    CUDAException(cudaError_t error, const char* file, int line)
        : std::runtime_error(
            std::string("CUDA Error: ") + 
            cudaGetErrorString(error) +
            " at " + file + ":" + std::to_string(line)
        ) {}
};

#define CUDA_THROW(call) \
do { \
    cudaError_t error = call; \
    if (error != cudaSuccess) { \
        throw CUDAException(error, __FILE__, __LINE__); \
    } \
} while(0)

// 使用示例
try {
    CUDA_THROW(cudaMalloc(&d_data, size));
    my_kernel<<<grid, block>>>(d_data);
    CUDA_THROW(cudaDeviceSynchronize());
} catch (const CUDAException& e) {
    std::cerr << e.what() << std::endl;
    // 清理资源...
}

Kernel内边界检查

基本边界检查

__global__ void safe_kernel(float* data, int N) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    
    // ✅ 边界检查
    if (idx < N) {
        data[idx] = process(data[idx]);
    }
}

2D边界检查

__global__ void safe_2d_kernel(float* data, int M, int N) {
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;
    
    // ✅ 2D边界检查
    if (row < M && col < N) {
        int idx = row * N + col;
        data[idx] = process(data[idx]);
    }
}

断言检查