cuda学习笔记(2)

上篇笔记中记录了cuda核函数的写法及调用的方法，并简单的介绍了grid，block，thread 的概念，即指定多少个线程来执行核函数。上篇例子演示了一个简单的N维数组（N很小）的例子，例子中调用了N个block,每个block分配一个线程，共N个并行的线程执行 c[N] = a[N] + b[N] 运算。 本篇扩展上篇内容，记录两个N维（N大于gpu可并行运算的线程数）数组点乘的运算 $A\cdot B = a_{0}*b_{0}+a_{1}*b_{1}+......+a_{N-2}*b_{N-2}+a_{N-1}*b_{N-1}$ 。展示了:

• 大维度数组运算核函数的写法
• 用cuda共享内存（__ share __ ）进行核函数线程间交互与同步（__syncthreads () ）的方法

1. 大维度数组运算核函数的写法

当数组维度N大于gpu可并行运算的线程数时，我们将数组分成不同partial,每个partial都是一个小数组，在一个线程中执行运算。上篇例子中核函数如下：

__global__ void add( int *a, int *b, int *c ) 
{
    int tid = blockIdx.x;    // this thread handles the data at its thread id
    if (tid < N)
        c[tid] = a[tid] + b[tid];
}

由于N很小，我们可以直接调用N个block，每个block一个线程，每个线程执行数组的索引（tid）不同。但当N大于gpu可调用的并行运算数时，我们就要把数组分成不同的partial,每个线程要循环以执行多个数组的索引。示例代码如下：

__global__ void add( int *a, int *b, int *c ) {
    int tid = blockIdx.x;
    while (tid < N) {
        c[tid] = a[tid] + b[tid];
        tid += gridDim.x;
    }
}

对比 if 跟 while 的不同。因为每个线程要执行多次运算，每次运算执行数组不同的索引，所以 tid 要进行更新！

2. 线程交互（共享内存）与同步

cuda变量声明时，在前面加上 __ share __ 关键字就可声明为共享变量。同一个block中的多个线程可并行的操作共享内存中的数据; 声明的共享变量会在每一个block中都有一份拷贝; 但不同block之间的共享变量不能互相访问。 对同一个block中的共享内存进行操作时读跟写不能冲突（需要用原子操作保证，后文再介绍），还有就是针对有前后步骤依赖的，前后时序不能乱，这时就需要用__syncthreads () 函数进行线程同步。下面用两个长数组的点乘（dot produce)来进行示例说明。

长维度数组的点乘运算可以拆成三步：第一步，先把长维度数组分成多个partial, 每个partial执行对应元素的乘法，并先将每个partial对应元素乘法的结果进行相加，将相加结果保存在共享数组中。由于共享内存数据只能在各个block内部访问，所以这里的相加结果只是每个block中的每个线程各自切分到的数据和; 第二步，用二分法（ O(log2) 复杂度）把各个block中的共享数组中的数据（各个block内所有线程的数据）加到一起，并将最终和保存在 index_0 地址中; 第三步，把所有block中的和的结果加到一起，就是最终的点乘结果。

需要注意的是执行第二步之前，需要确保所有线程的第一步都已经执行完成，所以要注意添加线程同步函数; 需要注意的是第二步二分法循环执行过程中，每下一步二分都要确保上一步所有线程执行完成，所以需要添加线程同步函数。需要指出的是，第三步在cpu中执行速度更快，所以核函数只需要完成前两步运算。

下面是示例代码：dot.cu

#include "../common/book.h"

#define imin(a,b) (a<b?a:b)

const int N = 33 * 1024;
const int threadsPerBlock = 256;
const int blocksPerGrid =
            imin( 32, (N+threadsPerBlock-1) / threadsPerBlock );


__global__ void dot( float *a, float *b, float *c ) {
    __shared__ float cache[threadsPerBlock];
    int tid = threadIdx.x + blockIdx.x * blockDim.x;
    int cacheIndex = threadIdx.x;

    float   temp = 0;
    while (tid < N) {
        temp += a[tid] * b[tid];
        tid += blockDim.x * gridDim.x;
    }
    
    // set the cache values
    cache[cacheIndex] = temp;
    
    // synchronize threads in this block
    __syncthreads();

    // for reductions, threadsPerBlock must be a power of 2
    // because of the following code
    int i = blockDim.x/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( void ) {
    float   *a, *b, c, *partial_c;
    float   *dev_a, *dev_b, *dev_partial_c;

    // allocate memory on the cpu side
    a = (float*)malloc( N*sizeof(float) );
    b = (float*)malloc( N*sizeof(float) );
    partial_c = (float*)malloc( blocksPerGrid*sizeof(float) );

    // allocate the memory on the GPU
    HANDLE_ERROR( cudaMalloc( (void**)&dev_a,
                              N*sizeof(float) ) );
    HANDLE_ERROR( cudaMalloc( (void**)&dev_b,
                              N*sizeof(float) ) );
    HANDLE_ERROR( cudaMalloc( (void**)&dev_partial_c,
                              blocksPerGrid*sizeof(float) ) );

    // fill in the host memory with data
    for (int i=0; i<N; i++) {
        a[i] = i;
        b[i] = i*2;
    }

    // copy the arrays 'a' and 'b' to the GPU
    HANDLE_ERROR( cudaMemcpy( dev_a, a, N*sizeof(float),
                              cudaMemcpyHostToDevice ) );
    HANDLE_ERROR( cudaMemcpy( dev_b, b, N*sizeof(float),
                              cudaMemcpyHostToDevice ) ); 

    dot<<<blocksPerGrid,threadsPerBlock>>>( dev_a, dev_b,
                                            dev_partial_c );

    // copy the array 'c' back from the GPU to the CPU
    HANDLE_ERROR( cudaMemcpy( partial_c, dev_partial_c,
                              blocksPerGrid*sizeof(float),
                              cudaMemcpyDeviceToHost ) );

    // finish up on the CPU side
    c = 0;
    for (int i=0; i<blocksPerGrid; i++) {
        c += partial_c[i];
    }

    #define sum_squares(x)  (x*(x+1)*(2*x+1)/6)
    printf( "Does GPU value %.6g = %.6g?\n", c,
             2 * sum_squares( (float)(N - 1) ) );

    // free memory on the gpu side
    HANDLE_ERROR( cudaFree( dev_a ) );
    HANDLE_ERROR( cudaFree( dev_b ) );
    HANDLE_ERROR( cudaFree( dev_partial_c ) );

    // free memory on the cpu side
    free( a );
    free( b );
    free( partial_c );
}