Как я могу сделать процесс GPU намного быстрее, чем процесс с помощью CUDA 10.0 в Visual Studio 2017? - PullRequest
Новая
       151

Как я могу сделать процесс GPU намного быстрее, чем процесс с помощью CUDA 10.0 в Visual Studio 2017?

0 голосов
/ 19 ноября 2018

Умный разработчик! Я новичок в программировании CUDA, и у меня большая проблема с моим кодом.

Следующий код является примером кода от Nvidia, и я немного изменился, чтобы показывать процесс на GPU намного быстрее, чем процесс на процессоре. Однако после компиляции этого кода я получил неожиданный результат от того, что процесс в ЦП намного быстрее, чем процесс в графическом процессоре.

Это информация о моем ноутбуке.

Это мой код cuda для Visual Studio 2017.

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

#define N 10

Это функция add2 () из процесса GPU 

`___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];
}
}

Это функция добавления () из процесса CPU 

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

    int tid = 0;

while (tid < N) {
    c[tid] = a[tid] + b[tid];
    tid += 1;
}
}

Это основная функция () 

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 = %d\n", 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 = %d\n", a[i], b[i], c[i]);
         }

    //Free GPU values
         cudaFree(dev_a);
         cudaFree(dev_b);
         cudaFree(dev_c);

         return 0;
}

Это результат компиляции этого кода.

Я хочу, чтобы процесс GPU выполнялся намного быстрее, чем процесс.

1 Ответ

0 голосов
/ 19 ноября 2018

Обычно GPU медленнее, чем центральный процессор, для выполнения одной операции. Кроме того, для отправки данных в графический процессор и их повторного чтения требуется время.

Преимущество графического процессора в том, что он может выполнять множество операций параллельно.

Поскольку вы определили N как 10, загрузка и выгрузка данных, вероятно, займет больше времени, чем выполнение в ЦП. Чтобы увидеть преимущества графического процессора, увеличьте размер проблемы до чего-то гораздо большего. В идеале вы хотите выполнить как минимум несколько операций на каждом ядре графического процессора, прежде чем начнете видеть какую-то выгоду. Например, с 1280 ядрами вашего GPU вы захотите выполнить что-то вроде 4000 или более операций одновременно, чтобы получить выгоду от GPU.

...