CUDA 程序不测量执行时间：cuda事件记录

我需要真正了解 CUDA 如何工作来衡量时间执行。

让我们专注于这一部分(如果要测试它，整个代码位于消息的末尾)。

// Launching Kernel and measuring its time
cudaEventRecord(startComputation);
MatProd << <BlockPerGrid, ThreadPerBlock >> >(C, A, B, dimAx, dimBx, dimCx, dimCy);
cudaEventRecord(stopComputation);
//cudaEventSynchronize(stopComputation); // this line must be HERE and it returns me a good computation time.
cudaEventElapsedTime(&millisecondsPureComputation, startComputation, stopComputation);
cudaDeviceSynchronize(); // putting this doesn't do the job
//cudaEventSynchronize(stopComputation); // if I put it here instead it doesn't work.
std::cout << "Computation time : " << millisecondsPureComputation << "ms" << std::endl;

我如何理解这些事情。当程序运行时，CPU 会多次调用内核。cudaEventRecord、MatProd 和 cudaEventElapsedTime都在 GPU 上执行。

我的两个 cudaEventRecord 之间的时间是在我的 cudaEventElapsedTime 中计算的。

问题是：如果我的CPU在GPU计算方面太快，变量毫秒PureComputaion将保持它的初始值：0。

因此，在显示计算之前，我必须对CPU说"等待GPU已完成cudaEventElapsedTime"。这样，变量毫秒PureComputing将具有我们想要的值。

因此，在 cudaEventElapsedTime 之后放置一个 cudaDeviceSynchronise(); 应该就足够了。

但实际上当我这样做时它不起作用，变量仍然是 0。拥有非零数的唯一方法是将 cudaEvntSynchronize(stopComputing) 放在 cudaEventElapsedTime之前，我不明白为什么。

我的问题 ：

为什么我放置cudaDeviceSynchronise()的方法不起作用？你能解释一下为什么在cudaEventElapsedTime工作之前放置cudaEventSynchronize(stopComputing)吗？它排他性的作用是什么？

#include <iostream>
#include <math.h>
#include <chrono>
__global__  void MatProd(float* C, float* A, float*B, int dimAx, int dimBx, int dimCx, int dimCy)
{
int row = blockDim.y*blockIdx.y + threadIdx.y;
int col = blockDim.x*blockIdx.x + threadIdx.x;
double Result = 0;
if (row <= dimCy - 1 && col <= dimCx - 1)
{
for (int k = 0; k < dimAx; k++)
{
Result += A[k + dimAx*row] * B[col + dimBx*k];
}
C[col + row*dimCx] = Result;
}
}
int main(void)
{
/* Initializing the inputs */
// Matrix sizes
int dimAx = 100;
int dimAy = 100;
int dimBx = 2;
int dimBy = dimAx;
int dimCx = dimBx;
int dimCy = dimAy;
// Matrix pointers
float *A, *B, *C;
// Variable to measure CUDA time execution.
float millisecondsPureComputation = 0;
cudaEvent_t startComputation, stopComputation;
cudaEventCreate(&startComputation);
cudaEventCreate(&stopComputation);
// Memory allocation
cudaMallocManaged(&A, dimAx*dimAy*sizeof(float));
cudaMallocManaged(&B, dimBx*dimBy*sizeof(float));
cudaMallocManaged(&C, dimCx*dimCy*sizeof(float));
// Initializing matrices
for (int i = 0; i < dimAy; i++)
{
for (int j = 0; j < dimAx; j++) 
{
A[j + dimAx*i] = j + 10 * i;
}
}
for (int i = 0; i < dimBy; i++)
{
for (int j = 0; j < dimBx; j++)
{
B[j + dimBx*i] = (j + 1)*pow(i, 2);
}
}
// Kernel properties
int threadPerBlockx = 32;
int threadPerBlocky = 32;
int BlockPerGridx = 1 + (dimCx - 1) / threadPerBlockx;
int BlockPerGridy = 1 + (dimCy - 1) / threadPerBlockx;

dim3 BlockPerGrid(BlockPerGridx, BlockPerGridy, 1);
dim3 ThreadPerBlock(threadPerBlockx, threadPerBlocky, 1);
// Launching Kernel and measuring its time
cudaEventRecord(startComputation);
MatProd << <BlockPerGrid, ThreadPerBlock >> >(C, A, B, dimAx, dimBx, dimCx, dimCy);
cudaEventRecord(stopComputation);
//cudaEventSynchronize(stopComputation); // this line must be HERE and it returns me a good computation time.
cudaEventElapsedTime(&millisecondsPureComputation, startComputation, stopComputation);
cudaDeviceSynchronize(); // putting this doesn't do the job
//cudaEventSynchronize(stopComputation); // if I put it here instead it doesn't work.
std::cout << "Computation time : " << millisecondsPureComputation << "ms" << std::endl;
cudaFree(A);
cudaFree(B);
cudaFree(C);
return 0;
}

[编辑] 我更改了代码，现在它可以工作了，但我仍然不明白发生了什么。

cudaEventRecord(startComputation);
MatProd << <BlockPerGrid, ThreadPerBlock >> >(C, A, B, dimAx, dimBx, dimCx, dimCy);
//cudaDeviceSynchronize();
cudaEventRecord(stopComputation);
cudaDeviceSynchronize();
cudaEventElapsedTime(&millisecondsPureComputation, startComputation, stopComputation);

这是我的问题：

• 所以，cudaEventRecord()，cudaEventElapsedTime()在我的情况下在主机上执行，如果我理解得很好(文档中__host__的bc)。

在文档中，他们说cudaEventRecord捕获了蒸汽的内容。我并不完全清楚他们所说的流的"内容"是什么。

但是我不明白它是如何工作的。事实上，如果 MatProd 需要很长时间，CPU 将在 GPU 完成工作之前到达第二个 cudaEventRecord。所以我应该得到一个错误的结果...？

我这样说是因为您向我解释了这些 API 函数是在主机上执行的。因此，据我了解，它们将与内核并行启动。当我们在两个 cudaEventRecord() 之后同步时，我应该得到一个错误的结果......？

也许是因为我并没有真正理解您在主机上执行的意思，但我将其理解为在 CPU 上启动的功能(因此，它不需要等待内核完成)。