Opération de transposition matricielle très lente avec CUBLAS

Question

J'essaie de paralléliser une opération de transposition matricielle en utilisant la bibliothèque CUBLAS (avec la fonction cublasSgeam). Les données de sortie sont correctes, mais il prend en moyenne 150 fois plus de temps que ma version CPU. Pourquoi?

code CPU (pour la transposition d'une matrice de N = 5000 par M=140)

// Starting the timer 
    float *matrixT = (float *) malloc (N * M * sizeof(float)); 
    for (int i = 0; i < N; i++) 
     for (int j = 0; j < M; j++) 
      matrixT[(j*N)+i] = matrix[(i*M)+j]; // matrix is obviously filled 

//Ending the timer 

de code GPU (pour la transposition d'une matrice de N = 5000 par M=140)

float *h_matrixT , *d_matrixT , *d_matrix; 
    h_matrixT = (float *) malloc (N * M * sizeof(float)); 
    cudaMalloc((void **)&d_matrixT , N * M * sizeof(float))); 
    cudaMalloc((void**)&d_matrix , N * M * sizeof(float))); 
    cudaMemcpy(d_matrix , matrix , N * M * sizeof(float) , cudaMemcpyHostToDevice)); 

//Starting the timer 

    const float alpha = 1.0; 
    const float beta = 0.0; 
    cublasHandle_t handle; 
    cublasCreate(&handle); 
    cublasSgeam(handle, CUBLAS_OP_T, CUBLAS_OP_N, N, M, &alpha, d_matrix, M, &beta, d_matrix, N, d_matrixT, N); 
    cublasDestroy(handle); 

//Ending the timer 

    cudaMemcpy(h_matrixT , d_matrixT , N * M * sizeof(float) , cudaMemcpyDeviceToHost)); 


    cudaFree(d_matrix); 
    cudaFree(d_matrixT); 

des temps écoulés

CUBLAS: 148.461 ms

CPU: 0.986944 ms

PS:Fonctionnant sur GeForce GTX 660 & Intel Core i5 660

Answer 1

exécuter votre code avec l'un des profilers pour voir où l'heure est passée.

Déplacez la fonction cublasCreate hors de votre région de synchronisation. Cela prend toutes sortes de CUDA et le temps de démarrage de la bibliothèque, qui ne devrait pas être incorporé dans l'évaluation d'une seule fonction (ou si vous avez l'intention de comparer cela, il est évidemment inutile d'utiliser un GPU pour effectuer cette fonction. Il ne l'accélèrera pas, comme vous l'avez découvert.)

Je vous recommande également de retirer le cublasDestroy de la boucle de synchronisation.

Vous pouvez ensuite inclure un cudaDeviceSynchronize(); avant votre fermeture de synchronisation finale.

Voici un exemple bien travaillé, en choisissant M = 1000 et N = 1000, avec les modifications ci-dessus mis en œuvre:

$ cat t469.cu 
#include <stdio.h> 
#include <cublas_v2.h> 
#include <time.h> 
#include <sys/time.h> 
#define uS_PER_SEC 1000000 
#define uS_PER_mS 1000 
#define N 1000 
#define M 1000 

int main(){ 

    timeval t1, t2; 
    float *matrix = (float *) malloc (N * M * sizeof(float)); 
// Starting the timer 
    gettimeofday(&t1, NULL); 
    float *matrixT = (float *) malloc (N * M * sizeof(float)); 
    for (int i = 0; i < N; i++) 
     for (int j = 0; j < M; j++) 
      matrixT[(j*N)+i] = matrix[(i*M)+j]; // matrix is obviously filled 

//Ending the timer 
    gettimeofday(&t2, NULL); 
    float et1 = (((t2.tv_sec*uS_PER_SEC)+t2.tv_usec) - ((t1.tv_sec*uS_PER_SEC)+t1.tv_usec))/(float)uS_PER_mS; 
    printf("CPU time = %fms\n", et1); 

    float *h_matrixT , *d_matrixT , *d_matrix; 
    h_matrixT = (float *) (malloc (N * M * sizeof(float))); 
    cudaMalloc((void **)&d_matrixT , N * M * sizeof(float)); 
    cudaMalloc((void**)&d_matrix , N * M * sizeof(float)); 
    cudaMemcpy(d_matrix , matrix , N * M * sizeof(float) , cudaMemcpyHostToDevice); 

//Starting the timer 
    gettimeofday(&t1, NULL); 

    const float alpha = 1.0; 
    const float beta = 0.0; 
    // gettimeofday(&t1, NULL); 
    cublasHandle_t handle; 
    cublasCreate(&handle); 
    gettimeofday(&t1, NULL); 
    cublasSgeam(handle, CUBLAS_OP_T, CUBLAS_OP_N, N, M, &alpha, d_matrix, M, &beta, d_matrix, N, d_matrixT, N); 
    cudaDeviceSynchronize(); 
    gettimeofday(&t2, NULL); 
    cublasDestroy(handle); 

//Ending the timer 
    float et2 = (((t2.tv_sec*uS_PER_SEC)+t2.tv_usec) - ((t1.tv_sec*uS_PER_SEC)+t1.tv_usec))/(float)uS_PER_mS; 
    printf("GPU time = %fms\n", et2); 

    cudaMemcpy(h_matrixT , d_matrixT , N * M * sizeof(float) , cudaMemcpyDeviceToHost); 


    cudaFree(d_matrix); 
    cudaFree(d_matrixT); 
    return 0; 
} 
$ nvcc -O3 -arch=sm_20 -o t469 t469.cu -lcublas 
$ ./t469 
CPU time = 8.744000ms 
GPU time = 0.327000ms 
$ 

Si au contraire, je modifier le code ci-dessus pour laisser la fonction de synchronisation départ avant la cublasCreate appel, je reçois ceci:

$ ./t469 
CPU time = 9.475000ms 
GPU time = 78.393997ms 
$