Agfdhyk

Smart developer!
I am the beginner of CUDA programming and I have a big problem with my code.

Following code is a sample code from Nvidia and I changed a little bit for showing the GPU process much faster than from CPU process. However, after compiling this code, I got a unexpected result from that CPU process is much faster than GPU process.

This is my laptop gpu info.

This is my cuda code for Visual Studio 2017.

===========================================================================

#define N 10

This is add2 function() from GPU process

`___global____  void add2(int *a, int *b, int *c) {`



    // GPU block from grid sector

    //int tid = blockIdx.x;     // checking the data of index  = if you 



insert min of N, you will get slow result from CPU. But if you put big number, this show much faster than CPU



// GPU thread

//int tid = threadIdx.x;    // Same result as blockIdx.x



// GPU unexpected vector    // Same result as above

int tid = threadIdx.x + blockIdx.x*blockDim.x;

if (tid < N) {

    c[tid] = a[tid] + b[tid];

}

}

This is add function() from CPU process

`void add(int *a, int *b, int *c) {



    int tid = 0;



while (tid < N) {

    c[tid] = a[tid] + b[tid];

    tid += 1;

}

}

This is Main function()

int main() {



    // Values for time duration

         LARGE_INTEGER tFreq, tStart, tEnd;

         cudaEvent_t start, stop;

         float tms, ms;



         int a[N], b[N], c[N];  // CPU values

         int *dev_a, *dev_b, *dev_c;    // GPU values----------------------------------------------



          // Creating alloc for GPU--------------------------------------------------------------

         cudaMalloc((void**)&dev_a, N * sizeof(int));

         cudaMalloc((void**)&dev_b, N * sizeof(int));

         cudaMalloc((void**)&dev_c, N * sizeof(int));



    // Fill 'a' and 'b' from CPU

         for (int i = 0; i < N; i++) {

            a[i] = -i;

            b[i] = i * i;

        }



    // Copy values of CPU to GPU values----------------------------------------------------

         cudaMemcpy(dev_a, a, N * sizeof(int), cudaMemcpyHostToDevice);

         cudaMemcpy(dev_b, b, N * sizeof(int), cudaMemcpyHostToDevice);





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

         QueryPerformanceFrequency(&tFreq);  // Frequency set

         QueryPerformanceCounter(&tStart);   // Time count Start



    // CPU operation

         add(a, b, c);



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

         QueryPerformanceCounter(&tEnd);     // TIme count End

         tms = ((tEnd.QuadPart - tStart.QuadPart) / (float)tFreq.QuadPart) * 1000;

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



    // show result of CPU

         cout << fixed;

         cout.precision(10);

         cout << "CPU Time=" << tms << endl << endl;



         for (int i = 0; i < N; i++) {

             printf("CPU calculate = %d + %d = %dn", a[i], b[i], c[i]);

         }



         cout << endl;



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

         cudaEventCreate(&start);

         cudaEventCreate(&stop);

         cudaEventRecord(start, 0);

    // GPU operatinog---------------------------------------------------------------------

         //add2 <<<N,1 >>> (dev_a, dev_b, dev_c);   // block

         //add2 << <1,N >> > (dev_a, dev_b, dev_c); // Thread

         add2 << <N/32+1, 32 >> > (dev_a, dev_b, dev_c);   // grid



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

         cudaEventRecord(stop, 0);

         cudaEventSynchronize(stop);

         cudaEventElapsedTime(&ms, start, stop);

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



    // show result of GPU

         cudaMemcpy(c, dev_c, N * sizeof(int), cudaMemcpyDeviceToHost);

         cout << fixed;

         cout.precision(10);

         cout << "GPU Time=" << ms << endl << endl;





         for (int i = 0; i < N; i++) {

              printf("GPU calculate = %d + %d = %dn", a[i], b[i], c[i]);

         }



    //Free GPU values

         cudaFree(dev_a);

         cudaFree(dev_b);

         cudaFree(dev_c);



         return 0;

}

This is result of compiling this code.

I want to make GPU process much faster than CPU process.

The GPU is generally actually slower than the CPU for running a single operation. Additionally it takes time to send data to the GPU and read it back again.

The advantage of the GPU is it can execute many operations in parallel.

As you have defined N to be 10 it probably takes longer to upload and download the data than to execute on the CPU. In order to see the advantage of the GPU increase your problem size to something much larger. Ideally you want to execute a minimum of a few operations on each GPU core before you start seeing some benefit. For example with your GPU's 1280 cores you would want to execute something like 4000 operations or more at once to get the benefit of the GPU.