Question

在我的玩具示例中，我首先将大小为32x32，100 000次的矩阵相乘，然后计算两个大小为1024，100 000次的向量的标量积再次。对于第一个我使用cublasSgemm，第二个使用cublasSdot。

因此，第一次计算的时间为530 msec，第二次计算的时间为10 000 msec。但是，为了使矩阵相乘，我们需要执行32^3运算（乘法 - 加法），对于标量积，只需执行1024=32^2运算。

那么为什么我会得到这样的结果呢？这是代码：

__device__ float res;
void randomInit(float *data, int size)
{
    for (int i = 0; i < size; ++i)
        data[i] = rand() / (float)RAND_MAX;
}
int main(){
    cublasHandle_t handle;
    float out;
    cudaError_t cudaerr;
    cudaEvent_t start1, stop1,start2,stop2;
    cublasStatus_t stat;
    int size = 32;
    int num = 100000;

    float *h_A = new float[size*size];
    float *h_B = new float[size*size];
    float *h_C = new float[size*size];
    float *d_A, *d_B, *d_C;
    const float alpha = 1.0f;
    const float beta = 0.0f;
    randomInit(h_A, size*size);
    randomInit(h_B, size*size);
    cudaMalloc((void **)&d_A, size *size *sizeof(float));
    cudaMalloc((void **)&d_B, size *size * sizeof(float));
    cudaMalloc((void **)&d_C, size *size * sizeof(float));
    stat = cublasCreate(&handle);
    cudaEventCreate(&start1);
    cudaEventCreate(&stop1);
    cudaEventCreate(&start2);
    cudaEventCreate(&stop2);
    cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, size, size, size, &alpha, d_A, size, 
                d_B, size, &beta, d_C, size);
    cudaEventRecord(start1, NULL);
    cudaMemcpy(d_A, h_A, size *size * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_B, h_B, size *size * sizeof(float), cudaMemcpyHostToDevice);
    for (int i = 0; i < num; i++){
        cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, size, size, size, &alpha, d_A, 
                        size, d_B, size, &beta, d_C, size);
    }
    cudaMemcpy(h_C, d_C, size*size*sizeof(float), cudaMemcpyDeviceToHost);
    cudaEventRecord(stop1, NULL);
    cudaEventSynchronize(stop1);
    float msecTotal1 = 0.0f;
    cudaEventElapsedTime(&msecTotal1, start1, stop1);
    std::cout <<"total time for MAtMul:" << msecTotal1 << "\n";
    cudaEventRecord(start2, NULL);
    cudaMemcpy(d_A, h_A, size *size * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_B, h_B, size *size * sizeof(float), cudaMemcpyHostToDevice);
    for (int i = 0; i < num; i++){
        cublasSdot(handle, 1024, d_A , 1, d_B , 1, &res);
    }
    cudaEventRecord(stop2, NULL);
    cudaEventSynchronize(stop2);
    float msecTotal2 = 0.0f;
    cudaEventElapsedTime(&msecTotal2, start2, stop2);
    std::cout << "total time for dotVec:" << msecTotal2 << "\n";
    cublasDestroy(handle);
    cudaFree(d_A);
    cudaFree(d_B);
    cudaFree(d_C);
    delete[] h_A;
    delete[] h_B;
    delete[] h_C;
    return 1;
}

更新：我还尝试通过将矢量视为cublasSgemm矩阵来执行带有1 by 1024的点积。结果是3550 msec，这是更好的，但仍然是第一次计算的7倍。

Answer 1

一个问题是您没有正确处理指针模式以调用cublasSdot。

您需要阅读手册的this section。

此外：

    cublasSdot(handle, 1024, d_A , 1, d_B , 1, &res);
                                               ^^^^

在任何情况下都是非法的。在CUDA中获取主机代码中的设备变量的地址是不合法的。你当然可以做到，但结果是垃圾。

当我按如下方式修改你的代码时：

cublasSetPointerMode(handle, CUBLAS_POINTER_MODE_DEVICE);
float *dres;
cudaMalloc(&dres, sizeof(float));
cudaEventRecord(start2, NULL);
cudaMemcpy(d_A, h_A, size *size * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_B, h_B, size *size * sizeof(float), cudaMemcpyHostToDevice);
for (int i = 0; i < num; i++){
    if(cublasSdot(handle, 1024, d_A , 1, d_B , 1, dres) != CUBLAS_STATUS_SUCCESS) {std::cout << ".";}
}

cublasSdot到cublasSgemm的执行时间比例为2：1，这可能是合理的，特别是对于这些尺寸。在引擎盖下，点操作意味着平行减少。 1024个线程可以计算部分结果，但是需要1024线程范围的并行减少。 gemm不需要平行缩小，因此可能更快。可以分配1024个线程以在单个线程中生成1024个结果。对于内存限制算法，32 ^ 2和32 ^ 3操作之间的差异可能不那么显着，但并行减少意味着显着的附加操作。当我然后将程序中的size从32更改为128时，我看到比率反转，矩阵乘法确实比点积长3倍。

cublasSdot的工作速度比cublasSgemm慢

1 个答案: