GPU编程自学5 —— 线程协作

深度学习的兴起，使得多线程以及GPU编程逐渐成为算法工程师无法规避的问题。这里主要记录自己的GPU自学历程。

五、线程协作

5.1 并行程序块的分解

首先回顾我们之前实现的矢量相加程序：

// 核函数：每个线程负责一个分量的加法
__global__ void addKernel(int *c, const int *a, const int *b)
{
    int i = threadIdx.x; // 获取线程ID
    c[i] = a[i] + b[i];
}

// 运行核函数，运行设置为1个block，每个block中size个线程
addKernel << <1, size >> >(dev_c, dev_a, dev_b);

通过前面小节，我们知道一个Block中的可开辟的线程数量是有限的(不超过1024)。

如果矢量特别长，上面的操作是会出现问题的。于是我们可以采用多个线程块(Block)来解决线程不足的问题。假如我们设定每个线程块包含128个线程，则需要的线程块的数量为 size / 128。为了避免不能整除带来的问题，我们可以稍微多开一点 (size + 127) / 128，但需要增加判断条件来避免越界。

// 核函数：每个线程负责一个分量的加法
__global__ void addKernel(int *c, const int *a, const int *b, const int size)
{
    int i = blockIdx.x * blockDim.x + threadIdx.x; // 获取线程ID
    if (i < size)
        c[i] = a[i] + b[i];
}

// 运行核函数，运行设置为多个block，每个block中128个线程
addKernel <<<(size + 127) / 128, 128 >>>(dev_c, dev_a, dev_b, size);

通过前面小节，我们同时也知道一个Grid中可开辟的Block数量也是有限的。

如果数据量大于 Block_num * Thread_num，那么我们就无法为每个分量单独分配一个线程了。不过，一个简单的解决办法就是在核函数中增加循环。

// 核函数：每个线程负责多个分量的加法
__global__ void addKernel(int *c, const int *a, const int *b, const int size)
{
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    while (i < size)
    {
        c[i] = a[i] + b[i];
        // 偏移分量等于一个Grid中包含的线程数量
        i += blockDim.x * gridDim.x;
    }
}

// 运行核函数，运行设置为1个Grid包含128个block，每个block包含128个线程
// 其中已经假设 size > 128*128
addKernel <<<128, 128 >>>(dev_c, dev_a, dev_b, size);

5.2 共享内存与同步

上面提到线程块的分解似乎是为了增加可用的线程数量，但这种说法并不靠谱，因为这完全可以由CUDA在幕后全权控制。其实，分解线程块的重要原因是因为内存。

在“4.3 内存结构”中我们已经知道，同一个Block中的线程可以访问一块共享内存。由于共享内存缓冲区驻留在物理GPU上，而不是GPU之外的系统内存上，因此访问共享内存的延迟要远远低于访问普通缓冲区的延迟。

不同Block之间存在隔离，如果我们需要不同线程之间进行通信，那么还需要考虑线程同步的问题。比如线程A将某个数值写入内存，然后线程B会对该数值进行一些操作，那么显然必须等A完成之后B才可以操作，如果没有同步，程序将会因进入“竞态条件”而产生意想不到的错误。

接下来我们通过一个矢量点积的例子来说明上述问题。

矢量点积的定义如下：

\((x_1,x_2,x_3,x_4)\cdot (y_1,y_2,y_3,y_4)=x_1y_1+x_2y_2+x_3y_3+x_4y_4\)

由上面的定义来看，点积的实现可以分为两步：

（1）计算每个分量的乘积，并暂存该结果；
（2）将所有临时结果加和。

我们先来简单实现下第一步：

// 定义我们的矢量长度
const int N = 64 * 256; 

// 定义每个Block中包含的Thread数量
const int threadsPerBlock = 256;  

// 定义每个Grid中包含的Block数量, 这里32 < 64， 是为了模拟线程数量不足的情况
const int blocksPerGrid = 32;

__global__ void dot( float *a, float *b, float *c )
{
    // 声明共享内存用于存储临时乘积结果，内存大小为1个Block中的线程数量
    // PS. 每个Block都相当于有一份程序副本，因此相当于每个Block都有这样的一份共享内存
    __shared__ float cache[threadsPerBlock];  

    // 线程索引
    int tid = threadIdx.x + blockIdx.x * blockDim.x;  

    // 一个Block中的线程索引
    int cacheIndex = threadIdx.x;  

    // 计算分量乘积，同时处理线程不足的问题
    float   temp = 0;
    while (tid < N) {
        temp += a[tid] * b[tid];
        tid += blockDim.x * gridDim.x;
    }  

    // 存储临时乘积结果
    cache[cacheIndex] = temp;
    }

执行完上面的部分，我们剩下的就是把cache中的值相加求和。但是，我们必须要保证所有乘积都已经计算完成，才能去计算求和。命令如下：

// 对线程块中的所有线程进行同步
// 线程块中的所有线程都执行完前面的代码后才会继续往后执行
__syncthreads();

求和最直接的方式就是循环累加，此时复杂度与数组长度成正比。不过我们可以再用一种更加高效的方法，其复杂度与数组长度的log成正比：将值两两合并，于是数据量减小一半，再重复两两合并直至全部计算完成。代码如下：

// 合并算法要求长度为2的指数倍
int i = blockDim.x/2;
while (i != 0)
{
    if (cacheIndex < i)
        cache[cacheIndex] += cache[cacheIndex + i];
    __syncthreads();
    i /= 2;
} 

// 最后将一个Block的求和结果进行保存
if (cacheIndex == 0)
        c[blockIdx.x] = cache[0];

下面给出完整的代码(简单起见，不再做错误检查)：

#include <iostream>

#include "cuda_runtime.h"

//定义矢量长度
const int N = 64 * 256;

// 定义每个Block中包含的Thread数量
const int threadsPerBlock = 256;

// 定义每个Grid中包含的Block数量, 这里32 < 64， 是为了模拟线程数量不足的情况
const int blocksPerGrid = 32;

// 核函数：矢量点积
__global__ void dot(float* a, float* b, float* c)
{
    // 声明共享内存用于存储临时乘积结果，内存大小为1个Block中的线程数量
    // PS. 每个Block都相当于有一份程序副本，因此相当于每个Block都有这样的一份共享内存
    __shared__ float cache[threadsPerBlock];

    // 线程索引
    int tid = blockIdx.x * blockDim.x + threadIdx.x;

    // 一个Block中的线程索引
    int cacheIndex = threadIdx.x;

    // 计算分量乘积，同时处理线程不足的问题
    float temp = 0.0f;
    while (tid < N)
    {
        temp += a[tid] * b[tid];
        tid  += gridDim.x * blockDim.x;
    }

    // 存储临时乘积结果
    cache[cacheIndex] = temp;

    // 对线程块中的所有线程进行同步
    // 线程块中的所有线程都执行完前面的代码后才会继续往后执行
    __syncthreads();

    // 合并算法要求长度为2的指数倍
    int i = threadsPerBlock / 2;
    while (i != 0)
    {
        if (cacheIndex < i)
            cache[cacheIndex] += cache[cacheIndex + i];
        __syncthreads();
        i /= 2;
    }

    if (cacheIndex == 0)
        c[blockIdx.x] = cache[0];
}

int main()
{
    // 在主机端创建数组
    float a[N];
    float b[N];
    float c[threadsPerBlock];
    for (size_t i = 0; i < N; i++)
    {
        a[i] = 1.f;
        b[i] = 1.f;
    }

    // 申请GPU内存
    float* dev_a = nullptr;
    float* dev_b = nullptr;
    float* dev_c = nullptr;
    cudaMalloc((void**)&dev_a, N * sizeof(float));
    cudaMalloc((void**)&dev_b, N * sizeof(float));
    cudaMalloc((void**)&dev_c, blocksPerGrid * sizeof(float));

    //将数据从主机copy进GPU
    cudaMemcpy(dev_a, a, N * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(dev_b, b, N * sizeof(float), cudaMemcpyHostToDevice);

    //进行点积计算
    dot<<<32, 256>>>(dev_a, dev_b, dev_c);

    //将计算结果copy回主机
    cudaMemcpy(c, dev_c, blocksPerGrid * sizeof(float), cudaMemcpyDeviceToHost);

    //将每个block的结果进行累加
    for (size_t i = 1; i < blocksPerGrid; i++)
        c[0] += c[i];

    // 输出结果
    std::cout << "The ground truth is 16384, our answer is " << c[0] << std::endl;

    //释放内存
    cudaFree(dev_a); cudaFree(dev_b); cudaFree(dev_c);

    system("pause");
    return 0;
}

参考资料：

《CUDA by Example: An Introduction to General-Purpose GPU Programming》中文名《GPU高性能编程CUDA实战》
深入理解CUDA点积运算 https://segmentfault.com/a/1190000007519944