Upd 2D Conv[DepthWise] kernels

Context

Part of #31

Update 2D Convolution kernels Conv and ConvDethWise Operators to perform faster computation.

Protocol

Tests were made on x86-64 CPU architecture. Code was compiled with GCC 9.4.0 / Clang 10.0.0 compilers. The number of trials was 50 with no warm-up and the time measured was the CPU time using clock() function from the ctime library.

My results are presented measuring the value new_kernel_time / old_kernel_time.

I oberved that time could vary up to 20% between two sets of trials spaced in time.

Convolution

Each trial is based on a convolution with the following parameters:

Conv2D(in_channels = 16,
       out_channels = 16,
       kernels = [3,3],
       stride = [1,1],
       dilation = [1,1])

input = Tensor([8,16,64,64]) # shape

Then, a single parameter is tweaked from this base convolution:

• kernel size
• dilation size
• stride size
• number of inpt channels
• number of output channels
• number of batchs
• size of each dimensions of the feature map

Additionaly, a comparison was also performed with parameters that appeared the least favorable in the new convolution implementation. Even though this case is rare, I found it relevant to show. It is titled "special" in the results.

Conv2D(in_channels = 16,
       out_channels = 16,
       kernels = [5,5],
       stride = [3,3],
       dilation = [2,2])

Convolution depth-wise

The parameters and protocole are the same as for convolution. The only exception is for in_channels and out_channels that are merged into a single parameter channels.

Results

Conv

ConvDepthWise

include/aidge/backend/cpu/operator/ConvImpl_kernels.hpp

@@ -157,57 +157,52 @@ void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
     // input  (batch, inCh, Xin, Yin)
     // weight (outCh, inCh, kernelX, kernelY)
     // does not take Dilation attribute into account
-    using signedsize = std::make_signed<std::size_t>::type;
+    const std::size_t outChannels_s =  oxSize * oySize;
+
     for (std::size_t batch = 0; batch < inputDims[0]; ++batch) {
         for (std::size_t outCh = 0; outCh < outChannels; ++outCh) {
-            const std::size_t oIndex = (outCh + batch*outChannels) * oxSize * oySize;
             // If bias = nullptr, set B(0)
             B biasVal = (biases != nullptr) ? biases[outCh] : B(0);
-            std::fill(output + oIndex, output+(oIndex+oxSize*oySize), biasVal);
+            std::fill(output, output+outChannels_s, biasVal);
+
             for (std::size_t inCh = 0; inCh < inputDims[1]; ++inCh) {
                 const std::size_t iIndex = (inCh + batch*inputDims[1]) * inputDims[2] * inputDims[3];
                 const std::size_t wIndex = (inCh + outCh*inputDims[1]) * kernelDims[0] * kernelDims[1];
                 for (std::size_t ox = 0; ox < oxSize; ++ox) {
-                    // const signedsize difx = static_cast<signedsize>(- ox * strideDims[0]);
-                    // const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
-                    // const std::size_t sxMax = (static_cast<signedsize>(inputDims[2]) + difx) < 0 ? 0 : ((inputDims[2] + difx) > kernelDims[0] ? kernelDims[0] : inputDims[2] + difx);
-                    const std::size_t sxMin = 0;
-                    const std::size_t sxMax = dilated_kernel_x;
+
                     for (std::size_t oy = 0; oy < oySize; ++oy) {
-                        // const signedsize dify = static_cast<signedsize>(- oy * strideDims[1]);
-                        // const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
-                        // const std::size_t syMax = (static_cast<signedsize>(inputDims[3]) + dify) < 0 ? 0 : ((inputDims[3] + dify) > kernelDims[1] ? kernelDims[1] : inputDims[3] + dify);
-                        const std::size_t syMin = 0;
-                        const std::size_t syMax = dilated_kernel_y;
-                        const std::size_t oIndexFull = oIndex + ox*oySize + oy;
-                        const signedsize ix = static_cast<signedsize>(ox * strideDims[0]);
-                        const signedsize iy = static_cast<signedsize>(oy * strideDims[1]);
-
-                        if (sxMin == 0 && syMin == 0 && sxMax == 3 && syMax == 3) {
-                            output[oIndexFull] += (weights[wIndex + 0*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
-                                                   weights[wIndex + 0*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
-                                                   weights[wIndex + 0*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+0)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
-                                                   weights[wIndex + 1*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
-                                                   weights[wIndex + 1*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
-                                                   weights[wIndex + 1*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
-                                                   weights[wIndex + 2*kernelDims[1] + 0] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+0)] +
+
+                        const std::size_t oIndexFull = ox*oySize + oy;
+                        const size_t ix = ox * strideDims[0];
+                        const size_t iy = oy * strideDims[1];
+
+                        if (kernelDims[0] == 3 && kernelDims[1] == 3 && dilationDims[0] == 1 && dilationDims[1] == 1) {
+                            output[oIndexFull] += (weights[wIndex] * input[iIndex + static_cast<std::size_t>(ix)*inputDims[3] + static_cast<std::size_t>(iy)] +
+                                                   weights[wIndex + 1] * input[iIndex + static_cast<std::size_t>(ix)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+                                                   weights[wIndex + 2] * input[iIndex + static_cast<std::size_t>(ix)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
+                                                   weights[wIndex + kernelDims[1]] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy)] +
+                                                   weights[wIndex + kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
+                                                   weights[wIndex + kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+1)*inputDims[3] + static_cast<std::size_t>(iy+2)] +
+                                                   weights[wIndex + 2*kernelDims[1]] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy)] +
                                                    weights[wIndex + 2*kernelDims[1] + 1] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+1)] +
                                                    weights[wIndex + 2*kernelDims[1] + 2] * input[iIndex + static_cast<std::size_t>(ix+2)*inputDims[3] + static_cast<std::size_t>(iy+2)]);
                         } else {
-                            for (std::size_t sx = sxMin; sx*dilationDims[0] < sxMax; ++sx) {
-                                for (std::size_t sy = syMin; sy*dilationDims[1] < syMax; ++sy) {
+                            for (std::size_t sx = 0; sx*dilationDims[0] < dilated_kernel_x; ++sx) {
+                                for (std::size_t sy = 0; sy*dilationDims[1] < dilated_kernel_y; ++sy) {
                                     output[oIndexFull] += weights[wIndex + sx*kernelDims[1] + sy] *
-                                                            input[iIndex + static_cast<std::size_t>(ix+static_cast<signedsize>(sx*dilationDims[0]))*inputDims[3] + static_cast<std::size_t>(iy+static_cast<signedsize>(sy*dilationDims[1]))];
+                                                            input[iIndex + (ix + (sx*dilationDims[0]))*inputDims[3] + (iy + (sy*dilationDims[1]))];
                                 }
                             }
                         }
                     }
                 }
             }
+            output += outChannels_s;
         }
     }
 }
 
+
 // Kernels registration to implementation entry point
 REGISTRAR(ConvImpl2D_cpu,
     {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},