【CUDA-4】初探並行計算

本文將計算兩個矢量（數組）的和。分別在CPU和GPU上進行計算。

/**
 * 並行計算
 */

#include <stdio.h>
#include <iostream>
#include<sys/time.h>

using namespace std;

#define N (200000)

void add_cpu(int *a, int *b, int *c)
{
    int tid = 0;

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

__global__ void add(int *a, int *b, int *c)
{
    int tid = blockIdx.x;

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

// CPU 求和
int main_cpu() 
{
    int a[N], b[N], c[N];

    struct timeval tv1, tv2;

    
    for (int i = 0; i < N; i++)
    {
        a[i] = -i;
        b[i] = i*i;
    }

    gettimeofday(&tv1, NULL);
    add_cpu(a, b, c);
    gettimeofday(&tv2, NULL);
    float time = (1000000 * (tv2.tv_sec - tv1.tv_sec) + tv2.tv_usec- tv1.tv_usec)/1000.0;
    cout << "time cpu： " << time << "ms, num : " << c[N-1] << endl;
    
    return 0;
}

// GPU 求和
int main(int argc, char const *argv[]) 
{   
    int a[N], b[N], c[N];

    int *dev_a, *dev_b, *dev_c;

    struct timeval tv1, tv2;

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

    // 在CPU上爲數組 a/b賦值
    // 這裏在CPU就給輸出數據賦初值，並沒有特殊原因。事實上，如果在GPU上對數組賦值，這個步驟執行的會更快。
    // 但是這段代碼的目的是說明如何在顯卡上實現兩個矢量的加法運算，因此我們僅僅將計算部分放在顯卡上實現，
    // 輸入則在CPU上進行。
    for(unsigned i = 0; i < N; ++i) 
    {
        a[i] = -i;
        b[i] = i*i;
    }

    cudaMemcpy(dev_a, a, N * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dev_b, b, N * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dev_c, c, N * sizeof(int), cudaMemcpyHostToDevice);

    gettimeofday(&tv1, NULL);

    // 調用kernel函數，<<<1,1>>>指gpu啓動1個線程塊，每個線程塊中有1個線程
    // <<<256,1>>>指gpu啓動256個線程塊，每個線程塊中有1個線程, 如果是這樣，就會有一個問題：
    // 既然GPU將運行核函數的N個副本，那如何在代碼中知道當前正在運行的是哪一個線程塊？
    // 這個問題可以在代碼中找出答案：
    // int tid = blockIdx.x
    // 乍一看，將一個沒有定義的變量賦值給了變量tid,但是 blockIdx 是一個內置變量，在cuda運行是中已經定義了。
    // 這個變量把包含的值就是當前執行設備代碼的的線程塊索引。
    // 
    // 問題又來了，爲什麼不是寫 int  tid = blockIdx呢？ 事實上，這是因爲cuda支持二維的線程塊數組，對於二維空間的計算問題，
    // 例如矩陣數學運算或者圖像處理，使用二維索引往往回答來很大的便利，因爲他可以避免將線性索引轉換爲矩形索引。
    add<<<1, 1>>>(dev_a, dev_b, dev_c);

    gettimeofday(&tv2, NULL);
    float time = (1000000 * (tv2.tv_sec - tv1.tv_sec) + tv2.tv_usec- tv1.tv_usec)/1000.0;
    cout << "time gpu： " << time << "ms";


    cudaMemcpy(c, dev_c,  N * sizeof(int), cudaMemcpyDeviceToHost);
    cout << ", num : " << c[N-1] << endl;

    cudaFree(dev_a);
    cudaFree(dev_b);
    cudaFree(dev_c);

    main_cpu();

    return 0;
}

// time gpu： 0.048ms
// time cpu： 1.248

當我把N設置的很大的時候 N = 200000
結果，這個時候GPU的運算速度是CPU的33.6倍

當我把N設置的比較小的時候 N = 200，此時很明顯CPU的運算速度超過了GPU
爲什麼會出現上述情況呢？
舉個例子說明：
比如說現在有2000個人要乘船過江去，如果論單個人的運輸速度，那麼摩托艇肯定快於大輪渡了；但是要是論全部運輸完所用的時間，那肯定輪渡早運輸完了，摩托艇還在飛快的跑着呢？

從理論上來說，1080TI有 3584換個CUDA核心，頻率是1582MHz, 2FLOPS/cycle，浮點性能358415822=11.3TFOPS。
每個CUDA核心 2FLOPS/cycle * 1.5G = 3GTFLOPS

同期Intel® Xeon® CPU E5-2620 v3 @ 2.40GHz 12核心。運算峯值：2.4x1232（32是V4處理器支持SIMD的速算因子，即一個始終週期內能做32次浮點運算）=1.34TFLOPS。
單核性能：2.432=76.8TFLOPS

如此看來，單核CPU的新能完勝GPU的單核；也就是說，在CUDA和很少的情況下，計算性能不如CPU； 但是架不住CUDA的核心多呀，人多力量大。

所以得出結論：CPU和 GPU的計算能力存在一個交叉點。過了這個交叉點，GPU遠遠超過了CPU.