Multithreading CUDA帮助实现320*240图像处理的内核函数

我是cuda的新手，我试图通过这段代码读取cuda中的一帧，但我得到了一个翻转错误，并得到了一个黑色输出。。 这是我的密码

BYTE *imageBuf = 0;
BYTE *maBuf = 0;
BYTE *fgBuf = 0;
BYTE *tempBuf = 0;

cudaMalloc((void **)&maBuf , m_imgWidth*m_imgHeight);
cudaMalloc((void **)&fgBuf , m_imgWidth*m_imgHeight);
cudaMalloc((void **)&imageBuf , m_imgWidth*m_imgHeight);
cudaMalloc((void **)&tempBuf , m_imgWidth*m_imgHeight);
cudaMalloc((void **)&m_pixel_ptr , m_imgWidth*m_imgHeight);

cudaMemcpy(m_pixel_ptr , m_pixelParam , m_imgWidth*m_imgHeight , cudaMemcpyHostToDevice);
cudaMemcpy(imageBuf , inImgBuf , m_imgWidth*m_imgHeight , cudaMemcpyHostToDevice);
cudaMemcpy(fgBuf , foregroundBUf , m_imgWidth*m_imgHeight , cudaMemcpyHostToDevice);
cudaMemcpy(maBuf , maskBuf , m_imgWidth*m_imgHeight , cudaMemcpyHostToDevice);
cudaMemcpy(tempBuf , foregroundBUf , m_imgWidth*m_imgHeight , cudaMemcpyHostToDevice);

kernel<<<16,20>>>(imageBuf, maBuf, fgBuf , 320 , 240 , m_pixel_ptr , tempBuf , 0);


cudaMemcpy (maskBuf, maBuf , m_imgWidth*m_imgHeight , cudaMemcpyDeviceToHost);
cudaMemcpy (foregroundBUf, fgBuf , m_imgWidth*m_imgHeight , cudaMemcpyDeviceToHost);
cudaMemcpy (inImgBuf, imageBuf , m_imgWidth*m_imgHeight , cudaMemcpyDeviceToHost);
cudaMemcpy (m_pixelParam , m_pixel_ptr , m_imgWidth*m_imgHeight , cudaMemcpyDeviceToHost);

cudaFree(m_pixel_ptr);
cudaFree(imageBuf);
cudaFree(maBuf);
cudaFree(tempBuf);
cudaFree(fgBuf);

字节*imageBuf=0；
字节*maBuf=0；
字节*fgBuf=0；
字节*tempBuf=0；
Cudamaloc（（无效**）和maBuf，m_imgWidth*m_imgHeight）；
cudamaloc（（无效**）和fgBuf，m_imgWidth*m_imgHeight）；
Cudamaloc（（无效**）和imageBuf，m_imgWidth*m_imgHeight）；
Cudamaloc（（无效**）和tempBuf，m_imgWidth*m_imgHeight）；
cudamaloc（（void**）和m_pixel_ptr，m_imgWidth*m_imgHeight）；
cudaMemcpy（m_pixel_ptr，m_pixelParam，m_imgWidth*m_imgHeight，cudaMemcpyHostToDevice）；
cudaMemcpy（imageBuf、inImgBuf、m_imgWidth*m_imgHeight、cudamemcpyhostodevice）；
cudaMemcpy（fgBuf、foregroundBUf、m_imgWidth*m_imgHeight、cudamemcpyhostodevice）；
cudaMemcpy（maBuf、maskBuf、m_imgWidth*m_imgHeight、cudamemcpyhostodevice）；
cudaMemcpy（临时、前景、宽度*m_imgWidth、亮度、cudaMemcpyHostToDevice）；
内核（imageBuf、maBuf、fgBuf、320240、m_像素ptr、tempBuf、0）；
cudaMemcpy（maskBuf、maBuf、m_imgWidth*m_imgHeight、cudamemcpydevicetoost）；
cudaMemcpy（前端BUF、fgBuf、m_imgWidth*m_imgHeight、cudaMemcpyDeviceToHost）；
cudaMemcpy（inImgBuf、imageBuf、m_imgWidth*m_imgHeight、cudaMemcpyDeviceToHost）；
cudaMemcpy（m_像素参数、m_像素ptr、m_imgWidth*m_imghight、cudamemcpydevictohost）；
cudaFree（m_pixel_ptr）；
cudaFree（imageBuf）；
cudaFree（maBuf）；
cudaFree（tempBuf）；
cudaFree（fgBuf）；

这就是我如何调用我的内核函数，这是我的内核函数

    __global__ void kernel(BYTE *inImgBuf, BYTE *maskBuf,  BYTE *foregroundBUf , int width , int height , PixelPara *m_pixelParam , BYTE *tmpBuffer , int j)
{


int m_IniWeight = 0.005;
int m_IniStd = 400.0;
int m_Threshold = 0.7;
int fgTh;

int thresholdRank;


for(int i = 0; i < width; i++)
{
        int tid = ((threadIdx.x + blockIdx.x * blockDim.x)*width + i);
        if (m_pixelParam[tid].m_validModels == 0) 
        {
            m_pixelParam[j*width+i].m_weight[0] = m_IniWeight;
            m_pixelParam[j*width+i].m_stdVar[0] = m_IniStd;
            m_pixelParam[j*width+i].m_priRank[0] = 0;
            m_pixelParam[j*width+i].m_mean[0] = (double)inImgBuf[j*width+i];
            m_pixelParam[j*width+i].m_validModels++;


        }
        else
        {
            thresholdRank = 0;
            fgTh = 0.0;             
            while (true)
            {
                fgTh += m_pixelParam[j*width+i].m_weight[m_pixelParam[j*width+i].m_priRank[thresholdRank]];                 

                if ((fgTh > m_Threshold) || (thresholdRank >= m_pixelParam[j*width+i].m_validModels - 1)) 
                    break;      

                thresholdRank++;
            }

                gmmImplementation (inImgBuf, maskBuf, foregroundBUf ,width , height , m_pixelParam , (j*width+i) ,tmpBuffer ,thresholdRank );




            foregroundBUf = tmpBuffer;


        }

}






}

\uuuuu全局\uuuuuvoid内核（字节*inImgBuf、字节*maskBuf、字节*foregroundBUf、整型宽度、整型高度、像素参数*m\uPixelParam、字节*tmpBuffer、整型j）
{
int m_IniWeight=0.005；
int m_IniStd=400.0；
int m_阈值=0.7；
int-fgTh；
int阈值秩；
对于（int i=0；im_阈值）| |（thresholdRank>=m_pixelParam[j*width+i].m_validModels-1））
打破
thresholdRank++；
}
GMM实现（inImgBuf、maskBuf、foregroundBUf、宽度、高度、m_像素参数（j*width+i）、tmpBuffer、阈值秩）；
foregroundBUf=tmpBuffer；
}
}
}

---

有谁能帮我在cuda中如何处理320*240帧我正试图在cuda上实现GMM，但失败了。。任何帮助或指导。。谢谢。

问题似乎是您正在使用大小

m\u imgWidth*m\u imghight

分配m\u pixel\u ptr，而它看起来应该是

m\u imgWidth*m\u imghight*sizeof（PixelPara）

。这可以解释为什么会出现缓冲区溢出。您可能正在尝试读取和写入超出数组末尾的部分。当然，您对m_pixel_ptr的cudaMemcpy调用也需要长度

m_imgWidth*m_imghight*sizeof（PixelParam）

，以便将整个缓冲区复制到设备和从设备复制

---

另外，imageBuf应该包含双字节还是单字节？现在，您的代码只需从

inImgBuf

读取每个像素的一个字节，然后将其转换为一个双字节，然后将其存储在

m_pixelParam[j*width+i].m_mean[0]

中。如果它应该读取double，则需要使用size

m_imgWidth*m_imgHeight*sizeof（double）分配和复制imageBuf

并且您需要在内核参数列表中将

inImgBuf

声明为

double*

，而不是

BYTE*

在每个API调用中添加错误检查，以确保在进一步调试内核代码之前一切正常。还有，什么是“推翻”错误？嗨，谢谢你的帮助。。imageBuf是一个字节数组，我一次读取一个。。。并按照你的建议存储pixelParam。还有什么我该做的吗？您好，您能帮我解决这个问题吗？我正在运行这段代码，但它没有像m_pixelParam[tid]那样给我正确的输出。m_validModels对于每一帧都是0，这不应该是真的，我不太确定您的代码到底要做什么，但我似乎怀疑j初始化为零，然后再也没有设置过。因此，每个线程都在设置m_pixelParam的标记[0-宽度]中的字段。因为j总是0，所以[jwidth+i]总是等于[i]。此外，每列有一个线程（320个），但看起来您可能试图让每个线程处理一行而不是一列。也许您需要在内核调用中使用而不是，并用[tid]替换[jwidth+i]的实例。此外，我不确定这些行是如何编译的：

int m_IniWeight=0.005；int m_IniStd=400.0；int m_阈值=0.7整数（int）是整数（例如-1、0、1、2等）为了存储具有小数成分的数字（例如0.005或0.7），您需要使用浮点类型的变量，而不是int。如果您将带有小数成分的数字强制转换为整数变量（通过强制转换），小数部分将被截断，因此，0.005和0.7都将被截断为0。