COMPMID-2985 change PoolingLayerInfo to struct

Change-Id: I489205c2b65ec82c6d3da4df39c356a53265556b
Signed-off-by: Sang-Hoon Park <sang-hoon.park@arm.com>
Reviewed-on: https://review.mlplatform.org/c/2597
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Giorgio Arena <giorgio.arena@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>

13 files changed, 183 insertions, 216 deletions

diff --git a/arm_compute/core/Types.h b/arm_compute/core/Types.h
index cbcd3fa783..4cec63bff9 100644
--- a/arm_compute/core/Types.h
+++ b/arm_compute/core/Types.h
@@ -1206,13 +1206,12 @@ private:
     bool         _dequantize_scores;
 };
 
-/** Pooling Layer Information class */
-class PoolingLayerInfo
+/** Pooling Layer Information struct*/
+struct PoolingLayerInfo
 {
-public:
     /** Default Constructor */
     PoolingLayerInfo()
-        : _pool_type(PoolingType::MAX), _pool_size(Size2D()), _pad_stride_info(PadStrideInfo()), _exclude_padding(false), _is_global_pooling(false), _fp_mixed_precision(false)
+        : pool_type(PoolingType::MAX), pool_size(Size2D()), pad_stride_info(PadStrideInfo()), exclude_padding(false), is_global_pooling(false), fp_mixed_precision(false)
     {
     }
     /** Default Constructor
@@ -1230,8 +1229,7 @@ public:
                               PadStrideInfo pad_stride_info    = PadStrideInfo(),
                               bool          exclude_padding    = false,
                               bool          fp_mixed_precision = false)
-        : _pool_type(pool_type), _pool_size(Size2D(pool_size, pool_size)), _pad_stride_info(pad_stride_info), _exclude_padding(exclude_padding), _is_global_pooling(false),
-          _fp_mixed_precision(fp_mixed_precision)
+        : pool_type(pool_type), pool_size(Size2D(pool_size, pool_size)), pad_stride_info(pad_stride_info), exclude_padding(exclude_padding), is_global_pooling(false), fp_mixed_precision(fp_mixed_precision)
     {
     }
     /** Default Constructor
@@ -1249,7 +1247,7 @@ public:
                               PadStrideInfo pad_stride_info    = PadStrideInfo(),
                               bool          exclude_padding    = false,
                               bool          fp_mixed_precision = false)
-        : _pool_type(pool_type), _pool_size(pool_size), _pad_stride_info(pad_stride_info), _exclude_padding(exclude_padding), _is_global_pooling(false), _fp_mixed_precision(fp_mixed_precision)
+        : pool_type(pool_type), pool_size(pool_size), pad_stride_info(pad_stride_info), exclude_padding(exclude_padding), is_global_pooling(false), fp_mixed_precision(fp_mixed_precision)
     {
     }
     /** Default Constructor
@@ -1259,47 +1257,16 @@ public:
      * @param[in] pool_type Pooling type @ref PoolingType.
      */
     explicit PoolingLayerInfo(PoolingType pool_type)
-        : _pool_type(pool_type), _pool_size(Size2D()), _pad_stride_info(PadStrideInfo(1, 1, 0, 0)), _exclude_padding(false), _is_global_pooling(true), _fp_mixed_precision(false)
-    {
-    }
-    /** Get the pooling type */
-    PoolingType pool_type() const
-    {
-        return _pool_type;
-    }
-    /** Get the pooling size */
-    const Size2D &pool_size() const
-    {
-        return _pool_size;
-    }
-    /** Get the padding and stride */
-    PadStrideInfo pad_stride_info() const
-    {
-        return _pad_stride_info;
-    }
-    /** Check if padding is excluded in calculations */
-    bool exclude_padding() const
-    {
-        return _exclude_padding;
-    }
-    /** Check if a wider accumulator should be used. */
-    bool fp_mixed_precision() const
+        : pool_type(pool_type), pool_size(Size2D()), pad_stride_info(PadStrideInfo(1, 1, 0, 0)), exclude_padding(false), is_global_pooling(true), fp_mixed_precision(false)
     {
-        return _fp_mixed_precision;
-    }
-    /** Check if is global pooling */
-    bool is_global_pooling() const
-    {
-        return _is_global_pooling;
     }
 
-private:
-    PoolingType   _pool_type;
-    Size2D        _pool_size;
-    PadStrideInfo _pad_stride_info;
-    bool          _exclude_padding;
-    bool          _is_global_pooling;
-    bool          _fp_mixed_precision;
+    PoolingType   pool_type;
+    Size2D        pool_size;
+    PadStrideInfo pad_stride_info;
+    bool          exclude_padding;
+    bool          is_global_pooling;
+    bool          fp_mixed_precision;
 };
 
 /** ROI Pooling Layer Information class */
diff --git a/arm_compute/core/utils/misc/ShapeCalculator.h b/arm_compute/core/utils/misc/ShapeCalculator.h
index a7298d6cbf..7d2b7df43b 100644
--- a/arm_compute/core/utils/misc/ShapeCalculator.h
+++ b/arm_compute/core/utils/misc/ShapeCalculator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 ARM Limited.
+ * Copyright (c) 2017-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -791,17 +791,17 @@ inline TensorShape compute_pool_shape(const ITensorInfo &input, PoolingLayerInfo
 
     TensorShape output_shape{ input.tensor_shape() };
 
-    const bool         is_global_pooling = pool_info.is_global_pooling();
+    const bool         is_global_pooling = pool_info.is_global_pooling;
     const unsigned int idx_width         = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH);
     const unsigned int idx_height        = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::HEIGHT);
-    const unsigned int pool_size_x       = is_global_pooling ? output_shape[idx_width] : pool_info.pool_size().width;
-    const unsigned int pool_size_y       = is_global_pooling ? output_shape[idx_height] : pool_info.pool_size().height;
+    const unsigned int pool_size_x       = is_global_pooling ? output_shape[idx_width] : pool_info.pool_size.width;
+    const unsigned int pool_size_y       = is_global_pooling ? output_shape[idx_height] : pool_info.pool_size.height;
 
     std::tie(pooled_w, pooled_h) = scaled_dimensions(output_shape[idx_width],
                                                      output_shape[idx_height],
                                                      pool_size_x,
                                                      pool_size_y,
-                                                     pool_info.pad_stride_info());
+                                                     pool_info.pad_stride_info);
 
     output_shape.set(idx_width, pooled_w);
     output_shape.set(idx_height, pooled_h);
diff --git a/arm_compute/graph/backends/FunctionHelpers.h b/arm_compute/graph/backends/FunctionHelpers.h
index bf0250c623..65a3e15a66 100644
--- a/arm_compute/graph/backends/FunctionHelpers.h
+++ b/arm_compute/graph/backends/FunctionHelpers.h
@@ -1143,7 +1143,7 @@ std::unique_ptr<IFunction> create_pooling_layer(PoolingLayerNode &node)
                                << " Data Type: " << input->info()->data_type()
                                << " Input shape: " << input->info()->tensor_shape()
                                << " Output shape: " << output->info()->tensor_shape()
-                               << " Pooling info: " << pool_info.pool_type()
+                               << " Pooling info: " << pool_info.pool_type
                                << std::endl);
 
     return std::move(func);
diff --git a/src/core/CL/kernels/CLPoolingLayerKernel.cpp b/src/core/CL/kernels/CLPoolingLayerKernel.cpp
index 2d75e5f969..2c45df8d4d 100644
--- a/src/core/CL/kernels/CLPoolingLayerKernel.cpp
+++ b/src/core/CL/kernels/CLPoolingLayerKernel.cpp
@@ -60,7 +60,7 @@ Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, c
     ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
     ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(input);
     ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::QASYMM8, DataType::QASYMM8_SIGNED, DataType::F16, DataType::F32);
-    ARM_COMPUTE_RETURN_ERROR_ON_MSG((is_data_type_quantized_asymmetric(input->data_type()) && pool_info.pool_type() == PoolingType::L2),
+    ARM_COMPUTE_RETURN_ERROR_ON_MSG((is_data_type_quantized_asymmetric(input->data_type()) && pool_info.pool_type == PoolingType::L2),
                                     "Unsupported combination of parameters!");
 
     // Checks performed when output is configured
@@ -88,9 +88,9 @@ std::tuple<Status, Window, CLPoolingConfig> validate_and_configure_window(ITenso
     int                 pool_stride_y   = 0;
     unsigned int        pooled_w        = 0;
     unsigned int        pooled_h        = 0;
-    int                 pool_size_x     = pool_info.is_global_pooling() ? input->dimension(idx_width) : pool_info.pool_size().width;
-    int                 pool_size_y     = pool_info.is_global_pooling() ? input->dimension(idx_height) : pool_info.pool_size().height;
-    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info();
+    int                 pool_size_x     = pool_info.is_global_pooling ? input->dimension(idx_width) : pool_info.pool_size.width;
+    int                 pool_size_y     = pool_info.is_global_pooling ? input->dimension(idx_height) : pool_info.pool_size.height;
+    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info;
     std::tie(pool_stride_x, pool_stride_y) = pad_stride_info.stride();
     const int  pool_pad_right  = pad_stride_info.pad_right();
     const int  pool_pad_top    = pad_stride_info.pad_top();
@@ -183,14 +183,14 @@ void CLPoolingLayerKernel::configure(const ICLTensor *input, ICLTensor *output,
 
     int                 pool_stride_x   = 0;
     int                 pool_stride_y   = 0;
-    const PoolingType   pool_type       = pool_info.pool_type();
+    const PoolingType   pool_type       = pool_info.pool_type;
     const int           idx_width       = get_data_layout_dimension_index(_data_layout, DataLayoutDimension::WIDTH);
     const int           idx_height      = get_data_layout_dimension_index(_data_layout, DataLayoutDimension::HEIGHT);
     const int           idx_channel     = get_data_layout_dimension_index(_data_layout, DataLayoutDimension::CHANNEL);
-    const int           pool_size_x     = pool_info.is_global_pooling() ? input->info()->dimension(idx_width) : pool_info.pool_size().width;
-    const int           pool_size_y     = pool_info.is_global_pooling() ? input->info()->dimension(idx_height) : pool_info.pool_size().height;
-    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info();
-    const bool          exclude_padding = pool_info.exclude_padding();
+    const int           pool_size_x     = pool_info.is_global_pooling ? input->info()->dimension(idx_width) : pool_info.pool_size.width;
+    const int           pool_size_y     = pool_info.is_global_pooling ? input->info()->dimension(idx_height) : pool_info.pool_size.height;
+    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info;
+    const bool          exclude_padding = pool_info.exclude_padding;
     std::tie(pool_stride_x, pool_stride_y) = pad_stride_info.stride();
     const int pool_pad_top  = pad_stride_info.pad_top();
     const int pool_pad_left = pad_stride_info.pad_left();
@@ -244,7 +244,7 @@ void CLPoolingLayerKernel::configure(const ICLTensor *input, ICLTensor *output,
         build_opts.add_option("-DINITIAL_VALUE=0");
     }
 
-    const auto use_fp_mixed_precision = (data_type == DataType::F16) && pool_info.fp_mixed_precision();
+    const auto use_fp_mixed_precision = (data_type == DataType::F16) && pool_info.fp_mixed_precision;
     const auto use_wider_accumulator  = use_fp_mixed_precision && (pool_type != PoolingType::MAX);
     const auto acc_data_type          = get_cl_type_from_data_type(use_wider_accumulator ? DataType::F32 : data_type);
     build_opts.add_option("-DACC_DATA_TYPE=" + acc_data_type);
@@ -342,7 +342,7 @@ void CLPoolingLayerKernel::run(const Window &window, cl::CommandQueue &queue)
 
     unsigned int pool_stride_x = 0;
     unsigned int pool_stride_y = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
 
     // Collapse window
     Window window_collapsed = window.collapse_if_possible(ICLKernel::window(), Window::DimZ);
@@ -356,11 +356,11 @@ void CLPoolingLayerKernel::run(const Window &window, cl::CommandQueue &queue)
             {
                 // Upsample input by pool size
                 Window in_slice(slice);
-                in_slice.set(Window::DimX, Window::Dimension(in_slice.x().start() - _pool_info.pad_stride_info().pad_left(),
-                                                             (in_slice.x().end() - _pool_info.pad_stride_info().pad_left()) * pool_stride_x,
+                in_slice.set(Window::DimX, Window::Dimension(in_slice.x().start() - _pool_info.pad_stride_info.pad_left(),
+                                                             (in_slice.x().end() - _pool_info.pad_stride_info.pad_left()) * pool_stride_x,
                                                              pool_stride_x * _num_elems_processed_per_iteration));
-                in_slice.set(Window::DimY, Window::Dimension(in_slice.y().start() - _pool_info.pad_stride_info().pad_top(),
-                                                             (in_slice.y().end() - _pool_info.pad_stride_info().pad_top()) * pool_stride_y,
+                in_slice.set(Window::DimY, Window::Dimension(in_slice.y().start() - _pool_info.pad_stride_info.pad_top(),
+                                                             (in_slice.y().end() - _pool_info.pad_stride_info.pad_top()) * pool_stride_y,
                                                              pool_stride_y));
 
                 // Set inputs
diff --git a/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp b/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp
index 50171a1015..b7de955e6a 100644
--- a/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp
+++ b/src/core/GLES_COMPUTE/kernels/GCPoolingLayerKernel.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 ARM Limited.
+ * Copyright (c) 2017-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -58,18 +58,18 @@ Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, c
 {
     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),
+    ARM_COMPUTE_RETURN_ERROR_ON_MSG((is_data_type_quantized_asymmetric(input->data_type()) && pool_info.pool_type == PoolingType::L2),
                                     "Unsupported combination of parameters!");
-    ARM_COMPUTE_RETURN_ERROR_ON(!pool_info.pad_stride_info().padding_is_symmetric());
+    ARM_COMPUTE_RETURN_ERROR_ON(!pool_info.pad_stride_info.padding_is_symmetric());
 
-    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().width;
+    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.width;
 
     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)),
+    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!");
-    ARM_COMPUTE_RETURN_ERROR_ON_MSG(pool_info.pool_size().width != pool_info.pool_size().height, "Invalid Pool size, width not equal to height!");
+    ARM_COMPUTE_RETURN_ERROR_ON_MSG(pool_info.pool_size.width != pool_info.pool_size.height, "Invalid Pool size, width not equal to height!");
 
     // Checks performed when output is configured
     if(output->total_size() != 0)
@@ -82,7 +82,7 @@ Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, c
                                                          input->dimension(1),
                                                          pool_size,
                                                          pool_size,
-                                                         pool_info.pad_stride_info());
+                                                         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!");
     }
@@ -98,15 +98,15 @@ std::tuple<Status, Window, GCPoolingConfig> validate_and_configure_window(ITenso
     int                 pool_stride_y   = 0;
     unsigned int        pooled_w        = 0;
     unsigned int        pooled_h        = 0;
-    int                 pool_size       = pool_info.pool_size().width;
-    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info();
+    int                 pool_size       = pool_info.pool_size.width;
+    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;
+    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),
@@ -231,17 +231,17 @@ void GCPoolingLayerKernel::configure(const IGCTensor *input, IGCTensor *output,
     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().width;
-    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info();
-    const bool          exclude_padding = pool_info.exclude_padding();
+    const PoolingType   pool_type       = pool_info.pool_type;
+    int                 pool_size       = pool_info.pool_size.width;
+    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_NULLPTR(input, output);
 
     // Update pool size in case of global pooling
-    pool_size = pool_info.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),
@@ -337,8 +337,8 @@ void GCPoolingLayerKernel::run(const Window &window)
     unsigned int pool_pad_y;
     unsigned int pool_stride_x;
     unsigned int pool_stride_y;
-    std::tie(pool_pad_x, pool_pad_y)       = _pool_info.pad_stride_info().pad();
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_pad_x, pool_pad_y)       = _pool_info.pad_stride_info.pad();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
 
     _kernel.use();
 
diff --git a/src/core/NEON/kernels/NEPoolingLayerKernel.cpp b/src/core/NEON/kernels/NEPoolingLayerKernel.cpp
index 59c3543171..e48b8ffdba 100644
--- a/src/core/NEON/kernels/NEPoolingLayerKernel.cpp
+++ b/src/core/NEON/kernels/NEPoolingLayerKernel.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 ARM Limited.
+ * Copyright (c) 2017-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -126,8 +126,8 @@ Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, c
 
     int                 pool_stride_x   = 0;
     int                 pool_stride_y   = 0;
-    PoolingType         pool_type       = pool_info.pool_type();
-    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info();
+    PoolingType         pool_type       = pool_info.pool_type;
+    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info;
     std::tie(pool_stride_x, pool_stride_y) = pad_stride_info.stride();
 
     ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(input);
@@ -169,7 +169,7 @@ std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input, ITen
     const int           idx_height                   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
     const int           input_width                  = input->dimension(idx_width);
     const int           input_height                 = input->dimension(idx_height);
-    const PadStrideInfo pad_stride_info              = pool_info.pad_stride_info();
+    const PadStrideInfo pad_stride_info              = pool_info.pad_stride_info;
     std::tie(pool_stride_x, pool_stride_y) = pad_stride_info.stride();
     const int  pool_pad_right  = pad_stride_info.pad_right();
     const int  pool_pad_top    = pad_stride_info.pad_top();
@@ -334,8 +334,8 @@ void NEPoolingLayerKernel::configure(const ITensor *input, ITensor *output, cons
 {
     ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
 
-    const PadStrideInfo pad_stride_info   = pool_info.pad_stride_info();
-    const bool          is_global_pooling = pool_info.is_global_pooling();
+    const PadStrideInfo pad_stride_info   = pool_info.pad_stride_info;
+    const bool          is_global_pooling = pool_info.is_global_pooling;
     const int           pool_stride_x     = pad_stride_info.stride().first;
 
     // Get data layout
@@ -345,8 +345,8 @@ void NEPoolingLayerKernel::configure(const ITensor *input, ITensor *output, cons
 
     // Update pool size in case of global pooling
     const Size2D pool_size(
-        is_global_pooling ? input->info()->dimension(idx_width) : pool_info.pool_size().width,
-        is_global_pooling ? input->info()->dimension(idx_height) : pool_info.pool_size().height);
+        is_global_pooling ? input->info()->dimension(idx_width) : pool_info.pool_size.width,
+        is_global_pooling ? input->info()->dimension(idx_height) : pool_info.pool_size.height);
 
     // Validate pool info before calling scaled_dimensions
     ARM_COMPUTE_ERROR_THROW_ON(validate_arguments_pool_info(pool_size.x(), pool_size.y()));
@@ -550,11 +550,11 @@ void NEPoolingLayerKernel::pooling2_qasymm8_nchw(const Window &window_input, con
     constexpr int pool_size       = 2;
     int           pool_stride_x   = 0;
     int           pool_stride_y   = 0;
-    const int     pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int     pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int     pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int     pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    const int     pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int     pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int     pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int     pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -675,13 +675,13 @@ void NEPoolingLayerKernel::pooling3_f16_nchw(const Window &window_input, const W
     Iterator output(_output, window);
 
     constexpr const int pool_size       = 3;
-    const int           pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int           pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int           pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int           pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int           pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int           pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int           pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int           pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int                 pool_stride_x   = 0;
     int                 pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -745,12 +745,12 @@ void NEPoolingLayerKernel::pooling2_f16_nchw(const Window &window_input, const W
     Iterator      input(_input, window_input);
     Iterator      output(_output, window);
     constexpr int pool_size       = 2;
-    const int     pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int     pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int     pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int     pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int     pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int     pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int     pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int     pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int           pool_stride_x, pool_stride_y = 0;
-    std::tie(pool_stride_x, pool_stride_y)     = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y)     = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -807,13 +807,13 @@ void NEPoolingLayerKernel::pooling3_qasymm8_nchw(const Window &window_input, con
     Iterator output(_output, window);
 
     constexpr int pool_size       = 3;
-    const int     pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int     pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int     pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int     pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int     pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int     pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int     pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int     pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int           pool_stride_x   = 0;
     int           pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -949,15 +949,15 @@ void NEPoolingLayerKernel::poolingMxN_f16_nchw(const Window &window_input, const
     Iterator input(_input, window_input);
     Iterator output(_output, window);
 
-    const int pool_size_x     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().x() : _pool_info.pool_size().width;
-    const int pool_size_y     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().y() : _pool_info.pool_size().height;
-    const int pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int pool_size_x     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().x() : _pool_info.pool_size.width;
+    const int pool_size_y     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().y() : _pool_info.pool_size.height;
+    const int pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int       pool_stride_x   = 0;
     int       pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1075,15 +1075,15 @@ void NEPoolingLayerKernel::poolingMxN_f16_nhwc(const Window &window_input, const
     Iterator input(_input, window_input);
     Iterator output(_output, window);
 
-    const int pool_size_x     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().y() : _pool_info.pool_size().width;
-    const int pool_size_y     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().z() : _pool_info.pool_size().height;
-    const int pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int pool_size_x     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().y() : _pool_info.pool_size.width;
+    const int pool_size_y     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().z() : _pool_info.pool_size.height;
+    const int pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int       pool_stride_x   = 0;
     int       pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(2) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1170,15 +1170,15 @@ void NEPoolingLayerKernel::poolingMxN_f32_nchw(const Window &window_input, const
     Iterator input(_input, window_input);
     Iterator output(_output, window);
 
-    const int pool_size_x     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().x() : _pool_info.pool_size().width;
-    const int pool_size_y     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().y() : _pool_info.pool_size().height;
-    const int pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int pool_size_x     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().x() : _pool_info.pool_size.width;
+    const int pool_size_y     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().y() : _pool_info.pool_size.height;
+    const int pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int       pool_stride_x   = 0;
     int       pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1295,13 +1295,13 @@ void NEPoolingLayerKernel::pooling2_f32_nchw(const Window &window_input, const W
     Iterator output(_output, window);
 
     constexpr int pool_size       = 2;
-    const int     pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int     pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int     pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int     pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int     pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int     pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int     pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int     pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int           pool_stride_x   = 0;
     int           pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1357,13 +1357,13 @@ void NEPoolingLayerKernel::pooling3_f32_nchw(const Window &window_input, const W
     Iterator output(_output, window);
 
     constexpr const int pool_size       = 3;
-    const int           pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int           pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int           pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int           pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int           pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int           pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int           pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int           pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int                 pool_stride_x   = 0;
     int                 pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1424,13 +1424,13 @@ void NEPoolingLayerKernel::pooling7_f32_nchw(const Window &window_input, const W
     Iterator output(_output, window);
 
     constexpr const int pool_size       = 7;
-    const int           pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int           pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int           pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int           pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int           pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int           pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int           pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int           pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int                 pool_stride_x   = 0;
     int                 pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1505,15 +1505,15 @@ void NEPoolingLayerKernel::poolingMxN_f32_nhwc(const Window &window_input, const
     Iterator input(_input, window_input);
     Iterator output(_output, window);
 
-    const int pool_size_x     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().y() : _pool_info.pool_size().width;
-    const int pool_size_y     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().z() : _pool_info.pool_size().height;
-    const int pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int pool_size_x     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().y() : _pool_info.pool_size.width;
+    const int pool_size_y     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().z() : _pool_info.pool_size.height;
+    const int pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int       pool_stride_x   = 0;
     int       pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(2) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1598,15 +1598,15 @@ void NEPoolingLayerKernel::poolingMxN_qasymm8_nchw(const Window &window_input, c
     Iterator input(_input, window_input);
     Iterator output(_output, window);
 
-    const int pool_size_x     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().x() : _pool_info.pool_size().width;
-    const int pool_size_y     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().y() : _pool_info.pool_size().height;
-    const int pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int pool_size_x     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().x() : _pool_info.pool_size.width;
+    const int pool_size_y     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().y() : _pool_info.pool_size.height;
+    const int pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int       pool_stride_x   = 0;
     int       pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(0) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1699,15 +1699,15 @@ void NEPoolingLayerKernel::poolingMxN_qasymm8_nhwc(const Window &window_input, c
     Iterator input(_input, window_input);
     Iterator output(_output, window);
 
-    const int pool_size_x     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().y() : _pool_info.pool_size().width;
-    const int pool_size_y     = _pool_info.is_global_pooling() ? _input->info()->tensor_shape().z() : _pool_info.pool_size().height;
-    const int pool_pad_right  = _pool_info.pad_stride_info().pad_right();
-    const int pool_pad_top    = _pool_info.pad_stride_info().pad_top();
-    const int pool_pad_left   = _pool_info.pad_stride_info().pad_left();
-    const int pool_pad_bottom = _pool_info.pad_stride_info().pad_bottom();
+    const int pool_size_x     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().y() : _pool_info.pool_size.width;
+    const int pool_size_y     = _pool_info.is_global_pooling ? _input->info()->tensor_shape().z() : _pool_info.pool_size.height;
+    const int pool_pad_right  = _pool_info.pad_stride_info.pad_right();
+    const int pool_pad_top    = _pool_info.pad_stride_info.pad_top();
+    const int pool_pad_left   = _pool_info.pad_stride_info.pad_left();
+    const int pool_pad_bottom = _pool_info.pad_stride_info.pad_bottom();
     int       pool_stride_x   = 0;
     int       pool_stride_y   = 0;
-    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info().stride();
+    std::tie(pool_stride_x, pool_stride_y) = _pool_info.pad_stride_info.stride();
     const int upper_bound_w = _input->info()->dimension(1) + (exclude_padding ? 0 : pool_pad_right);
     const int upper_bound_h = _input->info()->dimension(2) + (exclude_padding ? 0 : pool_pad_bottom);
 
@@ -1804,7 +1804,7 @@ Status NEPoolingLayerKernel::validate(const ITensorInfo *input, const ITensorInf
     unsigned int num_elems_processed_per_iteration = 0;
     BorderSize   border_size(0);
 
-    const bool   is_global_pooling = pool_info.is_global_pooling();
+    const bool   is_global_pooling = pool_info.is_global_pooling;
     unsigned int pool_size_x       = 0;
     unsigned int pool_size_y       = 0;
 
@@ -1813,8 +1813,8 @@ Status NEPoolingLayerKernel::validate(const ITensorInfo *input, const ITensorInf
     const int        idx_width   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
     const int        idx_height  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
 
-    pool_size_x = is_global_pooling ? input->dimension(idx_width) : pool_info.pool_size().width;
-    pool_size_y = is_global_pooling ? input->dimension(idx_height) : pool_info.pool_size().height;
+    pool_size_x = is_global_pooling ? input->dimension(idx_width) : pool_info.pool_size.width;
+    pool_size_y = is_global_pooling ? input->dimension(idx_height) : pool_info.pool_size.height;
 
     // Validate pool info before calling scaled_dimensions
     ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments_pool_info(pool_size_x, pool_size_y));
@@ -1824,7 +1824,7 @@ Status NEPoolingLayerKernel::validate(const ITensorInfo *input, const ITensorInf
                                                      input->dimension(idx_height),
                                                      pool_size_x,
                                                      pool_size_y,
-                                                     pool_info.pad_stride_info());
+                                                     pool_info.pad_stride_info);
 
     ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, pool_info, pooled_w, pooled_h));
     ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input->clone().get(), output->clone().get(), pool_info, num_elems_processed_per_iteration, border_size, pooled_w, pooled_h,
@@ -1841,10 +1841,10 @@ void NEPoolingLayerKernel::run(const Window &window, const ThreadInfo &info)
     ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window);
     ARM_COMPUTE_ERROR_ON(_func == nullptr);
 
-    const unsigned int pool_stride_x   = _pool_info.pad_stride_info().stride().first;
-    const unsigned int pool_stride_y   = _pool_info.pad_stride_info().stride().second;
-    const unsigned int pool_size       = _pool_info.pool_size().width;
-    const bool         exclude_padding = _pool_info.exclude_padding();
+    const unsigned int pool_stride_x   = _pool_info.pad_stride_info.stride().first;
+    const unsigned int pool_stride_y   = _pool_info.pad_stride_info.stride().second;
+    const unsigned int pool_size       = _pool_info.pool_size.width;
+    const bool         exclude_padding = _pool_info.exclude_padding;
 
     Window window_input(window);
     if(_data_layout == DataLayout::NCHW)
@@ -1885,5 +1885,5 @@ void NEPoolingLayerKernel::run(const Window &window, const ThreadInfo &info)
     }
 
     // Run function
-    (this->*_func)(window_input, window, _pool_info.pool_type(), exclude_padding);
+    (this->*_func)(window_input, window, _pool_info.pool_type, exclude_padding);
 }
diff --git a/src/graph/nodes/PoolingLayerNode.cpp b/src/graph/nodes/PoolingLayerNode.cpp
index 48b93c9158..b6f317ad84 100644
--- a/src/graph/nodes/PoolingLayerNode.cpp
+++ b/src/graph/nodes/PoolingLayerNode.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2019 ARM Limited.
+ * Copyright (c) 2018-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -52,10 +52,10 @@ TensorDescriptor PoolingLayerNode::compute_output_descriptor(const TensorDescrip
 
     const unsigned int input_width  = get_dimension_size(input_descriptor, DataLayoutDimension::WIDTH);
     const unsigned int input_height = get_dimension_size(input_descriptor, DataLayoutDimension::HEIGHT);
-    const unsigned int pool_size_x  = info.is_global_pooling() ? input_width : info.pool_size().width;
-    const unsigned int pool_size_y  = info.is_global_pooling() ? input_height : info.pool_size().height;
+    const unsigned int pool_size_x  = info.is_global_pooling ? input_width : info.pool_size.width;
+    const unsigned int pool_size_y  = info.is_global_pooling ? input_height : info.pool_size.height;
 
-    std::tie(pooled_width, pooled_height) = scaled_dimensions(input_width, input_height, pool_size_x, pool_size_y, info.pad_stride_info());
+    std::tie(pooled_width, pooled_height) = scaled_dimensions(input_width, input_height, pool_size_x, pool_size_y, info.pad_stride_info);
 
     const DataLayout data_layout       = input_descriptor.layout;
     TensorDescriptor output_descriptor = input_descriptor;
diff --git a/src/graph/printers/DotGraphPrinter.cpp b/src/graph/printers/DotGraphPrinter.cpp
index 46f6ee828e..40890880fd 100644
--- a/src/graph/printers/DotGraphPrinter.cpp
+++ b/src/graph/printers/DotGraphPrinter.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2019 ARM Limited.
+ * Copyright (c) 2018-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -103,11 +103,11 @@ void DotGraphVisitor::visit(NormalizationLayerNode &n)
 void DotGraphVisitor::visit(PoolingLayerNode &n)
 {
     std::stringstream ss;
-    ss << n.pooling_info().pool_type();
+    ss << n.pooling_info().pool_type;
     ss << R"( \n )";
-    ss << n.pooling_info().pool_size();
+    ss << n.pooling_info().pool_size;
     ss << R"( \n )";
-    ss << n.pooling_info().pad_stride_info();
+    ss << n.pooling_info().pad_stride_info;
     _info = ss.str();
 }
 
diff --git a/src/runtime/CL/functions/CLPoolingLayer.cpp b/src/runtime/CL/functions/CLPoolingLayer.cpp
index f3ea926ae7..00e5447875 100644
--- a/src/runtime/CL/functions/CLPoolingLayer.cpp
+++ b/src/runtime/CL/functions/CLPoolingLayer.cpp
@@ -45,18 +45,18 @@ void CLPoolingLayer::configure(ICLTensor *input, ICLTensor *output, const Poolin
     // Configure border depending on operation required (quantize border in case of asymmetric data_type)
     BorderMode border_mode{};
     PixelValue pixel_value(0.f);
-    if(is_data_type_quantized_asymmetric(data_type) && !pool_info.exclude_padding())
+    if(is_data_type_quantized_asymmetric(data_type) && !pool_info.exclude_padding)
     {
         pixel_value = PixelValue(0, data_type, input->info()->quantization_info());
     }
     switch(input->info()->data_layout())
     {
         case DataLayout::NCHW:
-            border_mode = (PoolingType::MAX == pool_info.pool_type()) ? BorderMode::REPLICATE : BorderMode::CONSTANT;
+            border_mode = (PoolingType::MAX == pool_info.pool_type) ? BorderMode::REPLICATE : BorderMode::CONSTANT;
             break;
         case DataLayout::NHWC:
             border_mode = BorderMode::CONSTANT;
-            if(PoolingType::MAX == pool_info.pool_type())
+            if(PoolingType::MAX == pool_info.pool_type)
             {
                 if(is_data_type_quantized(data_type))
                 {
@@ -81,4 +81,4 @@ Status CLPoolingLayer::validate(const ITensorInfo *input, const ITensorInfo *out
 {
     return CLPoolingLayerKernel::validate(input, output, pool_info);
 }
-} // namespace arm_compute
\ No newline at end of file
+} // namespace arm_compute
diff --git a/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp b/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp
index dcbb39d87d..ef73fa8e61 100644
--- a/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp
+++ b/src/runtime/GLES_COMPUTE/functions/GCPoolingLayer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2018 ARM Limited.
+ * Copyright (c) 2017-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -44,7 +44,7 @@ void GCPoolingLayer::configure(IGCTensor *input, IGCTensor *output, const Poolin
     _kernel = std::move(k);
 
     // Configure border depending on operation required
-    BorderMode border_mode = (PoolingType::MAX == pool_info.pool_type()) ? BorderMode::REPLICATE : BorderMode::CONSTANT;
+    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));
 
     _shift_handler.configure(input);
diff --git a/src/runtime/NEON/functions/NEPoolingLayer.cpp b/src/runtime/NEON/functions/NEPoolingLayer.cpp
index d92086d08d..0ea7efe06d 100644
--- a/src/runtime/NEON/functions/NEPoolingLayer.cpp
+++ b/src/runtime/NEON/functions/NEPoolingLayer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 ARM Limited.
+ * Copyright (c) 2017-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -38,7 +38,7 @@ NEPoolingLayer::NEPoolingLayer()
 void NEPoolingLayer::configure(ITensor *input, ITensor *output, const PoolingLayerInfo &pool_info)
 {
     // Check if we have Global Pooling Layer
-    _is_global_pooling_layer = (input->info()->dimension(0) == pool_info.pool_size().width) && (input->info()->dimension(1) == pool_info.pool_size().height);
+    _is_global_pooling_layer = (input->info()->dimension(0) == pool_info.pool_size.width) && (input->info()->dimension(1) == pool_info.pool_size.height);
 
     // Get data layout
     _data_layout = input->info()->data_layout();
@@ -51,9 +51,9 @@ void NEPoolingLayer::configure(ITensor *input, ITensor *output, const PoolingLay
         case DataLayout::NCHW:
         {
             // Configure border depending on operation required (quantize border in case of asymmetric data_type)
-            BorderMode border_mode = (pool_info.pool_type() == PoolingType::MAX) ? BorderMode::REPLICATE : BorderMode::CONSTANT;
+            BorderMode border_mode = (pool_info.pool_type == PoolingType::MAX) ? BorderMode::REPLICATE : BorderMode::CONSTANT;
             PixelValue zero_value(0.f);
-            if(is_data_type_quantized_asymmetric(input->info()->data_type()) && !pool_info.exclude_padding())
+            if(is_data_type_quantized_asymmetric(input->info()->data_type()) && !pool_info.exclude_padding)
             {
                 zero_value = PixelValue(static_cast<uint32_t>(input->info()->quantization_info().uniform().offset));
             }
@@ -90,4 +90,4 @@ void NEPoolingLayer::run()
         default:
             ARM_COMPUTE_ERROR("Data layout not supported");
     }
-}
\ No newline at end of file
+}
diff --git a/tests/validation/reference/PoolingLayer.cpp b/tests/validation/reference/PoolingLayer.cpp
index 40dd6fa505..8ba5e4270d 100644
--- a/tests/validation/reference/PoolingLayer.cpp
+++ b/tests/validation/reference/PoolingLayer.cpp
@@ -41,21 +41,21 @@ template <typename T, typename ACC_T, typename std::enable_if<is_floating_point<
 SimpleTensor<T> pooling_layer_internal(const SimpleTensor<T> &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo)
 {
     ARM_COMPUTE_UNUSED(output_qinfo); // requantization occurs in pooling_layer<uint8_t>
-    ARM_COMPUTE_ERROR_ON(info.is_global_pooling() && (src.shape().x() != src.shape().y()));
+    ARM_COMPUTE_ERROR_ON(info.is_global_pooling && (src.shape().x() != src.shape().y()));
 
     // Create reference
     SimpleTensor<T> dst{ compute_pool_shape(TensorInfo(src.shape(), 1, src.data_type()), info), src.data_type(), 1 };
 
-    const int   pool_size_x     = info.is_global_pooling() ? src.shape().x() : info.pool_size().width;
-    const int   pool_size_y     = info.is_global_pooling() ? src.shape().y() : info.pool_size().height;
-    PoolingType type            = info.pool_type();
-    int         pool_stride_x   = info.pad_stride_info().stride().first;
-    int         pool_stride_y   = info.pad_stride_info().stride().second;
-    int         pad_left        = info.pad_stride_info().pad_left();
-    int         pad_top         = info.pad_stride_info().pad_top();
-    int         pad_right       = info.pad_stride_info().pad_right();
-    int         pad_bottom      = info.pad_stride_info().pad_bottom();
-    bool        exclude_padding = info.exclude_padding();
+    const int   pool_size_x     = info.is_global_pooling ? src.shape().x() : info.pool_size.width;
+    const int   pool_size_y     = info.is_global_pooling ? src.shape().y() : info.pool_size.height;
+    PoolingType type            = info.pool_type;
+    int         pool_stride_x   = info.pad_stride_info.stride().first;
+    int         pool_stride_y   = info.pad_stride_info.stride().second;
+    int         pad_left        = info.pad_stride_info.pad_left();
+    int         pad_top         = info.pad_stride_info.pad_top();
+    int         pad_right       = info.pad_stride_info.pad_right();
+    int         pad_bottom      = info.pad_stride_info.pad_bottom();
+    bool        exclude_padding = info.exclude_padding;
 
     const auto w_src      = static_cast<int>(src.shape()[0]);
     const auto h_src      = static_cast<int>(src.shape()[1]);
@@ -183,7 +183,7 @@ SimpleTensor<int8_t> pooling_layer<int8_t>(const SimpleTensor<int8_t> &src, cons
 template <>
 SimpleTensor<half> pooling_layer(const SimpleTensor<half> &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo)
 {
-    if(src.data_type() == DataType::F16 && info.fp_mixed_precision())
+    if(src.data_type() == DataType::F16 && info.fp_mixed_precision)
     {
         return pooling_layer_internal<half, float>(src, info, output_qinfo);
     }
diff --git a/utils/TypePrinter.h b/utils/TypePrinter.h
index 3f638d7e97..4390381a69 100644
--- a/utils/TypePrinter.h
+++ b/utils/TypePrinter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 ARM Limited.
+ * Copyright (c) 2017-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -516,7 +516,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const PoolingType &pool_ty
  */
 inline ::std::ostream &operator<<(::std::ostream &os, const PoolingLayerInfo &info)
 {
-    os << info.pool_type();
+    os << info.pool_type;
 
     return os;
 }
@@ -1620,13 +1620,13 @@ inline std::string to_string(const PoolingType &type)
 inline std::string to_string(const PoolingLayerInfo &info)
 {
     std::stringstream str;
-    str << "{Type=" << info.pool_type() << ","
-        << "IsGlobalPooling=" << info.is_global_pooling();
-    if(!info.is_global_pooling())
+    str << "{Type=" << info.pool_type << ","
+        << "IsGlobalPooling=" << info.is_global_pooling;
+    if(!info.is_global_pooling)
     {
         str << ","
-            << "PoolSize=" << info.pool_size().width << "," << info.pool_size().height << ","
-            << "PadStride=" << info.pad_stride_info();
+            << "PoolSize=" << info.pool_size.width << "," << info.pool_size.height << ","
+            << "PadStride=" << info.pad_stride_info;
     }
     str << "}";
     return str.str();