Cuda learn record two

这是一个cuda 自带的算例，包含cuda 计算的一般流程。

这个地址有比较清楚的cuda的介绍。感谢作者分享（http://blog.csdn.net/hjimce/article/details/51506207）

一般来说，cuda 计算的流程是:

1. 设置显卡编号：cudaSetDevice； 这个主要是在有多个GPU的机器上使用，其编号是从0号开始。

2. 为显卡开辟内存变量： cudaMalloc；使用方法：cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));  

这里的指针是指向设备端的内存地址，无法再主机端使用。

3.把主机端的数据拷贝到设备端：cudaMemcpy; 使用方法：

cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);  

这里注意需要指明数据传输的地址，

4. 调用内核函数__global__ 类型函数；

cudaAdd<<<blocksPerGrid, threadsPerBlock>>> (     )

这里blocksPerGrid, threadsPerBlock 都是Dim3型的数据，

5. 把计算结果拷贝到主机端。

6. 释放显存空间。

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>

static void HandleError(cudaError_t err,
    const char *file,
    int line) {
    if (err != cudaSuccess) {
        printf("%s in %s at line %d\n", cudaGetErrorString(err),
            file, line);
        exit(EXIT_FAILURE);
    }
}
#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ ))

cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
void printCudaInformation();

__global__ void addKernel(int *c, const int *a, const int *b)
{
    int i = threadIdx.x;
    c[i] = a[i] + b[i];
}

int main()
{
    const int arraySize = 5;
    const int a[arraySize] = { 1, 2, 3, 4, 5 };
    const int b[arraySize] = { 10, 20, 30, 40, 50 };
    int c[arraySize] = { 0 };

    // Add vectors in parallel.
    HANDLE_ERROR( addWithCuda(c, a, b, arraySize) );

    printf("{1,2,3,4,5} + {10,20,30,40,50} = {%d,%d,%d,%d,%d}\n",
        c[0], c[1], c[2], c[3], c[4]);

    // cudaDeviceReset must be called before exiting in order for profiling and
    // tracing tools such as Nsight and Visual Profiler to show complete traces.
    HANDLE_ERROR( cudaDeviceReset() );

    system("pause");
    printCudaInformation();
    system("pause");
    return 0;
}

// Helper function for using CUDA to add vectors in parallel.
cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
{
    int *dev_a = 0;
    int *dev_b = 0;
    int *dev_c = 0;
    cudaError_t cudaStatus=cudaSuccess;

    // Choose which GPU to run on, change this on a multi-GPU system.
    HANDLE_ERROR(cudaSetDevice(0));

    // Allocate GPU buffers for three vectors (two input, one output)   
    HANDLE_ERROR(cudaMalloc((void**)&dev_c, size * sizeof(int)));
    HANDLE_ERROR(cudaMalloc((void**)&dev_a, size * sizeof(int)));
    HANDLE_ERROR(cudaMalloc((void**)&dev_b, size * sizeof(int)));

    // Copy input vectors from host memory to GPU buffers.
    HANDLE_ERROR(cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice));
    HANDLE_ERROR(cudaMemcpy(dev_b, a, size * sizeof(int), cudaMemcpyHostToDevice));


    // Launch a kernel on the GPU with one thread for each element.
    addKernel<<<1, size>>>(dev_c, dev_a, dev_b);

    // Check for any errors launching the kernel
    HANDLE_ERROR(cudaGetLastError());
    
    // cudaDeviceSynchronize waits for the kernel to finish, and returns
    // any errors encountered during the launch.
    HANDLE_ERROR(cudaDeviceSynchronize());

    // Copy output vector from GPU buffer to host memory.
    HANDLE_ERROR(cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost));
    
    return cudaStatus;
}

void printCudaInformation()
{
    int count;
    cudaGetDeviceCount(&count);
    printf("count=%d \n", count);
    cudaDeviceProp myProp;
    cudaGetDeviceProperties(&myProp, 0);
    printf(" --- General Information of My Cuda Device ---\n");
    printf("     Device name: %s\n", myProp.name);
    printf("     Computer capatibility : %d.%d\n", myProp.major, myProp.minor);
    printf("     Clock rate: %d\n", myProp.clockRate);

    printf(" --- Memory Information of My Cuda Device ---\n");
    printf("    Total global memory: %ld =%d double \n", myProp.totalGlobalMem, myProp.totalGlobalMem / sizeof(double));
    printf("    Total const memory: %ld =%d int \n", myProp.totalConstMem, myProp.totalConstMem / sizeof(int));
    printf("    max memoory pitch: %ld \n", myProp.memPitch);

    printf(" --- Multiprocessor Information of My Cuda Device ---\n");
    printf("    multprocessor count= %d\n", myProp.multiProcessorCount);
    printf("    Shared mem per mp=%d\n", myProp.sharedMemPerBlock);
    printf("    Registers per mp=%d\n", myProp.regsPerBlock);
    printf("    Thread in wrap=%d\n", myProp.warpSize);
    printf("    Max thread per block=%d\n", myProp.maxThreadsPerBlock);
    printf("    Max threads dimensions= (%d, %d, %d) \n",
        myProp.maxThreadsDim[0], myProp.maxThreadsDim[1], myProp.maxThreadsDim[2]);
    printf("    Max Grid dimensions= (%d, %d, %d) \n",
        myProp.maxGridSize[0], myProp.maxGridSize[1], myProp.maxGridSize[2]);
    printf("\n");
}