COMPMID-692 Consistent names for the interfaces

Change-Id: I4b1f3f0da9ff5342c7de7083736fe91871d14e5b
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/110351
Tested-by: BSG Visual Compute Jenkins server to access repositories on http://mpd-gerrit.cambridge.arm.com <bsgcomp@arm.com>
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>

31 files changed, 151 insertions, 151 deletions

diff --git a/arm_compute/core/CL/CLKernels.h b/arm_compute/core/CL/CLKernels.h
index 1ffbad90cf..9da0e5ab3a 100644
--- a/arm_compute/core/CL/CLKernels.h
+++ b/arm_compute/core/CL/CLKernels.h
@@ -42,9 +42,9 @@
 #include "arm_compute/core/CL/kernels/CLCol2ImKernel.h"
 #include "arm_compute/core/CL/kernels/CLColorConvertKernel.h"
 #include "arm_compute/core/CL/kernels/CLConvolutionKernel.h"
-#include "arm_compute/core/CL/kernels/CLDepthConcatenateKernel.h"
-#include "arm_compute/core/CL/kernels/CLDepthConvertKernel.h"
-#include "arm_compute/core/CL/kernels/CLDepthwiseConvolution3x3Kernel.h"
+#include "arm_compute/core/CL/kernels/CLDepthConcatenateLayerKernel.h"
+#include "arm_compute/core/CL/kernels/CLDepthConvertLayerKernel.h"
+#include "arm_compute/core/CL/kernels/CLDepthwiseConvolutionLayer3x3Kernel.h"
 #include "arm_compute/core/CL/kernels/CLDepthwiseIm2ColKernel.h"
 #include "arm_compute/core/CL/kernels/CLDepthwiseVectorToTensorKernel.h"
 #include "arm_compute/core/CL/kernels/CLDepthwiseWeightsReshapeKernel.h"
@@ -76,7 +76,7 @@
 #include "arm_compute/core/CL/kernels/CLHistogramKernel.h"
 #include "arm_compute/core/CL/kernels/CLIm2ColKernel.h"
 #include "arm_compute/core/CL/kernels/CLIntegralImageKernel.h"
-#include "arm_compute/core/CL/kernels/CLL2NormalizeKernel.h"
+#include "arm_compute/core/CL/kernels/CLL2NormalizeLayerKernel.h"
 #include "arm_compute/core/CL/kernels/CLLKTrackerKernel.h"
 #include "arm_compute/core/CL/kernels/CLLocallyConnectedMatrixMultiplyKernel.h"
 #include "arm_compute/core/CL/kernels/CLMagnitudePhaseKernel.h"
diff --git a/arm_compute/core/CL/kernels/CLDepthConcatenateKernel.h b/arm_compute/core/CL/kernels/CLDepthConcatenateLayerKernel.h
index 2833d8ec23..467bdfab3b 100644
--- a/arm_compute/core/CL/kernels/CLDepthConcatenateKernel.h
+++ b/arm_compute/core/CL/kernels/CLDepthConcatenateLayerKernel.h
@@ -35,21 +35,21 @@ class ICLTensor;
 /** Interface for the depth concatenate kernel.
  *  The input tensor will be concatenated into the output tensor.
  */
-class CLDepthConcatenateKernel : public ICLKernel
+class CLDepthConcatenateLayerKernel : public ICLKernel
 {
 public:
     /** Default constructor */
-    CLDepthConcatenateKernel();
+    CLDepthConcatenateLayerKernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    CLDepthConcatenateKernel(const CLDepthConcatenateKernel &) = delete;
+    CLDepthConcatenateLayerKernel(const CLDepthConcatenateLayerKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    CLDepthConcatenateKernel &operator=(const CLDepthConcatenateKernel &) = delete;
+    CLDepthConcatenateLayerKernel &operator=(const CLDepthConcatenateLayerKernel &) = delete;
     /** Allow instances of this class to be moved */
-    CLDepthConcatenateKernel(CLDepthConcatenateKernel &&) = default;
+    CLDepthConcatenateLayerKernel(CLDepthConcatenateLayerKernel &&) = default;
     /** Allow instances of this class to be moved */
-    CLDepthConcatenateKernel &operator=(CLDepthConcatenateKernel &&) = default;
+    CLDepthConcatenateLayerKernel &operator=(CLDepthConcatenateLayerKernel &&) = default;
     /** Default destructor */
-    ~CLDepthConcatenateKernel() = default;
+    ~CLDepthConcatenateLayerKernel() = default;
     /** Initialise the kernel's inputs and output
      *
      * @param[in]     input        Input tensor. Data types supported: QS8/QS16/F16/F32.
diff --git a/arm_compute/core/CL/kernels/CLDepthConvertKernel.h b/arm_compute/core/CL/kernels/CLDepthConvertLayerKernel.h
index da70bff0fd..3a6310d69e 100644
--- a/arm_compute/core/CL/kernels/CLDepthConvertKernel.h
+++ b/arm_compute/core/CL/kernels/CLDepthConvertLayerKernel.h
@@ -36,7 +36,7 @@ class ICLTensor;
 /** Interface for the depth conversion kernel.
  *
  */
-class CLDepthConvertKernel : public ICLSimple2DKernel
+class CLDepthConvertLayerKernel : public ICLSimple2DKernel
 {
 public:
     /** Set the input and output of the kernel.
diff --git a/arm_compute/core/CL/kernels/CLDepthwiseConvolution3x3Kernel.h b/arm_compute/core/CL/kernels/CLDepthwiseConvolutionLayer3x3Kernel.h
index f9689a4329..eb62465f84 100644
--- a/arm_compute/core/CL/kernels/CLDepthwiseConvolution3x3Kernel.h
+++ b/arm_compute/core/CL/kernels/CLDepthwiseConvolutionLayer3x3Kernel.h
@@ -32,19 +32,19 @@ class ICLTensor;
 
 /** Interface for the kernel to run a 3x3 depthwise convolution on a tensor.
  */
-class CLDepthwiseConvolution3x3Kernel : public ICLKernel
+class CLDepthwiseConvolutionLayer3x3Kernel : public ICLKernel
 {
 public:
     /** Default constructor */
-    CLDepthwiseConvolution3x3Kernel();
+    CLDepthwiseConvolutionLayer3x3Kernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    CLDepthwiseConvolution3x3Kernel(const CLDepthwiseConvolution3x3Kernel &) = delete;
+    CLDepthwiseConvolutionLayer3x3Kernel(const CLDepthwiseConvolutionLayer3x3Kernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    CLDepthwiseConvolution3x3Kernel &operator=(const CLDepthwiseConvolution3x3Kernel &) = delete;
+    CLDepthwiseConvolutionLayer3x3Kernel &operator=(const CLDepthwiseConvolutionLayer3x3Kernel &) = delete;
     /** Default Move Constructor. */
-    CLDepthwiseConvolution3x3Kernel(CLDepthwiseConvolution3x3Kernel &&) = default;
+    CLDepthwiseConvolutionLayer3x3Kernel(CLDepthwiseConvolutionLayer3x3Kernel &&) = default;
     /** Default move assignment operator. */
-    CLDepthwiseConvolution3x3Kernel &operator=(CLDepthwiseConvolution3x3Kernel &&) = default;
+    CLDepthwiseConvolutionLayer3x3Kernel &operator=(CLDepthwiseConvolutionLayer3x3Kernel &&) = default;
     /** Initialize the function's source, destination, conv and border_size.
      *
      * @param[in]  input     Source tensor. DataType supported: QASYMM8/F32.
diff --git a/arm_compute/core/CL/kernels/CLL2NormalizeKernel.h b/arm_compute/core/CL/kernels/CLL2NormalizeLayerKernel.h
index 2056b4e615..f7d717119b 100644
--- a/arm_compute/core/CL/kernels/CLL2NormalizeKernel.h
+++ b/arm_compute/core/CL/kernels/CLL2NormalizeLayerKernel.h
@@ -32,21 +32,21 @@ namespace arm_compute
 class ICLTensor;
 
 /** Interface for the reduction operation kernel */
-class CLL2NormalizeKernel : public ICLKernel
+class CLL2NormalizeLayerKernel : public ICLKernel
 {
 public:
     /** Default constructor */
-    CLL2NormalizeKernel();
+    CLL2NormalizeLayerKernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    CLL2NormalizeKernel(const CLL2NormalizeKernel &) = delete;
+    CLL2NormalizeLayerKernel(const CLL2NormalizeLayerKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    CLL2NormalizeKernel &operator=(const CLL2NormalizeKernel &) = delete;
+    CLL2NormalizeLayerKernel &operator=(const CLL2NormalizeLayerKernel &) = delete;
     /** Allow instances of this class to be moved */
-    CLL2NormalizeKernel(CLL2NormalizeKernel &&) = default;
+    CLL2NormalizeLayerKernel(CLL2NormalizeLayerKernel &&) = default;
     /** Allow instances of this class to be moved */
-    CLL2NormalizeKernel &operator=(CLL2NormalizeKernel &&) = default;
+    CLL2NormalizeLayerKernel &operator=(CLL2NormalizeLayerKernel &&) = default;
     /** Default destructor */
-    ~CLL2NormalizeKernel() = default;
+    ~CLL2NormalizeLayerKernel() = default;
 
     /** Set the input and output tensors.
      *
diff --git a/arm_compute/core/GLES_COMPUTE/GCKernels.h b/arm_compute/core/GLES_COMPUTE/GCKernels.h
index 57d11d5f18..9831e25299 100644
--- a/arm_compute/core/GLES_COMPUTE/GCKernels.h
+++ b/arm_compute/core/GLES_COMPUTE/GCKernels.h
@@ -29,7 +29,7 @@
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCActivationLayerKernel.h"
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCBatchNormalizationLayerKernel.h"
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCCol2ImKernel.h"
-#include "arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateKernel.h"
+#include "arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateLayerKernel.h"
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCDirectConvolutionLayerKernel.h"
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCDropoutKernel.h"
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCFillBorderKernel.h"
diff --git a/arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateKernel.h b/arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateLayerKernel.h
index 9a34a9a9c5..ce220cc564 100644
--- a/arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateKernel.h
+++ b/arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateLayerKernel.h
@@ -35,21 +35,21 @@ class IGCTensor;
 /** Interface for the depth concatenate kernel.
  *  The input tensor will be concatenated into the output tensor.
  */
-class GCDepthConcatenateKernel : public IGCKernel
+class GCDepthConcatenateLayerKernel : public IGCKernel
 {
 public:
     /** Default constructor */
-    GCDepthConcatenateKernel();
+    GCDepthConcatenateLayerKernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    GCDepthConcatenateKernel(const GCDepthConcatenateKernel &) = delete;
+    GCDepthConcatenateLayerKernel(const GCDepthConcatenateLayerKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    GCDepthConcatenateKernel &operator=(const GCDepthConcatenateKernel &) = delete;
+    GCDepthConcatenateLayerKernel &operator=(const GCDepthConcatenateLayerKernel &) = delete;
     /** Allow instances of this class to be moved */
-    GCDepthConcatenateKernel(GCDepthConcatenateKernel &&) = default;
+    GCDepthConcatenateLayerKernel(GCDepthConcatenateLayerKernel &&) = default;
     /** Allow instances of this class to be moved */
-    GCDepthConcatenateKernel &operator=(GCDepthConcatenateKernel &&) = default;
+    GCDepthConcatenateLayerKernel &operator=(GCDepthConcatenateLayerKernel &&) = default;
     /** Default destructor */
-    ~GCDepthConcatenateKernel() = default;
+    ~GCDepthConcatenateLayerKernel() = default;
     /** Initialise the kernel's inputs and output
      *
      * @param[in]     input        Input tensor. Data types supported: F16/F32.
diff --git a/arm_compute/core/NEON/NEKernels.h b/arm_compute/core/NEON/NEKernels.h
index b23e2ac5a3..6c31fa4fb1 100644
--- a/arm_compute/core/NEON/NEKernels.h
+++ b/arm_compute/core/NEON/NEKernels.h
@@ -44,9 +44,9 @@
 #include "arm_compute/core/NEON/kernels/NEConvolutionKernel.h"
 #include "arm_compute/core/NEON/kernels/NECumulativeDistributionKernel.h"
 #include "arm_compute/core/NEON/kernels/NEDeconvolutionLayerUpsampleKernel.h"
-#include "arm_compute/core/NEON/kernels/NEDepthConcatenateKernel.h"
-#include "arm_compute/core/NEON/kernels/NEDepthConvertKernel.h"
-#include "arm_compute/core/NEON/kernels/NEDepthwiseConvolution3x3Kernel.h"
+#include "arm_compute/core/NEON/kernels/NEDepthConcatenateLayerKernel.h"
+#include "arm_compute/core/NEON/kernels/NEDepthConvertLayerKernel.h"
+#include "arm_compute/core/NEON/kernels/NEDepthwiseConvolutionLayer3x3Kernel.h"
 #include "arm_compute/core/NEON/kernels/NEDepthwiseIm2ColKernel.h"
 #include "arm_compute/core/NEON/kernels/NEDepthwiseVectorToTensorKernel.h"
 #include "arm_compute/core/NEON/kernels/NEDepthwiseWeightsReshapeKernel.h"
@@ -83,7 +83,7 @@
 #include "arm_compute/core/NEON/kernels/NEHistogramKernel.h"
 #include "arm_compute/core/NEON/kernels/NEIm2ColKernel.h"
 #include "arm_compute/core/NEON/kernels/NEIntegralImageKernel.h"
-#include "arm_compute/core/NEON/kernels/NEL2NormalizeKernel.h"
+#include "arm_compute/core/NEON/kernels/NEL2NormalizeLayerKernel.h"
 #include "arm_compute/core/NEON/kernels/NELKTrackerKernel.h"
 #include "arm_compute/core/NEON/kernels/NELocallyConnectedMatrixMultiplyKernel.h"
 #include "arm_compute/core/NEON/kernels/NEMagnitudePhaseKernel.h"
diff --git a/arm_compute/core/NEON/kernels/NEDepthConcatenateKernel.h b/arm_compute/core/NEON/kernels/NEDepthConcatenateLayerKernel.h
index 784dfc3f5c..6029873f22 100644
--- a/arm_compute/core/NEON/kernels/NEDepthConcatenateKernel.h
+++ b/arm_compute/core/NEON/kernels/NEDepthConcatenateLayerKernel.h
@@ -34,21 +34,21 @@ class ITensor;
 /** Interface for the depth concatenate kernel.
  *  The input tensor will be concatenated into the output tensor.
  */
-class NEDepthConcatenateKernel : public INEKernel
+class NEDepthConcatenateLayerKernel : public INEKernel
 {
 public:
     /** Default constructor */
-    NEDepthConcatenateKernel();
+    NEDepthConcatenateLayerKernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEDepthConcatenateKernel(const NEDepthConcatenateKernel &) = delete;
+    NEDepthConcatenateLayerKernel(const NEDepthConcatenateLayerKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEDepthConcatenateKernel &operator=(const NEDepthConcatenateKernel &) = delete;
+    NEDepthConcatenateLayerKernel &operator=(const NEDepthConcatenateLayerKernel &) = delete;
     /** Allow instances of this class to be moved */
-    NEDepthConcatenateKernel(NEDepthConcatenateKernel &&) = default;
+    NEDepthConcatenateLayerKernel(NEDepthConcatenateLayerKernel &&) = default;
     /** Allow instances of this class to be moved */
-    NEDepthConcatenateKernel &operator=(NEDepthConcatenateKernel &&) = default;
+    NEDepthConcatenateLayerKernel &operator=(NEDepthConcatenateLayerKernel &&) = default;
     /** Default destructor */
-    ~NEDepthConcatenateKernel() = default;
+    ~NEDepthConcatenateLayerKernel() = default;
     /** Initialise the kernel's inputs and output
      *
      * @param[in]     input        Input tensor. Data types supported: QS8/QS16/F16/F32.
diff --git a/arm_compute/core/NEON/kernels/NEDepthConvertKernel.h b/arm_compute/core/NEON/kernels/NEDepthConvertLayerKernel.h
index 332406f239..af51ded87a 100644
--- a/arm_compute/core/NEON/kernels/NEDepthConvertKernel.h
+++ b/arm_compute/core/NEON/kernels/NEDepthConvertLayerKernel.h
@@ -34,19 +34,19 @@ namespace arm_compute
 class ITensor;
 
 /** Depth conversion kernel */
-class NEDepthConvertKernel : public INEKernel
+class NEDepthConvertLayerKernel : public INEKernel
 {
 public:
     /** Default constructor*/
-    NEDepthConvertKernel();
+    NEDepthConvertLayerKernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEDepthConvertKernel(const NEDepthConvertKernel &) = delete;
+    NEDepthConvertLayerKernel(const NEDepthConvertLayerKernel &) = delete;
     /** Default move constructor */
-    NEDepthConvertKernel(NEDepthConvertKernel &&) = default;
+    NEDepthConvertLayerKernel(NEDepthConvertLayerKernel &&) = default;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEDepthConvertKernel &operator=(const NEDepthConvertKernel &) = delete;
+    NEDepthConvertLayerKernel &operator=(const NEDepthConvertLayerKernel &) = delete;
     /** Default move assignment operator */
-    NEDepthConvertKernel &operator=(NEDepthConvertKernel &&) = default;
+    NEDepthConvertLayerKernel &operator=(NEDepthConvertLayerKernel &&) = default;
     /** Set the input and output of the kernel
      *
      * Valid conversions Input -> Output :
diff --git a/arm_compute/core/NEON/kernels/NEDepthwiseConvolution3x3Kernel.h b/arm_compute/core/NEON/kernels/NEDepthwiseConvolutionLayer3x3Kernel.h
index a32a06b61d..b8f01cb635 100644
--- a/arm_compute/core/NEON/kernels/NEDepthwiseConvolution3x3Kernel.h
+++ b/arm_compute/core/NEON/kernels/NEDepthwiseConvolutionLayer3x3Kernel.h
@@ -32,19 +32,19 @@ class ITensor;
 
 /** Interface for the kernel to run a 3x3 depthwise convolution on a tensor.
  */
-class NEDepthwiseConvolution3x3Kernel : public INEKernel
+class NEDepthwiseConvolutionLayer3x3Kernel : public INEKernel
 {
 public:
     /** Default constructor */
-    NEDepthwiseConvolution3x3Kernel();
+    NEDepthwiseConvolutionLayer3x3Kernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEDepthwiseConvolution3x3Kernel(const NEDepthwiseConvolution3x3Kernel &) = delete;
+    NEDepthwiseConvolutionLayer3x3Kernel(const NEDepthwiseConvolutionLayer3x3Kernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEDepthwiseConvolution3x3Kernel &operator=(const NEDepthwiseConvolution3x3Kernel &) = delete;
+    NEDepthwiseConvolutionLayer3x3Kernel &operator=(const NEDepthwiseConvolutionLayer3x3Kernel &) = delete;
     /** Default Move Constructor. */
-    NEDepthwiseConvolution3x3Kernel(NEDepthwiseConvolution3x3Kernel &&) = default;
+    NEDepthwiseConvolutionLayer3x3Kernel(NEDepthwiseConvolutionLayer3x3Kernel &&) = default;
     /** Default move assignment operator. */
-    NEDepthwiseConvolution3x3Kernel &operator=(NEDepthwiseConvolution3x3Kernel &&) = default;
+    NEDepthwiseConvolutionLayer3x3Kernel &operator=(NEDepthwiseConvolutionLayer3x3Kernel &&) = default;
     /** Initialize the function's source, destination, conv and border_size.
      *
      * @param[in]  input     Source tensor. DataType supported: F32.
diff --git a/arm_compute/core/NEON/kernels/NEL2NormalizeKernel.h b/arm_compute/core/NEON/kernels/NEL2NormalizeLayerKernel.h
index fbbe4bee99..7aa5116b68 100644
--- a/arm_compute/core/NEON/kernels/NEL2NormalizeKernel.h
+++ b/arm_compute/core/NEON/kernels/NEL2NormalizeLayerKernel.h
@@ -31,21 +31,21 @@ namespace arm_compute
 class ITensor;
 
 /** Interface for performing a L2 normalize on a given axis given the square sum of it in this axis */
-class NEL2NormalizeKernel : public INEKernel
+class NEL2NormalizeLayerKernel : public INEKernel
 {
 public:
     /** Default constructor */
-    NEL2NormalizeKernel();
+    NEL2NormalizeLayerKernel();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEL2NormalizeKernel(const NEL2NormalizeKernel &) = delete;
+    NEL2NormalizeLayerKernel(const NEL2NormalizeLayerKernel &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers) */
-    NEL2NormalizeKernel &operator=(const NEL2NormalizeKernel &) = delete;
+    NEL2NormalizeLayerKernel &operator=(const NEL2NormalizeLayerKernel &) = delete;
     /** Allow instances of this class to be moved */
-    NEL2NormalizeKernel(NEL2NormalizeKernel &&) = default;
+    NEL2NormalizeLayerKernel(NEL2NormalizeLayerKernel &&) = default;
     /** Allow instances of this class to be moved */
-    NEL2NormalizeKernel &operator=(NEL2NormalizeKernel &&) = default;
+    NEL2NormalizeLayerKernel &operator=(NEL2NormalizeLayerKernel &&) = default;
     /** Default destructor */
-    ~NEL2NormalizeKernel() = default;
+    ~NEL2NormalizeLayerKernel() = default;
     /** Set the input and output tensors.
      *
      * @param[in]  input   Source tensor. Data types supported: F32.
diff --git a/arm_compute/graph/nodes/L2NormalizeLayer.h b/arm_compute/graph/nodes/L2NormalizeLayer.h
index fc2bbc2d19..a423306bd2 100644
--- a/arm_compute/graph/nodes/L2NormalizeLayer.h
+++ b/arm_compute/graph/nodes/L2NormalizeLayer.h
@@ -33,7 +33,7 @@ namespace arm_compute
 {
 namespace graph
 {
-/** L2Normalize layer node */
+/** L2NormalizeLayer layer node */
 class L2NormalizeLayer final : public INode
 {
 public:
diff --git a/arm_compute/runtime/CL/CLFunctions.h b/arm_compute/runtime/CL/CLFunctions.h
index 9a20769ca1..f6ecef7a51 100644
--- a/arm_compute/runtime/CL/CLFunctions.h
+++ b/arm_compute/runtime/CL/CLFunctions.h
@@ -42,9 +42,9 @@
 #include "arm_compute/runtime/CL/functions/CLColorConvert.h"
 #include "arm_compute/runtime/CL/functions/CLConvolution.h"
 #include "arm_compute/runtime/CL/functions/CLConvolutionLayer.h"
-#include "arm_compute/runtime/CL/functions/CLDepthConcatenate.h"
-#include "arm_compute/runtime/CL/functions/CLDepthConvert.h"
-#include "arm_compute/runtime/CL/functions/CLDepthwiseConvolution.h"
+#include "arm_compute/runtime/CL/functions/CLDepthConcatenateLayer.h"
+#include "arm_compute/runtime/CL/functions/CLDepthConvertLayer.h"
+#include "arm_compute/runtime/CL/functions/CLDepthwiseConvolutionLayer.h"
 #include "arm_compute/runtime/CL/functions/CLDepthwiseSeparableConvolutionLayer.h"
 #include "arm_compute/runtime/CL/functions/CLDequantizationLayer.h"
 #include "arm_compute/runtime/CL/functions/CLDerivative.h"
@@ -72,7 +72,7 @@
 #include "arm_compute/runtime/CL/functions/CLHarrisCorners.h"
 #include "arm_compute/runtime/CL/functions/CLHistogram.h"
 #include "arm_compute/runtime/CL/functions/CLIntegralImage.h"
-#include "arm_compute/runtime/CL/functions/CLL2Normalize.h"
+#include "arm_compute/runtime/CL/functions/CLL2NormalizeLayer.h"
 #include "arm_compute/runtime/CL/functions/CLLaplacianPyramid.h"
 #include "arm_compute/runtime/CL/functions/CLLaplacianReconstruct.h"
 #include "arm_compute/runtime/CL/functions/CLLocallyConnectedLayer.h"
diff --git a/arm_compute/runtime/CL/functions/CLDepthConcatenate.h b/arm_compute/runtime/CL/functions/CLDepthConcatenateLayer.h
index 77997f6bd1..00b3b66c97 100644
--- a/arm_compute/runtime/CL/functions/CLDepthConcatenate.h
+++ b/arm_compute/runtime/CL/functions/CLDepthConcatenateLayer.h
@@ -29,7 +29,7 @@
 #include "arm_compute/core/Window.h"
 #include "arm_compute/runtime/IFunction.h"
 
-#include "arm_compute/core/CL/kernels/CLDepthConcatenateKernel.h"
+#include "arm_compute/core/CL/kernels/CLDepthConcatenateLayerKernel.h"
 #include "arm_compute/core/CL/kernels/CLFillBorderKernel.h"
 
 #include <memory>
@@ -42,14 +42,14 @@ class ICLTensor;
 /** Basic function to execute concatenate tensors along z axis. This function calls the following kernels:
  *
  * -# @ref CLFillBorderKernel (executed if input's lowest two dimensions are smaller than respective output's dimensions)
- * -# @ref CLDepthConcatenateKernel
+ * -# @ref CLDepthConcatenateLayerKernel
  *
  */
-class CLDepthConcatenate : public IFunction
+class CLDepthConcatenateLayer : public IFunction
 {
 public:
     /** Default constructor */
-    CLDepthConcatenate();
+    CLDepthConcatenateLayer();
     /** Initialise the kernel's inputs vector and output.
      *
      * @param[in,out] inputs_vector The vectors containing all the tensors to concatenate. Data types supported: QS8/QS16/F16/F32.
@@ -61,10 +61,10 @@ public:
     void run() override;
 
 private:
-    std::vector<ICLTensor *>                    _inputs_vector;
-    std::unique_ptr<CLDepthConcatenateKernel[]> _concat_kernels_vector;
-    std::unique_ptr<CLFillBorderKernel[]>       _border_handlers_vector;
-    unsigned int                                _num_inputs;
+    std::vector<ICLTensor *>                         _inputs_vector;
+    std::unique_ptr<CLDepthConcatenateLayerKernel[]> _concat_kernels_vector;
+    std::unique_ptr<CLFillBorderKernel[]>            _border_handlers_vector;
+    unsigned int                                     _num_inputs;
 };
 }
 #endif /* __ARM_COMPUTE_CLDEPTHCONCATENATE_H__ */
diff --git a/arm_compute/runtime/CL/functions/CLDepthConvert.h b/arm_compute/runtime/CL/functions/CLDepthConvertLayer.h
index 9a4c63dd6d..c84dc15508 100644
--- a/arm_compute/runtime/CL/functions/CLDepthConvert.h
+++ b/arm_compute/runtime/CL/functions/CLDepthConvertLayer.h
@@ -33,8 +33,8 @@ namespace arm_compute
 {
 class ICLTensor;
 
-/** Basic function to run @ref CLDepthConvertKernel. */
-class CLDepthConvert : public ICLSimpleFunction
+/** Basic function to run @ref CLDepthConvertLayerKernel. */
+class CLDepthConvertLayer : public ICLSimpleFunction
 {
 public:
     /** Initialize the function's source, destination
diff --git a/arm_compute/runtime/CL/functions/CLDepthwiseConvolution.h b/arm_compute/runtime/CL/functions/CLDepthwiseConvolutionLayer.h
index 40eb8523fb..f7899415d2 100644
--- a/arm_compute/runtime/CL/functions/CLDepthwiseConvolution.h
+++ b/arm_compute/runtime/CL/functions/CLDepthwiseConvolutionLayer.h
@@ -24,7 +24,7 @@
 #ifndef __ARM_COMPUTE_CLDEPTHWISECONVOLUTION_H__
 #define __ARM_COMPUTE_CLDEPTHWISECONVOLUTION_H__
 
-#include "arm_compute/core/CL/kernels/CLDepthwiseConvolution3x3Kernel.h"
+#include "arm_compute/core/CL/kernels/CLDepthwiseConvolutionLayer3x3Kernel.h"
 #include "arm_compute/core/CL/kernels/CLDepthwiseIm2ColKernel.h"
 #include "arm_compute/core/CL/kernels/CLDepthwiseVectorToTensorKernel.h"
 #include "arm_compute/core/CL/kernels/CLDepthwiseWeightsReshapeKernel.h"
@@ -40,15 +40,15 @@ class ICLTensor;
 
 /** Basic function to execute a depthwise convolution for kernel size 3x3xC. This function calls the following OpenCL kernels:
  *
- * -# @ref CLDepthwiseConvolution3x3Kernel
+ * -# @ref CLDepthwiseConvolutionLayer3x3Kernel
  * -# @ref CLFillBorderKernel (if pad_x or pad_y > 0)
  *
  */
-class CLDepthwiseConvolution3x3 : public IFunction
+class CLDepthwiseConvolutionLayer3x3 : public IFunction
 {
 public:
     /** Default constructor */
-    CLDepthwiseConvolution3x3();
+    CLDepthwiseConvolutionLayer3x3();
     /** Initialize the function's source, destination, conv and border_size.
      *
      * @param[in, out] input     Source tensor. Data type supported: QASYMM8/F32. (Written to only for border filling).
@@ -64,8 +64,8 @@ public:
     void run() override;
 
 private:
-    CLDepthwiseConvolution3x3Kernel _kernel;
-    CLFillBorderKernel              _border_handler;
+    CLDepthwiseConvolutionLayer3x3Kernel _kernel;
+    CLFillBorderKernel                   _border_handler;
 };
 
 /** Basic function to execute a generic depthwise convolution. This function calls the following OpenCL kernels:
@@ -76,11 +76,11 @@ private:
  * -# @ref CLFillBorderKernel (if pad_x or pad_y > 0)
  *
  */
-class CLDepthwiseConvolution : public IFunction
+class CLDepthwiseConvolutionLayer : public IFunction
 {
 public:
     /** Default constructor */
-    CLDepthwiseConvolution();
+    CLDepthwiseConvolutionLayer();
     /** Initialize the function's source, destination, weights and convolution information.
      *
      * @param[in, out] input     Source tensor. Data type supported: F32. (Written to only for border filling).
diff --git a/arm_compute/runtime/CL/functions/CLDepthwiseSeparableConvolutionLayer.h b/arm_compute/runtime/CL/functions/CLDepthwiseSeparableConvolutionLayer.h
index a38446293b..27cee5ed3b 100644
--- a/arm_compute/runtime/CL/functions/CLDepthwiseSeparableConvolutionLayer.h
+++ b/arm_compute/runtime/CL/functions/CLDepthwiseSeparableConvolutionLayer.h
@@ -27,7 +27,7 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/CL/CLTensor.h"
 #include "arm_compute/runtime/CL/ICLSimpleFunction.h"
-#include "arm_compute/runtime/CL/functions/CLDepthwiseConvolution.h"
+#include "arm_compute/runtime/CL/functions/CLDepthwiseConvolutionLayer.h"
 #include "arm_compute/runtime/CL/functions/CLDirectConvolutionLayer.h"
 #include "arm_compute/runtime/IFunction.h"
 
@@ -39,7 +39,7 @@ class ICLTensor;
 
 /** Basic function to execute depthwise convolution. This function calls the following OpenCL kernels and function:
  *
- * -# @ref CLDepthwiseConvolution
+ * -# @ref CLDepthwiseConvolutionLayer
  * -# @ref CLDirectConvolutionLayer
  *
  */
@@ -72,8 +72,8 @@ public:
     void run() override;
 
 private:
-    CLDepthwiseConvolution   _depthwise_conv;
-    CLDirectConvolutionLayer _pointwise_conv;
+    CLDepthwiseConvolutionLayer _depthwise_conv;
+    CLDirectConvolutionLayer    _pointwise_conv;
 };
 }
 #endif /*__ARM_COMPUTE_CL_DEPTHWISE_SEPARABLE_CONVOLUTION_H__ */
diff --git a/arm_compute/runtime/CL/functions/CLL2Normalize.h b/arm_compute/runtime/CL/functions/CLL2NormalizeLayer.h
index 20af54eda2..8aea7a641b 100644
--- a/arm_compute/runtime/CL/functions/CLL2Normalize.h
+++ b/arm_compute/runtime/CL/functions/CLL2NormalizeLayer.h
@@ -24,7 +24,7 @@
 #ifndef __ARM_COMPUTE_CLL2NORMALIZE_H__
 #define __ARM_COMPUTE_CLL2NORMALIZE_H__
 
-#include "arm_compute/core/CL/kernels/CLL2NormalizeKernel.h"
+#include "arm_compute/core/CL/kernels/CLL2NormalizeLayerKernel.h"
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/CL/CLMemoryGroup.h"
 #include "arm_compute/runtime/CL/CLTensor.h"
@@ -41,11 +41,11 @@ class ICLTensor;
 
 /** Perform reduction operation.
  */
-class CLL2Normalize : public IFunction
+class CLL2NormalizeLayer : public IFunction
 {
 public:
     /** Constructor */
-    CLL2Normalize(std::shared_ptr<IMemoryManager> memory_manager = nullptr);
+    CLL2NormalizeLayer(std::shared_ptr<IMemoryManager> memory_manager = nullptr);
 
     /** Set the input and output tensors.
      *
@@ -60,10 +60,10 @@ public:
     void run() override;
 
 private:
-    CLMemoryGroup        _memory_group;
-    CLReductionOperation _reduce_func;
-    CLL2NormalizeKernel  _normalize_kernel;
-    CLTensor             _sumsq;
+    CLMemoryGroup            _memory_group;
+    CLReductionOperation     _reduce_func;
+    CLL2NormalizeLayerKernel _normalize_kernel;
+    CLTensor                 _sumsq;
 };
 }
 #endif /*__ARM_COMPUTE_CLL2NORMALIZE_H__ */
diff --git a/arm_compute/runtime/CL/functions/CLLaplacianPyramid.h b/arm_compute/runtime/CL/functions/CLLaplacianPyramid.h
index 0c6708aa73..585a013e31 100644
--- a/arm_compute/runtime/CL/functions/CLLaplacianPyramid.h
+++ b/arm_compute/runtime/CL/functions/CLLaplacianPyramid.h
@@ -27,7 +27,7 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/CL/CLPyramid.h"
 #include "arm_compute/runtime/CL/functions/CLArithmeticSubtraction.h"
-#include "arm_compute/runtime/CL/functions/CLDepthConvert.h"
+#include "arm_compute/runtime/CL/functions/CLDepthConvertLayer.h"
 #include "arm_compute/runtime/CL/functions/CLGaussian5x5.h"
 #include "arm_compute/runtime/CL/functions/CLGaussianPyramid.h"
 #include "arm_compute/runtime/IFunction.h"
@@ -77,7 +77,7 @@ private:
     CLGaussianPyramidHalf                      _gaussian_pyr_function;
     std::unique_ptr<CLGaussian5x5[]>           _convf;
     std::unique_ptr<CLArithmeticSubtraction[]> _subf;
-    CLDepthConvert                             _depth_function;
+    CLDepthConvertLayer                        _depth_function;
     CLPyramid                                  _gauss_pyr;
     CLPyramid                                  _conv_pyr;
 };
diff --git a/arm_compute/runtime/CL/functions/CLLaplacianReconstruct.h b/arm_compute/runtime/CL/functions/CLLaplacianReconstruct.h
index 4bc7eb65ce..4a676c85a0 100644
--- a/arm_compute/runtime/CL/functions/CLLaplacianReconstruct.h
+++ b/arm_compute/runtime/CL/functions/CLLaplacianReconstruct.h
@@ -27,7 +27,7 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/CL/CLPyramid.h"
 #include "arm_compute/runtime/CL/functions/CLArithmeticAddition.h"
-#include "arm_compute/runtime/CL/functions/CLDepthConvert.h"
+#include "arm_compute/runtime/CL/functions/CLDepthConvertLayer.h"
 #include "arm_compute/runtime/CL/functions/CLScale.h"
 #include "arm_compute/runtime/IFunction.h"
 
@@ -43,7 +43,7 @@ using ICLImage = ICLTensor;
  *
  * -# @ref CLArithmeticAddition
  * -# @ref CLScale
- * -# @ref CLDepthConvert
+ * -# @ref CLDepthConvertLayer
  *
  * This function reconstructs the original image from a Laplacian Image Pyramid.
  *
@@ -85,7 +85,7 @@ private:
     CLPyramid                               _tmp_pyr;
     std::unique_ptr<CLArithmeticAddition[]> _addf;
     std::unique_ptr<CLScale[]>              _scalef;
-    CLDepthConvert                          _depthf;
+    CLDepthConvertLayer                     _depthf;
 };
 }
 #endif /*__ARM_COMPUTE_CLLAPLACIANRECONSTRUCT_H__ */
diff --git a/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h b/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h
index 8a345c5fab..e76d4efb27 100644
--- a/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h
+++ b/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h
@@ -28,7 +28,7 @@
 #include "arm_compute/runtime/GLES_COMPUTE/functions/GCAbsoluteDifference.h"
 #include "arm_compute/runtime/GLES_COMPUTE/functions/GCActivationLayer.h"
 #include "arm_compute/runtime/GLES_COMPUTE/functions/GCBatchNormalizationLayer.h"
-#include "arm_compute/runtime/GLES_COMPUTE/functions/GCDepthConcatenate.h"
+#include "arm_compute/runtime/GLES_COMPUTE/functions/GCDepthConcatenateLayer.h"
 #include "arm_compute/runtime/GLES_COMPUTE/functions/GCDirectConvolutionLayer.h"
 #include "arm_compute/runtime/GLES_COMPUTE/functions/GCDropoutLayer.h"
 #include "arm_compute/runtime/GLES_COMPUTE/functions/GCFillBorder.h"
diff --git a/arm_compute/runtime/GLES_COMPUTE/functions/GCDepthConcatenate.h b/arm_compute/runtime/GLES_COMPUTE/functions/GCDepthConcatenateLayer.h
index 801dc0e111..1151399f92 100644
--- a/arm_compute/runtime/GLES_COMPUTE/functions/GCDepthConcatenate.h
+++ b/arm_compute/runtime/GLES_COMPUTE/functions/GCDepthConcatenateLayer.h
@@ -25,7 +25,7 @@
 #define __ARM_COMPUTE_GCDEPTHCONCATENATE_H__
 
 #include "arm_compute/core/GLES_COMPUTE/OpenGLES.h"
-#include "arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateKernel.h"
+#include "arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateLayerKernel.h"
 #include "arm_compute/core/GLES_COMPUTE/kernels/GCFillBorderKernel.h"
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/IFunction.h"
@@ -40,14 +40,14 @@ class IGCTensor;
 /** Basic function to execute concatenate tensors along z axis. This function calls the following kernels:
  *
  * -# @ref GCFillBorderKernel (executed if input's lowest two dimensions are smaller than respective output's dimensions)
- * -# @ref GCDepthConcatenateKernel
+ * -# @ref GCDepthConcatenateLayerKernel
  *
  */
-class GCDepthConcatenate : public IFunction
+class GCDepthConcatenateLayer : public IFunction
 {
 public:
     /** Default constructor */
-    GCDepthConcatenate();
+    GCDepthConcatenateLayer();
     /** Initialise the kernel's inputs vector and output.
      *
      * @param[in,out] inputs_vector The vectors containing all the tensors to concatenate. Data types supported: F16/F32.
@@ -59,9 +59,9 @@ public:
     void run() override;
 
 private:
-    std::unique_ptr<GCDepthConcatenateKernel[]> _concat_kernels_vector;
-    std::unique_ptr<GCFillBorderKernel[]>       _border_handlers_vector;
-    unsigned int                                _num_inputs;
+    std::unique_ptr<GCDepthConcatenateLayerKernel[]> _concat_kernels_vector;
+    std::unique_ptr<GCFillBorderKernel[]>            _border_handlers_vector;
+    unsigned int                                     _num_inputs;
 };
 }
 #endif /* __ARM_COMPUTE_GCDEPTHCONCATENATE_H__ */
diff --git a/arm_compute/runtime/NEON/NEFunctions.h b/arm_compute/runtime/NEON/NEFunctions.h
index 2e8c084371..08852cf368 100644
--- a/arm_compute/runtime/NEON/NEFunctions.h
+++ b/arm_compute/runtime/NEON/NEFunctions.h
@@ -45,9 +45,9 @@
 #include "arm_compute/runtime/NEON/functions/NEConvolutionLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEDeconvolutionLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEDeconvolutionLayerUpsample.h"
-#include "arm_compute/runtime/NEON/functions/NEDepthConcatenate.h"
-#include "arm_compute/runtime/NEON/functions/NEDepthConvert.h"
-#include "arm_compute/runtime/NEON/functions/NEDepthwiseConvolution.h"
+#include "arm_compute/runtime/NEON/functions/NEDepthConcatenateLayer.h"
+#include "arm_compute/runtime/NEON/functions/NEDepthConvertLayer.h"
+#include "arm_compute/runtime/NEON/functions/NEDepthwiseConvolutionLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEDepthwiseSeparableConvolutionLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEDequantizationLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEDerivative.h"
@@ -77,7 +77,7 @@
 #include "arm_compute/runtime/NEON/functions/NEHistogram.h"
 #include "arm_compute/runtime/NEON/functions/NEIm2Col.h"
 #include "arm_compute/runtime/NEON/functions/NEIntegralImage.h"
-#include "arm_compute/runtime/NEON/functions/NEL2Normalize.h"
+#include "arm_compute/runtime/NEON/functions/NEL2NormalizeLayer.h"
 #include "arm_compute/runtime/NEON/functions/NELaplacianPyramid.h"
 #include "arm_compute/runtime/NEON/functions/NELaplacianReconstruct.h"
 #include "arm_compute/runtime/NEON/functions/NELocallyConnectedLayer.h"
diff --git a/arm_compute/runtime/NEON/functions/NEDepthConcatenate.h b/arm_compute/runtime/NEON/functions/NEDepthConcatenateLayer.h
index cc65099575..5b63b70634 100644
--- a/arm_compute/runtime/NEON/functions/NEDepthConcatenate.h
+++ b/arm_compute/runtime/NEON/functions/NEDepthConcatenateLayer.h
@@ -26,7 +26,7 @@
 
 #include "arm_compute/runtime/IFunction.h"
 
-#include "arm_compute/core/NEON/kernels/NEDepthConcatenateKernel.h"
+#include "arm_compute/core/NEON/kernels/NEDepthConcatenateLayerKernel.h"
 #include "arm_compute/core/NEON/kernels/NEFillBorderKernel.h"
 
 #include <memory>
@@ -39,14 +39,14 @@ class ITensor;
 /** Basic function to execute concatenate tensors along z axis. This function calls the following kernels:
  *
  * -# @ref NEFillBorderKernel (executed if input's lowest two dimensions are smaller than respective output's dimensions)
- * -# @ref NEDepthConcatenateKernel
+ * -# @ref NEDepthConcatenateLayerKernel
  *
  */
-class NEDepthConcatenate : public IFunction
+class NEDepthConcatenateLayer : public IFunction
 {
 public:
     /** Default constructor */
-    NEDepthConcatenate();
+    NEDepthConcatenateLayer();
     /** Initialise the kernel's inputs vector and output.
      *
      * @param[in,out] inputs_vector The vectors containing all the tensors to concatenate. Data types supported:  QS8/QS16/F16/F32.
@@ -58,10 +58,10 @@ public:
     void run() override;
 
 private:
-    std::vector<ITensor *>                      _inputs_vector;
-    std::unique_ptr<NEDepthConcatenateKernel[]> _concat_kernels_vector;
-    std::unique_ptr<NEFillBorderKernel[]>       _border_handlers_vector;
-    unsigned int                                _num_inputs;
+    std::vector<ITensor *>                           _inputs_vector;
+    std::unique_ptr<NEDepthConcatenateLayerKernel[]> _concat_kernels_vector;
+    std::unique_ptr<NEFillBorderKernel[]>            _border_handlers_vector;
+    unsigned int                                     _num_inputs;
 };
 }
 #endif /* __ARM_COMPUTE_NEDEPTHCONCATENATE_H__ */
diff --git a/arm_compute/runtime/NEON/functions/NEDepthConvert.h b/arm_compute/runtime/NEON/functions/NEDepthConvertLayer.h
index 37f7293fb3..b235e87b4a 100644
--- a/arm_compute/runtime/NEON/functions/NEDepthConvert.h
+++ b/arm_compute/runtime/NEON/functions/NEDepthConvertLayer.h
@@ -33,16 +33,16 @@ namespace arm_compute
 {
 class ITensor;
 
-/**Basic function to run @ref NEDepthConvertKernel */
-class NEDepthConvert : public INESimpleFunction
+/**Basic function to run @ref NEDepthConvertLayerKernel */
+class NEDepthConvertLayer : public INESimpleFunction
 {
 public:
     /* Contructor */
-    NEDepthConvert() = default;
+    NEDepthConvertLayer() = default;
     /** Prevent instances of this class from being copied (As this class contains pointers)*/
-    NEDepthConvert(const NEDepthConvert &) = delete;
+    NEDepthConvertLayer(const NEDepthConvertLayer &) = delete;
     /** Prevent instances of this class from being copied (As this class contains pointers)*/
-    const NEDepthConvert &operator=(const NEDepthConvert &) = delete;
+    const NEDepthConvertLayer &operator=(const NEDepthConvertLayer &) = delete;
     /** Initialize the function's source, destination
      *
      * Valid conversions Input -> Output :
diff --git a/arm_compute/runtime/NEON/functions/NEDepthwiseConvolution.h b/arm_compute/runtime/NEON/functions/NEDepthwiseConvolutionLayer.h
index f2c209cd80..0da16ab2a9 100644
--- a/arm_compute/runtime/NEON/functions/NEDepthwiseConvolution.h
+++ b/arm_compute/runtime/NEON/functions/NEDepthwiseConvolutionLayer.h
@@ -24,7 +24,7 @@
 #ifndef __ARM_COMPUTE_NEDEPTHWISECONVOLUTION_H__
 #define __ARM_COMPUTE_NEDEPTHWISECONVOLUTION_H__
 
-#include "arm_compute/core/NEON/kernels/NEDepthwiseConvolution3x3Kernel.h"
+#include "arm_compute/core/NEON/kernels/NEDepthwiseConvolutionLayer3x3Kernel.h"
 #include "arm_compute/core/NEON/kernels/NEDepthwiseIm2ColKernel.h"
 #include "arm_compute/core/NEON/kernels/NEDepthwiseVectorToTensorKernel.h"
 #include "arm_compute/core/NEON/kernels/NEDepthwiseWeightsReshapeKernel.h"
@@ -43,15 +43,15 @@ class ITensor;
 
 /** Basic function to execute a depthwise convolution for kernel size 3x3xC. This function calls the following NEON kernels:
  *
- * -# @ref NEDepthwiseConvolution3x3
+ * -# @ref NEDepthwiseConvolutionLayer3x3
  * -# @ref NEFillBorderKernel (if pad_x or pad_y > 0)
  *
  */
-class NEDepthwiseConvolution3x3 : public IFunction
+class NEDepthwiseConvolutionLayer3x3 : public IFunction
 {
 public:
     /** Default constructor */
-    NEDepthwiseConvolution3x3();
+    NEDepthwiseConvolutionLayer3x3();
     /** Initialize the function's source, destination, kernels and border_size.
      *
      * @param[in, out] input     Source tensor. Data type supported: F32. (Written to only for border filling).
@@ -67,7 +67,7 @@ public:
     void run() override;
 
 private:
-    NEDepthwiseConvolution3x3Kernel              _kernel;
+    NEDepthwiseConvolutionLayer3x3Kernel         _kernel;
     NEDirectConvolutionLayerBiasAccumulateKernel _bias_kernel;
     NEFillBorderKernel                           _border_handler;
     bool                                         _has_bias;
@@ -81,11 +81,11 @@ private:
  * -# @ref NEFillBorderKernel (if pad_x or pad_y > 0)
  *
  */
-class NEDepthwiseConvolution : public IFunction
+class NEDepthwiseConvolutionLayer : public IFunction
 {
 public:
     /** Default constructor */
-    NEDepthwiseConvolution();
+    NEDepthwiseConvolutionLayer();
     /** Initialize the function's source, destination, weights and convolution information.
      *
      * @param[in, out] input     Source tensor. Data type supported: F32. (Written to only for border filling).
diff --git a/arm_compute/runtime/NEON/functions/NEDepthwiseSeparableConvolutionLayer.h b/arm_compute/runtime/NEON/functions/NEDepthwiseSeparableConvolutionLayer.h
index 3f4c1389f0..0562c07515 100644
--- a/arm_compute/runtime/NEON/functions/NEDepthwiseSeparableConvolutionLayer.h
+++ b/arm_compute/runtime/NEON/functions/NEDepthwiseSeparableConvolutionLayer.h
@@ -27,7 +27,7 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/IFunction.h"
 #include "arm_compute/runtime/NEON/INESimpleFunction.h"
-#include "arm_compute/runtime/NEON/functions/NEDepthwiseConvolution.h"
+#include "arm_compute/runtime/NEON/functions/NEDepthwiseConvolutionLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEDirectConvolutionLayer.h"
 #include "arm_compute/runtime/Tensor.h"
 
@@ -39,7 +39,7 @@ class ITensor;
 
 /** Basic function to execute depthwise convolution. This function calls the following NEON kernels and function:
  *
- * -# @ref NEDepthwiseConvolution
+ * -# @ref NEDepthwiseConvolutionLayer
  * -# @ref NEDirectConvolutionLayer
  *
  */
@@ -72,8 +72,8 @@ public:
     void run() override;
 
 private:
-    NEDepthwiseConvolution   _depthwise_conv;
-    NEDirectConvolutionLayer _pointwise_conv;
+    NEDepthwiseConvolutionLayer _depthwise_conv;
+    NEDirectConvolutionLayer    _pointwise_conv;
 };
 }
 #endif /*__ARM_COMPUTE_NEON_DEPTHWISE_SEPARABLE_CONVOLUTION_H__ */
diff --git a/arm_compute/runtime/NEON/functions/NEL2Normalize.h b/arm_compute/runtime/NEON/functions/NEL2NormalizeLayer.h
index 95d5186c13..100e239406 100644
--- a/arm_compute/runtime/NEON/functions/NEL2Normalize.h
+++ b/arm_compute/runtime/NEON/functions/NEL2NormalizeLayer.h
@@ -24,7 +24,7 @@
 #ifndef __ARM_COMPUTE_NEL2NORMALIZE_H__
 #define __ARM_COMPUTE_NEL2NORMALIZE_H__
 
-#include "arm_compute/core/NEON/kernels/NEL2NormalizeKernel.h"
+#include "arm_compute/core/NEON/kernels/NEL2NormalizeLayerKernel.h"
 #include "arm_compute/runtime/IFunction.h"
 #include "arm_compute/runtime/IMemoryManager.h"
 #include "arm_compute/runtime/MemoryGroup.h"
@@ -41,13 +41,13 @@ class ITensor;
  *
  * This function runs the following kernels:
  * -# @ref NEReductionOperation
- * -# @ref NEL2NormalizeKernel
+ * -# @ref NEL2NormalizeLayerKernel
  */
-class NEL2Normalize : public IFunction
+class NEL2NormalizeLayer : public IFunction
 {
 public:
     /** Constructor */
-    NEL2Normalize(std::shared_ptr<IMemoryManager> memory_manager = nullptr);
+    NEL2NormalizeLayer(std::shared_ptr<IMemoryManager> memory_manager = nullptr);
     /** Set the input and output tensors.
      *
      * @param[in, out] input   Source tensor. Data types supported: F32. (Written to only for border_size != 0)
@@ -61,10 +61,10 @@ public:
     void run() override;
 
 private:
-    MemoryGroup          _memory_group;
-    NEReductionOperation _reduce_func;
-    NEL2NormalizeKernel  _normalize_kernel;
-    Tensor               _sumsq;
+    MemoryGroup              _memory_group;
+    NEReductionOperation     _reduce_func;
+    NEL2NormalizeLayerKernel _normalize_kernel;
+    Tensor                   _sumsq;
 };
 }
 #endif /* __ARM_COMPUTE_NEL2NORMALIZE_H__ */
diff --git a/arm_compute/runtime/NEON/functions/NELaplacianPyramid.h b/arm_compute/runtime/NEON/functions/NELaplacianPyramid.h
index 991ae7c293..baa4b7b1a5 100644
--- a/arm_compute/runtime/NEON/functions/NELaplacianPyramid.h
+++ b/arm_compute/runtime/NEON/functions/NELaplacianPyramid.h
@@ -27,7 +27,7 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/IFunction.h"
 #include "arm_compute/runtime/NEON/functions/NEArithmeticSubtraction.h"
-#include "arm_compute/runtime/NEON/functions/NEDepthConvert.h"
+#include "arm_compute/runtime/NEON/functions/NEDepthConvertLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEGaussian5x5.h"
 #include "arm_compute/runtime/NEON/functions/NEGaussianPyramid.h"
 #include "arm_compute/runtime/Pyramid.h"
@@ -79,7 +79,7 @@ private:
     std::unique_ptr<NEArithmeticSubtraction[]> _subf;
     Pyramid                                    _gauss_pyr;
     Pyramid                                    _conv_pyr;
-    NEDepthConvert                             _depth_function;
+    NEDepthConvertLayer                        _depth_function;
 };
 }
 #endif /*__ARM_COMPUTE_NELAPLACIANPYRAMID_H__ */
diff --git a/arm_compute/runtime/NEON/functions/NELaplacianReconstruct.h b/arm_compute/runtime/NEON/functions/NELaplacianReconstruct.h
index 4139733499..3d423607a3 100644
--- a/arm_compute/runtime/NEON/functions/NELaplacianReconstruct.h
+++ b/arm_compute/runtime/NEON/functions/NELaplacianReconstruct.h
@@ -27,7 +27,7 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/IFunction.h"
 #include "arm_compute/runtime/NEON/functions/NEArithmeticAddition.h"
-#include "arm_compute/runtime/NEON/functions/NEDepthConvert.h"
+#include "arm_compute/runtime/NEON/functions/NEDepthConvertLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEScale.h"
 #include "arm_compute/runtime/Pyramid.h"
 
@@ -43,7 +43,7 @@ using IImage = ITensor;
  *
  * -# @ref NEArithmeticAddition
  * -# @ref NEScale
- * -# @ref NEDepthConvert
+ * -# @ref NEDepthConvertLayer
  *
  * This function reconstructs the original image from a Laplacian Image Pyramid.
  *
@@ -85,7 +85,7 @@ private:
     Pyramid                                 _tmp_pyr;
     std::unique_ptr<NEArithmeticAddition[]> _addf;
     std::unique_ptr<NEScale[]>              _scalef;
-    NEDepthConvert                          _depthf;
+    NEDepthConvertLayer                     _depthf;
 };
 }
 #endif /*__ARM_COMPUTE_NELAPLACIANRECONSTRUCT_H__ */