CODEWITHSUNDEEP
cuda
강주원
강주원

Reputation: 1

several cublasSgemm calls in matrixMulCUBLAS.cpp

I have questions about marixMulCUBLAS.cpp(CUDA-9.0) code.

In matrixMultiply function of this code, there are several cublasSgemm calls to calculate matrix multiplication.

However, I don't know why these calls should be called several times. It seems useless.

What is the difference between cublasSgemm warmup call and cublasSgemm calls in loop?

In addition, why induction varialbe j is not exist in cublasSgemm calls?

int matrixMultiply(int argc, char **argv, int devID, sMatrixSize &matrix_size)
{
cudaDeviceProp deviceProp;

checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));

int block_size = 32;

// set seed for rand()
srand(2006);

// allocate host memory for matrices A and B
unsigned int size_A = matrix_size.uiWA * matrix_size.uiHA;
unsigned int mem_size_A = sizeof(float) * size_A;
float *h_A = (float *)malloc(mem_size_A);
unsigned int size_B = matrix_size.uiWB * matrix_size.uiHB;
unsigned int mem_size_B = sizeof(float) * size_B;
float *h_B = (float *)malloc(mem_size_B);

// set seed for rand()
srand(2006);

// initialize host memory
randomInit(h_A, size_A);
randomInit(h_B, size_B);

// allocate device memory
float *d_A, *d_B, *d_C;
unsigned int size_C = matrix_size.uiWC * matrix_size.uiHC;
unsigned int mem_size_C = sizeof(float) * size_C;

// allocate host memory for the result
float *h_C      = (float *) malloc(mem_size_C);
float *h_CUBLAS = (float *) malloc(mem_size_C);

checkCudaErrors(cudaMalloc((void **) &d_A, mem_size_A));
checkCudaErrors(cudaMalloc((void **) &d_B, mem_size_B));
checkCudaErrors(cudaMemcpy(d_A, h_A, mem_size_A, cudaMemcpyHostToDevice));
checkCudaErrors(cudaMemcpy(d_B, h_B, mem_size_B, cudaMemcpyHostToDevice));
checkCudaErrors(cudaMalloc((void **) &d_C, mem_size_C));

// setup execution parameters
dim3 threads(block_size, block_size);
dim3 grid(matrix_size.uiWC / threads.x, matrix_size.uiHC / threads.y);

// create and start timer
printf("Computing result using CUBLAS...");

// execute the kernel
int nIter = 30;

// CUBLAS version 2.0
{
    const float alpha = 1.0f;
    const float beta  = 0.0f;
    cublasHandle_t handle;
    cudaEvent_t start, stop;

    checkCudaErrors(cublasCreate(&handle));

    //Perform warmup operation with cublas
    **checkCudaErrors(cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, matrix_size.uiWB, matrix_size.uiHA, matrix_size.uiWA, &alpha, d_B, matrix_size.uiWB, d_A, matrix_size.uiWA, &beta, d_C, matrix_size.uiWB));**

    // Allocate CUDA events that we'll use for timing
    checkCudaErrors(cudaEventCreate(&start));
    checkCudaErrors(cudaEventCreate(&stop));

    // Record the start event
    checkCudaErrors(cudaEventRecord(start, NULL));

    **for (int j = 0; j < nIter; j++)
    {
        //note cublas is column primary!
        //need to transpose the order
        checkCudaErrors(cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, matrix_size.uiWB, matrix_size.uiHA, matrix_size.uiWA, &alpha, d_B, matrix_size.uiWB, d_A, matrix_size.uiWA, &beta, d_C, matrix_size.uiWB));
    }**

    printf("done.\n");

Upvotes: 0

Views: 272

Answers (1)

talonmies
talonmies

Reputation: 72372

However, I don't know why these calls should be called several times. It seems useless.

The code is benchmarking code, and the multiple calls are simply to be able to calculate an average run time over a number of executions of the CUBLAS gemm call.

What is the difference between cublasSgemm warmup call and cublasSgemm calls in loop?

Warm-up is exactly what its name suggests. The first call to CUDA code can result in additional one-time latency associated with the lazy context establishment mechanism of the CUDA runtime API. By running a warm-up call first, this latency can be removed from the performance measurements.

In addition, why induction varialbe j is not exist in cublasSgemm calls?

Because the only purpose of the loop is to allow the call to be run multiple times for average performance measurement.

Upvotes: 1

Related Questions