Clean up macro definitions in arm_compute headers

- Expose loose macros by prefixing "ARM_COMPUTE_"

Resolves: COMPMID-3701

Signed-off-by: Giorgio Arena <giorgio.arena@arm.com>
Change-Id: I4334b01c1a5cd8585f4a1ba2d870be956c61a83d
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/4769
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>

15 files changed, 251 insertions, 251 deletions

diff --git a/arm_compute/core/TracePoint.h b/arm_compute/core/TracePoint.h
index 799d62ec2c..508c86acff 100644
--- a/arm_compute/core/TracePoint.h
+++ b/arm_compute/core/TracePoint.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -31,7 +31,7 @@
 namespace arm_compute
 {
 #ifdef ARM_COMPUTE_TRACING_ENABLED
-#define CREATE_TRACEPOINT(...) TracePoint __tp(__VA_ARGS__)
+#define ARM_COMPUTE_CREATE_TRACEPOINT(...) TracePoint __tp(__VA_ARGS__)
 
 /** Class used to dump configuration values in functions and kernels  */
 class TracePoint final
@@ -77,7 +77,7 @@ TracePoint::Args &&operator<<(typename std::enable_if < !std::is_pointer<T>::val
 template <typename T>
 TracePoint::Args &&operator<<(TracePoint::Args &&tp, const T *arg);
 
-#define CONST_REF_CLASS(type)                                             \
+#define ARM_COMPUTE_CONST_REF_CLASS(type)                                 \
     template <>                                                           \
     TracePoint::Args &&operator<<(TracePoint::Args &&tp, const type &arg) \
     {                                                                     \
@@ -86,7 +86,7 @@ TracePoint::Args &&operator<<(TracePoint::Args &&tp, const T *arg);
         return std::move(tp);                                             \
     }
 
-#define CONST_PTR_ADDRESS(type)                                           \
+#define ARM_COMPUTE_CONST_PTR_ADDRESS(type)                               \
     template <>                                                           \
     TracePoint::Args &&operator<<(TracePoint::Args &&tp, const type *arg) \
     {                                                                     \
@@ -94,7 +94,7 @@ TracePoint::Args &&operator<<(TracePoint::Args &&tp, const T *arg);
         tp.args.push_back(#type "*(" + to_ptr_string(arg) + ")");         \
         return std::move(tp);                                             \
     }
-#define CONST_PTR_CLASS(type)                                             \
+#define ARM_COMPUTE_CONST_PTR_CLASS(type)                                 \
     template <>                                                           \
     TracePoint::Args &&operator<<(TracePoint::Args &&tp, const type *arg) \
     {                                                                     \
@@ -106,7 +106,7 @@ TracePoint::Args &&operator<<(TracePoint::Args &&tp, const T *arg);
         return std::move(tp);                                             \
     }
 
-#define CONST_REF_SIMPLE(type)                                               \
+#define ARM_COMPUTE_CONST_REF_SIMPLE(type)                                   \
     template <>                                                              \
     TracePoint::Args &&operator<<(TracePoint::Args &&tp, const type &arg)    \
     {                                                                        \
@@ -115,19 +115,19 @@ TracePoint::Args &&operator<<(TracePoint::Args &&tp, const T *arg);
         return std::move(tp);                                                \
     }
 
-#define TRACE_TO_STRING(type)              \
+#define ARM_COMPUTE_TRACE_TO_STRING(type)  \
     std::string to_string(const type &arg) \
     {                                      \
         ARM_COMPUTE_UNUSED(arg);           \
         return "";                         \
     }
 #else /* ARM_COMPUTE_TRACING_ENABLED */
-#define CREATE_TRACEPOINT(...)
-#define CONST_REF_CLASS(type)
-#define CONST_PTR_ADDRESS(type)
-#define CONST_PTR_CLASS(type)
-#define CONST_REF_SIMPLE(type)
-#define TRACE_TO_STRING(type)
+#define ARM_COMPUTE_CREATE_TRACEPOINT(...)
+#define ARM_COMPUTE_CONST_REF_CLASS(type)
+#define ARM_COMPUTE_CONST_PTR_ADDRESS(type)
+#define ARM_COMPUTE_CONST_PTR_CLASS(type)
+#define ARM_COMPUTE_CONST_REF_SIMPLE(type)
+#define ARM_COMPUTE_TRACE_TO_STRING(type)
 #endif /* ARM_COMPUTE_TRACING_ENABLED */
 } //namespace arm_compute
 
diff --git a/arm_compute/core/WindowIterator.h b/arm_compute/core/WindowIterator.h
index 0967cefe7a..c15a50cf47 100644
--- a/arm_compute/core/WindowIterator.h
+++ b/arm_compute/core/WindowIterator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2019 Arm Limited.
+ * Copyright (c) 2018-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -28,9 +28,9 @@
 #include "arm_compute/core/ITensor.h"
 #include "arm_compute/core/Window.h"
 
-//FIXME: Delete the "PRINTF" before the release. In the meantime it's probably going to be useful to debug
-//#define PRINTF printf
-#define PRINTF(...)
+//FIXME: Delete the "ARM_COMPUTE_PRINTF" before the release. In the meantime it's probably going to be useful to debug
+//#define ARM_COMPUTE_PRINTF printf
+#define ARM_COMPUTE_PRINTF(...)
 
 namespace arm_compute
 {
@@ -170,14 +170,14 @@ public:
     {
         while(_end.z() != _position.z())
         {
-            PRINTF("New slice %d\n", _position.z());
+            ARM_COMPUTE_PRINTF("New slice %d\n", _position.z());
             iterate_2D_internal(on_new_row_size, _w.x().end() - _w.x().step(), _w.y().end() - _w.y().step());
             _position[2] += _w.z().step();
             _position[1] = _w.y().start();
             _position[0] = _w.x().start();
         }
         // Left over:
-        PRINTF("Left over slice\n");
+        ARM_COMPUTE_PRINTF("Left over slice\n");
         iterate_2D(on_new_row_size);
     }
 
@@ -220,7 +220,7 @@ private:
         if(end_y == _position.y())
         {
             // Single row:
-            PRINTF("Partial row only\n");
+            ARM_COMPUTE_PRINTF("Partial row only\n");
             // Both start and end belong to the same row:
             iterate_over_dim0(end_x + _w.x().step(), on_new_row_size);
         }
@@ -230,7 +230,7 @@ private:
             if(_w.x().start() != _position.x())
             {
                 //Start in the middle of a row: process left-over X
-                PRINTF("Partial row first\n");
+                ARM_COMPUTE_PRINTF("Partial row first\n");
                 iterate_over_dim0(_w.x().end(), on_new_row_size);
                 _position[1] += _w.y().step();
             }
@@ -239,7 +239,7 @@ private:
             bool no_leftover = end_x + _w.x().step() == _w.x().end();
             if(no_leftover)
             {
-                PRINTF("no left over\n");
+                ARM_COMPUTE_PRINTF("no left over\n");
                 //Switch to full row size:
                 on_new_row_size(_w[0].start(), _w.x().end());
                 // Shouldn't be possible to reach that point and not have at least one entire row to process
@@ -249,17 +249,17 @@ private:
             }
             else
             {
-                PRINTF("with left over\n");
+                ARM_COMPUTE_PRINTF("with left over\n");
                 // Are there full rows to process ?
                 if(_position[1] != end_y)
                 {
-                    PRINTF("full rows\n");
+                    ARM_COMPUTE_PRINTF("full rows\n");
                     //Switch to full row size:
                     on_new_row_size(_w[0].start(), _w.x().end());
                     iterate_over_dim1(end_y);
                 }
 
-                PRINTF("Final leftover\n");
+                ARM_COMPUTE_PRINTF("Final leftover\n");
                 //Leftover end x
                 _position[0] = _w.x().start();
                 iterate_over_dim0(end_x + _w.x().step(), on_new_row_size);
@@ -298,7 +298,7 @@ private:
      */
     void iterate_over_dim0(int end)
     {
-        PRINTF("X [%d, %d, %d]\n", _position.x(), end, _w[0].step());
+        ARM_COMPUTE_PRINTF("X [%d, %d, %d]\n", _position.x(), end, _w[0].step());
         // Both start and end belong to the same row:
         ARM_COMPUTE_ERROR_ON(_position[0] > end);
         for(; _position.x() < end; _position[0] += _w[0].step())
diff --git a/arm_compute/core/utils/math/SafeOps.h b/arm_compute/core/utils/math/SafeOps.h
index c222c65e84..f0d76a3d02 100644
--- a/arm_compute/core/utils/math/SafeOps.h
+++ b/arm_compute/core/utils/math/SafeOps.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2020 Arm Limited.
+ * Copyright (c) 2019-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -46,7 +46,7 @@ namespace math
  *
  * @return The addition result
  */
-template <typename T, REQUIRES_TA(std::is_integral<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(std::is_integral<T>::value)>
 T safe_integer_add(T val_a, T val_b)
 {
     T result = 0;
@@ -78,7 +78,7 @@ T safe_integer_add(T val_a, T val_b)
  *
  * @return The subtraction result
  */
-template <typename T, REQUIRES_TA(std::is_integral<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(std::is_integral<T>::value)>
 T safe_integer_sub(T val_a, T val_b)
 {
     T result = 0;
@@ -110,7 +110,7 @@ T safe_integer_sub(T val_a, T val_b)
  *
  * @return The multiplication result
  */
-template <typename T, REQUIRES_TA(std::is_integral<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(std::is_integral<T>::value)>
 T safe_integer_mul(T val_a, T val_b)
 {
     T result = 0;
@@ -160,7 +160,7 @@ T safe_integer_mul(T val_a, T val_b)
  *
  * @return The quotient
  */
-template <typename T, REQUIRES_TA(std::is_integral<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(std::is_integral<T>::value)>
 T safe_integer_div(T val_a, T val_b)
 {
     T result = 0;
diff --git a/scripts/enable_tracing.py b/scripts/enable_tracing.py
index 842c58edf1..fb06a8c6c2 100755
--- a/scripts/enable_tracing.py
+++ b/scripts/enable_tracing.py
@@ -72,7 +72,7 @@ def do_insert_tracing(source, function, fd):
     if len(arg_names):
         assert len(arg_names), "No argument to configure for %s ?" % class_name
         spaces = re.match("([ ]*)void", function[0]).group(1)
-        fd.write("%s    CREATE_TRACEPOINT(%s, \"%s\", this, TracePoint::Args()" % (spaces, source, class_name))
+        fd.write("%s    ARM_COMPUTE_CREATE_TRACEPOINT(%s, \"%s\", this, TracePoint::Args()" % (spaces, source, class_name))
         for arg in arg_names:
             fd.write("<<%s" % arg)
         fd.write(");\n")
diff --git a/src/core/CL/CLTracePoint.cpp b/src/core/CL/CLTracePoint.cpp
index d603f40c26..c3d4899740 100644
--- a/src/core/CL/CLTracePoint.cpp
+++ b/src/core/CL/CLTracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -51,35 +51,35 @@ TracePoint::Args &&operator<<(TracePoint::Args &&tp, const ICLTensor *arg)
     return std::move(tp);
 }
 
-TRACE_TO_STRING(std::vector<ICLTensor *>)
-TRACE_TO_STRING(ICLMultiImage)
-TRACE_TO_STRING(ICLDetectionWindowArray)
-TRACE_TO_STRING(ICLKeyPointArray)
-TRACE_TO_STRING(ICLLKInternalKeypointArray)
-TRACE_TO_STRING(ICLCoefficientTableArray)
-TRACE_TO_STRING(ICLCoordinates2DArray)
-TRACE_TO_STRING(ICLOldValArray)
-TRACE_TO_STRING(cl::Buffer)
-TRACE_TO_STRING(ICLDistribution1D)
-TRACE_TO_STRING(ICLMultiHOG)
-TRACE_TO_STRING(ICLHOG)
-TRACE_TO_STRING(ICLLut)
-TRACE_TO_STRING(ICLSize2DArray)
-TRACE_TO_STRING(std::vector<const ICLTensor *>)
+ARM_COMPUTE_TRACE_TO_STRING(std::vector<ICLTensor *>)
+ARM_COMPUTE_TRACE_TO_STRING(ICLMultiImage)
+ARM_COMPUTE_TRACE_TO_STRING(ICLDetectionWindowArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLKeyPointArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLLKInternalKeypointArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLCoefficientTableArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLCoordinates2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLOldValArray)
+ARM_COMPUTE_TRACE_TO_STRING(cl::Buffer)
+ARM_COMPUTE_TRACE_TO_STRING(ICLDistribution1D)
+ARM_COMPUTE_TRACE_TO_STRING(ICLMultiHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ICLHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ICLLut)
+ARM_COMPUTE_TRACE_TO_STRING(ICLSize2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(std::vector<const ICLTensor *>)
 
-CONST_PTR_CLASS(std::vector<ICLTensor *>)
-CONST_PTR_CLASS(ICLMultiImage)
-CONST_PTR_CLASS(ICLDetectionWindowArray)
-CONST_PTR_CLASS(ICLKeyPointArray)
-CONST_PTR_CLASS(ICLLKInternalKeypointArray)
-CONST_PTR_CLASS(ICLCoefficientTableArray)
-CONST_PTR_CLASS(ICLCoordinates2DArray)
-CONST_PTR_CLASS(ICLOldValArray)
-CONST_PTR_CLASS(cl::Buffer)
-CONST_PTR_CLASS(ICLDistribution1D)
-CONST_PTR_CLASS(ICLMultiHOG)
-CONST_PTR_CLASS(ICLHOG)
-CONST_PTR_CLASS(ICLLut)
-CONST_PTR_CLASS(ICLSize2DArray)
-CONST_PTR_CLASS(std::vector<const ICLTensor *>)
+ARM_COMPUTE_CONST_PTR_CLASS(std::vector<ICLTensor *>)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLMultiImage)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLDetectionWindowArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLKeyPointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLLKInternalKeypointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLCoefficientTableArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLCoordinates2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLOldValArray)
+ARM_COMPUTE_CONST_PTR_CLASS(cl::Buffer)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLDistribution1D)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLMultiHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLLut)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLSize2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(std::vector<const ICLTensor *>)
 } // namespace arm_compute
diff --git a/src/core/NEON/NETracePoint.cpp b/src/core/NEON/NETracePoint.cpp
index bf48b411ec..756451d230 100644
--- a/src/core/NEON/NETracePoint.cpp
+++ b/src/core/NEON/NETracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -37,11 +37,11 @@ std::string to_string(const PaddingType &arg)
     return ((arg == PADDING_SAME) ? "PADDING_SAME" : "PADDING_VALID");
 }
 
-TRACE_TO_STRING(INELKInternalKeypointArray)
-TRACE_TO_STRING(std::unique_ptr<INEGEMMWrapperKernel>)
+ARM_COMPUTE_TRACE_TO_STRING(INELKInternalKeypointArray)
+ARM_COMPUTE_TRACE_TO_STRING(std::unique_ptr<INEGEMMWrapperKernel>)
 
-CONST_PTR_CLASS(INELKInternalKeypointArray)
-CONST_PTR_CLASS(std::unique_ptr<INEGEMMWrapperKernel>)
+ARM_COMPUTE_CONST_PTR_CLASS(INELKInternalKeypointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(std::unique_ptr<INEGEMMWrapperKernel>)
 
 template <>
 TracePoint::Args &&operator<<(TracePoint::Args &&tp, const PaddingType &arg)
diff --git a/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h b/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h
index 59f5c6c6b3..bc592193bf 100644
--- a/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h
+++ b/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Arm Limited.
+ * Copyright (c) 2017-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -64,7 +64,7 @@ inline float32x4x3_t load_matrix_row(const float *ptr, int weights_offset = 0)
  *
  * @return The loaded matrix.
  */
-template < typename T, REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
+template < typename T, ARM_COMPUTE_REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
 inline int32x4x3_t load_matrix_row(const T *ptr, int weights_offset = 0)
 {
     const int32x4_t v_weights_offset = vdupq_n_s32(weights_offset);
@@ -463,7 +463,7 @@ inline void convolve_3x3(const float *in_top, const float *in_mid, const float *
  * @param[in] input_offset Input quantization offset.
  *
  */
-template < typename T, REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
+template < typename T, ARM_COMPUTE_REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
 inline int32x4_t single_convolve_3x3_dilation(const T *in_top, const T *in_mid, const T *in_low,
                                               const int32x4x3_t &m0, const int32x4x3_t &m1, const int32x4x3_t &m2,
                                               size_t dilation_x, int32_t input_offset)
@@ -551,7 +551,7 @@ inline int32x4_t single_convolve_3x3_dilation(const T *in_top, const T *in_mid,
  * @param[in] input_offset Input quantization offset.
  *
  */
-template < typename T, REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
+template < typename T, ARM_COMPUTE_REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
 inline int32x4x2_t convolve_3x3_dilation(const T *in_top, const T *in_mid, const T *in_low, const int32x4x3_t &m0, const int32x4x3_t &m1, const int32x4x3_t &m2,
                                          const size_t dilation_x, unsigned int stridex, int input_offset)
 {
@@ -590,7 +590,7 @@ inline int32x4x2_t convolve_3x3_dilation(const T *in_top, const T *in_mid, const
  * @param[in]  input_offset Input quantization offset.
  *
  */
-template < bool accumulate, typename T1, typename T2, REQUIRES_TA(std::is_same<T1, uint8_t>::value || std::is_same<T1, int8_t>::value) >
+template < bool accumulate, typename T1, typename T2, ARM_COMPUTE_REQUIRES_TA(std::is_same<T1, uint8_t>::value || std::is_same<T1, int8_t>::value) >
 void convolve_3x3(const T1 *in_top, const T1 *in_mid, const T1 *in_low, T2 *out_ptr,
                   const int32x4x3_t &m0, const int32x4x3_t &m1, const int32x4x3_t &m2,
                   unsigned int stridex, int32_t input_offset)
diff --git a/src/core/TracePoint.cpp b/src/core/TracePoint.cpp
index d67faad868..69374fbc8c 100644
--- a/src/core/TracePoint.cpp
+++ b/src/core/TracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -123,150 +123,150 @@ std::string to_ptr_string(const void *arg)
     return ss.str();
 }
 
-TRACE_TO_STRING(ThresholdType)
-TRACE_TO_STRING(IDetectionWindowArray)
-TRACE_TO_STRING(ICoordinates2DArray)
-TRACE_TO_STRING(IMultiImage)
+ARM_COMPUTE_TRACE_TO_STRING(ThresholdType)
+ARM_COMPUTE_TRACE_TO_STRING(IDetectionWindowArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICoordinates2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(IMultiImage)
 using pair_uint = std::pair<unsigned int, unsigned int>;
-TRACE_TO_STRING(pair_uint)
-TRACE_TO_STRING(IKeyPointArray)
-TRACE_TO_STRING(IDistribution1D)
-TRACE_TO_STRING(IHOG)
-TRACE_TO_STRING(ILut)
-TRACE_TO_STRING(IPyramid)
-TRACE_TO_STRING(IMultiHOG)
-TRACE_TO_STRING(ISize2DArray)
-TRACE_TO_STRING(MemoryGroup)
-TRACE_TO_STRING(BoxNMSLimitInfo)
-TRACE_TO_STRING(DepthwiseConvolutionReshapeInfo)
-TRACE_TO_STRING(DWCWeightsKernelInfo)
-TRACE_TO_STRING(DWCKernelInfo)
-TRACE_TO_STRING(GEMMLHSMatrixInfo)
-TRACE_TO_STRING(GEMMRHSMatrixInfo)
-TRACE_TO_STRING(GEMMKernelInfo)
-TRACE_TO_STRING(InstanceNormalizationLayerKernelInfo)
-TRACE_TO_STRING(SoftmaxKernelInfo)
-TRACE_TO_STRING(FuseBatchNormalizationType)
-TRACE_TO_STRING(DirectConvolutionLayerOutputStageKernelInfo)
-TRACE_TO_STRING(FFTScaleKernelInfo)
-TRACE_TO_STRING(GEMMLowpOutputStageInfo)
-TRACE_TO_STRING(FFT1DInfo)
-TRACE_TO_STRING(FFT2DInfo)
-TRACE_TO_STRING(FFTDigitReverseKernelInfo)
-TRACE_TO_STRING(FFTRadixStageKernelInfo)
-TRACE_TO_STRING(IWeightsManager)
-TRACE_TO_STRING(Coordinates2D)
-TRACE_TO_STRING(ITensorInfo)
-TRACE_TO_STRING(InternalKeypoint)
-TRACE_TO_STRING(arm_gemm::Nothing)
-TRACE_TO_STRING(PixelValue)
-TRACE_TO_STRING(std::allocator<ITensor const *>)
+ARM_COMPUTE_TRACE_TO_STRING(pair_uint)
+ARM_COMPUTE_TRACE_TO_STRING(IKeyPointArray)
+ARM_COMPUTE_TRACE_TO_STRING(IDistribution1D)
+ARM_COMPUTE_TRACE_TO_STRING(IHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ILut)
+ARM_COMPUTE_TRACE_TO_STRING(IPyramid)
+ARM_COMPUTE_TRACE_TO_STRING(IMultiHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ISize2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(MemoryGroup)
+ARM_COMPUTE_TRACE_TO_STRING(BoxNMSLimitInfo)
+ARM_COMPUTE_TRACE_TO_STRING(DepthwiseConvolutionReshapeInfo)
+ARM_COMPUTE_TRACE_TO_STRING(DWCWeightsKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(DWCKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMLHSMatrixInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMRHSMatrixInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(InstanceNormalizationLayerKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(SoftmaxKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FuseBatchNormalizationType)
+ARM_COMPUTE_TRACE_TO_STRING(DirectConvolutionLayerOutputStageKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFTScaleKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMLowpOutputStageInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFT1DInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFT2DInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFTDigitReverseKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFTRadixStageKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(IWeightsManager)
+ARM_COMPUTE_TRACE_TO_STRING(Coordinates2D)
+ARM_COMPUTE_TRACE_TO_STRING(ITensorInfo)
+ARM_COMPUTE_TRACE_TO_STRING(InternalKeypoint)
+ARM_COMPUTE_TRACE_TO_STRING(arm_gemm::Nothing)
+ARM_COMPUTE_TRACE_TO_STRING(PixelValue)
+ARM_COMPUTE_TRACE_TO_STRING(std::allocator<ITensor const *>)
 using array_f32 = std::array<float, 9ul>;
-TRACE_TO_STRING(array_f32)
+ARM_COMPUTE_TRACE_TO_STRING(array_f32)
 
-CONST_REF_CLASS(arm_gemm::GemmArgs)
-CONST_REF_CLASS(arm_gemm::Nothing)
-CONST_REF_CLASS(arm_gemm::Activation)
-CONST_REF_CLASS(DirectConvolutionLayerOutputStageKernelInfo)
-CONST_REF_CLASS(GEMMLowpOutputStageInfo)
-CONST_REF_CLASS(DWCWeightsKernelInfo)
-CONST_REF_CLASS(DWCKernelInfo)
-CONST_REF_CLASS(DepthwiseConvolutionReshapeInfo)
-CONST_REF_CLASS(GEMMLHSMatrixInfo)
-CONST_REF_CLASS(GEMMRHSMatrixInfo)
-CONST_REF_CLASS(GEMMKernelInfo)
-CONST_REF_CLASS(InstanceNormalizationLayerKernelInfo)
-CONST_REF_CLASS(SoftmaxKernelInfo)
-CONST_REF_CLASS(PaddingMode)
-CONST_REF_CLASS(Coordinates)
-CONST_REF_CLASS(FFT1DInfo)
-CONST_REF_CLASS(FFT2DInfo)
-CONST_REF_CLASS(FFTDigitReverseKernelInfo)
-CONST_REF_CLASS(FFTRadixStageKernelInfo)
-CONST_REF_CLASS(FFTScaleKernelInfo)
-CONST_REF_CLASS(MemoryGroup)
-CONST_REF_CLASS(IWeightsManager)
-CONST_REF_CLASS(ActivationLayerInfo)
-CONST_REF_CLASS(PoolingLayerInfo)
-CONST_REF_CLASS(PadStrideInfo)
-CONST_REF_CLASS(NormalizationLayerInfo)
-CONST_REF_CLASS(Size2D)
-CONST_REF_CLASS(WeightsInfo)
-CONST_REF_CLASS(GEMMInfo)
-CONST_REF_CLASS(GEMMReshapeInfo)
-CONST_REF_CLASS(Window)
-CONST_REF_CLASS(BorderSize)
-CONST_REF_CLASS(BorderMode)
-CONST_REF_CLASS(PhaseType)
-CONST_REF_CLASS(MagnitudeType)
-CONST_REF_CLASS(Termination)
-CONST_REF_CLASS(ReductionOperation)
-CONST_REF_CLASS(InterpolationPolicy)
-CONST_REF_CLASS(SamplingPolicy)
-CONST_REF_CLASS(DataType)
-CONST_REF_CLASS(DataLayout)
-CONST_REF_CLASS(Channel)
-CONST_REF_CLASS(ConvertPolicy)
-CONST_REF_CLASS(TensorShape)
-CONST_REF_CLASS(PixelValue)
-CONST_REF_CLASS(Strides)
-CONST_REF_CLASS(WinogradInfo)
-CONST_REF_CLASS(RoundingPolicy)
-CONST_REF_CLASS(MatrixPattern)
-CONST_REF_CLASS(NonLinearFilterFunction)
-CONST_REF_CLASS(ThresholdType)
-CONST_REF_CLASS(ROIPoolingLayerInfo)
-CONST_REF_CLASS(BoundingBoxTransformInfo)
-CONST_REF_CLASS(ComparisonOperation)
-CONST_REF_CLASS(ArithmeticOperation)
-CONST_REF_CLASS(BoxNMSLimitInfo)
-CONST_REF_CLASS(FuseBatchNormalizationType)
-CONST_REF_CLASS(ElementWiseUnary)
-CONST_REF_CLASS(ComputeAnchorsInfo)
-CONST_REF_CLASS(PriorBoxLayerInfo)
-CONST_REF_CLASS(DetectionOutputLayerInfo)
-CONST_REF_CLASS(Coordinates2D)
-CONST_REF_CLASS(std::vector<const ITensor *>)
-CONST_REF_CLASS(std::vector<ITensor *>)
-CONST_REF_CLASS(std::vector<pair_uint>)
-CONST_REF_CLASS(pair_uint)
-CONST_REF_CLASS(array_f32)
+ARM_COMPUTE_CONST_REF_CLASS(arm_gemm::GemmArgs)
+ARM_COMPUTE_CONST_REF_CLASS(arm_gemm::Nothing)
+ARM_COMPUTE_CONST_REF_CLASS(arm_gemm::Activation)
+ARM_COMPUTE_CONST_REF_CLASS(DirectConvolutionLayerOutputStageKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMLowpOutputStageInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DWCWeightsKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DWCKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DepthwiseConvolutionReshapeInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMLHSMatrixInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMRHSMatrixInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(InstanceNormalizationLayerKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(SoftmaxKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PaddingMode)
+ARM_COMPUTE_CONST_REF_CLASS(Coordinates)
+ARM_COMPUTE_CONST_REF_CLASS(FFT1DInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFT2DInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFTDigitReverseKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFTRadixStageKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFTScaleKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(MemoryGroup)
+ARM_COMPUTE_CONST_REF_CLASS(IWeightsManager)
+ARM_COMPUTE_CONST_REF_CLASS(ActivationLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PoolingLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PadStrideInfo)
+ARM_COMPUTE_CONST_REF_CLASS(NormalizationLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(Size2D)
+ARM_COMPUTE_CONST_REF_CLASS(WeightsInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMReshapeInfo)
+ARM_COMPUTE_CONST_REF_CLASS(Window)
+ARM_COMPUTE_CONST_REF_CLASS(BorderSize)
+ARM_COMPUTE_CONST_REF_CLASS(BorderMode)
+ARM_COMPUTE_CONST_REF_CLASS(PhaseType)
+ARM_COMPUTE_CONST_REF_CLASS(MagnitudeType)
+ARM_COMPUTE_CONST_REF_CLASS(Termination)
+ARM_COMPUTE_CONST_REF_CLASS(ReductionOperation)
+ARM_COMPUTE_CONST_REF_CLASS(InterpolationPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(SamplingPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(DataType)
+ARM_COMPUTE_CONST_REF_CLASS(DataLayout)
+ARM_COMPUTE_CONST_REF_CLASS(Channel)
+ARM_COMPUTE_CONST_REF_CLASS(ConvertPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(TensorShape)
+ARM_COMPUTE_CONST_REF_CLASS(PixelValue)
+ARM_COMPUTE_CONST_REF_CLASS(Strides)
+ARM_COMPUTE_CONST_REF_CLASS(WinogradInfo)
+ARM_COMPUTE_CONST_REF_CLASS(RoundingPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(MatrixPattern)
+ARM_COMPUTE_CONST_REF_CLASS(NonLinearFilterFunction)
+ARM_COMPUTE_CONST_REF_CLASS(ThresholdType)
+ARM_COMPUTE_CONST_REF_CLASS(ROIPoolingLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(BoundingBoxTransformInfo)
+ARM_COMPUTE_CONST_REF_CLASS(ComparisonOperation)
+ARM_COMPUTE_CONST_REF_CLASS(ArithmeticOperation)
+ARM_COMPUTE_CONST_REF_CLASS(BoxNMSLimitInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FuseBatchNormalizationType)
+ARM_COMPUTE_CONST_REF_CLASS(ElementWiseUnary)
+ARM_COMPUTE_CONST_REF_CLASS(ComputeAnchorsInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PriorBoxLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DetectionOutputLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(Coordinates2D)
+ARM_COMPUTE_CONST_REF_CLASS(std::vector<const ITensor *>)
+ARM_COMPUTE_CONST_REF_CLASS(std::vector<ITensor *>)
+ARM_COMPUTE_CONST_REF_CLASS(std::vector<pair_uint>)
+ARM_COMPUTE_CONST_REF_CLASS(pair_uint)
+ARM_COMPUTE_CONST_REF_CLASS(array_f32)
 
-CONST_PTR_CLASS(ITensor)
-CONST_PTR_CLASS(ITensorInfo)
-CONST_PTR_CLASS(IWeightsManager)
-CONST_PTR_CLASS(InternalKeypoint)
-CONST_PTR_CLASS(IDetectionWindowArray)
-CONST_PTR_CLASS(ICoordinates2DArray)
-CONST_PTR_CLASS(IMultiImage)
-CONST_PTR_CLASS(Window)
-CONST_PTR_CLASS(IKeyPointArray)
-CONST_PTR_CLASS(HOGInfo)
-CONST_PTR_CLASS(IDistribution1D)
-CONST_PTR_CLASS(IHOG)
-CONST_PTR_CLASS(ILut)
-CONST_PTR_CLASS(IPyramid)
-CONST_PTR_CLASS(IMultiHOG)
-CONST_PTR_CLASS(ISize2DArray)
-CONST_PTR_CLASS(std::allocator<ITensor const *>)
-CONST_PTR_CLASS(std::vector<unsigned int>)
+ARM_COMPUTE_CONST_PTR_CLASS(ITensor)
+ARM_COMPUTE_CONST_PTR_CLASS(ITensorInfo)
+ARM_COMPUTE_CONST_PTR_CLASS(IWeightsManager)
+ARM_COMPUTE_CONST_PTR_CLASS(InternalKeypoint)
+ARM_COMPUTE_CONST_PTR_CLASS(IDetectionWindowArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICoordinates2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(IMultiImage)
+ARM_COMPUTE_CONST_PTR_CLASS(Window)
+ARM_COMPUTE_CONST_PTR_CLASS(IKeyPointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(HOGInfo)
+ARM_COMPUTE_CONST_PTR_CLASS(IDistribution1D)
+ARM_COMPUTE_CONST_PTR_CLASS(IHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ILut)
+ARM_COMPUTE_CONST_PTR_CLASS(IPyramid)
+ARM_COMPUTE_CONST_PTR_CLASS(IMultiHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ISize2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(std::allocator<ITensor const *>)
+ARM_COMPUTE_CONST_PTR_CLASS(std::vector<unsigned int>)
 
-CONST_REF_SIMPLE(bool)
-CONST_REF_SIMPLE(uint64_t)
-CONST_REF_SIMPLE(int64_t)
-CONST_REF_SIMPLE(uint32_t)
-CONST_REF_SIMPLE(int32_t)
-CONST_REF_SIMPLE(int16_t)
-CONST_REF_SIMPLE(float)
+ARM_COMPUTE_CONST_REF_SIMPLE(bool)
+ARM_COMPUTE_CONST_REF_SIMPLE(uint64_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(int64_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(uint32_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(int32_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(int16_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(float)
 
-CONST_PTR_ADDRESS(float)
-CONST_PTR_ADDRESS(uint8_t)
-CONST_PTR_ADDRESS(void)
-CONST_PTR_ADDRESS(short)
-CONST_PTR_ADDRESS(int)
-CONST_PTR_ADDRESS(uint64_t)
-CONST_PTR_ADDRESS(uint32_t)
-CONST_PTR_ADDRESS(uint16_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(float)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint8_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(void)
+ARM_COMPUTE_CONST_PTR_ADDRESS(short)
+ARM_COMPUTE_CONST_PTR_ADDRESS(int)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint64_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint32_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint16_t)
 
 template <>
 TracePoint::Args &&operator<<(TracePoint::Args &&tp, const uint16_t &arg)
diff --git a/src/core/utils/helpers/bit_ops.h b/src/core/utils/helpers/bit_ops.h
index ef60214c9f..954fb56460 100644
--- a/src/core/utils/helpers/bit_ops.h
+++ b/src/core/utils/helpers/bit_ops.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2020 Arm Limited.
+ * Copyright (c) 2018-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -41,7 +41,7 @@ namespace bit_ops
  *
  * @return True if the idx-th bit is set else false
  */
-template <typename T, REQUIRES_TA(std::is_integral<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(std::is_integral<T>::value)>
 bool is_bit_set(T v, unsigned int idx)
 {
     return (v & 1 << idx) != 0;
diff --git a/src/runtime/CL/TracePoint.cpp b/src/runtime/CL/TracePoint.cpp
index 9991424ea6..542bb185bc 100644
--- a/src/runtime/CL/TracePoint.cpp
+++ b/src/runtime/CL/TracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -32,10 +32,10 @@
 
 namespace arm_compute
 {
-TRACE_TO_STRING(CLPyramid)
-TRACE_TO_STRING(LSTMParams<ICLTensor>)
-TRACE_TO_STRING(CLCoordinates2DArray)
-CONST_PTR_CLASS(CLPyramid)
-CONST_PTR_CLASS(LSTMParams<ICLTensor>)
-CONST_PTR_CLASS(CLCoordinates2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(CLPyramid)
+ARM_COMPUTE_TRACE_TO_STRING(LSTMParams<ICLTensor>)
+ARM_COMPUTE_TRACE_TO_STRING(CLCoordinates2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(CLPyramid)
+ARM_COMPUTE_CONST_PTR_CLASS(LSTMParams<ICLTensor>)
+ARM_COMPUTE_CONST_PTR_CLASS(CLCoordinates2DArray)
 } // namespace arm_compute
diff --git a/src/runtime/TracePoint.cpp b/src/runtime/TracePoint.cpp
index 6cb672c348..1732df4432 100644
--- a/src/runtime/TracePoint.cpp
+++ b/src/runtime/TracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,17 +33,17 @@
 
 namespace arm_compute
 {
-TRACE_TO_STRING(KeyPointArray)
-TRACE_TO_STRING(Pyramid)
-TRACE_TO_STRING(LSTMParams<ITensor>)
-TRACE_TO_STRING(FullyConnectedLayerInfo)
-TRACE_TO_STRING(arm_gemm::Requantize32)
+ARM_COMPUTE_TRACE_TO_STRING(KeyPointArray)
+ARM_COMPUTE_TRACE_TO_STRING(Pyramid)
+ARM_COMPUTE_TRACE_TO_STRING(LSTMParams<ITensor>)
+ARM_COMPUTE_TRACE_TO_STRING(FullyConnectedLayerInfo)
+ARM_COMPUTE_TRACE_TO_STRING(arm_gemm::Requantize32)
 
-CONST_PTR_CLASS(KeyPointArray)
-CONST_PTR_CLASS(Pyramid)
-CONST_PTR_CLASS(LSTMParams<ITensor>)
-CONST_PTR_CLASS(DetectionPostProcessLayerInfo)
-CONST_PTR_CLASS(FullyConnectedLayerInfo)
-CONST_PTR_CLASS(GenerateProposalsInfo)
-CONST_PTR_CLASS(arm_gemm::Requantize32)
+ARM_COMPUTE_CONST_PTR_CLASS(KeyPointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(Pyramid)
+ARM_COMPUTE_CONST_PTR_CLASS(LSTMParams<ITensor>)
+ARM_COMPUTE_CONST_PTR_CLASS(DetectionPostProcessLayerInfo)
+ARM_COMPUTE_CONST_PTR_CLASS(FullyConnectedLayerInfo)
+ARM_COMPUTE_CONST_PTR_CLASS(GenerateProposalsInfo)
+ARM_COMPUTE_CONST_PTR_CLASS(arm_gemm::Requantize32)
 } // namespace arm_compute
diff --git a/support/Requires.h b/support/Requires.h
index bc4932adc5..21c98ca766 100644
--- a/support/Requires.h
+++ b/support/Requires.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2020 Arm Limited.
+ * Copyright (c) 2018-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -40,9 +40,9 @@ enum class enabler
 } // namespace arm_compute
 
 /** Requirements as template */
-#define REQUIRES_T(...) template <bool Cond = (__VA_ARGS__), typename std::enable_if<Cond, int>::type = 0>
+#define ARM_COMPUTE_REQUIRES_T(...) template <bool Cond = (__VA_ARGS__), typename std::enable_if<Cond, int>::type = 0>
 /** Requirements as template argument */
-#define REQUIRES_TA(...) typename = typename std::enable_if<(__VA_ARGS__), arm_compute::utils::requires::detail::enabler>::type
+#define ARM_COMPUTE_REQUIRES_TA(...) typename = typename std::enable_if<(__VA_ARGS__), arm_compute::utils::requires::detail::enabler>::type
 // clang-format on
 // *INDENT-ON*
 } // namespace requires
diff --git a/support/Rounding.h b/support/Rounding.h
index ba9266d323..47c8f76834 100644
--- a/support/Rounding.h
+++ b/support/Rounding.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2020 Arm Limited.
+ * Copyright (c) 2018-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -57,7 +57,7 @@ enum class RoundingMode
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round_to_zero(T value)
 {
     T res = std::floor(std::fabs(value));
@@ -72,7 +72,7 @@ inline T round_to_zero(T value)
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round_away_from_zero(T value)
 {
     T res = std::ceil(std::fabs(value));
@@ -87,7 +87,7 @@ inline T round_away_from_zero(T value)
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round_half_to_zero(T value)
 {
     T res = T(std::ceil(std::fabs(value) - 0.5f));
@@ -102,7 +102,7 @@ inline T round_half_to_zero(T value)
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round_half_away_from_zero(T value)
 {
     T res = T(std::floor(std::fabs(value) + 0.5f));
@@ -117,7 +117,7 @@ inline T round_half_away_from_zero(T value)
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round_half_up(T value)
 {
     return std::floor(value + 0.5f);
@@ -131,7 +131,7 @@ inline T round_half_up(T value)
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round_half_down(T value)
 {
     return std::ceil(value - 0.5f);
@@ -146,7 +146,7 @@ inline T round_half_down(T value)
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round_half_even(T value, T epsilon = std::numeric_limits<T>::epsilon())
 {
     T positive_value = std::abs(value);
@@ -176,7 +176,7 @@ inline T round_half_even(T value, T epsilon = std::numeric_limits<T>::epsilon())
  *
  * @return Floating-point value of rounded @p value.
  */
-template <typename T, REQUIRES_TA(traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(traits::is_floating_point<T>::value)>
 inline T round(T value, RoundingMode rounding_mode)
 {
     switch(rounding_mode)
diff --git a/tests/validation/NEON/ActivationLayer.cpp b/tests/validation/NEON/ActivationLayer.cpp
index f8f35f0a8e..45e09fb94f 100644
--- a/tests/validation/NEON/ActivationLayer.cpp
+++ b/tests/validation/NEON/ActivationLayer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Arm Limited.
+ * Copyright (c) 2017-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -159,7 +159,7 @@ const auto NeonActivationFunctionsDataset = concat(datasets::ActivationFunctions
 /** Input data sets. */
 const auto ActivationDataset = combine(combine(framework::dataset::make("InPlace", { false, true }), NeonActivationFunctionsDataset), framework::dataset::make("AlphaBeta", { 0.5f, 1.f }));
 
-template <typename T, REQUIRES_TA(arm_compute::utils::traits::is_floating_point<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(arm_compute::utils::traits::is_floating_point<T>::value)>
 void test_float_sqrt_boundary_value()
 {
     constexpr auto vector_size = uint32_t{ 16 };
diff --git a/tests/validation/reference/Convolution3d.h b/tests/validation/reference/Convolution3d.h
index 34e27f499b..1666e3857b 100644
--- a/tests/validation/reference/Convolution3d.h
+++ b/tests/validation/reference/Convolution3d.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Arm Limited.
+ * Copyright (c) 2017-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -95,8 +95,8 @@ inline void convolution3d(const SimpleTensor<T> &in, const SimpleTensor<TW> &wei
 }
 
 // 3D convolution for QASYMM8 type
-template < typename T, typename TW, typename TB, REQUIRES_TA((std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) &&(std::is_same<TW, uint8_t>::value
-                                                             || std::is_same<TW, int8_t>::value)) >
+template < typename T, typename TW, typename TB, ARM_COMPUTE_REQUIRES_TA((std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) &&(std::is_same<TW, uint8_t>::value
+                                                                         || std::is_same<TW, int8_t>::value)) >
 inline void convolution3d(const SimpleTensor<T> &in, const SimpleTensor<TW> &weights, const SimpleTensor<TB> &bias, SimpleTensor<T> &out,
                           int i_offset, int w_offset, int b_offset, int o_offset,
                           int xi, int yi, int width_in, int height_in, int depth_in, int width_weights, int height_weights, int dilation_x = 1, int dilation_y = 1, int filter_id = 0)