一个不错的关于CPU和GPU（CUDA）的性能比较讨论话题

http://topic.csdn.net/u/20081027/23/67ff3857-3c71-4d5c-acf6-095f3497c7a9.html
这里是今天的一个论坛的一个帖子，大家可以讨论一下：）
1.那些程序适合用cpu来做，那些适合用gpu来做
2.如果用gpu来做，需要注意那些东西
3.如果需要优化，需要那些思路：）

在lz的代码的基础上做了一些变化，大家可以自己测试一下，就知道那些工作适合用cpu做，那些是适合用gpu来做。
这里面的LOOP_ADD_TIME 从1->10->100->1000->10000....
大家可以做一个测试，看看最后的效果是怎么样的，可以画一个曲线图出来：）

过一段时间，还可以把这个代码在修改一下，添加更多的内容进去，再看看两者的效果怎么样：）
C/C++ code

#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <cutil.h>

// Simple utility function to check for CUDA runtime errors
//void checkCUDAError(const char* msg)
#define LOOP_ADD_TIME 100

// Part 2 of 2: implement the kernel
__global__ void reverseArrayBlock( int*d_a)
{
int dx=blockDim.x*blockIdx.x+threadIdx.x;

for (int i = 1; i <= LOOP_ADD_TIME; i++)
{
d_a[dx] += i;
}
}

int gpu_test()
{
clock_t start, finish;
double duration;

// pointer for host memory and size
int *h_a,transfer;
int dimA = 512*21056; // 256K elements (1MB total)

// pointer for device memory
int *d_a;

// define grid and block size
int numThreadsPerBlock =512;

// Part 1 of 2: compute number of blocks needed based on array size and desired block size
int numBlocks = dimA/numThreadsPerBlock;
printf("blocks: %d/n",numBlocks);

// allocate host and device memory
size_t memSize = numBlocks * numThreadsPerBlock * sizeof(int);
h_a = (int *) malloc(memSize);
CUDA_SAFE_CALL(cudaMalloc( (void **) &d_a, memSize ));

// Initialize input array on host
for (int i = 0; i < dimA; ++i)
{
h_a[i] = i;
//printf("%d ",h_a[i]);
}

start = clock();
//unsigned int timer;
//CUT_SAFE_CALL(cutCreateTimer(&timer));
//CUT_SAFE_CALL(cutStartTimer(timer));
// Copy host array to device array
CUDA_SAFE_CALL(cudaMemcpy( d_a, h_a, memSize, cudaMemcpyHostToDevice ));

// launch kernel
dim3 dimGrid(numBlocks);
dim3 dimBlock(numThreadsPerBlock);
reverseArrayBlock <<< dimGrid, dimBlock >>>( d_a );

// device to host copy
CUDA_SAFE_CALL(cudaMemcpy(h_a, d_a, memSize, cudaMemcpyDeviceToHost ));

//CUT_SAFE_CALL(cutStopTimer(timer));
finish = clock();
duration = (double)(finish - start)*1000 / CLOCKS_PER_SEC;
printf( "gpu time is %f ms/n", duration );
//printf( "gpu time is %f ms/n", cutGetTimerValue(timer));

int *h_a2;

// allocate host memory
h_a2 = (int *) malloc(memSize);

// Initialize input array on host
for (int i = 0; i < dimA; ++i)
{
h_a2[i] = i;
//printf("%d ",h_a[i]);
}
for( int j=0; j < dimA ; ++j )
{
for(int k = 1; k <= LOOP_ADD_TIME; k++)
{
h_a2[j] += k;
}
}

for( int j=0; j < dimA ; ++j )
{
if (h_a[j] != h_a2[j])printf("error!/n");
}
// free host memory
free(h_a2);

// free host memory
free(h_a);

// free device memory
cudaFree(d_a);

return 0;

}

////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int cpu_test()
{
clock_t start, finish;
double duration;

// pointer for host memory and size
int *h_a,transfer;
int dimA = 512*21056; // 256K elements (1MB total)

// allocate host memory
size_t memSize = 512*21056* sizeof(int);
h_a = (int *) malloc(memSize);

// Initialize input array on host
for (int i = 0; i < dimA; ++i)
{
h_a[i] = i;
//printf("%d ",h_a[i]);
}
printf("/n");

start = clock();
for( int j=0; j < dimA ; ++j )
{
for(int k = 1; k <= LOOP_ADD_TIME; k++)
{
h_a[j] += k;
}
}

finish = clock();
duration = (double)(finish - start)*1000 / CLOCKS_PER_SEC;
printf( "cpu time is %f ms/n", duration );

// free host memory
free(h_a);

return 0;

}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main( int argc, char** argv)
{

CUT_DEVICE_INIT(argc, argv);
gpu_test();

cpu_test();

CUT_EXIT(argc, argv);
}