Port NEWinogradConvolutionLayer

Rename to CpuWinogradConv2d
Allow memory to be injected externally

Change-Id: I1f0a26ea533e326a7c63df86e708895c31752a39
Signed-off-by: Michalis Spyrou <michalis.spyrou@arm.com>
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/5926
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Michele Di Giorgio <michele.digiorgio@arm.com>

3 files changed, 222 insertions, 241 deletions

diff --git a/src/core/NEON/NEKernels.h b/src/core/NEON/NEKernels.h
index cd09544d31..6c6c51dd87 100644
--- a/src/core/NEON/NEKernels.h
+++ b/src/core/NEON/NEKernels.h
@@ -66,6 +66,5 @@
 #include "src/core/NEON/kernels/NEStridedSliceKernel.h"
 #include "src/core/NEON/kernels/NETileKernel.h"
 #include "src/core/NEON/kernels/NEWeightsReshapeKernel.h"
-#include "src/core/NEON/kernels/NEWinogradConvolutionLayerKernel.h"
 
 #endif /* ARM_COMPUTE_NEKERNELS_H */
diff --git a/src/core/NEON/kernels/NEWinogradConvolutionLayerKernel.cpp b/src/core/cpu/kernels/CpuWinogradConv2dKernel.cpp
index be34980663..74b031b226 100644
--- a/src/core/NEON/kernels/NEWinogradConvolutionLayerKernel.cpp
+++ b/src/core/cpu/kernels/CpuWinogradConv2dKernel.cpp
@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#include "src/core/NEON/kernels/NEWinogradConvolutionLayerKernel.h"
+#include "src/core/cpu/kernels/CpuWinogradConv2dKernel.h"
 
 #include "arm_compute/core/Error.h"
 #include "arm_compute/core/Helpers.h"
@@ -39,6 +39,8 @@
 
 namespace arm_compute
 {
+namespace cpu
+{
 //Batched Gemms
 
 namespace
@@ -175,7 +177,7 @@ std::pair<Status, Window> validate_and_configure_window_winograd_output_trans(IT
 }
 } // namespace
 
-Status INEWinogradLayerTransformWeightsKernel::validate(const ITensorInfo *input, const ITensorInfo *weights)
+Status ICpuWinogradConv2dTransformWeightsKernel::validate(const ITensorInfo *input, const ITensorInfo *weights)
 {
     ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F16, DataType::F32);
     ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, weights);
@@ -189,7 +191,7 @@ Status INEWinogradLayerTransformWeightsKernel::validate(const ITensorInfo *input
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-unsigned int NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_weight_storage_size(int num_output_channels, int num_input_channels) const
+unsigned int CpuWinogradConv2dTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_weight_storage_size(int num_output_channels, int num_input_channels) const
 {
     const KernelShape shape(num_output_channels, KernelRows, KernelCols, num_input_channels);
     return static_cast<unsigned int>(
@@ -198,89 +200,94 @@ unsigned int NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTile
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::NEWinogradLayerTransformWeightsKernel()
-    : _transform(nullptr), _weights_hwio(nullptr), _output(nullptr), _matrix_stride(0), _num_output_channels(0), _num_input_channels(0)
+CpuWinogradConv2dTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::CpuWinogradConv2dTransformWeightsKernel()
+    : _transform(nullptr), _num_output_channels(0), _matrix_stride(0)
 {
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-int NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_matrix_stride(int num_output_channels, int num_input_channels) const
+int CpuWinogradConv2dTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_matrix_stride(int num_output_channels, int num_input_channels) const
 {
     return WinogradConv::get_kernel_matrix_stride(num_input_channels, num_output_channels);
 }
 
 #ifndef DOXYGEN_SKIP_THIS
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-void NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::configure(
-    const ITensor *weights_hwio,
-    ITensor       *output,
-    const int      matrix_stride,       /** Stride across matrices in the output. */
-    const int      num_output_channels, /** Number of filters. */
-    const int      num_input_channels)  /** Number of channels in each filter. */
-{
-    _weights_hwio        = weights_hwio;
-    _output              = output;
-    _matrix_stride       = matrix_stride;
-    _num_output_channels = num_output_channels;
-    _num_input_channels  = num_input_channels;
+void CpuWinogradConv2dTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::configure(
+    const ITensorInfo *weights_hwio,
+    ITensorInfo       *output,
+    const int          matrix_stride,       /** Stride across matrices in the output. */
+    const int          num_output_channels, /** Number of filters. */
+    const int          num_input_channels)  /** Number of channels in each filter. */
+{
+    ARM_COMPUTE_UNUSED(weights_hwio, output);
+
     _transform           = std::make_unique<WeightsTransform>(num_output_channels, num_input_channels);
+    _num_output_channels = num_output_channels;
+    _matrix_stride       = matrix_stride;
 
     Window win;
     auto   win_last = _transform->get_window();
     win.set(Window::DimX, Window::Dimension(0, win_last, 1));
-    INEKernel::configure(win);
+    ICpuKernel::configure(win);
 }
 #endif /* DOXYGEN_SKIP_THIS */
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-void NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::run(const Window &window, const ThreadInfo &info)
+void CpuWinogradConv2dTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::run_op(ITensorPack &tensors, const Window &window, const ThreadInfo &info)
 {
     ARM_COMPUTE_UNUSED(info);
     ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
+    ARM_COMPUTE_ERROR_ON(tensors.empty());
+
     const size_t fst = window.x().start();
     const size_t lst = window.x().end();
-    _transform->set_weight_tensor(_weights_hwio->buffer());
+
+    const ITensor *weights_hwio = tensors.get_const_tensor(TensorType::ACL_SRC);
+    ITensor       *output       = tensors.get_tensor(TensorType::ACL_DST);
+
+    _transform->set_weight_tensor(weights_hwio->buffer());
     const int matrix_row_stride = roundup(_num_output_channels, WinogradConv::N_BLOCK);
-    _transform->set_output_matrices(_output->buffer(), _matrix_stride, matrix_row_stride);
-    _transform->set_working_space(_output->buffer());
+    _transform->set_output_matrices(output->buffer(), _matrix_stride, matrix_row_stride);
+    _transform->set_working_space(output->buffer());
 
     _transform->run(fst, lst);
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-bool NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::is_parallelisable() const
+bool CpuWinogradConv2dTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::is_parallelisable() const
 {
     return false;
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-Status NEWinogradLayerTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::validate(const ITensorInfo *input, const ITensorInfo *output,
-                                                                                                                  const WinogradInfo &winograd_info)
+Status CpuWinogradConv2dTransformWeightsKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::validate(const ITensorInfo *input, const ITensorInfo *output,
+                                                                                                                    const WinogradInfo &winograd_info)
 {
     ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments_winograd_weight_trans(input, output, winograd_info));
     ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window_winograd_weight_trans(input->clone().get(), output->clone().get(), winograd_info).first);
     return Status{};
 }
 
-template class NEWinogradLayerTransformWeightsKernel<float, 2, 2, 3, 3>;
-template class NEWinogradLayerTransformWeightsKernel<float, 4, 4, 3, 3>;
-template class NEWinogradLayerTransformWeightsKernel<float, 2, 2, 5, 5>;
-template class NEWinogradLayerTransformWeightsKernel<float, 1, 6, 1, 3>;
-template class NEWinogradLayerTransformWeightsKernel<float, 6, 1, 3, 1>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 2, 2, 3, 3>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 4, 4, 3, 3>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 2, 2, 5, 5>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 1, 6, 1, 3>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 6, 1, 3, 1>;
 
-template class NEWinogradLayerTransformWeightsKernel<float, 1, 4, 1, 5>;
-template class NEWinogradLayerTransformWeightsKernel<float, 4, 1, 5, 1>;
-template class NEWinogradLayerTransformWeightsKernel<float, 1, 2, 1, 7>;
-template class NEWinogradLayerTransformWeightsKernel<float, 2, 1, 7, 1>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 1, 4, 1, 5>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 4, 1, 5, 1>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 1, 2, 1, 7>;
+template class CpuWinogradConv2dTransformWeightsKernel<float, 2, 1, 7, 1>;
 
 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
-template class NEWinogradLayerTransformWeightsKernel<__fp16, 4, 4, 3, 3>;
+template class CpuWinogradConv2dTransformWeightsKernel<__fp16, 4, 4, 3, 3>;
 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
 
 // Input transform
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-unsigned int NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_input_storage_size(
+unsigned int CpuWinogradConv2dTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_input_storage_size(
     int  num_batches,  /* Number of batches in the input tensor. */
     int  num_channels, /* Number of feature maps in the input tensor. */
     int  num_rows,     /* Number of rows in each feature map. */
@@ -296,13 +303,13 @@ unsigned int NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCo
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-unsigned int NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_working_space_size(unsigned int num_threads) const
+unsigned int CpuWinogradConv2dTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_working_space_size(unsigned int num_threads) const
 {
     return _transform->get_working_space_size(num_threads) / sizeof(T);
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-int NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_matrix_stride(
+int CpuWinogradConv2dTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_matrix_stride(
     int  num_batches,  /* Number of batches in the input tensor. */
     int  num_channels, /* Number of feature maps in the input tensor. */
     int  num_rows,     /* Number of rows in each feature map. */
@@ -313,38 +320,32 @@ int NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, Kerne
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::NEWinogradLayerTransformInputKernel()
-    : _transform(nullptr), _input_nhwc(nullptr), _num_batches(0), _num_rows(0), _num_cols(0), _num_channels(0), _padding(), _output(nullptr), _matrix_stride(0), _padding_top(), _padding_left(),
-      _padding_right(), _padding_bottom(), _workspace(nullptr)
+CpuWinogradConv2dTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::CpuWinogradConv2dTransformInputKernel()
+    : _transform(nullptr), _num_channels(0), _matrix_stride(0)
 {
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-void NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::configure(
-    const ITensor    *input_nhwc,
-    const int         num_batches,   /* Number of batches in input tensor. */
-    const int         num_rows,      /* Number of rows in input tensor. */
-    const int         num_cols,      /* Number of columns in input tensor. */
-    const int         num_channels,  /* Number of channels in input tensor. */
-    const PaddingType padding,       /* Padding type. */
-    ITensor          *output,        /* Base of output matrices. */
-    const int         matrix_stride, /* Stride between output matrices. */
-    ITensor          *workspace)
-{
-    _input_nhwc    = input_nhwc;
-    _num_batches   = num_batches;
-    _num_rows      = num_rows;
-    _num_cols      = num_cols;
+void CpuWinogradConv2dTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::configure(
+    const ITensorInfo *input_nhwc,
+    const int          num_batches,   /* Number of batches in input tensor. */
+    const int          num_rows,      /* Number of rows in input tensor. */
+    const int          num_cols,      /* Number of columns in input tensor. */
+    const int          num_channels,  /* Number of channels in input tensor. */
+    const PaddingType  padding,       /* Padding type. */
+    ITensorInfo       *output,        /* Base of output matrices. */
+    const int          matrix_stride, /* Stride between output matrices. */
+    ITensorInfo       *workspace)
+{
+    ARM_COMPUTE_UNUSED(input_nhwc, output, matrix_stride, workspace);
+
     _num_channels  = num_channels;
-    _padding       = padding;
-    _output        = output;
     _matrix_stride = matrix_stride;
-    _workspace     = workspace;
 
-    _padding_top    = (padding == PADDING_SAME) ? (KernelRows - 1) / 2 : 0;
-    _padding_left   = (padding == PADDING_SAME) ? (KernelCols - 1) / 2 : 0;
-    _padding_bottom = (padding == PADDING_SAME) ? iceildiv(KernelRows - 1, 2) : 0;
-    _padding_right  = (padding == PADDING_SAME) ? iceildiv(KernelCols - 1, 2) : 0;
+    const int padding_top    = (padding == PADDING_SAME) ? (KernelRows - 1) / 2 : 0;
+    const int padding_left   = (padding == PADDING_SAME) ? (KernelCols - 1) / 2 : 0;
+    const int padding_bottom = (padding == PADDING_SAME) ? iceildiv(KernelRows - 1, 2) : 0;
+    const int padding_right  = (padding == PADDING_SAME) ? iceildiv(KernelCols - 1, 2) : 0;
 
     _transform = std::make_unique<InputTransform>(
                      KernelRows,
@@ -353,37 +354,41 @@ void NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, Kern
                      num_rows,
                      num_cols,
                      num_channels,
-                     _padding_top,    /**< Padding to apply to the top of the image. */
-                     _padding_left,   /**< Padding to apply to the left of the image. */
-                     _padding_bottom, /**< Padding to apply to the bottom of the image. */
-                     _padding_right   /**< Padding to apply to the right of the image. */
+                     padding_top,    /**< Padding to apply to the top of the image. */
+                     padding_left,   /**< Padding to apply to the left of the image. */
+                     padding_bottom, /**< Padding to apply to the bottom of the image. */
+                     padding_right   /**< Padding to apply to the right of the image. */
                  );
 
     Window win;
     auto   win_last = _transform->get_window();
     win.set(Window::DimX, Window::Dimension(0, win_last, 1));
-    INEKernel::configure(win);
+    ICpuKernel::configure(win);
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-void NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::run(const Window &window, const ThreadInfo &info)
+void CpuWinogradConv2dTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::run_op(ITensorPack &tensors, const Window &window, const ThreadInfo &info)
 {
     ARM_COMPUTE_UNUSED(info);
     ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
-    ARM_COMPUTE_ERROR_ON_NULLPTR(_workspace);
-
-    const int  element_size_in_bytes = _input_nhwc->info()->element_size();
-    const int  input_col_stride      = _input_nhwc->info()->strides_in_bytes().y() / element_size_in_bytes;
-    const int  input_row_stride      = _input_nhwc->info()->strides_in_bytes().z() / element_size_in_bytes;
-    const int  input_batch_stride    = _input_nhwc->info()->strides_in_bytes()[3] / element_size_in_bytes;
-    const auto input_nhwc_ptr        = reinterpret_cast<const T *>(_input_nhwc->buffer() + _input_nhwc->info()->offset_first_element_in_bytes());
-    auto       output_ptr            = reinterpret_cast<T *>(_output->buffer() + _output->info()->offset_first_element_in_bytes());
+    ARM_COMPUTE_ERROR_ON(tensors.empty());
+
+    const ITensor *input_nhwc = tensors.get_const_tensor(TensorType::ACL_SRC);
+    const ITensor *workspace  = tensors.get_const_tensor(TensorType::ACL_INT);
+    ITensor       *output     = tensors.get_tensor(TensorType::ACL_DST);
+
+    const int  element_size_in_bytes = input_nhwc->info()->element_size();
+    const int  input_col_stride      = input_nhwc->info()->strides_in_bytes().y() / element_size_in_bytes;
+    const int  input_row_stride      = input_nhwc->info()->strides_in_bytes().z() / element_size_in_bytes;
+    const int  input_batch_stride    = input_nhwc->info()->strides_in_bytes()[3] / element_size_in_bytes;
+    const auto input_nhwc_ptr        = reinterpret_cast<const T *>(input_nhwc->buffer() + input_nhwc->info()->offset_first_element_in_bytes());
+    auto       output_ptr            = reinterpret_cast<T *>(output->buffer() + output->info()->offset_first_element_in_bytes());
     ARM_COMPUTE_ERROR_ON_NULLPTR(output_ptr);
 
     _transform->set_input_tensor(input_nhwc_ptr, input_batch_stride, input_row_stride, input_col_stride);
     _transform->set_output_matrices(output_ptr, _matrix_stride, _num_channels);
 
-    _transform->set_working_space(_workspace->buffer());
+    _transform->set_working_space(workspace->buffer());
 
     // The code below cannot be moved to configure because biases hasn't been allocated at that point
     const size_t fst = window.x().start();
@@ -392,7 +397,8 @@ void NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, Kern
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-Status NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::validate(const ITensorInfo *input, const ITensorInfo *output, const WinogradInfo &winograd_info)
+Status CpuWinogradConv2dTransformInputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::validate(const ITensorInfo *input, const ITensorInfo *output,
+                                                                                                                  const WinogradInfo &winograd_info)
 {
     ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments_winograd_input_trans(input, output, winograd_info));
     ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window_winograd_input_trans(input->clone().get(), output->clone().get(), winograd_info).first);
@@ -400,25 +406,25 @@ Status NEWinogradLayerTransformInputKernel<T, OutputTileRows, OutputTileCols, Ke
     return Status{};
 }
 
-template class NEWinogradLayerTransformInputKernel<float, 2, 2, 3, 3>;
-template class NEWinogradLayerTransformInputKernel<float, 4, 4, 3, 3>;
-template class NEWinogradLayerTransformInputKernel<float, 2, 2, 5, 5>;
-template class NEWinogradLayerTransformInputKernel<float, 1, 6, 1, 3>;
-template class NEWinogradLayerTransformInputKernel<float, 6, 1, 3, 1>;
+template class CpuWinogradConv2dTransformInputKernel<float, 2, 2, 3, 3>;
+template class CpuWinogradConv2dTransformInputKernel<float, 4, 4, 3, 3>;
+template class CpuWinogradConv2dTransformInputKernel<float, 2, 2, 5, 5>;
+template class CpuWinogradConv2dTransformInputKernel<float, 1, 6, 1, 3>;
+template class CpuWinogradConv2dTransformInputKernel<float, 6, 1, 3, 1>;
 
-template class NEWinogradLayerTransformInputKernel<float, 1, 4, 1, 5>;
-template class NEWinogradLayerTransformInputKernel<float, 4, 1, 5, 1>;
-template class NEWinogradLayerTransformInputKernel<float, 1, 2, 1, 7>;
-template class NEWinogradLayerTransformInputKernel<float, 2, 1, 7, 1>;
+template class CpuWinogradConv2dTransformInputKernel<float, 1, 4, 1, 5>;
+template class CpuWinogradConv2dTransformInputKernel<float, 4, 1, 5, 1>;
+template class CpuWinogradConv2dTransformInputKernel<float, 1, 2, 1, 7>;
+template class CpuWinogradConv2dTransformInputKernel<float, 2, 1, 7, 1>;
 
 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
-template class NEWinogradLayerTransformInputKernel<__fp16, 4, 4, 3, 3>;
+template class CpuWinogradConv2dTransformInputKernel<__fp16, 4, 4, 3, 3>;
 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
 
 // Output transform
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-unsigned int NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_output_storage_size(
+unsigned int CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_output_storage_size(
     int num_batches,        /* Number of batches in the output tensor. */
     int num_rows,           /* Number of rows in each feature map of the input tensor. */
     int num_cols,           /* Number of columns in each feature map of the input tensor. */
@@ -434,20 +440,19 @@ unsigned int NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileC
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::NEWinogradLayerTransformOutputKernel()
-    : _transform(nullptr), _biases(nullptr), _transformed_output(nullptr), _workspace(nullptr), _matrix_stride(0), _matrix_row_stride(0), _output_nhwc(nullptr), _num_batches(0), _num_rows(0),
-      _num_cols(0), _num_channels(0)
+CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::CpuWinogradConv2dTransformOutputKernel()
+    : _transform(nullptr), _matrix_stride(0), _matrix_row_stride(0)
 {
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-unsigned int NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_working_space_size(unsigned int num_threads) const
+unsigned int CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_working_space_size(unsigned int num_threads) const
 {
     return _transform->get_working_space_size(num_threads) / sizeof(T);
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-int NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_matrix_stride(
+int CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_matrix_stride(
     int num_batches,        /* Number of batches in the output tensor. */
     int num_rows,           /* Number of rows in each feature map of the input tensor. */
     int num_cols,           /* Number of columns in each feature map of the input tensor. */
@@ -458,7 +463,7 @@ int NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, Kern
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-std::pair<unsigned int, unsigned int> NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_output_shape(
+std::pair<unsigned int, unsigned int> CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::get_output_shape(
     int  num_rows, /* Number of rows in each feature map of the input tensor. */
     int  num_cols, /* Number of columns in each feature map of the input tensor. */
     bool padding_same) const
@@ -467,54 +472,52 @@ std::pair<unsigned int, unsigned int> NEWinogradLayerTransformOutputKernel<T, Ou
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-void NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::configure(
-    const ITensor              *biases,
-    const ITensor              *transformed_output,
+void CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::configure(
+    const ITensorInfo          *biases,
+    const ITensorInfo          *transformed_output,
     const int                   matrix_stride,
-    ITensor                    *output_nhwc,
+    ITensorInfo                *output_nhwc,
     const int                   num_batches,
     const int                   num_rows,
     const int                   num_cols,
     const int                   num_channels,
-    ITensor                    *workspace,
+    ITensorInfo                *workspace,
     const arm_gemm::Activation &activation)
 {
-    _biases             = biases;
-    _workspace          = workspace;
-    _transformed_output = transformed_output;
-    _matrix_stride      = matrix_stride;
-    _matrix_row_stride  = roundup(num_channels, WinogradConv::N_BLOCK);
-    _output_nhwc        = output_nhwc;
-    _num_batches        = num_batches;
-    _num_rows           = num_rows;
-    _num_cols           = num_cols;
-    _num_channels       = num_channels;
+    ARM_COMPUTE_UNUSED(biases, transformed_output, output_nhwc, num_batches, num_rows, num_cols, workspace, activation);
+
+    _matrix_stride     = matrix_stride;
+    _matrix_row_stride = roundup(num_channels, WinogradConv::N_BLOCK);
+
     // We don't have the biases buffer at this stage as it hasn't been allocated, we pass in nullptr OutputTransform is only used here to compute the window
     _transform = std::make_unique<OutputTransform>(num_batches, num_rows, num_cols, num_channels, activation);
     Window win;
     auto   win_last = _transform->get_window();
     win.set(Window::DimX, Window::Dimension(0, win_last, 1));
 
-    INEKernel::configure(win);
+    ICpuKernel::configure(win);
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-void NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::run(const Window &window, const ThreadInfo &info)
+void CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::run_op(ITensorPack &tensors, const Window &window, const ThreadInfo &info)
 {
-    ARM_COMPUTE_UNUSED(info);
     ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
-    ARM_COMPUTE_ERROR_ON_NULLPTR(_workspace);
-    ARM_COMPUTE_ERROR_ON_NULLPTR(_transformed_output);
-    ARM_COMPUTE_ERROR_ON_NULLPTR(_output_nhwc);
-
-    const int out_batch_stride = _output_nhwc->info()->strides_in_bytes()[3] / sizeof(T);
-    const int out_row_stride   = _output_nhwc->info()->strides_in_bytes()[2] / sizeof(T);
-    const int out_col_stride   = _output_nhwc->info()->strides_in_bytes()[1] / sizeof(T);
-
-    _transform->set_input_matrices(_transformed_output->buffer(), _matrix_stride, _matrix_row_stride);
-    _transform->set_bias((_biases ? reinterpret_cast<T *>(_biases->buffer() + _biases->info()->offset_first_element_in_bytes()) : nullptr));
-    _transform->set_output_tensor(_output_nhwc->buffer() + _output_nhwc->info()->offset_first_element_in_bytes(), out_batch_stride, out_row_stride, out_col_stride);
-    _transform->set_working_space(_workspace->buffer());
+    ARM_COMPUTE_ERROR_ON(tensors.empty());
+
+    const ITensor *biases             = tensors.get_const_tensor(TensorType::ACL_SRC_0);
+    const ITensor *transformed_output = tensors.get_const_tensor(TensorType::ACL_SRC_1);
+    ITensor       *workspace          = tensors.get_tensor(TensorType::ACL_INT);
+    ITensor       *dst_nhwc           = tensors.get_tensor(TensorType::ACL_DST);
+
+    const int out_batch_stride = dst_nhwc->info()->strides_in_bytes()[3] / sizeof(T);
+    const int out_row_stride   = dst_nhwc->info()->strides_in_bytes()[2] / sizeof(T);
+    const int out_col_stride   = dst_nhwc->info()->strides_in_bytes()[1] / sizeof(T);
+
+    _transform->set_input_matrices(transformed_output->buffer(), _matrix_stride, _matrix_row_stride);
+    _transform->set_bias((biases ? reinterpret_cast<T *>(biases->buffer() + biases->info()->offset_first_element_in_bytes()) : nullptr));
+    _transform->set_output_tensor(dst_nhwc->buffer() + dst_nhwc->info()->offset_first_element_in_bytes(), out_batch_stride, out_row_stride, out_col_stride);
+    _transform->set_working_space(workspace->buffer());
+
     // The code below cannot be moved to configure because biases hasn't been allocated at that point
     const size_t fst = window.x().start();
     const size_t lst = window.x().end();
@@ -522,8 +525,8 @@ void NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, Ker
 }
 
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-Status NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::validate(const ITensorInfo *input, const ITensorInfo *bias, const ITensorInfo *output,
-                                                                                                                 const WinogradInfo &winograd_info)
+Status CpuWinogradConv2dTransformOutputKernel<T, OutputTileRows, OutputTileCols, KernelRows, KernelCols>::validate(const ITensorInfo *input, const ITensorInfo *bias, const ITensorInfo *output,
+                                                                                                                   const WinogradInfo &winograd_info)
 {
     ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments_winograd_output_trans(input, (bias != nullptr ? bias->clone().get() : nullptr), output, winograd_info));
     ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window_winograd_output_trans(input->clone().get(), output->clone().get(), winograd_info).first);
@@ -531,18 +534,19 @@ Status NEWinogradLayerTransformOutputKernel<T, OutputTileRows, OutputTileCols, K
     return Status{};
 }
 
-template class NEWinogradLayerTransformOutputKernel<float, 2, 2, 3, 3>;
-template class NEWinogradLayerTransformOutputKernel<float, 4, 4, 3, 3>;
-template class NEWinogradLayerTransformOutputKernel<float, 2, 2, 5, 5>;
-template class NEWinogradLayerTransformOutputKernel<float, 1, 6, 1, 3>;
-template class NEWinogradLayerTransformOutputKernel<float, 6, 1, 3, 1>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 2, 2, 3, 3>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 4, 4, 3, 3>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 2, 2, 5, 5>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 1, 6, 1, 3>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 6, 1, 3, 1>;
 
-template class NEWinogradLayerTransformOutputKernel<float, 1, 4, 1, 5>;
-template class NEWinogradLayerTransformOutputKernel<float, 4, 1, 5, 1>;
-template class NEWinogradLayerTransformOutputKernel<float, 1, 2, 1, 7>;
-template class NEWinogradLayerTransformOutputKernel<float, 2, 1, 7, 1>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 1, 4, 1, 5>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 4, 1, 5, 1>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 1, 2, 1, 7>;
+template class CpuWinogradConv2dTransformOutputKernel<float, 2, 1, 7, 1>;
 
 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
-template class NEWinogradLayerTransformOutputKernel<__fp16, 4, 4, 3, 3>;
+template class CpuWinogradConv2dTransformOutputKernel<__fp16, 4, 4, 3, 3>;
 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
+} // namespace cpu
 } // namespace arm_compute
diff --git a/src/core/NEON/kernels/NEWinogradConvolutionLayerKernel.h b/src/core/cpu/kernels/CpuWinogradConv2dKernel.h
index 75d257de4b..b5a29ffd02 100644
--- a/src/core/NEON/kernels/NEWinogradConvolutionLayerKernel.h
+++ b/src/core/cpu/kernels/CpuWinogradConv2dKernel.h
@@ -21,22 +21,21 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#ifndef ARM_COMPUTE_NEGEMMWINOGRADCONVOLUTIONLAYERKERNEL_H
-#define ARM_COMPUTE_NEGEMMWINOGRADCONVOLUTIONLAYERKERNEL_H
+#ifndef ARM_COMPUTE_CPUWINOGRADCONV2DKERNEL_H
+#define ARM_COMPUTE_CPUWINOGRADCONV2DKERNEL_H
 
-#include "src/core/NEON/INEKernel.h"
 #include "src/core/NEON/kernels/convolution/common/convolution.hpp"
 #include "src/core/NEON/kernels/convolution/common/tensor.hpp"
+#include "src/core/cpu/ICpuKernel.h"
 
 #include "src/core/NEON/kernels/convolution/winograd/winograd_layer.hpp"
 
 namespace arm_compute
 {
-// Forward declarations
-class ITensor;
-
+namespace cpu
+{
 /** Interface for the kernel to perform Winograd input transform. */
-class INEWinogradLayerTransformInputKernel : public INEKernel
+class ICpuWinogradConv2dTransformInputKernel : public ICpuKernel
 {
 public:
     /** Get the working space required to perform the transformation.
@@ -87,30 +86,30 @@ public:
      * @param[in]  matrix_stride Stride between output matrices.
      * @param[in]  workspace     Tensor to be used as the working space during the computation.
      */
-    virtual void configure(const ITensor *input_nhwc, const int num_batches, const int num_rows, const int num_cols, const int num_channels,
-                           const PaddingType padding, ITensor *output, const int matrix_stride, ITensor *workspace) = 0;
+    virtual void configure(const ITensorInfo *input_nhwc, const int num_batches, const int num_rows, const int num_cols, const int num_channels,
+                           const PaddingType padding, ITensorInfo *output, const int matrix_stride, ITensorInfo *workspace) = 0;
 
     /** Destructor */
-    virtual ~INEWinogradLayerTransformInputKernel()
+    virtual ~ICpuWinogradConv2dTransformInputKernel()
     {
     }
 };
 
 /** Kernel to perform Winograd input transform. */
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-class NEWinogradLayerTransformInputKernel : public INEWinogradLayerTransformInputKernel
+class CpuWinogradConv2dTransformInputKernel : public ICpuWinogradConv2dTransformInputKernel
 {
 public:
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEWinogradLayerTransformInputKernel(const NEWinogradLayerTransformInputKernel &) = delete;
+    CpuWinogradConv2dTransformInputKernel(const CpuWinogradConv2dTransformInputKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEWinogradLayerTransformInputKernel &operator=(const NEWinogradLayerTransformInputKernel &) = delete;
+    CpuWinogradConv2dTransformInputKernel &operator=(const CpuWinogradConv2dTransformInputKernel &) = delete;
     /** Allow instances of this class to be moved */
-    NEWinogradLayerTransformInputKernel(NEWinogradLayerTransformInputKernel &&) = default;
+    CpuWinogradConv2dTransformInputKernel(CpuWinogradConv2dTransformInputKernel &&) = default;
     /** Allow instances of this class to be moved */
-    NEWinogradLayerTransformInputKernel &operator=(NEWinogradLayerTransformInputKernel &&) = default;
+    CpuWinogradConv2dTransformInputKernel &operator=(CpuWinogradConv2dTransformInputKernel &&) = default;
     /** Default destructor */
-    ~NEWinogradLayerTransformInputKernel() = default;
+    ~CpuWinogradConv2dTransformInputKernel() = default;
 
     /** Determine how much memory (in units of TIn) to allocate for the
      * transformed input.
@@ -160,11 +159,11 @@ public:
         bool same_padding) const override;
 
     /** Default constructor */
-    NEWinogradLayerTransformInputKernel();
+    CpuWinogradConv2dTransformInputKernel();
 
     const char *name() const override
     {
-        return "NEWinogradLayerTransformInputKernel";
+        return "CpuWinogradConv2dTransformInputKernel";
     }
 
     /** Configure the output transform kernel.
@@ -180,25 +179,25 @@ public:
      * @param[in]  workspace     Tensor to be used as the working space during the computation.
      */
     void configure(
-        const ITensor    *input_nhwc,
-        const int         num_batches,
-        const int         num_rows,
-        const int         num_cols,
-        const int         num_channels,
-        const PaddingType padding,
-        ITensor          *output,
-        const int         matrix_stride,
-        ITensor          *workspace) override;
+        const ITensorInfo *input_nhwc,
+        const int          num_batches,
+        const int          num_rows,
+        const int          num_cols,
+        const int          num_channels,
+        const PaddingType  padding,
+        ITensorInfo       *output,
+        const int          matrix_stride,
+        ITensorInfo       *workspace) override;
 
     // Inherited methods overridden:
-    void run(const Window &window, const ThreadInfo &info) override;
+    void run_op(ITensorPack &tensors, const Window &window, const ThreadInfo &info) override;
 
     /** Winograd base kernel */
     using WinogradBase = winograd::WinogradGEMM<OutputTileRows, OutputTileCols, KernelRows, KernelCols, winograd::WinogradRoots::Integers>;
     /** Winograd convolution kernel */
     using WinogradConv = typename WinogradBase::template Convolution<T, T>;
 
-    /** Static function to check if given info will lead to a valid configuration of @ref NEWinogradLayerTransformInputKernel
+    /** Static function to check if given info will lead to a valid configuration of @ref CpuWinogradConv2dTransformInputKernel
      *
      * @param[in] input         First tensor input info. Data types supported: F16/F32.
      * @param[in] output        Output tensor info. Data types supported: same as @p input.
@@ -212,23 +211,12 @@ private:
     using InputTransform = typename WinogradBase::template InputTransform<T, T>;
 
     std::unique_ptr<InputTransform> _transform{ nullptr };
-    const ITensor                  *_input_nhwc;
-    int                             _num_batches;    /**< Number of batches in input tensor. */
-    int                             _num_rows;       /**< Number of rows in input tensor. */
-    int                             _num_cols;       /**< Number of columns in input tensor. */
-    int                             _num_channels;   /**< Number of channels in input tensor. */
-    PaddingType                     _padding;        /**< Padding type. */
-    ITensor                        *_output;         /**< Base of output matrices. */
-    int                             _matrix_stride;  /**< Stride between output matrices. */
-    int                             _padding_top;    /**< Padding to apply to the top of the image. */
-    int                             _padding_left;   /**< Padding to apply to the left of the image. */
-    int                             _padding_right;  /**< Padding to apply to the right of the image. */
-    int                             _padding_bottom; /**< Padding to apply to the bottom of the image. */
-    ITensor                        *_workspace;
+    int                             _num_channels;  /**< Number of channels in input tensor. */
+    int                             _matrix_stride; /**< Stride between output matrices. */
 };
 
 /** Interface for the kernel to perform Winograd output transform. */
-class INEWinogradLayerTransformOutputKernel : public INEKernel
+class ICpuWinogradConv2dTransformOutputKernel : public ICpuKernel
 {
 public:
     /** Get the working space required to perform the transformation.
@@ -294,44 +282,44 @@ public:
      * @param[in]  activation         Activation to be used
      */
     virtual void configure(
-        const ITensor              *biases,
-        const ITensor              *transformed_output,
+        const ITensorInfo          *biases,
+        const ITensorInfo          *transformed_output,
         const int                   matrix_stride,
-        ITensor                    *output_nhwc,
+        ITensorInfo                *output_nhwc,
         const int                   num_batches,
         const int                   num_rows,
         const int                   num_cols,
         const int                   num_channels,
-        ITensor                    *workspace,
+        ITensorInfo                *workspace,
         const arm_gemm::Activation &activation) = 0;
 
-    virtual ~INEWinogradLayerTransformOutputKernel()
+    virtual ~ICpuWinogradConv2dTransformOutputKernel()
     {
     }
 };
 
 /** Kernel to perform Winograd output transform. */
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-class NEWinogradLayerTransformOutputKernel : public INEWinogradLayerTransformOutputKernel
+class CpuWinogradConv2dTransformOutputKernel : public ICpuWinogradConv2dTransformOutputKernel
 {
 public:
     const char *name() const override
     {
-        return "NEWinogradLayerTransformOutputKernel";
+        return "CpuWinogradConv2dTransformOutputKernel";
     }
     /** Constructor */
-    NEWinogradLayerTransformOutputKernel();
+    CpuWinogradConv2dTransformOutputKernel();
 
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEWinogradLayerTransformOutputKernel(const NEWinogradLayerTransformOutputKernel &) = delete;
+    CpuWinogradConv2dTransformOutputKernel(const CpuWinogradConv2dTransformOutputKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEWinogradLayerTransformOutputKernel &operator=(const NEWinogradLayerTransformOutputKernel &) = delete;
+    CpuWinogradConv2dTransformOutputKernel &operator=(const CpuWinogradConv2dTransformOutputKernel &) = delete;
     /** Allow instances of this class to be moved */
-    NEWinogradLayerTransformOutputKernel(NEWinogradLayerTransformOutputKernel &&) = default;
+    CpuWinogradConv2dTransformOutputKernel(CpuWinogradConv2dTransformOutputKernel &&) = default;
     /** Allow instances of this class to be moved */
-    NEWinogradLayerTransformOutputKernel &operator=(NEWinogradLayerTransformOutputKernel &&) = default;
+    CpuWinogradConv2dTransformOutputKernel &operator=(CpuWinogradConv2dTransformOutputKernel &&) = default;
     /** Default destructor */
-    ~NEWinogradLayerTransformOutputKernel() = default;
+    ~CpuWinogradConv2dTransformOutputKernel() = default;
 
     // Inherited methods overridden:
     /** Determine how much memory (in units of TOut) to allocate for the
@@ -395,20 +383,20 @@ public:
      * @param[in]  activation         Activation to be used
      */
     void configure(
-        const ITensor              *biases,
-        const ITensor              *transformed_output,
+        const ITensorInfo          *biases,
+        const ITensorInfo          *transformed_output,
         const int                   matrix_stride,
-        ITensor                    *output_nhwc,
+        ITensorInfo                *output_nhwc,
         const int                   num_batches,
         const int                   num_rows,
         const int                   num_cols,
         const int                   num_channels,
-        ITensor                    *workspace,
+        ITensorInfo                *workspace,
         const arm_gemm::Activation &activation) override;
 
-    void run(const Window &window, const ThreadInfo &info) override;
+    void run_op(ITensorPack &tensors, const Window &window, const ThreadInfo &info) override;
 
-    /** Static function to check if given info will lead to a valid configuration of @ref NEWinogradLayerTransformOutputKernel
+    /** Static function to check if given info will lead to a valid configuration of @ref CpuWinogradConv2dTransformOutputKernel
      *
      * @param[in] input         Source tensor info with shape [C, N, 16, batches] or [C, N, 36, batches]. Data types supported: F16/F32.
      * @param[in] bias          Biases tensor info. Shared biases supported. Biases are 1D tensor with dimensions [OFM]. It can be a nullptr. Data type supported: as @p input
@@ -425,35 +413,27 @@ private:
     using OutputTransform = typename WinogradBase::template OutputTransform<T, T>;
 
     std::unique_ptr<OutputTransform> _transform{ nullptr };
-    const ITensor                   *_biases;
-    const ITensor                   *_transformed_output;
-    ITensor                         *_workspace;
     int                              _matrix_stride;
     int                              _matrix_row_stride;
-    ITensor                         *_output_nhwc;
-    int                              _num_batches;
-    int                              _num_rows;
-    int                              _num_cols;
-    int                              _num_channels;
 };
 
 /** Interface for the kernel to perform Winograd weights transform. */
-class INEWinogradLayerTransformWeightsKernel : public INEKernel
+class ICpuWinogradConv2dTransformWeightsKernel : public ICpuKernel
 {
 public:
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    INEWinogradLayerTransformWeightsKernel(const INEWinogradLayerTransformWeightsKernel &) = default;
+    ICpuWinogradConv2dTransformWeightsKernel(const ICpuWinogradConv2dTransformWeightsKernel &) = default;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    INEWinogradLayerTransformWeightsKernel &operator=(const INEWinogradLayerTransformWeightsKernel &) = default;
+    ICpuWinogradConv2dTransformWeightsKernel &operator=(const ICpuWinogradConv2dTransformWeightsKernel &) = default;
     /** Allow instances of this class to be moved */
-    INEWinogradLayerTransformWeightsKernel(INEWinogradLayerTransformWeightsKernel &&) = default;
+    ICpuWinogradConv2dTransformWeightsKernel(ICpuWinogradConv2dTransformWeightsKernel &&) = default;
     /** Allow instances of this class to be moved */
-    INEWinogradLayerTransformWeightsKernel &operator=(INEWinogradLayerTransformWeightsKernel &&) = default;
+    ICpuWinogradConv2dTransformWeightsKernel &operator=(ICpuWinogradConv2dTransformWeightsKernel &&) = default;
 
-    INEWinogradLayerTransformWeightsKernel()
+    ICpuWinogradConv2dTransformWeightsKernel()
     {
     }
-    virtual ~INEWinogradLayerTransformWeightsKernel()
+    virtual ~ICpuWinogradConv2dTransformWeightsKernel()
     {
     }
     /** Determine how much memory (in units of T) to allocate for the
@@ -476,16 +456,16 @@ public:
 
     /** Configure the weights transform kernel.
      *
-     * @param[in]  weights_hwio        Pointer to the weights tensor
+     * @param[in]  weights_hwio        Pointer to the weights tensor info
      * @param[out] output              Pointer to working space for the output tensor in the Winograd domain.
      * @param[in]  matrix_stride       Stride across matrices in the output workspace.
      * @param[in]  num_output_channels Number of filters.
      * @param[in]  num_input_channels  Number of channels in each filter.
      */
 
-    virtual void configure(const ITensor *weights_hwio, ITensor *output, const int matrix_stride, const int num_output_channels, const int num_input_channels) = 0;
+    virtual void configure(const ITensorInfo *weights_hwio, ITensorInfo *output, const int matrix_stride, const int num_output_channels, const int num_input_channels) = 0;
 
-    /** Static function to check if given info will lead to a valid configuration of @ref NEWinogradLayerTransformWeightsKernel
+    /** Static function to check if given info will lead to a valid configuration of @ref CpuWinogradConv2dTransformWeightsKernel
      *
      * @param[in] input   First tensor input info. Data types supported: F16/F32.
      * @param[in] weights Weights tensor info. Data types supported: same as @p input.
@@ -497,28 +477,28 @@ public:
 
 /** Kernel to perform Winograd weights transform. */
 template <typename T, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-class NEWinogradLayerTransformWeightsKernel final : public INEWinogradLayerTransformWeightsKernel
+class CpuWinogradConv2dTransformWeightsKernel final : public ICpuWinogradConv2dTransformWeightsKernel
 {
 public:
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEWinogradLayerTransformWeightsKernel(const NEWinogradLayerTransformWeightsKernel &) = delete;
+    CpuWinogradConv2dTransformWeightsKernel(const CpuWinogradConv2dTransformWeightsKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEWinogradLayerTransformWeightsKernel &operator=(const NEWinogradLayerTransformWeightsKernel &) = delete;
+    CpuWinogradConv2dTransformWeightsKernel &operator=(const CpuWinogradConv2dTransformWeightsKernel &) = delete;
     /** Allow instances of this class to be moved */
-    NEWinogradLayerTransformWeightsKernel(NEWinogradLayerTransformWeightsKernel &&) = default;
+    CpuWinogradConv2dTransformWeightsKernel(CpuWinogradConv2dTransformWeightsKernel &&) = default;
     /** Allow instances of this class to be moved */
-    NEWinogradLayerTransformWeightsKernel &operator=(NEWinogradLayerTransformWeightsKernel &&) = default;
+    CpuWinogradConv2dTransformWeightsKernel &operator=(CpuWinogradConv2dTransformWeightsKernel &&) = default;
     /** Default destructor */
-    ~NEWinogradLayerTransformWeightsKernel() = default;
+    ~CpuWinogradConv2dTransformWeightsKernel() = default;
 
     /** Default constructor. */
-    NEWinogradLayerTransformWeightsKernel();
+    CpuWinogradConv2dTransformWeightsKernel();
     const char *name() const override
     {
-        return "NEWinogradLayerTransformWeightsKernel";
+        return "CpuWinogradConv2dTransformWeightsKernel";
     }
 
-    /** Static function to check if given info will lead to a valid configuration of @ref NEWinogradLayerTransformWeightsKernel
+    /** Static function to check if given info will lead to a valid configuration of @ref CpuWinogradConv2dTransformWeightsKernel
      *
      * @param[in] input         Source tensor info. The input is a 4D tensor with dimensions [kernel_x, kernel_y, IFM, OFM] (NCHW data layout).
      *                          kernel_x must be 3 and equal to kernel_y. Data types supported: F16/F32.
@@ -534,13 +514,13 @@ public:
 #ifndef DOXYGEN_SKIP_THIS
     /** Configure the weights transform kernel.
      *
-     * @param[in]  weights_hwio        Pointer to the weights tensor
+     * @param[in]  weights_hwio        Pointer to the weights tensor info
      * @param[out] output              Pointer to working space for the output tensor in the Winograd domain.
      * @param[in]  matrix_stride       Stride across matrices in the output workspace.
      * @param[in]  num_output_channels Number of filters.
      * @param[in]  num_input_channels  Number of channels in each filter.
      */
-    void configure(const ITensor *weights_hwio, ITensor *output, const int matrix_stride, const int num_output_channels, const int num_input_channels) override;
+    void configure(const ITensorInfo *weights_hwio, ITensorInfo *output, const int matrix_stride, const int num_output_channels, const int num_input_channels) override;
 #endif /* DOXYGEN_SKIP_THIS */
 
     /** Determine how much memory (in units of T) to allocate for the
@@ -561,7 +541,7 @@ public:
      * @return Stride expressed in bytes.
      */
     int get_matrix_stride(int num_output_channels, int num_input_channels) const override;
-    void run(const Window &window, const ThreadInfo &info) override;
+    void run_op(ITensorPack &tensors, const Window &window, const ThreadInfo &info) override;
     bool is_parallelisable() const override;
 
 private:
@@ -570,16 +550,13 @@ private:
     using WeightsTransform = typename WinogradBase::template WeightsTransform<T, T>;
 
     std::unique_ptr<WeightsTransform> _transform{ nullptr };
-    const ITensor                    *_weights_hwio;
-    ITensor                          *_output;
-    int                               _matrix_stride;
     int                               _num_output_channels;
-    int                               _num_input_channels;
+    int                               _matrix_stride;
 };
 
 /** Kernel to perform Winograd. */
 template <typename TIn, typename TOut, int OutputTileRows, int OutputTileCols, int KernelRows, int KernelCols>
-class NEWinogradLayerConfiguration
+class CpuWinogradConv2dConfiguration
 {
 public:
     /** Winograd base kernel */
@@ -588,10 +565,11 @@ public:
 
     using WinogradConv = typename WinogradBase::template Convolution<TIn, TOut>;
 
-    using TransformInputKernel   = NEWinogradLayerTransformInputKernel<TIn, OutputTileRows, OutputTileCols, KernelRows, KernelCols>;
-    using TransformWeightsKernel = NEWinogradLayerTransformWeightsKernel<TIn, OutputTileRows, OutputTileCols, KernelRows, KernelCols>;
-    using TransformOutputKernel  = NEWinogradLayerTransformOutputKernel<TOut, OutputTileRows, OutputTileCols, KernelRows, KernelCols>;
+    using TransformInputKernel   = CpuWinogradConv2dTransformInputKernel<TIn, OutputTileRows, OutputTileCols, KernelRows, KernelCols>;
+    using TransformWeightsKernel = CpuWinogradConv2dTransformWeightsKernel<TIn, OutputTileRows, OutputTileCols, KernelRows, KernelCols>;
+    using TransformOutputKernel  = CpuWinogradConv2dTransformOutputKernel<TOut, OutputTileRows, OutputTileCols, KernelRows, KernelCols>;
 };
 
+} // namespace cpu
 } // namespace arm_compute
-#endif /*ARM_COMPUTE_NEGEMMWINOGRADCONVOLUTIONLAYERKERNEL_H*/
+#endif /*ARM_COMPUTE_CPUWINOGRADCONV2DKERNEL_H*/