CUDA 编程实例:计算点云法线

程序参考文章：http://blog.csdn.net/gamesdev/article/details/17535755  程序优化2

简介：CUDA ，MPI，Hadoop都是并行运算的工具。CUDA是基于NVIDIA GPU芯片计算。

阐述：GPU有很多个核(几百个)，每个核可以跑一个线程，多个线程组成一个单位叫做块。

举个例子：
有三个向量 int a, b, c; 我们要计算a和b的向量之和存放到c中。

一般C语言：for(int i=0; i<10; i++)  c = a + b; 这个程序是顺序执行的！

CUDA编程做法：

GPU中的每个线程(核)有一个独立序号叫index，那么只要序号从0到9的线程执行c[index] = a[index] + b[index]; 就可以实现以上的for循环。

GPU的可贵之处就是，可以并发运行多个线程，相当于一个时间内赋值10次。

 ////////////////////////
 cuda.cu
 ////////////////////////
 #include
 #include

 //运行在GPU
 __global__ void vectorADD(int* a, int* b, int* c)
 {
      int index = threadIdx.x; //获得当前线程的序号
      if(index < blockDim.x)
          c = a + b;
 }
 int main ()
 {
         //定义10个GPU运算线程
         int N = 10;
         // 本地开辟三个数组存放我们要计算的内容
         int* h_a = (int*) malloc (N * sizeof(int));
         int* h_b = (int*) malloc (N * sizeof(int));
         int* h_c = (int*) malloc (N * sizeof(int));
         // 初始化数组A, B和C
         for(int i=0; i
                 h_a = i;
                 h_b = i;
                 h_c = 0;
         }
         // 计算10个int型需要的空间
         int size = N * sizeof(int);
         // 在GPU上分配同样大小的三个数组
         int* d_a;
         int* d_b;
         int* d_c;
         cudaMalloc((void**)&d_a, size);
         cudaMalloc((void**)&d_b, size);
         cudaMalloc((void**)&d_c, size);

         // 把本地的数组拷贝进GPU内存
         cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
         cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);
         cudaMemcpy(d_c, h_c, size, cudaMemcpyHostToDevice);

         // 定义一个GPU运算块 由 10个运算线程组成
         dim3 DimBlock = N;
         // 通知GPU用10个线程执行函数vectorADD
         vectorADD<<<1, DimBlock>>>(d_a, d_b, d_c);
         //  将GPU运算完的结果复制回本地
         cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);
         // 释放GPU的内存
         cudaFree(d_a);
         cudaFree(d_b);
         cudaFree(d_c);
         //  验证计算结果
         for(int j=0; j
                 printf("%d ", h_c);
         printf("\n");
 }

警告！：这个例子是编译不通过的；

首先：对 threadidx的使用，只能在CU文件里面；

其次：在cu文件里初始化数组是错误的： int * a ； a = new int [x]；是错误的；  并且 malloc也是不可以的；

再者：文件路径里面不能包含中文，否则会出现 MSB8791 这种错误！

2. 利用CUDA并行计算点云法线

两个函数都存在于CU文件里! 通过外部CPP文件函数进行调用 

 void normalEstimate(
     pcl::PointCloud &input ,
     pcl::PointCloud &output,
     int  k_,
     float search_parameter_,
     int THREAD_NUM
     )

//运行在GPU//cal the Normal

 __global__ void normalEstimateSingle(pcl::PointCloud &input ,pcl::PointCloud &output, int* nn_indices ,int*   nn_dists, int Gap, float search_parameter_)
 {
     const size_t computeSize =input.size() / Gap;
     const size_t tID = size_t(threadIdx.x );
     int Mark;
     clock_t startTime; // 开始计时
     if ( tID == 0 ) startTime =clock( );// 选择任意一个线程进行计时
     //Thread loop!//循环发现邻域！寻找法线！
     for ( size_t idx = tID *computeSize; idx < ( tID + 1 ) * computeSize && idx < input.size(); ++idx )  {
       // pOut[threadIdx.x] += pIn[i] * pIn[i];
        Mark = pcl::searchForNeighbors (idx, search_parameter_, nn_indices, nn_dists);//对第IDX个建立索引!
        if (Mark == 0){
                 output.points[idx].normal[0] = output.points[idx].normal[1] = output.points[idx].normal[2] = output.points[idx].curvature = std::numeric_limits<float>::quiet_NaN ();
                 continue;
             }
        else {
                 if (!isFinite (input[idx]) || Mark == 0){
                     output.points[idx].normal[0] = output.points[idx].normal[1] = output.points[idx].normal[2] = output.points[idx].curvature = std::numeric_limits<float>::quiet_NaN ();
                     continue;
                 }
             }
        pcl::computePointNormal (input, nn_indices,output.points[idx].normal[0], output.points[idx].normal[1], output.points[idx].normal[2], output.points[idx].curvature);
        pcl::flipNormalTowardsViewpoint (input_->points[idx], vpx_, vpy_, vpz_,
        output.points[idx].normal[0], output.points[idx].normal[1], output.points[idx].normal[2]);

     }
     if ( tID == 0 ) *pElapsed =clock( ) - startTime;// 结束计时，返回至主程序
 }

//运行在CPU端！

 // as the input
 extern "C" void normalEstimate(
     pcl::PointCloud &input ,
     pcl::PointCloud &output,
     int  k_,
     float search_parameter_,
     int THREAD_NUM
     )
 {
      // 在GPU上分配同样大小的三个数组
       pcl::PointCloud &inputX ;
       pcl::PointCloud &outputX;
        int* nn_indices ;
        int*   nn_dists;


     // 1、设置设备
     cudaError_t cudaStatus = cudaSetDevice( 0 );// 只要机器安装了英伟达显卡，那么会调用成功
     if ( cudaStatus != cudaSuccess )
     {
        fprintf( stderr, "调用cudaSetDevice()函数失败！" );
        return ;//false;
     }

     // 使用CUDA内存分配器分配host端
     //cudaError_t cudaStatus = cudaMallocHost( &inputX, input.size() * sizeof( pcl::pointXYZRGB ) );
     //cudaError_t cudaStatus = cudaMallocHost( &outputX, output.size() * sizeof( pcl::Normal ) );

     // 2、分配显存空间
     cudaError_t cudaStatus  = cudaMalloc( &inputX, input.size() * sizeof( pcl::pointXYZRGB ) );
     cudaError_t cudaStatusX = cudaMalloc( &outputX, output.size() * sizeof( pcl::Normal ) );

       // cudaStatus = cudaMalloc( (void**)&pData, DataSize * sizeof( int) );
        if ( cudaStatus != cudaSuccess)
        {
            fprintf( stderr, "调用cudaMalloc()函数初始化显卡中数组时失败！" );
            break;
        }

         // 3、将宿主程序数据复制到显存中
        cudaError_t cudaStatus2  = cudaMemcpy( inputX, input, input.size() * sizeof( pcl::pointXYZRGB ),cudaMemcpyHostToDevice );
        cudaError_t cudaStatusX2 = cudaMemcpy(outputX,output,output.size() * sizeof( pcl::pointXYZRGB ),cudaMemcpyHostToDevice );
        if ( cudaStatus != cudaSuccess)
        {
            fprintf( stderr, "调用cudaMemcpy()函数初始化宿主程序数据数组到显卡时失败！" );
            break;
        }

        //cudaMalloc( (void**)&nn_dists,   k_ * sizeof( int) );
        //cudaMalloc( (void**)&nn_indices, k_ * sizeof( int) );
        //cudaMalloc( (void**)&Normal3f,  3 * sizeof( float) );

      // 4、执行程序，宿主程序等待显卡执行完毕
        normalEstimateSingle<<<1, THREAD_NUM>>>( inputX,outputX, nn_indices, nn_dists, THREAD_NUM ,search_parameter_);
        //normalEstimateSingle(pcl::PointCloud &input ,pcl::PointCloud &output, int* nn_indices ,int*   nn_dists, int Gap)

        // 5、查询内核初始化的时候是否出错
        cudaStatus = cudaGetLastError( );
        if ( cudaStatus != cudaSuccess)
        {
            fprintf( stderr, "显卡执行程序时失败！" );
            break;
        }

      // 6、与内核同步等待执行完毕
        cudaStatus = cudaDeviceSynchronize( );
        if ( cudaStatus != cudaSuccess)
        {
            fprintf( stderr, "在与内核同步的过程中发生问题！" );
            break;
        }

        // 7、获取数据  //只复制出法线即可！
        cudaStatus = cudaMemcpy(output,outputX,output.size() * sizeof( pcl::pointXYZRGB ),cudaMemcpyHostToDevice );
        if ( cudaStatus != cudaSuccess)
        {
            fprintf( stderr, "在将结果数据从显卡复制到宿主程序中失败！" );
            break;
        }

        cudaFree( outputX );
        cudaFree(  inputX );
 }

注意事项：运行在GPU的函数，只能是原子函数，详情请见 《高性能并行编程实践》