cuda复数稀疏矩阵计算

最新推荐文章于 2024-08-07 04:32:21 发布

用户名溢出

最新推荐文章于 2024-08-07 04:32:21 发布

阅读量110

点赞数 2

分类专栏： Cuda 文章标签：矩阵线性代数

本文链接：https://blog.csdn.net/bocai1215/article/details/140016031

版权

Cuda 专栏收录该内容

16 篇文章 2 订阅

订阅专栏

void testSparseComplex()
{
    const int rows = 2;
    const int cols = 3;
    const int nnz = 3;  // 非零元素数量

    // 主机端数据
    std::vector<int> h_rowPtr;
    std::vector<int> h_colInd;
    std::vector<Complex> h_values;
    std::vector<Complex> h_x(cols, make_cuComplex(1.0, 1.0)); // 初始化向量 x
    std::vector<Complex> h_y(rows);

    for (int i = 0; i < cols; ++i) {
        h_x[i] = make_cuComplex(static_cast<float>(i + 1), static_cast<float>(i + 2));
    }

    // 初始化矩阵和向量
    initializeSparseMatrix(h_rowPtr, h_colInd, h_values);

    // 设备端数据指针
    int* d_rowPtr, * d_colInd;
    Complex* d_values, * d_x, * d_y;
    cusparseHandle_t handle;
    cusparseSpMatDescr_t matA;
    cusparseDnVecDescr_t vecX, vecY;

    // 初始化 cuSPARSE 库
    cusparseCreate(&handle);

    // 分配设备内存
    cudaMalloc((void**)&d_rowPtr, h_rowPtr.size() * sizeof(int));
    cudaMalloc((void**)&d_colInd, h_colInd.size() * sizeof(int));
    cudaMalloc((void**)&d_values, h_values.size() * sizeof(Complex));
    cudaMalloc((void**)&d_x, cols * sizeof(Complex));
    cudaMalloc((void**)&d_y, rows * sizeof(Complex));

    // 将数据从主机复制到设备
    cudaMemcpy(d_rowPtr, h_rowPtr.data(), h_rowPtr.size() * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(d_colInd, h_colInd.data(), h_colInd.size() * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(d_values, h_values.data(), h_values.size() * sizeof(Complex), cudaMemcpyHostToDevice);
    cudaMemcpy(d_x, h_x.data(), cols * sizeof(Complex), cudaMemcpyHostToDevice);

    // 创建和设置稀疏矩阵描述符
    cusparseCreateCsr(&matA, rows, cols, nnz,
        d_rowPtr, d_colInd, d_values,
        CUSPARSE_INDEX_32I, CUSPARSE_INDEX_32I,
        CUSPARSE_INDEX_BASE_ZERO, CUDA_C_32F);


    // 创建和设置密集向量描述符
    cusparseCreateDnVec(&vecX, cols, d_x, CUDA_C_32F);
    cusparseCreateDnVec(&vecY, rows, d_y, CUDA_C_32F);


    // 执行稀疏矩阵-向量乘法
    Complex alpha = make_cuComplex(1.0, 0.0);
    Complex beta = make_cuComplex(0.0, 0.0);
    size_t bufferSize = 0;
    void* dBuffer = nullptr;


    // 获取临时缓冲区大小
    cusparseSpMV_bufferSize(handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
        &alpha, matA, vecX, &beta, vecY, CUDA_C_32F,
        CUSPARSE_MV_ALG_DEFAULT, &bufferSize);

    // 分配临时缓冲区
    cudaMalloc(&dBuffer, bufferSize);

    // 进行计算
    cusparseSpMV(handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
        &alpha, matA, vecX, &beta, vecY, CUDA_C_32F,
        CUSPARSE_MV_ALG_DEFAULT, dBuffer);

    // 将结果从设备复制到主机
    cudaMemcpy(h_y.data(), d_y, rows * sizeof(Complex), cudaMemcpyDeviceToHost);


    // 打印结果
    for (int i = 0; i < rows; ++i) {
        std::cout << "(" << cuCrealf(h_y[i]) << ", " << cuCimagf(h_y[i]) << ") ";
    }
    std::cout << std::endl;

    // 释放设备内存和 cuSPARSE 库
    cudaFree(d_rowPtr);
    cudaFree(d_colInd);
    cudaFree(d_values);
    cudaFree(d_x);
    cudaFree(d_y);
    cudaFree(dBuffer);
    cusparseDestroySpMat(matA);
    cusparseDestroyDnVec(vecX);
    cusparseDestroyDnVec(vecY);
    cusparseDestroy(handle);