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>

8 files changed, 146 insertions, 146 deletions

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
+}