<p>CUDA編程首先呢是分配thread以及block<p>

#include<stdio.h>
#include<time.h>
#include<cuda_runtime.h>   //cuda運(yùn)行時(shí)間接口
#define Thread_Num 256     //每一block包含的線程數(shù)
#define Matrix_Size 10
const int block_num=(Matrix_Size+Thread_Num-1)/Thread_Num;

然后是兩個(gè)基本的函數(shù)：
//打印設(shè)備信息

void printDeviceProp(const cudaDeviceProp &prop)
{
    printf("Device Name : %s.\n", prop.name);
    printf("totalGlobalMem : %d.\n", prop.totalGlobalMem);
    printf("sharedMemPerBlock : %d.\n", prop.sharedMemPerBlock);
    printf("regsPerBlock : %d.\n", prop.regsPerBlock);
    printf("warpSize : %d.\n", prop.warpSize);
    printf("memPitch : %d.\n", prop.memPitch);
    printf("maxThreadsPerBlock : %d.\n", prop.maxThreadsPerBlock);
    printf("maxThreadsDim[0 - 2] : %d %d %d.\n", prop.maxThreadsDim[0],    prop.maxThreadsDim[1], prop.maxThreadsDim[2]);
    printf("maxGridSize[0 - 2] : %d %d %d.\n", prop.maxGridSize[0], prop.maxGridSize[1], prop.maxGridSize[2]);
    printf("totalConstMem : %d.\n", prop.totalConstMem);
    printf("major.minor : %d.%d.\n", prop.major, prop.minor);
    printf("clockRate : %d.\n", prop.clockRate);
    printf("textureAlignment : %d.\n", prop.textureAlignment);
    printf("deviceOverlap : %d.\n", prop.deviceOverlap);
    printf("multiProcessorCount : %d.\n", prop.multiProcessorCount);
}

//初始化cuda

bool InitCUDA()
{
    int count;
    cudaGetDeviceCount(&count);
    if(count==0){
        fprintf(stderr,"three is no device.\n");
        return false;
    }
    int i;
    for(i=0;i<count;i++)
    {
        cudaDeviceProp prop;
        cudaGetDeviceProperties(&prop,i);
        printDeviceProp(prop);
        if(cudaGetDeviceProperties(&prop,i)==cudaSuccess){
            if(prop.major>=1){break;}
        }
    }
    if (i == count) {
        fprintf(stderr, "There is no device supporting CUDA 1.x.\n");
        return false;
    }
    cudaSetDevice(i);
    return true;
}

//接著隨機(jī)生成兩個(gè)矩陣

void matGen(float* a, int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            a[i*n+j]=(float)rand()/(float)RAND_MAX+1.00;
        }
    }
}

//并行矩陣乘法函數(shù)，最主要的一部分

__global__ static void matMultCuda(const float* a,const float* b,float* c,int n,clock_t* time)
{
    const int tid=threadIdx.x;
    const int bid=blockIdx.x;

    //從 bid 和 tid 計(jì)算出這個(gè) thread 應(yīng)該計(jì)算的 row 和 column
    const int idx = bid * Thread_Num + tid;
    const int row = idx / n;
    const int column = idx % n;

    int i;
    //clock_t start;
    
    //每個(gè)block開始時(shí)記錄
    if(tid==0) time[bid]=clock();

    //計(jì)算矩陣乘法
    if(row < n && column < n)
    {
        float t=0;
        for(i=0;i<n;i++)
        {
            t=t+a[row*n+i]+a[i*n+column];
        }
        c[row*n+column]=t;
    }
    //計(jì)算時(shí)間,記錄結(jié)果，只在 thread 0（即 threadIdx.x = 0 的時(shí)候）進(jìn)行，每個(gè) block 都會記錄開始時(shí)間及結(jié)束時(shí)間
    if (tid == 0) time[bid + block_num] = clock();
}

//運(yùn)算完后打印出矩陣

void printMatrix(const float *A, const int n) {
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            printf("%.2f" ,A[i*n+j]);
            printf(" ");
        }
        printf("\n");
    }
    printf("\n");
}

//最后我們來看一下主函數(shù)

int main()
{
    if(!InitCUDA()) return 0;
    float *a,*b,*c;
    int n=Matrix_Size;

    //分配內(nèi)存
    a=(float*)malloc(sizeof(float)*n*n);
    b=(float*)malloc(sizeof(float)* n*n);
    c=(float*)malloc(sizeof(float)* n*n);

    //設(shè)置隨機(jī)種子
    srand(0);

    //隨機(jī)生成兩個(gè)矩陣
    matGen(a,n);
    matGen(b,n);

    float *cuda_a,*cuda_b,*cuda_c;
    clock_t* time;

    //cudaMalloc 獲取一塊顯卡內(nèi)存
    cudaMalloc((void**)&cuda_a, sizeof(float)* n*n);
    cudaMalloc((void**)&cuda_b, sizeof(float)* n*n);
    cudaMalloc((void**)&cuda_c, sizeof(float)* n*n);
    cudaMalloc((void**)&time, sizeof(clock_t)* block_num*2);

    //cudaMemcpy 將產(chǎn)生的矩陣復(fù)制到顯卡內(nèi)存中
    //cudaMemcpyHostToDevice - 從內(nèi)存復(fù)制到顯卡內(nèi)存
    //cudaMemcpyDeviceToHost - 從顯卡內(nèi)存復(fù)制到內(nèi)存
    cudaMemcpy(a,cuda_a,sizeof(float)* n*n,cudaMemcpyHostToDevice);
    cudaMemcpy(b,cuda_b,sizeof(float)* n*n,cudaMemcpyHostToDevice);

    //printMatrix(cuda_a, n);
    //printMatrix(cuda_b, n);

    // 在CUDA 中執(zhí)行函數(shù) 語法：函數(shù)名稱<<<block 數(shù)目, thread 數(shù)目, shared memory 大小>>>(參數(shù)...);
    matMultCuda<<<block_num, Thread_Num, 0>>>(cuda_a,cuda_b,cuda_c,n,time);

    //把結(jié)果復(fù)制回內(nèi)存中
    clock_t time_use[block_num*2];

    cudaMemcpy(c,cuda_c,sizeof(float)* n*n,cudaMemcpyDeviceToHost);
    cudaMemcpy(&time_use, time, sizeof(clock_t)* block_num * 2, cudaMemcpyDeviceToHost);

    printMatrix(a, n);
    printMatrix(b, n);
    printMatrix(c, n);

    //釋放資源
    cudaFree(cuda_a);
    cudaFree(cuda_b);
    cudaFree(cuda_c);
    cudaFree(time);

    //把每個(gè) block 最早的開始時(shí)間，和最晚的結(jié)束時(shí)間相減，取得總運(yùn)行時(shí)間
    clock_t min_start, max_end;
    min_start = time_use[0];
    max_end = time_use[block_num];
    for (int i = 1; i < block_num; i++) 
    {
        if (min_start > time_use[i]) min_start = time_use[i];
        if (max_end < time_use[i + block_num]) max_end = time_use[i + block_num];
    }

    //核函數(shù)運(yùn)行時(shí)間
    clock_t final_time = max_end - min_start;
    printf("gputime: %d\n", final_time);
    return 0;
}