Programa para sumar las columnas de una matriz en CUDA, programación en paralelo. Nsight

Programa para sumar las columnas de una matriz en CUDA

Primero se muestran los resultados y posteriormente el código. Recordar que se utiliza el Nsight de Nvidia sobre linux Ubuntu

PRIMERO

La matriz a inicial es:

0 0 0 0 0
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4

Los resultados deben ser:

10 10 10 10 10


Depues de compilar y ejecutar SE MUESTRA EL RESULTADO






LUEGO (CÓDIGO)

////////////////////////////////////////////////////////////////////////////////////////////////

// Includes
#include <stdio.h>

#define N 5 //512
#define BLOCK_DIM 5//512

__global__ void colsAdd (int *a, int *b);

int main() {
 int a[N][N], b[N];
 int *dev_a, *dev_b;
 int size_A = N * N * sizeof(int);
 int size_B = N * sizeof(int);
 int i,j;

 // initialize a and b with real values (NOT SHOWN)
 for(i=0;i<N;i++){
     for(j=0;j<N;j++){
         a[i][j]=i;
         printf("%d ",a[i][j]);
     }
     b[i]=0;
     printf("b%d \n",b[i]);
 }


 // Allocate en device
 cudaMalloc(&dev_a, size_A);
 cudaMalloc(&dev_b, size_B);

 // Inicializo matrices en el device
 cudaMemcpy(dev_a, a, size_A, cudaMemcpyHostToDevice);
 cudaMemset(b ,0, N * sizeof(int));
 //cudaMemcpy(dev_b, b, size, cudaMemcpyHostToDevice);

 // Invocar el kernel que suma en GPU
 //dim3 dimBlock(BLOCK_DIM, BLOCK_DIM);
 //dim3 dimGrid((int)ceil(N/dimBlock.x),(int)ceil(N/dimBlock.y));
 //colsAdd<<<dimGrid,dimBlock>>>(dev_a,dev_b);

 //Lanzamiento de threads con un solo bloque
 // configuración de la ejecución
dim3 dimBlock(BLOCK_DIM, BLOCK_DIM);
dim3 dimGrid((int)ceil(N/dimBlock.x),(int)ceil(N/dimBlock.y));
 // lanzamiento del kernel
 colsAdd<<<dimGrid,dimBlock>>>(dev_a,dev_b);


 // Traer resultado
 cudaMemcpy(b, dev_b, size_B, cudaMemcpyDeviceToHost);

 for(i=0;i<N;i++){
      printf("%d ",b[i]);
  }


 cudaFree(dev_a); cudaFree(dev_b);
}

// Suma por columnas de una matriz
__global__ void colsAdd (int* a, int* b) {

//int col = blockIdx.x * blockDim.x + threadIdx.x;
//int row = blockIdx.y * blockDim.y + threadIdx.y;

int Pvalue=0;
 for (int k = 0; k < N; ++k) {
    Pvalue = Pvalue + a[threadIdx.y+k*N];
 }
 b[threadIdx.y] = Pvalue;

}

////////////////////////////////////////////////////////////////////////////////////////////////

 




REFERENCIAS
Algunas páginas de ayuda
http://www.fing.edu.uy/inco/cursos/gpgpu/clases/P12xh.pdf
http://computacion.cs.cinvestav.mx/~ameneses/pub/notas/cuda_taller.pdf
http://users.wfu.edu/choss/CUDA/docs/Lecture%205.pdf

http://www.3dgep.com/introduction-to-cuda-5-0/