alexsetyaev

task_3_div

Sep 28th, 2021 (edited)
555
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <stdlib.h>
  3. #include <math.h>
  4.  
  5. __global__ void vecAdd(double *A, double *B, double *C, int n){
  6.         int idx = blockIdx.x * blockDim.x + threadIdx.x;
  7.  
  8.         if (idx < n){
  9.                 if (idx%2 == 0){
  10.  
  11.                                 C[idx] = A[idx] + B[idx];
  12.  
  13.                 }
  14.                 else{
  15.  
  16.  
  17.                                 C[idx] = A[idx] * B[idx];
  18.  
  19.                 }
  20.         }
  21. }
  22.  
  23. int main(int argc, char **argv){
  24.         if (argc != 2){
  25.                 std::cerr << "Wrong arguments" << std::endl;
  26.                 return 1;
  27.         }
  28.         int n = atoi(argv[1]);
  29.         double *h_a, *h_b, *h_c;
  30.         size_t bytes = n *sizeof(double);
  31.  
  32.         h_a = (double*)malloc(bytes);
  33.         h_b = (double*)malloc(bytes);
  34.         h_c = (double*)malloc(bytes);
  35.  
  36.         for (int i = 0; i < n; ++i){
  37.                 h_a[i] = sin(i)*sin(i);
  38.                 h_b[i] = cos(i)*cos(i);
  39.         }
  40.  
  41.         double *d_a, *d_b, *d_c;
  42.  
  43.         cudaMalloc(&d_a, bytes);
  44.         cudaMalloc(&d_b, bytes);
  45.         cudaMalloc(&d_c, bytes);
  46.  
  47.         cudaMemcpy(d_a, h_a, bytes, cudaMemcpyHostToDevice);
  48.         cudaMemcpy(d_b, h_b, bytes, cudaMemcpyHostToDevice);
  49. int block_size, grid_size;
  50.         block_size = 1024;
  51.         grid_size = (n-1)/block_size + 1;
  52.  
  53.  
  54.         cudaEvent_t start_gpu, stop_gpu;
  55.         cudaEventCreate(&start_gpu);
  56.         cudaEventCreate(&stop_gpu);
  57.  
  58.         cudaEventRecord(start_gpu);
  59.  
  60.         vecAdd<<<grid_size, block_size>>>(d_a, d_b, d_c, n);
  61.  
  62.         cudaDeviceSynchronize();
  63.         cudaEventRecord(stop_gpu);
  64.  
  65.         float delta = 0.0;
  66.         cudaEventElapsedTime(&delta, start_gpu, stop_gpu);
  67.  
  68.  
  69.  
  70.         cudaMemcpy(h_c, d_c, bytes, cudaMemcpyDeviceToHost);
  71.         /*
  72.         for (int i = 0; i < n; ++i){
  73.                 std::cout << h_c[i] << std::endl;
  74.         }*/
  75.        
  76.        
  77.         std::cout << "Elapsed time" << delta << std::endl;
  78.        
  79.         cudaFree(d_a);
  80.         cudaFree(d_b);
  81.         cudaFree(d_c);
  82.  
  83.         free(h_a);
  84.         free(h_b);
  85.         free(h_c);
  86.  
  87.  
  88.         return 0;
  89. }
  90.  
RAW Paste Data