使用cublas 矩阵库函数实现矩阵相乘

2014-08-10

cublas中执行矩阵乘法运算的函数

首先要注意的是cublas使用的是以列为主的存储方式，和c/c++中的以行为主的方式是不一样的。处理方法可参考下面的注释代码

// SOME PRECAUTIONS:
// IF WE WANT TO CALCULATE ROW-MAJOR MATRIX MULTIPLY C = A * B,
// WE JUST NEED CALL CUBLAS API IN A REVERSE ORDER: cublasSegemm(B, A)!
// The reason is explained as follows:

// CUBLAS library uses column-major storage, but C/C++ use row-major storage.
// When passing the matrix pointer to CUBLAS, the memory layout alters from
// row-major to column-major, which is equivalent to an implict transpose.

// In the case of row-major C/C++ matrix A, B, and a simple matrix multiplication
// C = A * B, we can't use the input order like cublasSgemm(A, B)  because of
// implict transpose. The actual result of cublasSegemm(A, B) is A(T) * B(T).
// If col(A(T)) != row(B(T)), equal to row(A) != col(B), A(T) and B(T) are not
// multipliable. Moreover, even if A(T) and B(T) are multipliable, the result C
// is a column-based cublas matrix, which means C(T) in C/C++, we need extra
// transpose code to convert it to a row-based C/C++ matrix.

// To solve the problem, let's consider our desired result C, a row-major matrix.
// In cublas format, it is C(T) actually (becuase of the implict transpose).
// C = A * B, so C(T) = (A * B) (T) = B(T) * A(T). Cublas matrice B(T) and A(T)
// happen to be C/C++ matrice B and A (still becuase of the implict transpose)!
// We don't need extra transpose code, we only need alter the input order!
//
// CUBLAS provides high-performance matrix multiplication.
// See also:
// V. Volkov and J. Demmel, "Benchmarking GPUs to tune dense linear algebra,"
// in Proc. 2008 ACM/IEEE Conf. on Superconducting (SC '08),
// Piscataway, NJ: IEEE Press, 2008, pp. Art. 31:1-11.
//

小例子C++中：

A矩阵：0   3   5                      B矩阵：1   1   1

0   0   4                             1   1   1

1   0   0                             1   1   1

现在要求C = A*B

C++中的结果

C矩阵：8   8   8

4   4   4

1   1   1

在cublas中：变成以行为主

A矩阵：0   0   1                      B矩阵：1   1   1

3   0   0                             1   1   1

5   4   0                             1   1   1

在cublas中求C2=B*A

结果如下：C2在cublas中以列为主

惯性思维，先把结果用行为主存储好理解：

C2矩阵：8   4   1

8   4   1

8   4   1

在cublas实际是一列存储的，结果如下：

C2矩阵：8   8   8

4   4   4

1   1   1

此时在cublas中B*A的结果与C++中A*B结果一样，使用cublas时只需改变下参数的位置即可得到想要的结果。

cublas<t>gemm()

cublasStatus_t cublasSgemm(cublasHandle_t handle,
                           cublasOperation_t transa, cublasOperation_t transb,
                           intm, intn, intk,
                           const float*alpha,
                           const float*A, intlda,
                           const float*B, intldb,
                           const float*beta,
                           float*C, intldc);
cublasStatus_t cublasDgemm(cublasHandle_t handle,
                           cublasOperation_t transa, cublasOperation_t transb,
                           intm, intn, intk,
                           const double*alpha,
                           const double*A, intlda,
                           const double*B, intldb,
                           const double*beta,
                           double*C, intldc);
cublasStatus_t cublasCgemm(cublasHandle_t handle,
                           cublasOperation_t transa, cublasOperation_t transb,
                           intm, intn, intk,
                           constcuComplex *alpha,
                           constcuComplex *A, intlda,
                           constcuComplex *B, intldb,
                           constcuComplex *beta,
                           cuComplex *C, intldc);
cublasStatus_t cublasZgemm(cublasHandle_t handle,
                           cublasOperation_t transa, cublasOperation_t transb,
                           intm, intn, intk,
                           constcuDoubleComplex *alpha,
                           constcuDoubleComplex *A, intlda,
                           constcuDoubleComplex *B, intldb,
                           constcuDoubleComplex *beta,
                           cuDoubleComplex *C, intldc);

参数含义可参考下面的信息：

使用cublas中cublasSgemm实现简单的矩阵相乘代码如下：

头文件：matrix.h

 // SOME PRECAUTIONS:
 // IF WE WANT TO CALCULATE ROW-MAJOR MATRIX MULTIPLY C = A * B,
 // WE JUST NEED CALL CUBLAS API IN A REVERSE ORDER: cublasSegemm(B, A)!
 // The reason is explained as follows:

 // CUBLAS library uses column-major storage, but C/C++ use row-major storage.
 // When passing the matrix pointer to CUBLAS, the memory layout alters from
 // row-major to column-major, which is equivalent to an implict transpose.

 // In the case of row-major C/C++ matrix A, B, and a simple matrix multiplication
 // C = A * B, we can't use the input order like cublasSgemm(A, B)  because of
 // implict transpose. The actual result of cublasSegemm(A, B) is A(T) * B(T).
 // If col(A(T)) != row(B(T)), equal to row(A) != col(B), A(T) and B(T) are not
 // multipliable. Moreover, even if A(T) and B(T) are multipliable, the result C
 // is a column-based cublas matrix, which means C(T) in C/C++, we need extra
 // transpose code to convert it to a row-based C/C++ matrix.

 // To solve the problem, let's consider our desired result C, a row-major matrix.
 // In cublas format, it is C(T) actually (becuase of the implict transpose).
 // C = A * B, so C(T) = (A * B) (T) = B(T) * A(T). Cublas matrice B(T) and A(T)
 // happen to be C/C++ matrice B and A (still becuase of the implict transpose)!
 // We don't need extra transpose code, we only need alter the input order!
 //
 // CUBLAS provides high-performance matrix multiplication.
 // See also:
 // V. Volkov and J. Demmel, "Benchmarking GPUs to tune dense linear algebra,"
 // in Proc. 2008 ACM/IEEE Conf. on Superconducting (SC '08),
 // Piscataway, NJ: IEEE Press, 2008, pp. Art. 31:1-11.
 //

 #include <stdio.h>
 #include <stdlib.h>

 //cuda runtime
 #include <cuda_runtime.h>
 #include <cublas_v2.h>

 //包含的库
 #pragma comment (lib,"cudart")
 #pragma comment (lib,"cublas")

 //使用这个宏就可以很方便的将我们习惯的行为主的数据转化为列为主的数据
 //#define  IDX2C(i,j,leading) (((j)*(leading))+(i))

 typedef struct _matrixSize      // Optional Command-line multiplier for matrix sizes
 {
     unsigned int uiWA, uiHA, uiWB, uiHB, uiWC, uiHC;
 } sMatrixSize;

 cudaError_t matrixMultiply(float *h_C, const float *h_A, const float *h_B,int devID, sMatrixSize &matrix_size);

CPP文件：matrix.cpp

 #include "matrix.h"

 cudaError_t matrixMultiply(float *h_C, const float *h_A, const float *h_B,int devID, sMatrixSize &matrix_size){
     float *dev_A = NULL;
     float *dev_B = NULL;
     float *dev_C = NULL;
     float *h_CUBLAS = NULL;

     cudaDeviceProp devicePro;
     cudaError_t cudaStatus;

     cudaStatus = cudaGetDeviceProperties(&devicePro, devID);

     if(cudaStatus != cudaSuccess){
         fprintf(stderr,"cudaGetDeviceProperties returned error code %d, line(%d)\n", cudaStatus, __LINE__);
         goto Error;
     }

     // allocate device memory for matrices dev_A 、 dev_B and dev_C
     unsigned int size_A = matrix_size.uiWA * matrix_size.uiHA;
     unsigned int mem_size_A = sizeof(float) * size_A;

     unsigned int size_B = matrix_size.uiWB * matrix_size.uiHB;
     unsigned int mem_size_B = sizeof(float) * size_B; 

     unsigned int size_C = matrix_size.uiWC * matrix_size.uiHC;
     unsigned int mem_size_C = sizeof(float) * size_C;

     //cudaMalloc dev_A
     cudaStatus = cudaMalloc( (void**)&dev_A, mem_size_A);
     if(cudaStatus != cudaSuccess){
         fprintf(stderr, "cudaMalloc dev_A return error code %d, line(%d)\n", cudaStatus, __LINE__);
         goto Error;
     }

     //cudaMalloc dev_B
     cudaStatus = cudaMalloc( (void**)&dev_B, mem_size_B);
     if(cudaStatus != cudaSuccess){
         fprintf(stderr, "cudaMalloc dev_B return error code %d, line(%d)\n", cudaStatus, __LINE__);
         goto Error;
     }

     //cudaMalloc dev_C
     cudaStatus = cudaMalloc( (void**)&dev_C, mem_size_C);
     if(cudaStatus != cudaSuccess){
         fprintf(stderr, "cudaMalloc dev_C return error code %d, line(%d)\n", cudaStatus, __LINE__);
         goto Error;
     }

     // allocate host memory for result matrices h_CUBLAS
     h_CUBLAS = (float*)malloc(mem_size_C);
     if( h_CUBLAS == NULL && size_C > ){
         fprintf(stderr, "malloc h_CUBLAS error, line(%d)\n",__LINE__);
         goto Error;
     }

     /*
     copy the host input vector h_A, h_B in host memory
     to the device input vector dev_A, dev_B in device memory
     */

     //cudaMemcpy h_A to dev_A
     cudaStatus = cudaMemcpy(dev_A, h_A, mem_size_A, cudaMemcpyHostToDevice);
     if( cudaStatus != cudaSuccess){
         fprintf(stderr,"cudaMemcpy h_A to dev_A return error code %d, line(%d)", cudaStatus, __LINE__);
         goto Error;
     }

     //cudaMemcpy h_B to dev_B
     cudaStatus = cudaMemcpy(dev_B, h_B, mem_size_B, cudaMemcpyHostToDevice);
     if( cudaStatus != cudaSuccess){
         fprintf(stderr,"cudaMemcpy h_B to dev_B returned error code %d, line(%d)", cudaStatus, __LINE__);
         goto Error;
     }

     //CUBLAS version 2.0
     {
         cublasHandle_t handle;
         cublasStatus_t ret;

         ret = cublasCreate(&handle);
         if(ret != CUBLAS_STATUS_SUCCESS){
             fprintf(stderr, "cublasSgemm returned error code %d, line(%d)", ret, __LINE__);
             goto Error;
         }

         cudaEvent_t start;
         cudaEvent_t stop;

         cudaStatus = cudaEventCreate(&start);
         if(cudaStatus != cudaSuccess){
             fprintf(stderr,"Falied to create start Event (error code %s)!\n",cudaGetErrorString( cudaStatus ) );
             goto Error;
         }

         cudaStatus = cudaEventCreate(&stop);
         if(cudaStatus != cudaSuccess){
             fprintf(stderr,"Falied to create stop Event (error code %s)!\n",cudaGetErrorString( cudaStatus ) );
             goto Error;
         }

         //recode start event
         cudaStatus = cudaEventRecord(start,NULL);
         if(cudaStatus != cudaSuccess){
             fprintf(stderr,"Failed to record start event (error code %s)!\n",cudaGetErrorString( cudaStatus ) );
             goto Error;
         }

         //matrix multiple A*B, beceause matrix is column  primary in cublas, so we can change the input
         //order to B*A.the reason you can see the file matrix.h

         float alpha = 1.0f;
         float beta = 0.0f;
         //ret = cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, matrix_size.uiHB, matrix_size.uiHA, matrix_size.uiWA,
             //&alpha, dev_B, matrix_size.uiWB, dev_A, matrix_size.uiWA, &beta, dev_C, matrix_size.uiWA);

         ret = cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, matrix_size.uiHA, matrix_size.uiHB, matrix_size.uiWB,
             &alpha, dev_A, matrix_size.uiWA, dev_B, matrix_size.uiWB, &beta, dev_C, matrix_size.uiWB);

         if(ret != CUBLAS_STATUS_SUCCESS){
             fprintf(stderr,"cublasSgemm returned error code %d, line(%d)\n", ret, __LINE__);
         }

         printf("cublasSgemm done.\n");

         //recode stop event
         cudaStatus = cudaEventRecord(stop,NULL);
         if(cudaStatus != cudaSuccess){
             fprintf(stderr,"Failed to record stop event (error code %s)!\n",cudaGetErrorString( cudaStatus ) );
             goto Error;
         }

         //wait for the stop event to complete
         cudaStatus = cudaEventSynchronize(stop);
         if(cudaStatus != cudaSuccess){
             fprintf(stderr,"Failed to synchronize on the stop event (error code %s)!\n", cudaGetErrorString( cudaStatus ) );
             goto Error;
         }

         float secTotal = 0.0f;
         cudaStatus = cudaEventElapsedTime(&secTotal ,start, stop);
         if(cudaStatus != cudaSuccess){
             fprintf(stderr,"Failed to get time elapsed between event (error code %s)!\n", cudaGetErrorString( cudaStatus ) );
             goto Error;
         }

         //copy result from device to host
         cudaStatus = cudaMemcpy(h_CUBLAS, dev_C, mem_size_C, cudaMemcpyDeviceToHost);
         if(cudaStatus != cudaSuccess){
             fprintf(stderr,"cudaMemcpy dev_C to h_CUBLAS error code %d, line(%d)!\n", cudaStatus, __LINE__);
             goto Error;
         }

     }

     for(int i = ; i < matrix_size.uiWC; i++){
         for(int j = ; j < matrix_size.uiHC; j++){
             printf("%f    ", h_CUBLAS[ i*matrix_size.uiWC + j]);
         }
         printf("\n");
     }

 /*
     //change the matrix from column primary to rows column primary
     for(int i = 0; i<matrix_size.uiWC; i++){
         for(int j = 0; j<matrix_size.uiHC; j++){
             int at1 = IDX2C(i,j,matrix_size.uiWC);  //element location in rows primary
             int at2 = i*matrix_size.uiWC +j;        //element location in column primary
             if(at1 >= matrix_size.uiWC*matrix_size.uiHC || at2 >= matrix_size.uiWC*matrix_size.uiHC)
                 printf("transc error \n");
             h_C[ at1 ] = h_CUBLAS[ at2 ];
         }
     }
 */
 /*
     for(int i = 0; i<matrix_size.uiWC; i++){
         for(int j = 0; j<matrix_size.uiHC; j++){
             //int at1 = IDX2C(i,j,matrix_size.uiWC);  //element location in rows primary
             int at2 = i*matrix_size.uiWC +j;        //element location in column primary
             //if(at1 >= matrix_size.uiWC*matrix_size.uiHC || at2 >= matrix_size.uiWC*matrix_size.uiHC)
                 //printf("transc error \n");
             h_C[ at2 ] = h_CUBLAS[ at2 ];
         }
     }
 */

 Error:
     cudaFree(dev_A);
     cudaFree(dev_B);
     cudaFree(dev_C);
     free(h_CUBLAS);
     dev_A = NULL;
     dev_B = NULL;
     dev_C = NULL;
     h_CUBLAS = NULL;
     return cudaStatus;
 }

 cudaError_t reduceEdge(){
     cudaError_t cudaStatus = cudaSuccess;
 Error:
     return cudaStatus;
 }