将CUDA类集成到C++程序并实现设备内存跨调用保留的方法咨询

首先明确：extern "C"不支持修饰C类，C链接规范没有类相关的语义，但是可以通过**不透明指针+C接口封装内部C类**的方式完全实现你的需求，既可以让CUDA资源的生命周期覆盖整个程序运行期，也能避免每次调用重复传输设备数据，同时兼容纯C++主机代码的调用逻辑。

核心实现思路 #

• 所有CUDA相关逻辑（设备内存管理、cuSPARSE/cuBLAS句柄持有、计算逻辑）都封装在内部C++类中，类的实现全部放在.cu文件中由nvcc编译，对外不可见。
• 对外暴露C风格的操作接口，用不透明指针（void*或空结构体指针）指代内部类的实例，主机侧纯C++代码不需要依赖任何CUDA头文件，也不需要用nvcc编译，只需要调用这些C接口即可。
• 内部类的构造函数完成设备内存预分配、计算库句柄初始化；析构函数完成资源释放；成员函数实现计算逻辑，直接复用已有的设备资源。

具体代码示例 #

CUDA侧代码（.cu文件，nvcc编译） #

#include <cuda_runtime.h>
#include <cusparse.h>
#include <cublas_v2.h>

// 内部实现类，完全不对外暴露
class CuHandler {
private:
    double* d_arg1 = nullptr;
    double* d_arg2 = nullptr;
    cusparseHandle_t cusparse_h = nullptr;
    cublasHandle_t cublas_h = nullptr;
    int buf_size = 0;
public:
    CuHandler(int N) : buf_size(N) {
        // 初始化计算库句柄，全程只执行一次
        cusparseCreate(&cusparse_h);
        cublasCreate(&cublas_h);
        // 预分配设备内存，全程只分配一次
        cudaMalloc(&d_arg1, sizeof(double) * N);
        cudaMalloc(&d_arg2, sizeof(double) * N);
    }

    void do_stuff(double* h_new_arg1, double* h_new_arg2) {
        // 仅当主机侧数据有更新时才执行传输，否则直接复用设备已有数据
        if (h_new_arg1 != nullptr) {
            cudaMemcpy(d_arg1, h_new_arg1, sizeof(double) * buf_size, cudaMemcpyHostToDevice);
        }
        if (h_new_arg2 != nullptr) {
            cudaMemcpy(d_arg2, h_new_arg2, sizeof(double) * buf_size, cudaMemcpyHostToDevice);
        }

        // 此处编写你的cuSPARSE、cuBLAS计算逻辑
        // ...
    }

    ~CuHandler() {
        // 程序退出时统一释放资源
        cudaFree(d_arg1);
        cudaFree(d_arg2);
        cusparseDestroy(cusparse_h);
        cublasDestroy(cublas_h);
    }
};

// 对外暴露的C风格接口，避免C++名字修饰
extern "C" {
    // 创建CUDA处理实例，返回不透明指针
    void* create_cu_handler(int N) {
        return new CuHandler(N);
    }

    // 执行计算逻辑
    void cu_do_stuff(void* handler, double* h_new_arg1, double* h_new_arg2) {
        static_cast<CuHandler*>(handler)->do_stuff(h_new_arg1, h_new_arg2);
    }

    // 销毁CUDA处理实例
    void destroy_cu_handler(void* handler) {
        delete static_cast<CuHandler*>(handler);
    }
}

主机侧纯C++代码调用示例 #

主机侧只需要声明上述三个C接口即可，不需要引入任何CUDA依赖：

// 主机侧声明C接口，可单独放在头文件中
extern "C" {
    void* create_cu_handler(int N);
    void cu_do_stuff(void* handler, double* h_new_arg1, double* h_new_arg2);
    void destroy_cu_handler(void* handler);
}

int main() {
    const int data_size = 2048;
    // 程序启动时创建实例，完成资源初始化
    void* cu_handler = create_cu_handler(data_size);

    double host_arg1[data_size], host_arg2[data_size];
    // 高频调用的循环逻辑
    for (int iter = 0; iter < 10000; iter++) {
        // 示例：仅当数据更新时才传入新的主机指针，否则传nullptr跳过传输
        if (iter % 10 == 0) {
            // 此处更新host_arg1、host_arg2的业务逻辑
            cu_do_stuff(cu_handler, host_arg1, host_arg2);
        } else {
            // 直接复用设备上已有的数据，无传输开销
            cu_do_stuff(cu_handler, nullptr, nullptr);
        }
    }

    // 程序退出前销毁实例，释放所有CUDA资源
    destroy_cu_handler(cu_handler);
    return 0;
}

可选优化点 #

• 若需要更严格的类型安全，可以在主机侧声明空结构体struct CuHandler;，用CuHandler*代替void*作为不透明指针，避免和其他类型的指针混用。
• 可以在主机侧再封装一层薄薄的C++类，把不透明指针的创建、销毁、调用逻辑包进去，即可实现你预期的handler.doStuff()调用风格，主机代码完全看不到底层C接口的细节。
• 对于全程不变的常驻数据，可以只在构造函数中执行一次主机到设备的传输，后续所有调用完全跳过传输步骤，性能收益更高。
• cuSPARSE、cuBLAS的句柄创建销毁开销极高，放在构造析构中仅初始化一次，相比每次调用都创建销毁可以带来数量级的性能提升。

内容的提问来源于stack exchange，提问作者konovification