APPBROWSER-304,342: Add exclude padding support for OpenGL ES implementation and implement MaxPool operators

Change-Id: Ie6ba36ff114feec2a21739dba11bbb60b76af443
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/113697
Tested-by: Jenkins <bsgcomp@arm.com>
Reviewed-by: Stephen Li <stephen.li@arm.com>
Reviewed-by: Pablo Tello <pablo.tello@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>

4 files changed, 386 insertions, 160 deletions

diff --git a/src/core/GLES_COMPUTE/cs_shaders/fill_border.cs b/src/core/GLES_COMPUTE/cs_shaders/fill_border.cs
index c64572b061..4f87b9242a 100644
--- a/src/core/GLES_COMPUTE/cs_shaders/fill_border.cs
+++ b/src/core/GLES_COMPUTE/cs_shaders/fill_border.cs
@@ -132,7 +132,7 @@ void main()
     ImageIterator buf_iter = CONVERT_TENSOR3D_TO_IMAGE_ITERATOR_NO_STEP(buf_attrs, buf_shift);
 
     // Update pointer to point to the starting point of the valid region
-    TENSOR_ITERATOR_ADVANCE_IN_BYTES(buf_iter, uint(start_pos_y) * buf_attrs.stride_y + uint(start_pos_x) * buf_attrs.stride_x);
+    TENSOR_ITERATOR_ADVANCE_IN_BYTES(buf_iter, start_pos_y * int(buf_attrs.stride_y) + start_pos_x * int(buf_attrs.stride_x));
 
     int total_width = BORDER_SIZE_LEFT + int(width) + BORDER_SIZE_RIGHT;
     int gid0        = int(gl_GlobalInvocationID.x);
@@ -158,12 +158,29 @@ void main()
             {
                 if(pos % 2 == 0)
                 {
-                    STORE_PACK2_HALF(buf_ptr, offset, left_val.xx);
+                    if(BORDER_SIZE_LEFT % 2 == 0)
+                    {
+                        STORE_PACK2_HALF(buf_ptr, offset, left_val.xx);
+                    }
+                    else
+                    {
+                        STORE_PACK2_HALF(buf_ptr, offset, left_val.yy);
+                    }
+                    i++;
                 }
             }
         }
         // Handle right border
-        vec2 right_val = LOAD_UNPACK2_HALF(buf_ptr, IMAGE_OFFSET(buf_iter, int(width) - 1, gidH));
+        vec2 right_val_origin = LOAD_UNPACK2_HALF(buf_ptr, IMAGE_OFFSET(buf_iter, int(width) - 1, gidH));
+        vec2 right_val;
+        if((((BORDER_SIZE_LEFT + int(width)) % 2)) == 1)
+        {
+            right_val = vec2(right_val_origin.x, right_val_origin.x);
+        }
+        else
+        {
+            right_val = vec2(right_val_origin.y, right_val_origin.y);
+        }
         for(int i = 0; i < BORDER_SIZE_RIGHT; ++i)
         {
             uint offset = IMAGE_OFFSET(buf_iter, int(width) + i, gidH);
@@ -173,7 +190,8 @@ void main()
             {
                 if(pos % 2 == 0)
                 {
-                    STORE_PACK2_HALF(buf_ptr, offset, right_val.yy);
+                    STORE_PACK2_HALF(buf_ptr, offset, right_val);
+                    i++;
                 }
                 else
                 {
@@ -184,7 +202,8 @@ void main()
             {
                 if(pos % 2 == 0)
                 {
-                    STORE_PACK2_HALF(buf_ptr, offset, right_val.yy);
+                    STORE_PACK2_HALF(buf_ptr, offset, right_val);
+                    i++;
                 }
             }
         }
@@ -208,7 +227,14 @@ void main()
             {
                 if(gidW == (int(width) - 1))
                 {
-                    STORE_PACK2_HALF(buf_ptr, offset, top_val.xx);
+                    if(((BORDER_SIZE_LEFT + int(width)) % 2 == 1))
+                    {
+                        STORE_PACK2_HALF(buf_ptr, offset, top_val.xx);
+                    }
+                    else
+                    {
+                        STORE_PACK2_HALF(buf_ptr, offset, top_val.yy);
+                    }
                 }
                 else
                 {
@@ -229,6 +255,10 @@ void main()
                         {
                             STORE_PACK2_HALF(buf_ptr, offset, top_val.yy);
                         }
+                        else
+                        {
+                            STORE_PACK2_HALF(buf_ptr, offset, top_val.xx);
+                        }
                     }
                     else
                     {
@@ -268,6 +298,10 @@ void main()
                         {
                             STORE_PACK2_HALF(buf_ptr, offset, bottom_val.yy);
                         }
+                        else
+                        {
+                            STORE_PACK2_HALF(buf_ptr, offset, bottom_val.xx);
+                        }
                     }
                     else
                     {
diff --git a/src/core/GLES_COMPUTE/cs_shaders/pooling_layer.cs b/src/core/GLES_COMPUTE/cs_shaders/pooling_layer.cs
index 401b002111..64767a7ef1 100644
--- a/src/core/GLES_COMPUTE/cs_shaders/pooling_layer.cs
+++ b/src/core/GLES_COMPUTE/cs_shaders/pooling_layer.cs
@@ -259,7 +259,7 @@ layout(std140) uniform shader_params
     POOL_OP(data001.xyzw, data001.xyzw, data201.xyzw);                                                 \
     POOL_OP(data010.xyzw, data010.xyzw, data21.xyzw);                                                  \
     POOL_OP(res.xyzw, vec4(data000.xw, data001.z, data010.y), vec4(data000.y, data001.xw, data010.z)); \
-    POOL_OP(res.xyzw, res.xyzw, vec4(data000.z, data001.y data010.xw))
+    POOL_OP(res.xyzw, res.xyzw, vec4(data000.z, data001.y, data010.xw))
 
 float calculate_max(const int pool_size, Tensor3D src, const int upper_bound_w, const int upper_bound_h, const int pad_x, const int pad_y, const int stride_x, const int stride_y)
 {
@@ -271,11 +271,11 @@ float calculate_max(const int pool_size, Tensor3D src, const int upper_bound_w,
     float data_max;
     data_max = LOAD4(src, tensor3D_offset(src, 0, 0, 0));
 
-    for(int i = 0; (start_x + i) < end_x; ++i)
+    for(int i = 0; (start_y + i) < end_y; ++i)
     {
-        for(int j = 0; (start_y + j) < end_y; ++j)
+        for(int j = 0; (start_x + j) < end_x; ++j)
         {
-            float data = LOAD4(src, tensor3D_offset(src, i, j, 0));
+            float data = LOAD4(src, tensor3D_offset(src, j, i, 0));
             POOL_OP_float(data_max, data_max, data);
         }
     }
@@ -308,6 +308,11 @@ float calculate_avg(const int pool_size, Tensor3D src, const int upper_bound_w,
         }
     }
 
+#if defined(EXCLUDE_PADDING)
+    start_x = max(0, start_x);
+    start_y = max(0, start_y);
+#endif /* defined(EXCLUDE_PADDING) */
+
     return data_total / float((end_y - start_y) * (end_x - start_x));
 }
 
@@ -460,6 +465,10 @@ void main(void)
     int   start_y = int(gl_GlobalInvocationID.y) * STRIDE_Y - PAD_Y;
     ivec4 end_x   = min((start_x + (ivec4(3))), (ivec4(MAX_WIDTH)));
     int   end_y   = min((start_y + 3), MAX_HEIGHT);
+#if defined(EXCLUDE_PADDING)
+    start_x       = max(ivec4(0), start_x);
+    start_y       = max(0, start_y);
+#endif /* defined(EXCLUDE_PADDING) */
     res *= (vec4((1.f)) / vec4((ivec4(end_y - start_y)) * (end_x - start_x)));
 #endif /*POOL_AVG*/
 
@@ -606,12 +615,16 @@ void main(void)
 #if defined(POOL_AVG) || defined(POOL_L2)
     {
         // Divide by pool region in case of average pooling
-        int   start_x = int(gl_GlobalInvocationID.x) * STRIDE_X - PAD_X;
-        int   start_y = int(gl_GlobalInvocationID.y) * STRIDE_Y - PAD_Y;
-        int   end_x   = int(min(start_x + POOL_SIZE, MAX_WIDTH));
-        int   end_y   = int(min(start_y + POOL_SIZE, MAX_HEIGHT));
-        float res1    = float((end_y - start_y) * (end_x - start_x));
-        res           = DIV_OP(res, res1);
+        int start_x = int(gl_GlobalInvocationID.x) * STRIDE_X - PAD_X;
+        int start_y = int(gl_GlobalInvocationID.y) * STRIDE_Y - PAD_Y;
+        int end_x   = int(min(start_x + POOL_SIZE, MAX_WIDTH));
+        int end_y   = int(min(start_y + POOL_SIZE, MAX_HEIGHT));
+#if defined(EXCLUDE_PADDING)
+        start_x     = max(0, start_x);
+        start_y     = max(0, start_y);
+#endif /* defined(EXCLUDE_PADDING) */
+        float res1  = float((end_y - start_y) * (end_x - start_x));
+        res         = DIV_OP(res, res1);
     }
 #endif /* defined(POOL_AVG) || defined(POOL_L2) */
 
@@ -867,7 +880,7 @@ layout(std140) uniform shader_params
     POOL_OP(data001.xyzw, data001.xyzw, data201.xyzw);                                                 \
     POOL_OP(data010.xyzw, data010.xyzw, data21.xyzw);                                                  \
     POOL_OP(res.xyzw, vec4(data000.xw, data001.z, data010.y), vec4(data000.y, data001.xw, data010.z)); \
-    POOL_OP(res.xyzw, res.xyzw, vec4(data000.z, data001.y data010.xw))
+    POOL_OP(res.xyzw, res.xyzw, vec4(data000.z, data001.y, data010.xw))
 
 vec2 load_and_unpack(Tensor3D src, uint offset)
 {
@@ -970,7 +983,7 @@ vec2 calculate_max(const int pool_size, Tensor3D src, const int upper_bound_w, c
 
 vec2 calculate_avg(const int pool_size, Tensor3D src, const int upper_bound_w, const int upper_bound_h, const int pad_x, const int pad_y, const int stride_x, const int stride_y)
 {
-    int start_x1 = int(gl_GlobalInvocationID.x) * stride_x - pad_x;
+    int start_x1 = (2 * int(gl_GlobalInvocationID.x)) * stride_x - pad_x;
     int start_y1 = int(gl_GlobalInvocationID.y) * stride_y - pad_y;
     int end_x1   = int(min(start_x1 + pool_size, upper_bound_w));
     int end_y1   = int(min(start_y1 + pool_size, upper_bound_h));
@@ -1002,11 +1015,11 @@ vec2 calculate_avg(const int pool_size, Tensor3D src, const int upper_bound_w, c
             }
 
             //Calculate sum2
-            if((start_x2 + j) < end_x2 && end_x1 < upper_bound_w)
+            if((start_x2 + j) < end_x2 && end_x1 <= upper_bound_w)
             {
                 if((stride_x % 2) == 0)
                 {
-                    vec2 data2 = load_and_unpack(src, (tensor3D_offset_fp16(src, (j + stride_x + 1), i, 0) >> uint(2)));
+                    vec2 data2 = load_and_unpack(src, (tensor3D_offset_fp16(src, (j + stride_x), i, 0) >> uint(2)));
 #if defined(POOL_L2)
                     // Raise to power of 2 for L2 Pooling
                     data2 = POW2_OP(data2, 2);
@@ -1040,6 +1053,13 @@ vec2 calculate_avg(const int pool_size, Tensor3D src, const int upper_bound_w, c
                 }
             }
         }
+#if defined(EXCLUDE_PADDING)
+    start_x1 = max(0, start_x1);
+    start_y1 = max(0, start_y1);
+    start_x2 = max(0, start_x2);
+    start_y2 = max(0, start_y2);
+#endif /* defined(EXCLUDE_PADDING) */
+
     //Calculate average
     vec2 data_avg;
     data_avg.x = data_total1 / float((end_y1 - start_y1) * (end_x1 - start_x1));
@@ -1203,6 +1223,10 @@ void main(void)
     int   start_y = int(gl_GlobalInvocationID.y) * STRIDE_Y - PAD_Y;
     ivec4 end_x   = min((start_x + (ivec4(3))), (ivec4(MAX_WIDTH)));
     int   end_y   = min((start_y + 3), MAX_HEIGHT);
+#if defined(EXCLUDE_PADDING)
+    start_x       = max(ivec4(0), start_x);
+    start_y       = max(0, start_y);
+#endif /* defined(EXCLUDE_PADDING) */
     res *= (vec4((1.f)) / vec4((ivec4(end_y - start_y)) * (end_x - start_x)));
 #endif /*POOL_AVG*/
 
@@ -1354,44 +1378,96 @@ void main(void)
         }
     }
 
-    for(int y = STRIDE_X; y < int(POOL_SIZE + STRIDE_X); y++)
+    for(int y = 0; y < int(POOL_SIZE); y++)
     {
-        int x1 = STRIDE_X;
-        for(; x1 <= (int(POOL_SIZE + STRIDE_X) - 8); x1 += 8)
+        if((STRIDE_X % 2) == 0)
         {
-            vec4 data2;
-            vec4 data3;
-            LOAD4_fp16(data2, src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)));
-            LOAD4_fp16(data3, src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)) + uint(2));
+            int x1 = STRIDE_X;
+            for(; x1 <= (int(POOL_SIZE + STRIDE_X) - 8); x1 += 8)
+            {
+                vec4 data2;
+                vec4 data3;
+                LOAD4_fp16(data2, src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)));
+                LOAD4_fp16(data3, src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)) + uint(2));
 
 #if defined(POOL_L2)
-            // Raise to power of 2 for L2 Pooling
-            data2 *= data2;
-            data3 *= data3;
+                // Raise to power of 2 for L2 Pooling
+                data2 *= data2;
+                data3 *= data3;
 #endif /* defined(POOL_L2) */
 
-            POOL_OP(vdata01, vdata01, data2);
-            POOL_OP(vdata11, vdata11, data3);
-        }
+                POOL_OP(vdata01, vdata01, data2);
+                POOL_OP(vdata11, vdata11, data3);
+            }
 
-        // Leftover
-        for(; x1 < int(POOL_SIZE + STRIDE_X); x1 = x1 + 2)
+            // Leftover
+            for(; x1 < int(POOL_SIZE + STRIDE_X); x1 = x1 + 2)
+            {
+                vec2 data4middle;
+                data4middle = load_and_unpack(src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)));
+#if defined(POOL_L2)
+                // Raise to power of 2 for L2 Pooling
+                data4middle *= data4middle;
+#endif /* defined(POOL_L2) */
+                if((x1 + 1) >= int(POOL_SIZE + STRIDE_X))
+                {
+                    POOL_OP_float(sdata.y, sdata.y, data4middle.x);
+                }
+                else
+                {
+                    float data4;
+                    POOL_OP_float(data4, data4middle.x, data4middle.y);
+                    POOL_OP_float(sdata.y, sdata.y, data4);
+                }
+            }
+        }
+        else
         {
-            vec2 data4middle;
-            data4middle = load_and_unpack(src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)));
+            vec2 dataorigin2;
+            dataorigin2 = load_and_unpack(src, (tensor3D_offset_fp16(src, (STRIDE_X - 1), y, 0) >> uint(2)));
 #if defined(POOL_L2)
             // Raise to power of 2 for L2 Pooling
-            data4middle *= data4middle;
+            dataorigin2.y *= dataorigin2.y;
 #endif /* defined(POOL_L2) */
-            if((x1 + 1) >= int(POOL_SIZE + STRIDE_X))
+            POOL_OP_float(sdata.y, sdata.y, dataorigin2.y);
+
+            int x1 = STRIDE_X + 1;
+            for(; x1 <= (int(POOL_SIZE + STRIDE_X) - 8); x1 += 8)
             {
-                POOL_OP_float(sdata.y, sdata.y, data4middle.x);
+                vec4 data2;
+                vec4 data3;
+                LOAD4_fp16(data2, src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)));
+                LOAD4_fp16(data3, src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)) + uint(2));
+
+#if defined(POOL_L2)
+                // Raise to power of 2 for L2 Pooling
+                data2 *= data2;
+                data3 *= data3;
+#endif /* defined(POOL_L2) */
+
+                POOL_OP(vdata01, vdata01, data2);
+                POOL_OP(vdata11, vdata11, data3);
             }
-            else
+
+            // Leftover
+            for(; x1 < int(POOL_SIZE + STRIDE_X); x1 = x1 + 2)
             {
-                float data4;
-                POOL_OP_float(data4, data4middle.x, data4middle.y);
-                POOL_OP_float(sdata.y, sdata.y, data4);
+                vec2 data4middle;
+                data4middle = load_and_unpack(src, (tensor3D_offset_fp16(src, x1, y, 0) >> uint(2)));
+#if defined(POOL_L2)
+                // Raise to power of 2 for L2 Pooling
+                data4middle *= data4middle;
+#endif /* defined(POOL_L2) */
+                if((x1 + 1) >= int(POOL_SIZE + STRIDE_X))
+                {
+                    POOL_OP_float(sdata.y, sdata.y, data4middle.x);
+                }
+                else
+                {
+                    float data4;
+                    POOL_OP_float(data4, data4middle.x, data4middle.y);
+                    POOL_OP_float(sdata.y, sdata.y, data4);
+                }
             }
         }
     }
@@ -1414,14 +1490,20 @@ void main(void)
 #if defined(POOL_AVG) || defined(POOL_L2)
     {
         // Divide by pool region in case of average pooling
-        int  start_x1 = int(gl_GlobalInvocationID.x) * STRIDE_X - PAD_X;
-        int  start_y1 = int(gl_GlobalInvocationID.y) * STRIDE_Y - PAD_Y;
-        int  end_x1   = int(min(start_x1 + POOL_SIZE, MAX_WIDTH));
-        int  end_y1   = int(min(start_y1 + POOL_SIZE, MAX_HEIGHT));
-        int  start_x2 = start_x1 + STRIDE_X;
-        int  start_y2 = start_y1;
-        int  end_x2   = int(min(start_x2 + POOL_SIZE, MAX_WIDTH));
-        int  end_y2   = int(min(start_y2 + POOL_SIZE, MAX_HEIGHT));
+        int start_x1 = (2 * int(gl_GlobalInvocationID.x)) * STRIDE_X - PAD_X;
+        int start_y1 = int(gl_GlobalInvocationID.y) * STRIDE_Y - PAD_Y;
+        int end_x1   = int(min(start_x1 + POOL_SIZE, MAX_WIDTH));
+        int end_y1   = int(min(start_y1 + POOL_SIZE, MAX_HEIGHT));
+        int start_x2 = start_x1 + STRIDE_X;
+        int start_y2 = start_y1;
+        int end_x2   = int(min(start_x2 + POOL_SIZE, MAX_WIDTH));
+        int end_y2   = int(min(start_y2 + POOL_SIZE, MAX_HEIGHT));
+#if defined(EXCLUDE_PADDING)
+        start_x1     = max(0, start_x1);
+        start_y1     = max(0, start_y1);
+        start_x2     = max(0, start_x2);
+        start_y2     = max(0, start_y2);
+#endif /* defined(EXCLUDE_PADDING) */
         vec2 res1;
         res1.x = float((end_y1 - start_y1) * (end_x1 - start_x1));
         res1.y = float((end_y2 - start_y2) * (end_x2 - start_x2));
diff --git a/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp b/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp
index 0b6ba583a3..6451db741d 100644
--- a/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp
+++ b/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp
@@ -40,6 +40,176 @@
 
 using namespace arm_compute;
 
+namespace
+{
+// Internal window config info
+using GCPoolingConfig = std::pair<unsigned int, BorderSize>; //num_elems_processed_per_iteration, border_size
+
+void auto_init(const ITensorInfo *input, ITensorInfo *output, unsigned int pooled_w, unsigned int pooled_h)
+{
+    TensorShape output_shape{ input->tensor_shape() };
+    output_shape.set(0, pooled_w);
+    output_shape.set(1, pooled_h);
+
+    auto_init_if_empty(*output, input->clone()->set_tensor_shape(output_shape));
+}
+
+Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, const PoolingLayerInfo &pool_info)
+{
+    ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
+    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F16, DataType::F32);
+    ARM_COMPUTE_RETURN_ERROR_ON_MSG((is_data_type_quantized_asymmetric(input->data_type()) && pool_info.pool_type() == PoolingType::L2),
+                                    "Unsupported combination of parameters!");
+
+    const bool         is_global_pooling = pool_info.is_global_pooling();
+    const unsigned int pool_size         = is_global_pooling ? input->tensor_shape().x() : pool_info.pool_size();
+
+    ARM_COMPUTE_RETURN_ERROR_ON_MSG(is_global_pooling && (input->tensor_shape().x() != input->tensor_shape().y()),
+                                    "Global pooling is supported only with rectangular inputs!");
+    ARM_COMPUTE_RETURN_ERROR_ON_MSG(!is_global_pooling && ((pool_info.pad_stride_info().pad().first >= pool_size) || (pool_info.pad_stride_info().pad().second >= pool_size)),
+                                    "Invalid pool size and pool pad combination!");
+
+    // Checks performed when output is configured
+    if(output->total_size() != 0)
+    {
+        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
+        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_FIXED_POINT(input, output);
+
+        unsigned int pooled_w = 0;
+        unsigned int pooled_h = 0;
+        std::tie(pooled_w, pooled_h) = scaled_dimensions(input->dimension(0),
+                                                         input->dimension(1),
+                                                         pool_size,
+                                                         pool_size,
+                                                         pool_info.pad_stride_info());
+        ARM_COMPUTE_RETURN_ERROR_ON_MSG((output->dimension(0) != pooled_w) || (output->dimension(1) != pooled_h),
+                                        "Invalid output pooling dimensions!");
+    }
+
+    return Status{};
+}
+
+std::tuple<Status, Window, GCPoolingConfig> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output, const PoolingLayerInfo &pool_info)
+{
+    int                 pool_pad_x      = 0;
+    int                 pool_pad_y      = 0;
+    int                 pool_stride_x   = 0;
+    int                 pool_stride_y   = 0;
+    unsigned int        pooled_w        = 0;
+    unsigned int        pooled_h        = 0;
+    int                 pool_size       = pool_info.pool_size();
+    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info();
+    std::tie(pool_pad_x, pool_pad_y)       = pad_stride_info.pad();
+    std::tie(pool_stride_x, pool_stride_y) = pad_stride_info.stride();
+
+    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
+
+    // Update pool size in case of global pooling
+    pool_size = pool_info.is_global_pooling() ? input->dimension(0) : pool_size;
+
+    // Check output dimensions
+    std::tie(pooled_w, pooled_h) = scaled_dimensions(input->dimension(0),
+                                                     input->dimension(1),
+                                                     pool_size,
+                                                     pool_size,
+                                                     pad_stride_info);
+
+    auto_init(input, output, pooled_w, pooled_h);
+
+    BorderSize     border_size = BorderSize(pool_pad_y, pool_pad_x);
+    const DataType data_type   = input->data_type();
+
+    const int input_width  = input->dimension(0);
+    const int input_height = input->dimension(1);
+
+    unsigned int num_elems_processed_per_iteration = 1;
+
+    // Create kernel
+    if(pool_size == 3)
+    {
+        // Check if we have pool3x3 with stride_x less equal than 3. In these cases, run an optimized OpenGLES kernel where
+        // each thread computes 4 output elements
+        const bool is_pool3x3_stride_le3 = (pool_size == 3) && (pool_stride_x <= 3) && !is_data_type_fixed_point(data_type);
+
+        int num_elems_read_per_iteration = pool_size;
+
+        if(input->data_type() == DataType::F32)
+        {
+            if(is_pool3x3_stride_le3)
+            {
+                // Change the number of elements processed and number of elements read per iteration for pooling 3x3 with stride less equal than 3
+                num_elems_processed_per_iteration = 4;
+                num_elems_read_per_iteration      = pool_size * (pool_stride_x + 1);
+            }
+        }
+        else
+        {
+            if(is_pool3x3_stride_le3)
+            {
+                num_elems_processed_per_iteration = 4;
+            }
+            else
+            {
+                num_elems_processed_per_iteration = 2;
+            }
+        }
+
+        const int upper_bound_w = ((pooled_w - 1) * pool_stride_x - pool_pad_x + num_elems_read_per_iteration) - input_width;
+        const int upper_bound_h = ((pooled_h - 1) * pool_stride_y - pool_pad_y + pool_size) - input_height;
+
+        border_size.right  = std::max(upper_bound_w, pool_pad_x);
+        border_size.bottom = std::max(upper_bound_h, pool_pad_y);
+    }
+    else // Run general case
+    {
+        if(input->data_type() == DataType::F32)
+        {
+            num_elems_processed_per_iteration = 1;
+        }
+        else
+        {
+            num_elems_processed_per_iteration = 2;
+        }
+
+        const int upper_bound_w = ((pooled_w - 1) * pool_stride_x - pool_pad_x + pool_size) - input_width;
+        const int upper_bound_h = ((pooled_h - 1) * pool_stride_y - pool_pad_y + pool_size) - input_height;
+
+        border_size.right  = std::max(upper_bound_w, pool_pad_x);
+        border_size.bottom = std::max(upper_bound_h, pool_pad_y);
+    }
+    // Configure kernel window
+    Window win = calculate_max_window(*output, Steps(num_elems_processed_per_iteration));
+
+    if(input->data_type() == DataType::F32)
+    {
+        AccessWindowStatic     input_access(input, -pool_pad_x, -pool_pad_y, input_width + border_size.right, input_height + border_size.bottom);
+        AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration);
+        bool                   window_changed = update_window_and_padding(win, input_access, output_access);
+        output_access.set_valid_region(win, ValidRegion(Coordinates(), output->tensor_shape()));
+        Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{};
+        return std::make_tuple(err, win, GCPoolingConfig(num_elems_processed_per_iteration, border_size));
+    }
+    else
+    {
+        // Calculate output right and bottom border
+        const int output_width          = output->dimension(0);
+        const int output_height         = output->dimension(1);
+        const int output_padding_right  = ceil_to_multiple(output_width, num_elems_processed_per_iteration) - output_width;
+        const int output_padding_bottom = ceil_to_multiple(output_height, 1) - output_height;
+        const int input_padding_right   = ceil_to_multiple(input_width + 2 * border_size.right, num_elems_processed_per_iteration) - (input_width + 2 * border_size.right);
+        const int input_padding_bottom  = ceil_to_multiple(input_height + 2 * border_size.bottom, 1) - (input_height + 2 * border_size.bottom);
+
+        // Configure kernel window
+        AccessWindowStatic input_access(input, -pool_pad_x, -pool_pad_y, input_width + border_size.right + input_padding_right, input_height + border_size.bottom + input_padding_bottom);
+        AccessWindowStatic output_access(output, 0, 0, output_width + output_padding_right, output_height + output_padding_bottom);
+        bool               window_changed = update_window_and_padding(win, input_access, output_access);
+        output_access.set_valid_region(win, ValidRegion(Coordinates(), output->tensor_shape()));
+        Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{};
+        return std::make_tuple(err, win, GCPoolingConfig(num_elems_processed_per_iteration, border_size));
+    }
+}
+} // namespace
+
 GCPoolingLayerKernel::GCPoolingLayerKernel()
     : _input(nullptr), _output(nullptr), _pool_info(), _border_size(0), _num_elems_processed_per_iteration(1)
 {
@@ -52,54 +222,41 @@ BorderSize GCPoolingLayerKernel::border_size() const
 
 void GCPoolingLayerKernel::configure(const IGCTensor *input, IGCTensor *output, const PoolingLayerInfo &pool_info)
 {
-    int                 pool_pad_x        = 0;
-    int                 pool_pad_y        = 0;
-    int                 pool_stride_x     = 0;
-    int                 pool_stride_y     = 0;
-    unsigned int        pooled_w          = 0;
-    unsigned int        pooled_h          = 0;
-    const PoolingType   pool_type         = pool_info.pool_type();
-    int                 pool_size         = pool_info.pool_size();
-    const PadStrideInfo pad_stride_info   = pool_info.pad_stride_info();
-    const bool          is_global_pooling = pool_info.is_global_pooling();
+    int                 pool_pad_x      = 0;
+    int                 pool_pad_y      = 0;
+    int                 pool_stride_x   = 0;
+    int                 pool_stride_y   = 0;
+    unsigned int        pooled_w        = 0;
+    unsigned int        pooled_h        = 0;
+    const PoolingType   pool_type       = pool_info.pool_type();
+    int                 pool_size       = pool_info.pool_size();
+    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info();
+    const bool          exclude_padding = pool_info.exclude_padding();
     std::tie(pool_pad_x, pool_pad_y)       = pad_stride_info.pad();
     std::tie(pool_stride_x, pool_stride_y) = pad_stride_info.stride();
 
-    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F16, DataType::F32);
-    ARM_COMPUTE_ERROR_ON_NULLPTR(output);
-    ARM_COMPUTE_ERROR_ON(!is_global_pooling && (pool_pad_x >= pool_size || pool_pad_y >= pool_size));
-    ARM_COMPUTE_ERROR_ON(is_global_pooling && (input->info()->tensor_shape().x() != input->info()->tensor_shape().y()));
+    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
 
     // Update pool size in case of global pooling
-    pool_size = is_global_pooling ? input->info()->dimension(0) : pool_size;
+    pool_size = pool_info.is_global_pooling() ? input->info()->dimension(0) : pool_size;
 
     // Check output dimensions
     std::tie(pooled_w, pooled_h) = scaled_dimensions(input->info()->dimension(0),
                                                      input->info()->dimension(1),
                                                      pool_size,
                                                      pool_size,
-                                                     pool_info.pad_stride_info());
-
-    // Output auto initialization if not yet initialized
-    {
-        TensorShape output_shape{ input->info()->tensor_shape() };
-        output_shape.set(0, pooled_w);
-        output_shape.set(1, pooled_h);
-
-        auto_init_if_empty(*output->info(), output_shape, 1, input->info()->data_type(), input->info()->fixed_point_position());
-    }
+                                                     pad_stride_info);
 
-    ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
-    ARM_COMPUTE_ERROR_ON((output->info()->dimension(0) != pooled_w) || (output->info()->dimension(1) != pooled_h));
+    auto_init(input->info(), output->info(), pooled_w, pooled_h);
 
-    const int input_width  = input->info()->dimension(0);
-    const int input_height = input->info()->dimension(1);
+    ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info(), pool_info));
 
     // Set instance variables
-    _input       = input;
-    _output      = output;
-    _pool_info   = pool_info;
-    _border_size = BorderSize(pool_pad_y, pool_pad_x);
+    _input     = input;
+    _output    = output;
+    _pool_info = pool_info;
+
+    const DataType data_type = input->info()->data_type();
 
     // Set build options
     std::set<std::string> build_opts;
@@ -114,10 +271,14 @@ void GCPoolingLayerKernel::configure(const IGCTensor *input, IGCTensor *output,
     {
         build_opts.insert("#define DATA_TYPE_FP16");
     }
+    if(exclude_padding)
+    {
+        build_opts.emplace("#define EXCLUDE_PADDING");
+    }
     build_opts.emplace(("#define POOL_" + string_from_pooling_type(pool_type)));
     build_opts.emplace(("#define STRIDE_X " + support::cpp11::to_string(pool_stride_x)));
-    build_opts.emplace(("#define MAX_WIDTH " + support::cpp11::to_string(input->info()->dimension(0) + pool_pad_x)));
-    build_opts.emplace(("#define MAX_HEIGHT " + support::cpp11::to_string(input->info()->dimension(1) + pool_pad_y)));
+    build_opts.emplace(("#define MAX_WIDTH " + support::cpp11::to_string(input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_x))));
+    build_opts.emplace(("#define MAX_HEIGHT " + support::cpp11::to_string(input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_y))));
     build_opts.emplace(("#define STRIDE_Y " + support::cpp11::to_string(pool_stride_y)));
     build_opts.emplace(("#define PAD_X " + support::cpp11::to_string(pool_pad_x)));
     build_opts.emplace(("#define PAD_Y " + support::cpp11::to_string(pool_pad_y)));
@@ -127,37 +288,7 @@ void GCPoolingLayerKernel::configure(const IGCTensor *input, IGCTensor *output,
     {
         // Check if we have pool3x3 with stride_x less equal than 3. In these cases, run an optimized OpenGLES kernel where
         // each thread computes 4 output elements
-        const bool is_pool3x3_stride_le3 = (pool_size == 3) && (pool_stride_x <= 3) && !is_data_type_fixed_point(input->info()->data_type());
-
-        int num_elements_read_per_iteration = (pool_size == 7) ? 8 : pool_size;
-
-        if(input->info()->data_type() == DataType::F32)
-        {
-            if(is_pool3x3_stride_le3)
-            {
-                // Change the number of elements processed and number of elements read per iteration for pooling 3x3 with stride less equal than 3
-                _num_elems_processed_per_iteration = 4;
-                num_elements_read_per_iteration    = pool_size * (pool_stride_x + 1);
-            }
-        }
-        else
-        {
-            num_elements_read_per_iteration = pool_size;
-            if(is_pool3x3_stride_le3)
-            {
-                _num_elems_processed_per_iteration = 4;
-            }
-            else
-            {
-                _num_elems_processed_per_iteration = 2;
-            }
-        }
-
-        const int upper_bound_w = ((pooled_w - 1) * pool_stride_x - pool_pad_x + num_elements_read_per_iteration) - input_width;
-        const int upper_bound_h = ((pooled_h - 1) * pool_stride_y - pool_pad_y + pool_size) - input_height;
-
-        _border_size.right  = std::max(upper_bound_w, pool_pad_x);
-        _border_size.bottom = std::max(upper_bound_h, pool_pad_y);
+        const bool is_pool3x3_stride_le3 = (pool_size == 3) && (pool_stride_x <= 3) && !is_data_type_fixed_point(data_type);
 
         std::string kernel_name = "pooling_layer_" + support::cpp11::to_string(pool_size);
         if(is_pool3x3_stride_le3)
@@ -173,53 +304,27 @@ void GCPoolingLayerKernel::configure(const IGCTensor *input, IGCTensor *output,
     }
     else // Run general case
     {
-        if(input->info()->data_type() == DataType::F32)
-        {
-            _num_elems_processed_per_iteration = 1;
-        }
-        else
-        {
-            _num_elems_processed_per_iteration = 2;
-        }
-        const int upper_bound_w = ((pooled_w - 1) * pool_stride_x - pool_pad_x + pool_size) - input_width;
-        const int upper_bound_h = ((pooled_h - 1) * pool_stride_y - pool_pad_y + pool_size) - input_height;
-
-        _border_size.right  = std::max(upper_bound_w, pool_pad_x);
-        _border_size.bottom = std::max(upper_bound_h, pool_pad_y);
-
         build_opts.emplace(("#define POOL_SIZE " + support::cpp11::to_string(pool_size)));
 
         build_opts.insert("#define POOLING_LAYER_N");
         _kernel = static_cast<GCKernel>(GCKernelLibrary::get().create_kernel("pooling_layer_n", build_opts));
     }
+    // Configure kernel window
+    auto win_config = validate_and_configure_window(input->info(), output->info(), pool_info);
+    ARM_COMPUTE_ERROR_THROW_ON(std::get<0>(win_config));
+
+    IGCKernel::configure(std::get<1>(win_config));
+    GCPoolingConfig pooling_config     = std::get<2>(win_config);
+    _num_elems_processed_per_iteration = pooling_config.first;
+    _border_size                       = pooling_config.second;
+}
 
-    Window win = calculate_max_window(*output->info(), Steps(_num_elems_processed_per_iteration));
-
-    if(input->info()->data_type() == DataType::F32)
-    {
-        AccessWindowStatic     input_access(input->info(), -pool_pad_x, -pool_pad_y, input_width + _border_size.right, input_height + _border_size.bottom);
-        AccessWindowHorizontal output_access(output->info(), 0, _num_elems_processed_per_iteration);
-        update_window_and_padding(win, input_access, output_access);
-        output_access.set_valid_region(win, ValidRegion(Coordinates(), output->info()->tensor_shape()));
-    }
-    else
-    {
-        // Calculate output right and bottom border
-        const int output_width          = output->info()->dimension(0);
-        const int output_height         = output->info()->dimension(1);
-        const int output_padding_right  = ceil_to_multiple(output_width, _num_elems_processed_per_iteration) - output_width;
-        const int output_padding_bottom = ceil_to_multiple(output_height, 1) - output_height;
-        const int input_padding_right   = ceil_to_multiple(input_width + 2 * _border_size.right, _num_elems_processed_per_iteration) - (input_width + 2 * _border_size.right);
-        const int input_padding_bottom  = ceil_to_multiple(input_height + 2 * _border_size.bottom, 1) - (input_height + 2 * _border_size.bottom);
-
-        // Configure kernel window
-        AccessWindowStatic input_access(input->info(), -pool_pad_x, -pool_pad_y, input_width + _border_size.right + input_padding_right, input_height + _border_size.bottom + input_padding_bottom);
-        AccessWindowStatic output_access(output->info(), 0, 0, output_width + output_padding_right, output_height + output_padding_bottom);
-        update_window_and_padding(win, input_access, output_access);
-        output_access.set_valid_region(win, ValidRegion(Coordinates(), output->info()->tensor_shape()));
-    }
+Status GCPoolingLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *output, const PoolingLayerInfo &pool_info)
+{
+    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, pool_info));
+    ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), output->clone().get(), pool_info)));
 
-    IGCKernel::configure(win);
+    return Status{};
 }
 
 void GCPoolingLayerKernel::run(const Window &window)
@@ -239,7 +344,7 @@ void GCPoolingLayerKernel::run(const Window &window)
     do
     {
         // Upsample input by pool size
-        Window in_slice(slice);
+        Window in_slice(slice); // NOLINT
         in_slice.set(Window::DimX, Window::Dimension(in_slice.x().start() - pool_pad_x, in_slice.x().end() * pool_stride_x, pool_stride_x * _num_elems_processed_per_iteration));
         in_slice.set(Window::DimY, Window::Dimension(in_slice.y().start() - pool_pad_y, in_slice.y().end() * pool_stride_y, pool_stride_y));
 
diff --git a/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp b/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp
index 46a60cddef..ff03effd3f 100644
--- a/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp
+++ b/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp
@@ -23,8 +23,8 @@
  */
 #include "arm_compute/runtime/GLES_COMPUTE/functions/GCPoolingLayer.h"
 
+#include "arm_compute/core/GLES_COMPUTE/IGCTensor.h"
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.h"
-#include "arm_compute/core/PixelValue.h"
 #include "support/ToolchainSupport.h"
 
 using namespace arm_compute;
@@ -40,3 +40,8 @@ void GCPoolingLayer::configure(IGCTensor *input, IGCTensor *output, const Poolin
     BorderMode border_mode = (PoolingType::MAX == pool_info.pool_type()) ? BorderMode::REPLICATE : BorderMode::CONSTANT;
     _border_handler.configure(input, _kernel->border_size(), border_mode, PixelValue(0.0f));
 }
+
+Status GCPoolingLayer::validate(const ITensorInfo *input, const ITensorInfo *output, const PoolingLayerInfo &pool_info)
+{
+    return GCPoolingLayerKernel::validate(input, output, pool_info);
+}
\ No newline at end of file