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 );
}