调用GPU内核后CPU性能下降

Question

我正在GPU上进行Harris角点检测。 我观察到我的CPU性能异常。

如果通过注释我的内核函数（此函数调用GPU的各个内核）来运行此调用，则以下是我的Main.cpp文件： "Harris_Algo(a,d_a,d_g,dx_My,dy_My,dxdy_My,suppressed,corner_response,Res,Height,length,SIZE);" 我的函数调用读取下一帧并转换为灰度（“ cap.read（Masrc）和cvtColor（Masrc，src，CV_BGR2GRAY））平均每帧需要0.003和0.004秒。

令人惊讶的是，当我取消注释我的GPU内核调用函数“ Harris_Algo”时，相同的CPU函数（cap.read（Masrc）和cvtColor（Masrc，src，CV_BGR2GRAY））平均每帧需要0.009和0.008 Sec。

由于时间在我的应用程序中非常关键，因此这种变化消除了我使用GPU所获得的优势。这两个函数的调用与GPU无关，但调用GPU函数（内核）需要花费更多时间。

我认为这叫我的GPU功能（内核）增加了CPU的开销，因此其利用率增加而性能下降。 但是这种变化是巨大的。 任何其他合适的方法都可以做到这一点。

任何帮助表示赞赏。

我正在使用Jetson TK1 GPU板。

Main.cpp文件

#include <iostream>
#include <time.h>
#include <fstream>
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"

using namespace std;
using namespace cv;
 void Cuda_Free(unsigned char *d_a,unsigned char *d_g,int *dx_My,int *dy_My,int *dxdy_My,int *suppressed,int *corner_response);

void Harris_Algo(unsigned char *a,unsigned char *d_a,unsigned char *d_g,int *dx_My,int *dy_My,int *dxdy_My,int *suppressed,int *corner_response,int *Res, int Height,int length,int SIZE);

void MemAlloc(unsigned char *&d_a,unsigned char *&d_g,int *&dx_My,int *&dy_My,int *&dxdy_My,int *&suppressed,int *&corner_response,int SIZE);


    int main(int argc, char** argv)
    {
        cv::VideoCapture cap(argv[1]);

        if (!cap.isOpened())
        {
            std::cout << "!!! Failed to open file: " << argv[1] << std::endl;
            return -1;
        }

        double time_spent;
        clock_t begin3, end3,begin4;
        bool start = false;

        Mat src;
        unsigned char *a,*d_a,*d_g;
        int *dx_My,*Res;
        int *dy_My;
        int *dxdy_My;
        int *suppressed;
        int *corner_response;
        int length;
        int Height;
        int SIZE;
        Size S;
        VideoWriter outputVideo;   

        Mat Masrc;
        for(;;)
        {

            begin4 = clock();
            begin3 = clock();
            if (!cap.read(Masrc))             
                break;
                    end3 = clock();
            time_spent = (double)(end3 - begin3) / CLOCKS_PER_SEC;
            cout<<"Read Frame              : "<<time_spent<<endl;

            begin3 = clock();
            cvtColor( Masrc, src, CV_BGR2GRAY );
                        end3 = clock();
            time_spent = (double)(end3 - begin3) / CLOCKS_PER_SEC;
            cout<<"Gray Convert             : "<<time_spent<<endl;   

            begin3 = clock(); 
            if(start == false)
            {
                length     = src.cols;
                Height     = src.rows;

                cout<<"Width"<<length<<endl;
                cout<<"Height"<<Height<<endl;
                SIZE = ((length)*(Height));

                Res = new int [SIZE];

                MemAlloc(d_a,d_g,dx_My,dy_My,dxdy_My,suppressed,corner_response,SIZE);

                start = true;

            }

            a = src.data;

            end3 = clock();
            time_spent = (double)(end3 - begin3) / CLOCKS_PER_SEC;
            cout<<"Initial Processsing Time              : "<<time_spent<<endl;

            Harris_Algo(a,d_a,d_g,dx_My,dy_My,dxdy_My,suppressed,corner_response,Res,Height,length,SIZE);

            begin3 = clock();

          // imshow( "Harris_OUT", Masrc );
         //   char key = cvWaitKey(1);
         //   if (key == 27) // ESC
          //      break;

            end3 = clock();
            time_spent = (double)(end3 - begin3) / CLOCKS_PER_SEC;
            cout<<"Time After Displaying image on Output : "<<time_spent<<endl;
            time_spent = (double)(end3 - begin4) / CLOCKS_PER_SEC;
            cout<<"Overall Time of entire program exec   : "<<time_spent<<endl;
            cout<<"-----------------------------------------------------------------------------"<<endl;

        }

        Cuda_Free(d_a,d_g,dx_My,dy_My,dxdy_My,suppressed,corner_response);
        delete Res;
        cvWaitKey(0);
    }

内核库

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>
#include <time.h>
#include <fstream>

using namespace std;
__global__ void Harris_Mat(int *corner_response,int* dx_My,int* dy_My,int* dxdy_My,int rows, int cols,int Size)
{

   /*...*/
}

__global__ void Supress_Neighbour(int *input,int *output, int rows, int cols, int Size) 
{
   /* ... */
}

__global__ void VectorGauss(unsigned char *D, unsigned char *M,int Length, int size_m )
{
    float Val;
    int i =  blockIdx . x * blockDim . x + threadIdx . x;
    if(i>0 & i<size_m)
    {
        if ((i%Length) ==(0) || (i%Length) == (Length-1)|| (i<Length) || (i>(size_m-Length))){
            M[i] = 0; 
        }

        Val = (( D[i] +(D[Length+i]) + D[2*Length+i]) +(D[i]+ (D[Length+i])+ D[2*Length+i])
                +(D[i+1] + D[i+Length+1] + D[2*Length+i+]));
    }
}

__global__ void VectorAdd(unsigned char *D,int* dx,int* dy,int* dxdy,int Length, int size_m)
{

/* ... */
}


__host__ void MemAlloc(unsigned char *&d_a,unsigned char *&d_g,int *&dx_My,int *&dy_My,int *&dxdy_My,int *&suppressed,int *&corner_response,int SIZE)
{
    cudaMalloc (&d_a,SIZE*sizeof(unsigned char));
    cudaMalloc (&d_g,SIZE*sizeof(unsigned char));
    cudaMalloc (&dx_My,SIZE*sizeof(int));
    cudaMalloc (&dy_My,SIZE*sizeof(int));
    cudaMalloc (&dxdy_My,SIZE*sizeof(int));
    cudaMalloc (&suppressed,SIZE*sizeof(int));
    cudaMalloc (&corner_response,SIZE*sizeof(int));
}

__host__ void Harris_Algo(unsigned char *a,unsigned char *d_a,unsigned char *d_g,int *dx_My,int *dy_My,int *dxdy_My,int *suppressed,int *corner_response,int *Res, int Height,int length,int SIZE)
{
    double time_spent;
    clock_t begin3, end3;
    begin3 = clock();
    cudaMemcpy(d_a,a,SIZE*sizeof(unsigned char),cudaMemcpyHostToDevice);


    VectorGauss<<< SIZE/512+1,512>>>(d_a,d_g,length,SIZE);

    VectorAdd<<< SIZE/512+1,512>>>(d_g,dx_My,dy_My,dxdy_My,length,SIZE);

    Harris_Mat<<< SIZE/512+1,512>>>(corner_response,dx_My,dy_My,dxdy_My,Height,length,SIZE);

    Supress_Neighbour<<< SIZE/512+1,512>>>(corner_response, suppressed,Height, length, SIZE); 


    cudaMemcpy(Res,suppressed,SIZE*sizeof(int),cudaMemcpyDeviceToHost);
    end3 = clock();
    time_spent = (double)(end3 - begin3) / CLOCKS_PER_SEC;

    cout<<"Processsing Time of Algorithm         : "<<time_spent<<endl;
}

__host__ void Cuda_Free(unsigned char *d_a,unsigned char *d_g,int *dx_My,int *dy_My,int *dxdy_My,int *suppressed,int *corner_response)
{
    cudaFree(d_a);
    cudaFree(d_g);
    cudaFree(dx_My);
    cudaFree(dy_My);
    cudaFree(dxdy_My);
    cudaFree(corner_response);
    cudaFree(suppressed);

}

我使用NVCC进行编译，也使用了（NVCC和g ++），但结果相同。

使用运行我的代码

g++-4.8 -c Main.cpp
nvcc -c Kernal.cu
g++-4.8 -o Output Main.o Kernal.o -L/usr/local/cuda/lib -lcudart -lcuda `pkg-config opencv --cflags --libs`

Answer 1

我看到两个主要原因导致您在调用与GPU相关的函数时在CPU上的时间更长：

• 它使用cudaMemCpy调用两个副本，一个从RAM到VRAM，一个从VRAM返回RAM。 这是有成本的。
• 在内核启动后调用第二个副本， 因为cudaMemCpy正在阻塞/同步 ，它使您等待GPU完成计算。

通过在GPU上执行此计算，您可能会提高性能，但是如果内存副本的成本更高，则与在CPU端执行所有操作相比，您的性能会更低。