Matrix CUDA中矩阵乘法的问题

我在CUDA C中遇到矩阵乘法的问题。检查了很长时间后，我发现问题在于我错误地使用了“dim3”。改正后我得到了正确的结果。但是我增加了矩阵的维数，答案是不正确的。即使我不能使用Nsight，但在我增加维度之前，它工作得很好，可以启动CUDA调试

内核代码：

__global__ void multiKernal(float* Md, float*Nd, float*Pd, int width)
{
    int row = blockIdx.y*blockDim.y + threadIdx.y;
    int col = blockIdx.x*blockDim.x + threadIdx.x;
  float Pvalue = 0;

for (int k = 0; k <width; ++k){
    Pvalue += Md[row*width + k] * Nd[col + width*k];
}
Pd[row*width + col] = Pvalue;
return;
}

\uuuu全局\uuuuu无效多核（float*Md、float*Nd、float*Pd、int-width）
{
int row=blockIdx.y*blockDim.y+threadIdx.y；
int col=blockIdx.x*blockDim.x+threadIdx.x；
浮点值=0；
对于（int k=0；k（Md，Nd，Pd，width）；
错误=cudaEventRecord（停止，空）；
错误=cudaEventSynchronize（停止）；
浮动msecTotal=0.0f；
错误=CUDAEventReleasedTime（&MSECOTAL、start、stop）；
浮点msecPerMatrixMul=msecTotal；
printf（“运行时间：%.3f毫秒”，msecPerMatrixMul）；
cudaMemcpy（主机、Pd、大小、cudaMemcpyDeviceToHost）；
cudaFree（Md）；cudaFree（Nd）；cudaFree（Pd）；
返回；
}

主要内容：

intmain（）
{
int M=512*512；
int N=512*512；
int P=512*512；
整数宽度=512；
int c[512]；
float*hostM=（float*）malloc（sizeof（float）*M）；
float*hostN=（float*）malloc（sizeof（float）*N）；
float*hostP=（float*）malloc（sizeof（float）*P）；
对于（int i=0；i对于（int i=0；i您的threadblock大小为128x128x1=16k，最大threadblock大小为1024。内核没有运行。尝试使用它运行应用程序可能会告诉您代码有问题。检查CUDA运行时API函数返回的结果代码是否有错误也是一个很好的做法。
您的threadblock大小为128x128x1=16k，the最大线程块大小为1024。内核只是不运行。尝试使用它运行应用程序可能会告诉您代码有问题。检查CUDA运行时API函数返回的结果代码是否有错误也是一个很好的做法。
我认为“1024*1024*64”是每个块的线程大小。谢谢！@CalvinLouBME:一个块的最大尺寸和每个块的最大线程数是不同的，它们都适用于限制合法块大小我认为是“1024*1024*64”是每个块的线程大小。谢谢！@CalvinLouBME:块的最大尺寸和每个块的最大线程数是不同的，两者都适用于限制合法块的大小
void matrixmutiplacation(float*hostM, float*hostN, float*hostP, int width)
{
    int size = width*width*sizeof(float);
    float* Md; float* Nd; float* Pd;
    dim3 dimGrid(4, 4, 1);
    dim3 dimBlock(128, 128, 1);
    cudaError_t error;
    cudaEvent_t start;
    error = cudaEventCreate(&start);
    cudaEvent_t stop;
    error = cudaEventCreate(&stop);

    cudaMalloc((void**)&Md, size);
    cudaMalloc((void**)&Nd, size);
    cudaMalloc((void**)&Pd, size);
    cudaMemcpy(Md, hostM, size, cudaMemcpyHostToDevice);
    cudaMemcpy(Nd, hostN, size, cudaMemcpyHostToDevice);
    cudaMemcpy(Pd, hostP, size, cudaMemcpyHostToDevice);

    error = cudaEventRecord(start, NULL);
    multiKernal << <dimGrid, dimBlock >> >(Md, Nd, Pd, width);
    error = cudaEventRecord(stop, NULL);
    error = cudaEventSynchronize(stop);
    float msecTotal = 0.0f;
    error = cudaEventElapsedTime(&msecTotal, start, stop);
    float msecPerMatrixMul = msecTotal;
    printf("running time:%.3f msec", msecPerMatrixMul);

    cudaMemcpy(hostP, Pd, size, cudaMemcpyDeviceToHost);
    cudaFree(Md); cudaFree(Nd); cudaFree(Pd);
    return;
}

int main()
{
    int M = 512 * 512;
    int N = 512 * 512;
    int P = 512 * 512;
    int width = 512;
    int c[512];
    float* hostM = (float*)malloc(sizeof(float)*M);
    float* hostN = (float*)malloc(sizeof(float)*N);
    float* hostP = (float*)malloc(sizeof(float)*P);

    for (int i = 0; i < P; ++i)
        hostP[i] = 0;

    for (int i = 0; i <width; i++)
        c[i] = i + 1;

    for (int i = 0; i <width; i++) {
        for (int j = 0; j <width; j++) {
            hostM[i*width + j] = c[j] + i;
            hostN[i*width + j] = c[j] + i;
        }
    }

    matrixmutiplacation(hostM, hostN, hostP, width);

    //for (int i = 0; i <width; i++){
    //for (int j = 0; j <width; j++){
    //  printf("%f\t", hostP[i*width + j]);
    //}
    //  printf("\n");
    //}

    free(hostM);
    free(hostN);
    free(hostP);

    return 0;

}