用批处理实现im2col的OpenCL内核

我正在尝试将一个为CPU编写的常用函数改编为GPU的OpenCL内核。 该函数是许多深度学习应用程序中使用的众所周知的im2col

我在OpenCV存储库中发现了一些代码，这些代码实现了这个用OpenCL编写的im2col函数，但我必须修改的代码使用了一个批处理，这让我感到困惑，似乎有点不同

我应该在OpenCL内核上做什么更改，使其在GPU上的工作方式与在CPU功能上的工作方式相同

CPU代码

int fn_im2col_cpu(int I, int WI, int HI, int B, int KW, int KH, int WO, int HO, int PW, int PH, int SW, int SH, type *in_ptr, type *out_ptr) {
    PROFILING_HEADER_EXTERN(im2col);
    PROFILING_DEVICE(im2col, DEV_CPU);

    int i;                                             // scrolls input channels
    int w;                                             // scrolls channel columns (width)
    int h;                                             // scrolls channel rows (height)
    int kw;                                            // scrolls filter columns (width)
    int kh;                                            // scrolls filter rows (height)

 // we sweep all output pixels, and for each pixel we compute the associated input pixel
 #pragma omp parallel for private (kh, kw, h, w)
    for (i = 0; i < I; i++) {
        size_t out_addr = ((size_t)B * (size_t)WO * (size_t)HO * (size_t)KW * (size_t)KH * (size_t)i);
        size_t in_addr1 = (size_t)i * (size_t)B * (size_t)WI * (size_t)HI;
        for (kh = 0; kh < KH; kh++) {
            for (kw = 0; kw < KW; kw++) {
                for (h = 0; h < HO; h++) {
                    int hi = h * SH - PH + kh;
                    size_t in_addr2 = in_addr1 + ((size_t)hi * (size_t)B * (size_t)WI);
                    for (w = 0; w < WO; w++) {
                        int wi = w * SW - PW + kw;
                        int force_padding = (wi < 0) || (wi >= WI) || (hi < 0) || (hi >= HI);
                        if (force_padding) {
                            bzero(&out_ptr[out_addr], B*sizeof(type));
                        } else {
                            int in_addr = in_addr2 + (wi * B);
                            memcpy(&out_ptr[out_addr], &in_ptr[in_addr], B*sizeof(type));
                        }
                        out_addr+=B;
                    }
                }
            }
        }
    }
    return 1;
}

intfn\u im2col\u cpu（inti、intwi、inthi、intb、intkw、intkh、intwo、intho、intpw、intph、intsw、intsh、type*in\u ptr、type*out\r）{
分析头外部（im2col）；
分析设备（im2col、开发CPU）；
int i；//滚动输入通道
int w；//滚动通道列（宽度）
int h；//滚动通道行（高度）
int kw；//滚动筛选列（宽度）
int kh；//滚动筛选行（高度）
//我们扫描所有输出像素，并为每个像素计算相关的输入像素
#专用pragma omp并联（kh、kw、h、w）
对于（i=0；i=wi）| |（hi<0）| |（hi>=hi）；
if（强制填充）{
bzero（&out_ptr[out_addr]，B*sizeof（type））；
}否则{
int in_addr=in_addr2+（wi*B）；
memcpy（&out_ptr[out_addr]，&in_ptr[in_addr]，B*sizeof（type））；
}
out_addr+=B；
}
}
}
}
}
返回1；
}

OpenCL内核来自

\uuuu内核无效im2col（\uuu全局常量浮点*im\u src，int im\u src\u偏移，
内部通道，内部高度，内部宽度，
int kernel_h，int kernel_w，int pad_h，int pad_w，
内跨步，内跨步，
整数高度，整数宽度，
__全局浮点*im\u col，int im\u col\u offset
)
{
int index=get_global_id（0）；
如果（索引>=高度*宽度*通道）
返回；
int j_out=索引%width_out；
int i_out=（索引/宽度_out）%height_out；
int c_inp=（索引/宽度输出）/高度输出；
int c_out=c_inp*内核h*内核w；
int i_inp=i_out*跨步h-垫h；
int j_inp=j_out*步幅w-垫w；
im_-src+=（c_-inp*高度+i_-inp）*宽度+j_-inp+im_-src\u偏移量；
im_col+=（c_out*高度+i_out）*宽度+j_out+im_col\u偏移量；
for（int ki=0；ki=0&&j>=0&&i

您的C版本将批次折叠到最低维度。opencl版本甚至没有使用批处理

您需要传入批大小“B”，并根据批大小将此副本更改为块副本（或仅执行循环）：

for (int b=0; b<B; b++) *(im_col*B+b) = (i >= 0 && j >= 0 && i < height_inp && j < width_inp) ? im_src[(ki * width_inp + kj)*B + b] : 0;

你所说的“我必须适应的一个使用了让我困惑的批次”是什么意思？

for (int b=0; b<B; b++) *(im_col*B+b) = (i >= 0 && j >= 0 && i < height_inp && j < width_inp) ? im_src[(ki * width_inp + kj)*B + b] : 0;

im_col += height_out * width_out * B;