【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.