Question

我正在尝试为1280x720图像编写优化的3x3 2D图像卷积。

为简单起见，通过将输入填充到1284 * 724来逼近边缘条件。

这是我的内核代码：

__kernel 
    __attribute__((vec_type_hint(float4)))
    void conv2d3x3(                                                     
       __global const float* restrict input,                         
       __global float* restrict output,
       __constant const float4* restrict hL, 
       /* 3x3 kernel, padded with 3 zeros on the right, used to calculate
        "left" output samples*/
       __constant const float4* restrict hR
       /*same 3x3 kernel, padded with 3 samples on the left*/)           
    {                                        
       int j = get_global_id(0)*2;  //[0,639]  
       int i = get_global_id(1)*2;  //[0,359]                

       /* load a 4x4 block, note stride is 1284 because input is padded by 4*/   
       float4 data0=vload4(0,input+1284*(i+0)+j);
       float4 data1=vload4(0,input+1284*(i+1)+j);
       float4 data2=vload4(0,input+1284*(i+2)+j);
       float4 data3=vload4(0,input+1284*(i+3)+j);

       /* sum(data[0:2,0:2].* h)*/
       float prodTL=dot(data0,hL[0])+dot(data1,hL[1])+dot(data2,hL[2]);
       /* sum(data[0:2,1:3].* h)*/
       float prodTR=dot(data0,hR[0])+dot(data1,hR[1])+dot(data2,hR[2]);
       /* sum(data[1:3,0:2].* h)*/
       float prodBL=dot(data1,hL[0])+dot(data2,hL[1])+dot(data3,hL[2]);
       /* sum(data[1:3,1:3].* h)*/
       float prodBR=dot(data1,hR[0])+dot(data2,hR[1])+dot(data3,hR[2]);

       output[1280*(i+0)+j]=prodTL;
       output[1280*(i+0)+j+1]=prodTR;
       output[1280*(i+1)+j]=prodBL;
       output[1280*(i+1)+j+1]=prodBR;
    }

这种设计的合理性是，加载4x4数据块，进行4次3x4卷积并生成4个输出样本。

此代码有一些明显的问题：

1）矢量载荷未与矢量边界对齐。

2）输出的存储没有矢量化

3）性能差：搭载P4600的英特尔XEON 1245v3（带有Beignet OpenCL实现）为3ms，带有GC2000的Freescale IMX6Q为27ms（带有Freescale OpenCL libOpenCL）。

问题：

1）我做错了什么以及为什么这么慢？

2）在原始FLOPS的百分比方面，我期望什么样的表现？（p4600能够在320MHz和1.2GHz之间运行20EU * 2PFU / EU * SIMD8 = 320FLOPS /周期，而GC2000能够至少14GFLOPS）

3）一般来说，如何在不产生过多内存流量和缓存冲突的情况下对固定大小的不可分离2D卷积进行矢量化？

Answer 1

首先，我未经优化的结果：

Amd FX 8150 @ 3.3 GHz（32 fp元素=＆gt; 1加+ 1 mul =每周期64 FLOPS）：

3.71ms 包括在单独的opencl缓冲区和C＃数组之间复制时间。

2.05ms 不包括数组副本。

使用1-D ndrange内核执行而不是2D。 [0,640x360]

__kernel 
    __attribute__((vec_type_hint(float4)))
    void bench(                                                     
       __global const float* restrict input,                         
       __global float* restrict output,
       __constant const float4* restrict hL, 

       __constant const float4* restrict hR
      )           
    {
                int gli=get_global_id(0); 
                int j = (gli%640) * 2 ;
                int i = (gli/640) * 2; 

                /* load a 4x4 block*/
                float4 data0 = vload4(0, input + 1280 * (i + 0) + j);
                float4 data1 = vload4(0, input + 1280 * (i + 1) + j);
                float4 data2 = vload4(0, input + 1280 * (i + 2) + j);
                float4 data3 = vload4(0, input + 1280 * (i + 3) + j);


                float prodTL = dot(data0, hL[0]) + dot(data1, hL[1]) + dot(data2, hL[2]);

                float prodTR = dot(data0, hR[0]) + dot(data1, hR[1]) + dot(data2, hR[2]);

                float prodBL = dot(data1, hL[0]) + dot(data2, hL[1]) + dot(data3, hL[2]);

                float prodBR = dot(data1, hR[0]) + dot(data2, hR[1]) + dot(data3, hR[2]);

                output[1280 * (i + 0) + j] = prodTL;
                output[1280 * (i + 0) + j + 1] = prodTR;
                output[1280 * (i + 1) + j] = prodBL;
                output[1280 * (i + 1) + j + 1] = prodBR;
            }

主机端（C＃阵列）：

        float[] inp = new float[1280*720*2];
        float[] outp = new float[1280*720*2];
        float[] hL = new float[1024];
        float[] hR = new float[1024];

预取私有寄存器（我只希望驱动程序使用cpu寄存器）：

<强> 2ms的

优化部分：

        float4 hl2=hL[2];
        float4 hl1=hL[1];
        float4 hl0=hL[0];

        float4 hr2=hR[2];
        float4 hr1=hR[1];
        float4 hr0=hR[0];

        float prodTL = dot(data0, hl0) + dot(data1, hl1) + dot(data2, hl2);

        float prodTR = dot(data0, hr0) + dot(data1, hr1) + dot(data2,  hr2);

        float prodBL = dot(data1, hl0) + dot(data2, hl1) + dot(data3, hl2);

        float prodBR = dot(data1, hr0) + dot(data2, hr1) + dot(data3,  hr2);

现在增加了点积的并行性：

三个点的总和将等于一个大点。

  float16 prodhl    =(float16)(hl0,  hl1,  hl2,  (float4)(0.0f,0.0f,0.0f,0.0f));                    
                float16 prodhl    =(float16)(hr0,  hr1,  hr2,  (float4)(0.0f,0.0f,0.0f,0.0f));   
                float16 prodTdata =(float16)(data0,data1,data2,(float4)(0.0f,0.0f,0.0f,0.0f));    

                float16 prodBdata=(float16)(data1,data2,data3,(float4)(0.0f,0.0f,0.0f,0.0f));    

                float prodTL = dot(prodTdata, prodhl);
                float prodTR = dot(prodTdata, prodhr);

                float prodBL = dot(prodBdata, prodhl);
                float prodBR = dot(prodBdata, prodhr);

没有任何数组副本的执行：

0.5412 ms

meybe它只是cpu的AVX功能。如果没有，则应该发生一些指令级并行性。

这个部分有1/4的计算能力浪费（float16的最新float4部分）所以必须有一种方法可以达到0.4毫秒。

注意：线程组大小为256.我没有尝试增加到1024，因为它不适用于所有设备，如amd gpu。

您可以尝试任务进程级并行性来提高吞吐量并击败单个opencl上下文（如果您已经这样做了）。

如何矢量化3x3 2D卷积？

1 个答案: