Advertisement
ithoran

PSLab5Final

Jun 7th, 2018
316
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 2.48 KB | None | 0 0
  1. #include <stdio.h>
  2. #define SIZE 100
  3. #define BLOCKSIZE 100
  4.  
  5.  
  6. void HANDLE_ERROR(cudaError_t call)
  7. {
  8.     cudaError_t ret = call;
  9.     switch (ret)
  10.     {
  11.     case cudaSuccess:
  12.         break;
  13.     case cudaErrorInvalidValue:
  14.         printf("ERROR: InvalidValue:%i.\n", __LINE__);
  15.         exit(-1);
  16.         break;
  17.     case cudaErrorInvalidMemcpyDirection:
  18.         printf("ERROR:Invalid memcpy direction:%i.\n", __LINE__);
  19.         exit(-1);
  20.         break;
  21.     default:
  22.         printf("ERROR>line:%i.%d' ‘ %s\n", __LINE__, ret, cudaGetErrorString(ret));
  23.         exit(-1);
  24.         break;
  25.     }
  26. }
  27.  
  28. __device__ int pomnozi(int a, int b)
  29. {
  30.     return a*b;
  31. }
  32.  
  33. __global__ void compute(int *d_a, int* d_b, int* d_c)
  34. {
  35.     d_c[threadIdx.x] = 0;
  36.     for (int i = 0; i<SIZE; i++) {
  37.         int ela = d_a[threadIdx.x * SIZE + i];
  38.         int elb = d_b[i];
  39.         d_c[threadIdx.x] += pomnozi(ela, elb);
  40.     }
  41. }
  42.  
  43. __host__ void outer_compute(int* h_a, int* h_b, int* h_c)
  44. {
  45.     int *d_a, *d_b, *d_c, i;
  46.     HANDLE_ERROR(cudaMalloc((void **)& d_a, SIZE * SIZE * sizeof(int)));
  47.     HANDLE_ERROR(cudaMalloc((void **)& d_b, SIZE * sizeof(int)));
  48.     HANDLE_ERROR(cudaMalloc((void **)& d_c, BLOCKSIZE * sizeof(int)));
  49.  
  50.     //kopiranje nizova iz CPU u GPU
  51.     HANDLE_ERROR(cudaMemcpy(d_a, h_a, SIZE * SIZE * sizeof(int), cudaMemcpyHostToDevice));
  52.     HANDLE_ERROR(cudaMemcpy(d_b, h_b, SIZE * sizeof(int), cudaMemcpyHostToDevice));
  53.  
  54.     compute<<<1, BLOCKSIZE >>>(d_a, d_b, d_c);
  55.  
  56.     //sinhronizovanje i kopiranje niza iz GPU u CPU
  57.     cudaThreadSynchronize();
  58.     HANDLE_ERROR(cudaMemcpy(h_c, d_c, BLOCKSIZE * sizeof(int), cudaMemcpyDeviceToHost));
  59.  
  60.     cudaFree(d_a);
  61.     cudaFree(d_b);
  62.     cudaFree(d_c);
  63. }
  64.  
  65.  
  66. int main(int argc, char **argv)
  67. {
  68.     int i, j;
  69.     int a[SIZE * SIZE], b[SIZE], c_array[BLOCKSIZE];
  70.     int sumCuda = 0, sumClassic=0;
  71.    
  72.     //a = (int*) malloc(SIZE * sizeof(int));
  73.     /*for (i = 0; i < 100; i++) {
  74.         a[i] = (*int) malloc(SIZE * sizeof(int));
  75.     }*/
  76.  
  77.     //inicijalizacija
  78.     for (i = 0; i < SIZE; ++i) {
  79.         b[i] = i;
  80.         for (j = 0; j < SIZE; ++j) {
  81.             a[i * SIZE + j] = i * SIZE + j;
  82.         }
  83.     }
  84.    
  85.     //pozivanje host funkcije za CUDA i
  86.     outer_compute(a, b, c_array);
  87.     //Sabiranje rezultata dobijenih iz niti
  88.     for (i = 0; i < SIZE; i++) {
  89.         printf("Rezultat paralelni %d \n", c_array[i]);
  90.         c_array[i] = 0;
  91.     }
  92.    
  93.    
  94.     //sekvencijalan kod
  95.     for (i = 0; i<SIZE; i++) {
  96.         for (j = 0; j < SIZE; ++j)
  97.             c_array[i] += a[i * SIZE + j] * b[j];
  98.     }
  99.  
  100.  
  101.     for (i = 0; i < SIZE; i++) {
  102.         printf("Rezultat sekvencijalni %d \n", c_array[i]);
  103.         c_array[i] = 0;
  104.     }
  105.    
  106.     //printf("Razlika izmedju dva rezultata je %d",sumClassic-sumCuda);
  107. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement