Exemplos de Multiplicação de Matrizes em CUDA.

1. Multiplicação de Matrizes em CUDA Divino César SoaresPontifícia Universidade Católica de Goiás (CMP/PUC-GO)

3. Gerar uma matriz resultado C com as mesmas dimensões das matrizes A e B.

4. Cada elemento (i, j) da matriz C é o produto (interno) da linha i de A pela coluna j de B.

5. Para cada elemento (i, j) de C:for (k=1; k<=LARGURA; k++) C[i][j] += (A[i][k] * B[k][j]);

14. Estrutura da Solução Alocar memória na GPU. Copia dados de entrada. Da CPU para a GPU. Configura execução. Número de threads e blocos. Copia resultados. cudaMalloc((void **)&A_d, size_A); cudaMalloc((void**)&B_d, size_B); cudaMalloc((void**)&C_d, size_C); cudaMemcpy(A_d, A, size_A, cudaMemcpyHostToDevice); cudaMemcpy(B_d, B, size_B , cudaMemcpyHostToDevice); cudaMemcpy(C_d, C, size_C , cudaMemcpyHostToDevice); dim3 gride(X, Y)dim3 bloco(Z, W, K)meu_kernel<<<gride, bloco>>>(A, B, C); cudaMemcpy(C, C_d, size_C , cudaMemcpyDeviceToHost);

15. Primeira Abordagem

16. Kernel 1 dim3 gride(1, 1) dim3 bloco(4, 4, 1) dim3 gride(2, 1) dim3 bloco(4, 4, 1) dim3 gride(1, 1) dim3 bloco(30, 30, 1) Gride Gride Gride << Launcherror >>> Bloco com 600 threads Bloco 0 Bloco 0 Bloco 1

17. Kernel 1 dim3 gride(1, 1) dim3 bloco(LARGURA, LARGURA, 1) Gride LARGURA LARGURA Bloco 0

18. Kernel 1 dim3 gride(1, 1) dim3 bloco(LARGURA, LARGURA, 1) Gride __global__voidmulGpu(int *A[], int *B[], int *C[]) { int i = threadIdx.x; int j = threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } LARGURA LARGURA Bloco 0 Kernel 1: Multiplicação na GPU

19. Kernel 1 1 Instante de tempo t=0 2 __global__voidmulGpu(int *A[], int *B[], int *C[]) { int i = threadIdx.x; int j = threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 1: Multiplicação na GPU 4 1 2 3

20. Kernel 1 1 Instante de tempo t=1 2 __global__voidmulGpu(int *A[], int *B[], int *C[]) { int i = threadIdx.x; int j = threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 1: Multiplicação na GPU 4 1 2 3

21. Kernel 1 1 Instante de tempo t=2 2 __global__voidmulGpu(int *A[], int *B[], int *C[]) { int i = threadIdx.x; int j = threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 1: Multiplicação na GPU 4 1 2 3

22. Kernel 1 1 Instante de tempo t=L 2 __global__voidmulGpu(int *A[], int *B[], int *C[]) { int i = threadIdx.x; int j = threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 1: Multiplicação na GPU 4 1 2 3

24. Segunda Abordagem

25. Kernel 2 dim3 gride(2, 2) dim3 bloco(15, 15, 1) dim3 gride(1, 1) dim3 bloco(30, 30, 1) Gride Gride << Launcherror >>> Bloco com 600 threads Bloco 0, 0 Bloco 0, 1 Bloco 1, 0 Bloco 1, 1

26. Kernel 2 dim3 gride(2, 2) dim3 bloco(15, 15, 1) Gride Bloco 0, 0 Bloco 0, 1 225 threads por bloco.Total de 900 threads. Bloco 1, 0 Bloco 1, 1

27. Kernel 2 dim3 gride(2, 2) dim3 bloco(15, 15, 1) Gride __global__void mulGpu2(int *A[], int *B[], int *C[]) { int i = blockIdx.x * SUB_LARGURA + threadIdx.x; int j = blockIdx.y * SUB_LARGURA + threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } Bloco 0, 0 Bloco 0, 1 Kernel 2: Multiplicação na GPU Bloco 1, 0 Bloco 1, 1

28. Kernel 2 1 2 __global__void mulGpu2(int *A[], int *B[], int *C[]) { int i = blockIdx.x * SUB_LARGURA + threadIdx.x; int j = blockIdx.y * SUB_LARGURA + threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 2: Multiplicação na GPU 4 1 2 3

29. Kernel 2 1 2 __global__void mulGpu2(int *A[], int *B[], int *C[]) { int i = blockIdx.x * SUB_LARGURA + threadIdx.x; int j = blockIdx.y * SUB_LARGURA + threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 2: Multiplicação na GPU 4 1 2 3

30. Kernel 2 1 2 __global__void mulGpu2(int *A[], int *B[], int *C[]) { int i = blockIdx.x * SUB_LARGURA + threadIdx.x; int j = blockIdx.y * SUB_LARGURA + threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 2: Multiplicação na GPU 4 1 2 3

31. Kernel 2 1 Instante de tempo t=L 2 __global__void mulGpu2(int *A[], int *B[], int *C[]) { int i = blockIdx.x * SUB_LARGURA + threadIdx.x; int j = blockIdx.y * SUB_LARGURA + threadIdx.y; for (int k=1; k<=LARGURA; k++) { C[i][j] += (A[i][k] * B[k][j]); } } 3 4 Kernel 2: Multiplicação na GPU 4 1 2 3

33. Dúvidas?