Update default C++ standard to C++14

(3RDPARTY_UPDATE)

Resolves: COMPMID-3849

Signed-off-by: Georgios Pinitas <georgios.pinitas@arm.com>
Change-Id: I6369f112337310140e2d6c8e79630cd11138dfa0
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/4544
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Michalis Spyrou <michalis.spyrou@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>

127 files changed, 329 insertions, 467 deletions

diff --git a/src/runtime/CL/CLBufferAllocator.cpp b/src/runtime/CL/CLBufferAllocator.cpp
index 3d380199e5..3673d65111 100644
--- a/src/runtime/CL/CLBufferAllocator.cpp
+++ b/src/runtime/CL/CLBufferAllocator.cpp
@@ -28,7 +28,6 @@
 #include "arm_compute/core/Error.h"
 #include "arm_compute/runtime/CL/CLMemoryRegion.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
-#include "support/MemorySupport.h"
 
 #include <cstddef>
 
@@ -63,6 +62,6 @@ void CLBufferAllocator::free(void *ptr)
 std::unique_ptr<IMemoryRegion> CLBufferAllocator::make_region(size_t size, size_t alignment)
 {
     ARM_COMPUTE_UNUSED(alignment);
-    return arm_compute::support::cpp14::make_unique<CLBufferMemoryRegion>(_ctx, CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE, size);
+    return std::make_unique<CLBufferMemoryRegion>(_ctx, CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE, size);
 }
 } // namespace arm_compute
diff --git a/src/runtime/CL/CLRuntimeContext.cpp b/src/runtime/CL/CLRuntimeContext.cpp
index 571e30931c..9d46126ee4 100644
--- a/src/runtime/CL/CLRuntimeContext.cpp
+++ b/src/runtime/CL/CLRuntimeContext.cpp
@@ -26,12 +26,10 @@
 #include "arm_compute/runtime/CL/CLHelpers.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 CLRuntimeContext::CLRuntimeContext()
-    : _gpu_owned_scheduler(support::cpp14::make_unique<CLScheduler>()), _gpu_scheduler(_gpu_owned_scheduler.get()), _symbols(), _core_context()
+    : _gpu_owned_scheduler(std::make_unique<CLScheduler>()), _gpu_scheduler(_gpu_owned_scheduler.get()), _symbols(), _core_context()
 {
     _symbols.load_default();
     auto ctx_dev_err = create_opencl_context_and_device();
diff --git a/src/runtime/CL/CLTensorAllocator.cpp b/src/runtime/CL/CLTensorAllocator.cpp
index f37fc779fe..fc789fa4b9 100644
--- a/src/runtime/CL/CLTensorAllocator.cpp
+++ b/src/runtime/CL/CLTensorAllocator.cpp
@@ -28,8 +28,6 @@
 #include "arm_compute/runtime/CL/CLRuntimeContext.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 const cl::Buffer CLTensorAllocator::_empty_buffer = cl::Buffer();
@@ -47,20 +45,20 @@ namespace
 std::unique_ptr<ICLMemoryRegion> allocate_region(CLCoreRuntimeContext *ctx, size_t size, cl_uint alignment)
 {
     // Try fine-grain SVM
-    std::unique_ptr<ICLMemoryRegion> region = support::cpp14::make_unique<CLFineSVMMemoryRegion>(ctx,
-                                                                                                 CL_MEM_READ_WRITE | CL_MEM_SVM_FINE_GRAIN_BUFFER,
-                                                                                                 size,
-                                                                                                 alignment);
+    std::unique_ptr<ICLMemoryRegion> region = std::make_unique<CLFineSVMMemoryRegion>(ctx,
+                                                                                      CL_MEM_READ_WRITE | CL_MEM_SVM_FINE_GRAIN_BUFFER,
+                                                                                      size,
+                                                                                      alignment);
 
     // Try coarse-grain SVM in case of failure
     if(region != nullptr && region->ptr() == nullptr)
     {
-        region = support::cpp14::make_unique<CLCoarseSVMMemoryRegion>(ctx, CL_MEM_READ_WRITE, size, alignment);
+        region = std::make_unique<CLCoarseSVMMemoryRegion>(ctx, CL_MEM_READ_WRITE, size, alignment);
     }
     // Try legacy buffer memory in case of failure
     if(region != nullptr && region->ptr() == nullptr)
     {
-        region = support::cpp14::make_unique<CLBufferMemoryRegion>(ctx, CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE, size);
+        region = std::make_unique<CLBufferMemoryRegion>(ctx, CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE, size);
     }
     return region;
 }
@@ -176,11 +174,11 @@ Status CLTensorAllocator::import_memory(cl::Buffer buffer)
     if(_ctx == nullptr)
     {
         auto legacy_ctx = CLCoreRuntimeContext(nullptr, CLScheduler::get().context(), CLScheduler::get().queue());
-        _memory.set_owned_region(support::cpp14::make_unique<CLBufferMemoryRegion>(buffer, &legacy_ctx));
+        _memory.set_owned_region(std::make_unique<CLBufferMemoryRegion>(buffer, &legacy_ctx));
     }
     else
     {
-        _memory.set_owned_region(support::cpp14::make_unique<CLBufferMemoryRegion>(buffer, _ctx->core_runtime_context()));
+        _memory.set_owned_region(std::make_unique<CLBufferMemoryRegion>(buffer, _ctx->core_runtime_context()));
     }
 
     info().set_is_resizable(false);
diff --git a/src/runtime/CL/ICLSimpleFunction.cpp b/src/runtime/CL/ICLSimpleFunction.cpp
index b075aa17e3..4530537789 100644
--- a/src/runtime/CL/ICLSimpleFunction.cpp
+++ b/src/runtime/CL/ICLSimpleFunction.cpp
@@ -28,13 +28,12 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/ICLKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 ICLSimpleFunction::ICLSimpleFunction(CLRuntimeContext *ctx) // NOLINT
     : _kernel(),
-      _border_handler(support::cpp14::make_unique<CLFillBorderKernel>()),
+      _border_handler(std::make_unique<CLFillBorderKernel>()),
       _ctx(ctx)
 {
 }
diff --git a/src/runtime/CL/functions/CLAbsoluteDifference.cpp b/src/runtime/CL/functions/CLAbsoluteDifference.cpp
index b7f40a516c..ff5b0a864d 100644
--- a/src/runtime/CL/functions/CLAbsoluteDifference.cpp
+++ b/src/runtime/CL/functions/CLAbsoluteDifference.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLAbsoluteDifference.h"
 
 #include "src/core/CL/kernels/CLAbsoluteDifferenceKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLAbsoluteDifference::configure(const ICLTensor *input1, const ICLTensor *i
 
 void CLAbsoluteDifference::configure(const CLCompileContext &compile_context, const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLAbsoluteDifferenceKernel>();
+    auto k = std::make_unique<CLAbsoluteDifferenceKernel>();
     k->configure(compile_context, input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLAccumulate.cpp b/src/runtime/CL/functions/CLAccumulate.cpp
index 742de64e34..44020fd816 100644
--- a/src/runtime/CL/functions/CLAccumulate.cpp
+++ b/src/runtime/CL/functions/CLAccumulate.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLAccumulate.h"
 
 #include "src/core/CL/kernels/CLAccumulateKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLAccumulate::configure(const ICLTensor *input, ICLTensor *accum)
 
 void CLAccumulate::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *accum)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLAccumulateKernel>();
+    auto k = std::make_unique<CLAccumulateKernel>();
     k->configure(compile_context, input, accum);
     _kernel = std::move(k);
 }
@@ -49,7 +48,7 @@ void CLAccumulateWeighted::configure(const ICLTensor *input, float alpha, ICLTen
 
 void CLAccumulateWeighted::configure(const CLCompileContext &compile_context, const ICLTensor *input, float alpha, ICLTensor *accum)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLAccumulateWeightedKernel>();
+    auto k = std::make_unique<CLAccumulateWeightedKernel>();
     k->configure(compile_context, input, alpha, accum);
     _kernel = std::move(k);
 }
@@ -61,7 +60,7 @@ void CLAccumulateSquared::configure(const ICLTensor *input, uint32_t shift, ICLT
 
 void CLAccumulateSquared::configure(const CLCompileContext &compile_context, const ICLTensor *input, uint32_t shift, ICLTensor *accum)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLAccumulateSquaredKernel>();
+    auto k = std::make_unique<CLAccumulateSquaredKernel>();
     k->configure(compile_context, input, shift, accum);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLActivationLayer.cpp b/src/runtime/CL/functions/CLActivationLayer.cpp
index 61c82b33eb..0070e43f8c 100644
--- a/src/runtime/CL/functions/CLActivationLayer.cpp
+++ b/src/runtime/CL/functions/CLActivationLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/CL/CLRuntimeContext.h"
 #include "src/core/CL/kernels/CLActivationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -35,7 +34,7 @@ namespace experimental
 {
 void CLActivation::configure(const CLCompileContext &compile_context, ITensorInfo *input, ITensorInfo *output, ActivationLayerInfo act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLActivationLayerKernel>();
+    auto k = std::make_unique<CLActivationLayerKernel>();
     k->configure(compile_context, input, output, act_info);
     _kernel = std::move(k);
 }
@@ -55,7 +54,7 @@ struct CLActivationLayer::Impl
 };
 
 CLActivationLayer::CLActivationLayer(CLRuntimeContext *ctx)
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
     _impl->ctx = ctx;
 }
@@ -78,7 +77,7 @@ void CLActivationLayer::configure(const CLCompileContext &compile_context, ICLTe
     _impl->src = input;
     _impl->dst = output == nullptr ? input : output;
 
-    _impl->op = arm_compute::support::cpp14::make_unique<experimental::CLActivation>();
+    _impl->op = std::make_unique<experimental::CLActivation>();
     _impl->op->configure(compile_context, _impl->src->info(), _impl->dst->info(), act_info);
 }
 
diff --git a/src/runtime/CL/functions/CLArgMinMaxLayer.cpp b/src/runtime/CL/functions/CLArgMinMaxLayer.cpp
index 5fc849e3c5..8c32563abb 100644
--- a/src/runtime/CL/functions/CLArgMinMaxLayer.cpp
+++ b/src/runtime/CL/functions/CLArgMinMaxLayer.cpp
@@ -33,7 +33,6 @@
 #include "src/core/CL/kernels/CLArgMinMaxLayerKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
 #include "src/runtime/Utils.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -132,7 +131,7 @@ void CLArgMinMaxLayer::configure(const CLCompileContext &compile_context, const
 
     auto add_reduction_kernel = [this, &compile_context, axis, op](const ICLTensor * input, const ICLTensor * prev_output, ICLTensor * output)
     {
-        _reduction_kernels_vector.emplace_back(support::cpp14::make_unique<CLArgMinMaxLayerKernel>());
+        _reduction_kernels_vector.emplace_back(std::make_unique<CLArgMinMaxLayerKernel>());
         _reduction_kernels_vector.back()->configure(compile_context, input, prev_output, output, axis, op);
     };
 
diff --git a/src/runtime/CL/functions/CLBatchNormalizationLayer.cpp b/src/runtime/CL/functions/CLBatchNormalizationLayer.cpp
index 77eed1140f..6b76da81c6 100644
--- a/src/runtime/CL/functions/CLBatchNormalizationLayer.cpp
+++ b/src/runtime/CL/functions/CLBatchNormalizationLayer.cpp
@@ -29,14 +29,13 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/Validate.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
-#include "support/MemorySupport.h"
 
 #include "src/core/CL/kernels/CLBatchNormalizationLayerKernel.h"
 
 namespace arm_compute
 {
 CLBatchNormalizationLayer::CLBatchNormalizationLayer()
-    : _norm_kernel(support::cpp14::make_unique<CLBatchNormalizationLayerKernel>())
+    : _norm_kernel(std::make_unique<CLBatchNormalizationLayerKernel>())
 {
 }
 
diff --git a/src/runtime/CL/functions/CLBatchToSpaceLayer.cpp b/src/runtime/CL/functions/CLBatchToSpaceLayer.cpp
index e0a2c430ed..c2fdb74777 100644
--- a/src/runtime/CL/functions/CLBatchToSpaceLayer.cpp
+++ b/src/runtime/CL/functions/CLBatchToSpaceLayer.cpp
@@ -31,12 +31,11 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 
 #include "src/core/CL/kernels/CLBatchToSpaceLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLBatchToSpaceLayer::CLBatchToSpaceLayer()
-    : _batch_to_space_kernel(support::cpp14::make_unique<CLBatchToSpaceLayerKernel>())
+    : _batch_to_space_kernel(std::make_unique<CLBatchToSpaceLayerKernel>())
 {
 }
 
diff --git a/src/runtime/CL/functions/CLBitwiseAnd.cpp b/src/runtime/CL/functions/CLBitwiseAnd.cpp
index cfcd63f170..0f9f68cb9c 100644
--- a/src/runtime/CL/functions/CLBitwiseAnd.cpp
+++ b/src/runtime/CL/functions/CLBitwiseAnd.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLBitwiseAnd.h"
 
 #include "src/core/CL/kernels/CLBitwiseAndKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLBitwiseAnd::configure(const ICLTensor *input1, const ICLTensor *input2, I
 
 void CLBitwiseAnd::configure(const CLCompileContext &compile_context, const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLBitwiseAndKernel>();
+    auto k = std::make_unique<CLBitwiseAndKernel>();
     k->configure(compile_context, input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLBitwiseNot.cpp b/src/runtime/CL/functions/CLBitwiseNot.cpp
index 588c793f6a..cd2384590e 100644
--- a/src/runtime/CL/functions/CLBitwiseNot.cpp
+++ b/src/runtime/CL/functions/CLBitwiseNot.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLBitwiseNot.h"
 
 #include "src/core/CL/kernels/CLBitwiseNotKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLBitwiseNot::configure(const ICLTensor *input, ICLTensor *output)
 
 void CLBitwiseNot::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLBitwiseNotKernel>();
+    auto k = std::make_unique<CLBitwiseNotKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLBitwiseOr.cpp b/src/runtime/CL/functions/CLBitwiseOr.cpp
index 3a5de193a3..38db5f78a0 100644
--- a/src/runtime/CL/functions/CLBitwiseOr.cpp
+++ b/src/runtime/CL/functions/CLBitwiseOr.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLBitwiseOr.h"
 
 #include "src/core/CL/kernels/CLBitwiseOrKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLBitwiseOr::configure(const ICLTensor *input1, const ICLTensor *input2, IC
 
 void CLBitwiseOr::configure(const CLCompileContext &compile_context, const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLBitwiseOrKernel>();
+    auto k = std::make_unique<CLBitwiseOrKernel>();
     k->configure(compile_context, input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLBitwiseXor.cpp b/src/runtime/CL/functions/CLBitwiseXor.cpp
index 62aeaaa31f..e477c3b847 100644
--- a/src/runtime/CL/functions/CLBitwiseXor.cpp
+++ b/src/runtime/CL/functions/CLBitwiseXor.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLBitwiseXor.h"
 
 #include "src/core/CL/kernels/CLBitwiseXorKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLBitwiseXor::configure(const ICLTensor *input1, const ICLTensor *input2, I
 
 void CLBitwiseXor::configure(const CLCompileContext &compile_context, const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLBitwiseXorKernel>();
+    auto k = std::make_unique<CLBitwiseXorKernel>();
     k->configure(compile_context, input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLBoundingBoxTransform.cpp b/src/runtime/CL/functions/CLBoundingBoxTransform.cpp
index 600d36290c..0dade0a369 100644
--- a/src/runtime/CL/functions/CLBoundingBoxTransform.cpp
+++ b/src/runtime/CL/functions/CLBoundingBoxTransform.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLBoundingBoxTransform.h"
 
 #include "src/core/CL/kernels/CLBoundingBoxTransformKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -36,7 +35,7 @@ void CLBoundingBoxTransform::configure(const ICLTensor *boxes, ICLTensor *pred_b
 void CLBoundingBoxTransform::configure(const CLCompileContext &compile_context, const ICLTensor *boxes, ICLTensor *pred_boxes, const ICLTensor *deltas, const BoundingBoxTransformInfo &info)
 {
     // Configure Bounding Box kernel
-    auto k = arm_compute::support::cpp14::make_unique<CLBoundingBoxTransformKernel>();
+    auto k = std::make_unique<CLBoundingBoxTransformKernel>();
     k->configure(compile_context, boxes, pred_boxes, deltas, info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLBox3x3.cpp b/src/runtime/CL/functions/CLBox3x3.cpp
index be40f25055..09e24d1bc0 100644
--- a/src/runtime/CL/functions/CLBox3x3.cpp
+++ b/src/runtime/CL/functions/CLBox3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLBox3x3Kernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ void CLBox3x3::configure(ICLTensor *input, ICLTensor *output, BorderMode border_
 
 void CLBox3x3::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLBox3x3Kernel>();
+    auto k = std::make_unique<CLBox3x3Kernel>();
     k->configure(compile_context, input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, BorderSize(1), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLCannyEdge.cpp b/src/runtime/CL/functions/CLCannyEdge.cpp
index 5a32564d2d..7e99a1bbb3 100644
--- a/src/runtime/CL/functions/CLCannyEdge.cpp
+++ b/src/runtime/CL/functions/CLCannyEdge.cpp
@@ -35,17 +35,16 @@
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLSobel5x5Kernel.h"
 #include "src/core/CL/kernels/CLSobel7x7Kernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLCannyEdge::CLCannyEdge(std::shared_ptr<IMemoryManager> memory_manager) // NOLINT
     : _memory_group(std::move(memory_manager)),
       _sobel(),
-      _gradient(support::cpp14::make_unique<CLGradientKernel>()),
-      _border_mag_gradient(support::cpp14::make_unique<CLFillBorderKernel>()),
-      _non_max_suppr(support::cpp14::make_unique<CLEdgeNonMaxSuppressionKernel>()),
-      _edge_trace(support::cpp14::make_unique<CLEdgeTraceKernel>()),
+      _gradient(std::make_unique<CLGradientKernel>()),
+      _border_mag_gradient(std::make_unique<CLFillBorderKernel>()),
+      _non_max_suppr(std::make_unique<CLEdgeNonMaxSuppressionKernel>()),
+      _edge_trace(std::make_unique<CLEdgeTraceKernel>()),
       _gx(),
       _gy(),
       _mag(),
@@ -123,19 +122,19 @@ void CLCannyEdge::configure(const CLCompileContext &compile_context, ICLTensor *
     // Configure/Init sobelNxN
     if(gradient_size == 3)
     {
-        auto k = arm_compute::support::cpp14::make_unique<CLSobel3x3>();
+        auto k = std::make_unique<CLSobel3x3>();
         k->configure(compile_context, input, &_gx, &_gy, border_mode, constant_border_value);
         _sobel = std::move(k);
     }
     else if(gradient_size == 5)
     {
-        auto k = arm_compute::support::cpp14::make_unique<CLSobel5x5>();
+        auto k = std::make_unique<CLSobel5x5>();
         k->configure(compile_context, input, &_gx, &_gy, border_mode, constant_border_value);
         _sobel = std::move(k);
     }
     else if(gradient_size == 7)
     {
-        auto k = arm_compute::support::cpp14::make_unique<CLSobel7x7>();
+        auto k = std::make_unique<CLSobel7x7>();
         k->configure(compile_context, input, &_gx, &_gy, border_mode, constant_border_value);
         _sobel = std::move(k);
     }
diff --git a/src/runtime/CL/functions/CLCast.cpp b/src/runtime/CL/functions/CLCast.cpp
index 2a28e06845..202140d8b9 100644
--- a/src/runtime/CL/functions/CLCast.cpp
+++ b/src/runtime/CL/functions/CLCast.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLCast.h"
 
 #include "src/core/CL/kernels/CLDepthConvertLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLCast::configure(const ICLTensor *input, ICLTensor *output, ConvertPolicy
 
 void CLCast::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, ConvertPolicy policy)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLDepthConvertLayerKernel>();
+    auto k = std::make_unique<CLDepthConvertLayerKernel>();
     k->configure(compile_context, input, output, policy, 0);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLChannelCombine.cpp b/src/runtime/CL/functions/CLChannelCombine.cpp
index e93aea31f4..543de9c653 100644
--- a/src/runtime/CL/functions/CLChannelCombine.cpp
+++ b/src/runtime/CL/functions/CLChannelCombine.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLChannelCombine.h"
 
 #include "src/core/CL/kernels/CLChannelCombineKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLChannelCombine::configure(const ICLTensor *plane0, const ICLTensor *plane
 
 void CLChannelCombine::configure(const CLCompileContext &compile_context, const ICLTensor *plane0, const ICLTensor *plane1, const ICLTensor *plane2, const ICLTensor *plane3, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLChannelCombineKernel>();
+    auto k = std::make_unique<CLChannelCombineKernel>();
     k->configure(compile_context, plane0, plane1, plane2, plane3, output);
     _kernel = std::move(k);
 }
@@ -49,7 +48,7 @@ void CLChannelCombine::configure(const ICLImage *plane0, const ICLImage *plane1,
 
 void CLChannelCombine::configure(const CLCompileContext &compile_context, const ICLImage *plane0, const ICLImage *plane1, const ICLImage *plane2, ICLMultiImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLChannelCombineKernel>();
+    auto k = std::make_unique<CLChannelCombineKernel>();
     k->configure(compile_context, plane0, plane1, plane2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLChannelExtract.cpp b/src/runtime/CL/functions/CLChannelExtract.cpp
index 8b4a3f7458..645fc051cb 100644
--- a/src/runtime/CL/functions/CLChannelExtract.cpp
+++ b/src/runtime/CL/functions/CLChannelExtract.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLChannelExtract.h"
 
 #include "src/core/CL/kernels/CLChannelExtractKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLChannelExtract::configure(const ICLTensor *input, Channel channel, ICLTen
 
 void CLChannelExtract::configure(const CLCompileContext &compile_context, const ICLTensor *input, Channel channel, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLChannelExtractKernel>();
+    auto k = std::make_unique<CLChannelExtractKernel>();
     k->configure(compile_context, input, channel, output);
     _kernel = std::move(k);
 }
@@ -49,7 +48,7 @@ void CLChannelExtract::configure(const ICLMultiImage *input, Channel channel, IC
 
 void CLChannelExtract::configure(const CLCompileContext &compile_context, const ICLMultiImage *input, Channel channel, ICLImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLChannelExtractKernel>();
+    auto k = std::make_unique<CLChannelExtractKernel>();
     k->configure(compile_context, input, channel, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLChannelShuffleLayer.cpp b/src/runtime/CL/functions/CLChannelShuffleLayer.cpp
index c443df3b37..c6af5a05d5 100644
--- a/src/runtime/CL/functions/CLChannelShuffleLayer.cpp
+++ b/src/runtime/CL/functions/CLChannelShuffleLayer.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLChannelShuffleLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -36,7 +35,7 @@ void CLChannelShuffleLayer::configure(const ICLTensor *input, ICLTensor *output,
 
 void CLChannelShuffleLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, unsigned int num_groups)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLChannelShuffleLayerKernel>();
+    auto k = std::make_unique<CLChannelShuffleLayerKernel>();
     k->configure(compile_context, input, output, num_groups);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLColorConvert.cpp b/src/runtime/CL/functions/CLColorConvert.cpp
index 95f4257929..9aeeb65dc4 100644
--- a/src/runtime/CL/functions/CLColorConvert.cpp
+++ b/src/runtime/CL/functions/CLColorConvert.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLColorConvert.h"
 
 #include "src/core/CL/kernels/CLColorConvertKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLColorConvert::configure(const ICLTensor *input, ICLTensor *output)
 
 void CLColorConvert::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLColorConvertKernel>();
+    auto k = std::make_unique<CLColorConvertKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
@@ -49,7 +48,7 @@ void CLColorConvert::configure(const ICLImage *input, ICLMultiImage *output)
 
 void CLColorConvert::configure(const CLCompileContext &compile_context, const ICLImage *input, ICLMultiImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLColorConvertKernel>();
+    auto k = std::make_unique<CLColorConvertKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
@@ -61,7 +60,7 @@ void CLColorConvert::configure(const ICLMultiImage *input, ICLImage *output)
 
 void CLColorConvert::configure(const CLCompileContext &compile_context, const ICLMultiImage *input, ICLImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLColorConvertKernel>();
+    auto k = std::make_unique<CLColorConvertKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
@@ -73,7 +72,7 @@ void CLColorConvert::configure(const ICLMultiImage *input, ICLMultiImage *output
 
 void CLColorConvert::configure(const CLCompileContext &compile_context, const ICLMultiImage *input, ICLMultiImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLColorConvertKernel>();
+    auto k = std::make_unique<CLColorConvertKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLComparison.cpp b/src/runtime/CL/functions/CLComparison.cpp
index 9b5840aa95..4122928578 100644
--- a/src/runtime/CL/functions/CLComparison.cpp
+++ b/src/runtime/CL/functions/CLComparison.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLComparisonKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -38,7 +37,7 @@ void CLComparison::configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *ou
 
 void CLComparison::configure(const CLCompileContext &compile_context, ICLTensor *input1, ICLTensor *input2, ICLTensor *output, ComparisonOperation operation)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLComparisonKernel>();
+    auto k = std::make_unique<CLComparisonKernel>();
     k->configure(compile_context, input1, input2, output, operation);
     _kernel = std::move(k);
 
@@ -67,7 +66,7 @@ void CLComparisonStatic<COP>::configure(ICLTensor *input1, ICLTensor *input2, IC
 template <ComparisonOperation COP>
 void CLComparisonStatic<COP>::configure(const CLCompileContext &compile_context, ICLTensor *input1, ICLTensor *input2, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLComparisonKernel>();
+    auto k = std::make_unique<CLComparisonKernel>();
     k->configure(compile_context, input1, input2, output, COP);
     _kernel = std::move(k);
 
diff --git a/src/runtime/CL/functions/CLComputeAllAnchors.cpp b/src/runtime/CL/functions/CLComputeAllAnchors.cpp
index 2cae0ee455..5838e32ed8 100644
--- a/src/runtime/CL/functions/CLComputeAllAnchors.cpp
+++ b/src/runtime/CL/functions/CLComputeAllAnchors.cpp
@@ -24,8 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLComputeAllAnchors.h"
 #include "src/core/CL/kernels/CLGenerateProposalsLayerKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 void CLComputeAllAnchors::configure(const ICLTensor *anchors, ICLTensor *all_anchors, const ComputeAnchorsInfo &info)
@@ -36,7 +34,7 @@ void CLComputeAllAnchors::configure(const ICLTensor *anchors, ICLTensor *all_anc
 void CLComputeAllAnchors::configure(const CLCompileContext &compile_context, const ICLTensor *anchors, ICLTensor *all_anchors, const ComputeAnchorsInfo &info)
 {
     // Configure ComputeAllAnchors kernel
-    auto k = arm_compute::support::cpp14::make_unique<CLComputeAllAnchorsKernel>();
+    auto k = std::make_unique<CLComputeAllAnchorsKernel>();
     k->configure(compile_context, anchors, all_anchors, info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLConcatenateLayer.cpp b/src/runtime/CL/functions/CLConcatenateLayer.cpp
index 54f71f9765..0c473a79c8 100644
--- a/src/runtime/CL/functions/CLConcatenateLayer.cpp
+++ b/src/runtime/CL/functions/CLConcatenateLayer.cpp
@@ -37,7 +37,6 @@
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLBatchConcatenateLayerKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -78,7 +77,7 @@ void CLConcatenation::configure(const CLCompileContext &compile_context, const s
                 case 2:
                 {
                     // Configure WidthConcatenate2Tensors kernel
-                    auto kernel = support::cpp14::make_unique<CLWidthConcatenate2TensorsKernel>();
+                    auto kernel = std::make_unique<CLWidthConcatenate2TensorsKernel>();
                     kernel->configure(compile_context, inputs_vector.at(0), inputs_vector.at(1), output);
                     _concat_kernels.emplace_back(std::move(kernel));
                     break;
@@ -86,7 +85,7 @@ void CLConcatenation::configure(const CLCompileContext &compile_context, const s
                 case 4:
                 {
                     // Configure WidthConcatenate4Tensors kernel
-                    auto kernel = support::cpp14::make_unique<CLWidthConcatenate4TensorsKernel>();
+                    auto kernel = std::make_unique<CLWidthConcatenate4TensorsKernel>();
                     kernel->configure(compile_context, inputs_vector.at(0), inputs_vector.at(1), inputs_vector.at(2), inputs_vector.at(3), output);
                     _concat_kernels.emplace_back(std::move(kernel));
                     break;
@@ -96,7 +95,7 @@ void CLConcatenation::configure(const CLCompileContext &compile_context, const s
                     // Configure generic case WidthConcatenate kernels
                     for(unsigned int i = 0; i < _num_inputs; ++i)
                     {
-                        auto kernel = support::cpp14::make_unique<CLWidthConcatenateLayerKernel>();
+                        auto kernel = std::make_unique<CLWidthConcatenateLayerKernel>();
                         kernel->configure(compile_context, inputs_vector.at(i), offset, output);
                         offset += inputs_vector.at(i)->dimension(_axis);
                         _concat_kernels.emplace_back(std::move(kernel));
@@ -110,7 +109,7 @@ void CLConcatenation::configure(const CLCompileContext &compile_context, const s
         {
             for(unsigned int i = 0; i < _num_inputs; ++i)
             {
-                auto kernel = support::cpp14::make_unique<CLHeightConcatenateLayerKernel>();
+                auto kernel = std::make_unique<CLHeightConcatenateLayerKernel>();
                 kernel->configure(compile_context, inputs_vector.at(i), offset, output);
                 offset += inputs_vector.at(i)->dimension(_axis);
                 _concat_kernels.emplace_back(std::move(kernel));
@@ -121,7 +120,7 @@ void CLConcatenation::configure(const CLCompileContext &compile_context, const s
         {
             for(unsigned int i = 0; i < _num_inputs; ++i)
             {
-                auto kernel = support::cpp14::make_unique<CLDepthConcatenateLayerKernel>();
+                auto kernel = std::make_unique<CLDepthConcatenateLayerKernel>();
                 kernel->configure(compile_context, inputs_vector.at(i), offset, output);
                 offset += inputs_vector.at(i)->dimension(_axis);
                 _concat_kernels.emplace_back(std::move(kernel));
@@ -132,7 +131,7 @@ void CLConcatenation::configure(const CLCompileContext &compile_context, const s
         {
             for(unsigned int i = 0; i < _num_inputs; ++i)
             {
-                auto kernel = support::cpp14::make_unique<CLBatchConcatenateLayerKernel>();
+                auto kernel = std::make_unique<CLBatchConcatenateLayerKernel>();
                 kernel->configure(compile_context, inputs_vector.at(i), offset, output);
                 offset += inputs_vector.at(i)->dimension(_axis);
                 _concat_kernels.emplace_back(std::move(kernel));
@@ -263,7 +262,7 @@ struct CLConcatenateLayer::Impl
 };
 
 CLConcatenateLayer::CLConcatenateLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -286,7 +285,7 @@ void CLConcatenateLayer::configure(const CLCompileContext &compile_context, std:
     _impl->dst        = output;
     _impl->axis       = axis;
     _impl->num_inputs = inputs_vector.size();
-    _impl->op         = arm_compute::support::cpp14::make_unique<experimental::CLConcatenation>();
+    _impl->op         = std::make_unique<experimental::CLConcatenation>();
 
     std::vector<ITensorInfo *> inputs_vector_info;
     for(unsigned int i = 0; i < inputs_vector.size(); ++i)
diff --git a/src/runtime/CL/functions/CLConvertFullyConnectedWeights.cpp b/src/runtime/CL/functions/CLConvertFullyConnectedWeights.cpp
index 8ecc114343..bbe9b487e5 100644
--- a/src/runtime/CL/functions/CLConvertFullyConnectedWeights.cpp
+++ b/src/runtime/CL/functions/CLConvertFullyConnectedWeights.cpp
@@ -25,8 +25,6 @@
 #include "src/core/CL/kernels/CLConvertFullyConnectedWeightsKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 void CLConvertFullyConnectedWeights::configure(const ICLTensor *input, ICLTensor *output, const TensorShape &original_input_shape,
@@ -38,7 +36,7 @@ void CLConvertFullyConnectedWeights::configure(const ICLTensor *input, ICLTensor
 void CLConvertFullyConnectedWeights::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, const TensorShape &original_input_shape,
                                                DataLayout data_layout)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLConvertFullyConnectedWeightsKernel>();
+    auto k = std::make_unique<CLConvertFullyConnectedWeightsKernel>();
     k->configure(compile_context, input, output, original_input_shape, data_layout);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLConvolution.cpp b/src/runtime/CL/functions/CLConvolution.cpp
index 1ad32d309c..49dae49146 100644
--- a/src/runtime/CL/functions/CLConvolution.cpp
+++ b/src/runtime/CL/functions/CLConvolution.cpp
@@ -33,7 +33,6 @@
 #include "arm_compute/runtime/ITensorAllocator.h"
 #include "src/core/CL/kernels/CLConvolutionKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -47,7 +46,7 @@ void CLConvolution3x3::configure(ICLTensor *input, ICLTensor *output, const int1
 void CLConvolution3x3::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const int16_t *conv, uint32_t scale, BorderMode border_mode,
                                  uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLConvolution3x3Kernel>();
+    auto k = std::make_unique<CLConvolution3x3Kernel>();
     k->configure(compile_context, input, output, conv, scale, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
@@ -55,9 +54,8 @@ void CLConvolution3x3::configure(const CLCompileContext &compile_context, ICLTen
 
 template <unsigned int matrix_size>
 CLConvolutionSquare<matrix_size>::CLConvolutionSquare(std::shared_ptr<IMemoryManager> memory_manager)
-    : _memory_group(std::move(memory_manager)), _tmp(), _is_separable(false), _kernel_hor(support::cpp14::make_unique<CLSeparableConvolutionHorKernel<matrix_size>>()),
-      _kernel_vert(support::cpp14::make_unique<CLSeparableConvolutionVertKernel<matrix_size>>()), _kernel(support::cpp14::make_unique<CLConvolutionKernel<matrix_size>>()),
-      _border_handler(support::cpp14::make_unique<CLFillBorderKernel>())
+    : _memory_group(std::move(memory_manager)), _tmp(), _is_separable(false), _kernel_hor(std::make_unique<CLSeparableConvolutionHorKernel<matrix_size>>()),
+      _kernel_vert(std::make_unique<CLSeparableConvolutionVertKernel<matrix_size>>()), _kernel(std::make_unique<CLConvolutionKernel<matrix_size>>()), _border_handler(std::make_unique<CLFillBorderKernel>())
 {
 }
 
@@ -138,7 +136,7 @@ void CLConvolutionRectangle::configure(ICLTensor *input, ICLTensor *output, cons
 void CLConvolutionRectangle::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const int16_t *conv, uint32_t rows, uint32_t cols, uint32_t scale,
                                        BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLConvolutionRectangleKernel>();
+    auto k = std::make_unique<CLConvolutionRectangleKernel>();
     k->configure(compile_context, input, output, conv, rows, cols, scale, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLConvolutionLayer.cpp b/src/runtime/CL/functions/CLConvolutionLayer.cpp
index e214bdf0f2..edd9298d26 100644
--- a/src/runtime/CL/functions/CLConvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLConvolutionLayer.cpp
@@ -29,7 +29,6 @@
 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
 #include "arm_compute/core/utils/quantization/AsymmHelpers.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 #include <memory>
@@ -66,7 +65,7 @@ void CLConvolutionLayer::configure(const CLCompileContext &compile_context, ICLT
         case ConvolutionMethod::WINOGRAD:
         {
             ARM_COMPUTE_ERROR_ON(num_groups != 1);
-            auto f = arm_compute::support::cpp14::make_unique<CLWinogradConvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<CLWinogradConvolutionLayer>(_memory_manager);
             f->configure(compile_context, input, weights, biases, output, conv_info, act_info, enable_fast_math);
             _function = std::move(f);
             break;
@@ -74,21 +73,21 @@ void CLConvolutionLayer::configure(const CLCompileContext &compile_context, ICLT
         case ConvolutionMethod::DIRECT:
         {
             ARM_COMPUTE_ERROR_ON(num_groups != 1);
-            auto f = arm_compute::support::cpp14::make_unique<CLDirectConvolutionLayer>();
+            auto f = std::make_unique<CLDirectConvolutionLayer>();
             f->configure(compile_context, input, weights, biases, output, conv_info, act_info);
             _function = std::move(f);
             break;
         }
         case ConvolutionMethod::GEMM:
         {
-            auto f = arm_compute::support::cpp14::make_unique<CLGEMMConvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<CLGEMMConvolutionLayer>(_memory_manager);
             f->configure(compile_context, input, weights, biases, output, conv_info, weights_info, dilation, act_info, num_groups);
             _function = std::move(f);
             break;
         }
         case ConvolutionMethod::FFT:
         {
-            auto f = arm_compute::support::cpp14::make_unique<CLFFTConvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<CLFFTConvolutionLayer>(_memory_manager);
             f->configure(compile_context, input, weights, biases, output, conv_info, act_info);
             _function = std::move(f);
             break;
diff --git a/src/runtime/CL/functions/CLCopy.cpp b/src/runtime/CL/functions/CLCopy.cpp
index f7b016a779..c3e30ada6e 100644
--- a/src/runtime/CL/functions/CLCopy.cpp
+++ b/src/runtime/CL/functions/CLCopy.cpp
@@ -29,7 +29,6 @@
 #include "arm_compute/core/TensorInfo.h"
 #include "arm_compute/core/Validate.h"
 #include "src/core/CL/kernels/CLCopyKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -42,7 +41,7 @@ void CLCopy::configure(ICLTensor *input, ICLTensor *output)
 
 void CLCopy::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLCopyKernel>();
+    auto k = std::make_unique<CLCopyKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLCropResize.cpp b/src/runtime/CL/functions/CLCropResize.cpp
index 4aaa674c5c..ed31446cf9 100644
--- a/src/runtime/CL/functions/CLCropResize.cpp
+++ b/src/runtime/CL/functions/CLCropResize.cpp
@@ -32,8 +32,6 @@
 #include "src/core/helpers/AutoConfiguration.h"
 #include "src/core/helpers/WindowHelpers.h"
 
-#include "support/MemorySupport.h"
-
 #include <cstddef>
 
 namespace arm_compute
@@ -126,13 +124,13 @@ void CLCropResize::configure(const CLCompileContext &compile_context, const ICLT
     _box_ind->map(CLScheduler::get().queue());
     for(unsigned int num_box = 0; num_box < _num_boxes; ++num_box)
     {
-        auto       crop_tensor = support::cpp14::make_unique<CLTensor>();
+        auto       crop_tensor = std::make_unique<CLTensor>();
         TensorInfo crop_result_info(1, DataType::F32);
         crop_result_info.set_data_layout(DataLayout::NHWC);
         crop_tensor->allocator()->init(crop_result_info);
         _crop_results.emplace_back(std::move(crop_tensor));
 
-        auto       scale_tensor = support::cpp14::make_unique<CLTensor>();
+        auto       scale_tensor = std::make_unique<CLTensor>();
         TensorInfo scaled_result_info(out_shape, 1, DataType::F32);
         scaled_result_info.set_data_layout(DataLayout::NHWC);
         scale_tensor->allocator()->init(scaled_result_info);
@@ -144,14 +142,14 @@ void CLCropResize::configure(const CLCompileContext &compile_context, const ICLT
         Coordinates end{};
         configure_crop(_input, _boxes, _box_ind, _crop_results[num_box].get(), num_box, start, end, batch_index);
 
-        auto scale_kernel = support::cpp14::make_unique<CLScale>();
+        auto scale_kernel = std::make_unique<CLScale>();
         scale_kernel->configure(compile_context, _crop_results[num_box].get(), _scaled_results[num_box].get(), ScaleKernelInfo{ _method, BorderMode::CONSTANT, PixelValue(_extrapolation_value), SamplingPolicy::TOP_LEFT });
         _scale.emplace_back(std::move(scale_kernel));
 
         Window win = calculate_max_window(*_output->info());
         win.set(3, Window::Dimension(num_box, num_box + 1, 1));
 
-        auto copy_kernel = support::cpp14::make_unique<CLCopyKernel>();
+        auto copy_kernel = std::make_unique<CLCopyKernel>();
         copy_kernel->configure(compile_context, _scaled_results[num_box].get(), _output, &win);
         _copy.emplace_back(std::move(copy_kernel));
 
@@ -209,7 +207,7 @@ void CLCropResize::configure(const CLCompileContext &compile_context, const ICLT
         {
             Window slice_fill_rows_before(full_window);
             slice_fill_rows_before.set(2, Window::Dimension(0, rows_out_of_bounds[0], 1));
-            auto kernel = arm_compute::support::cpp14::make_unique<CLMemsetKernel>();
+            auto kernel = std::make_unique<CLMemsetKernel>();
             kernel->configure(compile_context, _crop_results[num_box].get(), extrapolation_value, &slice_fill_rows_before);
             _internal_kernels.push_back(std::move(kernel));
         }
@@ -226,7 +224,7 @@ void CLCropResize::configure(const CLCompileContext &compile_context, const ICLT
             {
                 Window slice_fill_cols_before(slice_in);
                 slice_fill_cols_before.set(1, Window::Dimension(0, cols_out_of_bounds[0], 1));
-                auto kernel = arm_compute::support::cpp14::make_unique<CLMemsetKernel>();
+                auto kernel = std::make_unique<CLMemsetKernel>();
                 kernel->configure(compile_context, _crop_results[num_box].get(), extrapolation_value, &slice_fill_cols_before);
                 _internal_kernels.push_back(std::move(kernel));
             }
@@ -235,7 +233,7 @@ void CLCropResize::configure(const CLCompileContext &compile_context, const ICLT
             {
                 Window slice_fill_cols_after(slice_in);
                 slice_fill_cols_after.set(1, Window::Dimension(_crop_results[num_box].get()->info()->dimension(1) - cols_out_of_bounds[1], _crop_results[num_box].get()->info()->dimension(1), 1));
-                auto kernel = arm_compute::support::cpp14::make_unique<CLMemsetKernel>();
+                auto kernel = std::make_unique<CLMemsetKernel>();
                 kernel->configure(compile_context, _crop_results[num_box].get(), extrapolation_value, &slice_fill_cols_after);
                 _internal_kernels.push_back(std::move(kernel));
             }
@@ -248,7 +246,7 @@ void CLCropResize::configure(const CLCompileContext &compile_context, const ICLT
                                         is_height_flipped ? start[1] - rows_out_of_bounds[0] : start[1] + rows_out_of_bounds[0] };
                 Coordinates2D end_in{ is_width_flipped ? start_in.x - cols_in_bounds + 1 : start_in.x + cols_in_bounds - 1,
                                       is_height_flipped ? start_in.y - rows_in_bounds + 1 : start_in.y + rows_in_bounds - 1 };
-                auto kernel = arm_compute::support::cpp14::make_unique<CLCropKernel>();
+                auto kernel = std::make_unique<CLCropKernel>();
 
                 kernel->configure(compile_context, _input, _crop_results[num_box].get(), start_in, end_in, batch_index, extrapolation_value, &slice_in);
                 _internal_kernels.push_back(std::move(kernel));
@@ -260,7 +258,7 @@ void CLCropResize::configure(const CLCompileContext &compile_context, const ICLT
         {
             Window slice_fill_rows_after(full_window);
             slice_fill_rows_after.set(2, Window::Dimension(_crop_results[num_box].get()->info()->dimension(2) - rows_out_of_bounds[1], _crop_results[num_box].get()->info()->dimension(2), 1));
-            auto kernel = arm_compute::support::cpp14::make_unique<CLMemsetKernel>();
+            auto kernel = std::make_unique<CLMemsetKernel>();
             kernel->configure(compile_context, _crop_results[num_box].get(), extrapolation_value, &slice_fill_rows_after);
             _internal_kernels.push_back(std::move(kernel));
         }
diff --git a/src/runtime/CL/functions/CLDeconvolutionLayer.cpp b/src/runtime/CL/functions/CLDeconvolutionLayer.cpp
index 6fe231ea6c..75f34cc5ee 100644
--- a/src/runtime/CL/functions/CLDeconvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLDeconvolutionLayer.cpp
@@ -28,7 +28,6 @@
 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
 #include "arm_compute/core/utils/quantization/AsymmHelpers.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 #include <memory>
@@ -57,14 +56,14 @@ void CLDeconvolutionLayer::configure(const CLCompileContext &compile_context, IC
     {
         case DeconvolutionMethod::DIRECT:
         {
-            auto f = arm_compute::support::cpp14::make_unique<CLDirectDeconvolutionLayer>();
+            auto f = std::make_unique<CLDirectDeconvolutionLayer>();
             f->configure(compile_context, input, weights, bias, output, deconv_info, weights_info);
             _function = std::move(f);
             break;
         }
         case DeconvolutionMethod::GEMM:
         {
-            auto f = arm_compute::support::cpp14::make_unique<CLGEMMDeconvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<CLGEMMDeconvolutionLayer>(_memory_manager);
             f->configure(compile_context, input, weights, bias, output, deconv_info);
             _function = std::move(f);
             break;
diff --git a/src/runtime/CL/functions/CLDeconvolutionLayerUpsample.cpp b/src/runtime/CL/functions/CLDeconvolutionLayerUpsample.cpp
index 0cf2ea623f..4989f6460d 100644
--- a/src/runtime/CL/functions/CLDeconvolutionLayerUpsample.cpp
+++ b/src/runtime/CL/functions/CLDeconvolutionLayerUpsample.cpp
@@ -29,13 +29,12 @@
 #include "arm_compute/runtime/CL/CLTensor.h"
 #include "src/core/CL/kernels/CLDeconvolutionLayerUpsampleKernel.h"
 #include "src/core/CL/kernels/CLMemsetKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLDeconvolutionLayerUpsample::CLDeconvolutionLayerUpsample() // NOLINT
-    : _upsample(support::cpp14::make_unique<CLDeconvolutionLayerUpsampleKernel>()),
-      _memset(support::cpp14::make_unique<CLMemsetKernel>()),
+    : _upsample(std::make_unique<CLDeconvolutionLayerUpsampleKernel>()),
+      _memset(std::make_unique<CLMemsetKernel>()),
       _output(nullptr)
 {
 }
diff --git a/src/runtime/CL/functions/CLDepthConvertLayer.cpp b/src/runtime/CL/functions/CLDepthConvertLayer.cpp
index e58c0e5f4c..47bc52364d 100644
--- a/src/runtime/CL/functions/CLDepthConvertLayer.cpp
+++ b/src/runtime/CL/functions/CLDepthConvertLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLDepthConvertLayer.h"
 
 #include "src/core/CL/kernels/CLDepthConvertLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLDepthConvertLayer::configure(const ICLTensor *input, ICLTensor *output, C
 
 void CLDepthConvertLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, ConvertPolicy policy, uint32_t shift)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLDepthConvertLayerKernel>();
+    auto k = std::make_unique<CLDepthConvertLayerKernel>();
     k->configure(compile_context, input, output, policy, shift);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLDepthToSpaceLayer.cpp b/src/runtime/CL/functions/CLDepthToSpaceLayer.cpp
index 8dbd974ceb..bd2303c410 100644
--- a/src/runtime/CL/functions/CLDepthToSpaceLayer.cpp
+++ b/src/runtime/CL/functions/CLDepthToSpaceLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLDepthToSpaceLayer.h"
 
 #include "src/core/CL/kernels/CLDepthToSpaceLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLDepthToSpaceLayer::configure(const ICLTensor *input, ICLTensor *output, i
 
 void CLDepthToSpaceLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, int32_t block_shape)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLDepthToSpaceLayerKernel>();
+    auto k = std::make_unique<CLDepthToSpaceLayerKernel>();
     k->configure(compile_context, input, output, block_shape);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLDepthwiseConvolutionLayer.cpp b/src/runtime/CL/functions/CLDepthwiseConvolutionLayer.cpp
index 2440384e3b..8d2c81bc15 100644
--- a/src/runtime/CL/functions/CLDepthwiseConvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLDepthwiseConvolutionLayer.cpp
@@ -37,7 +37,6 @@
 #include "src/core/CL/kernels/CLDepthwiseConvolutionLayerReshapeWeightsKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/ICLDepthwiseConvolutionLayer3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -125,7 +124,7 @@ Status validate_arguments_3x3(const ITensorInfo *input, const ITensorInfo *weigh
 
 CLDepthwiseConvolutionLayer::CLDepthwiseConvolutionLayerGeneric::CLDepthwiseConvolutionLayerGeneric(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _dwc_native_kernel(support::cpp14::make_unique<CLDepthwiseConvolutionLayerNativeKernel>()),
+      _dwc_native_kernel(std::make_unique<CLDepthwiseConvolutionLayerNativeKernel>()),
       _permute_input_to_nhwc(),
       _permute_weights_to_nhwc(),
       _permute_output_to_nchw(),
@@ -351,11 +350,11 @@ void CLDepthwiseConvolutionLayer::CLDepthwiseConvolutionLayerGeneric::prepare()
 CLDepthwiseConvolutionLayer::CLDepthwiseConvolutionLayerInternal3x3::CLDepthwiseConvolutionLayerInternal3x3(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
       _kernel(nullptr),
-      _border_handler(support::cpp14::make_unique<CLFillBorderKernel>()),
+      _border_handler(std::make_unique<CLFillBorderKernel>()),
       _permute_input_to_nchw(),
       _permute_weights_to_nchw(),
       _permute_output_to_nhwc(),
-      _reshape_weights(support::cpp14::make_unique<CLDepthwiseConvolutionLayerReshapeWeightsKernel>()),
+      _reshape_weights(std::make_unique<CLDepthwiseConvolutionLayerReshapeWeightsKernel>()),
       _permuted_input(),
       _permuted_weights(),
       _permuted_output(),
@@ -436,7 +435,7 @@ void CLDepthwiseConvolutionLayer::CLDepthwiseConvolutionLayerInternal3x3::config
         weights_to_use = &_permuted_weights;
         output_to_use  = &_permuted_output;
 
-        _kernel = arm_compute::support::cpp14::make_unique<CLDepthwiseConvolutionLayer3x3NCHWKernel>();
+        _kernel = std::make_unique<CLDepthwiseConvolutionLayer3x3NCHWKernel>();
     }
     else if(is_nhwc)
     {
@@ -445,11 +444,11 @@ void CLDepthwiseConvolutionLayer::CLDepthwiseConvolutionLayerInternal3x3::config
             _reshape_weights->configure(compile_context, weights, &_permuted_weights, info);
             weights_to_use = &_permuted_weights;
         }
-        _kernel = arm_compute::support::cpp14::make_unique<CLDepthwiseConvolutionLayer3x3NHWCKernel>();
+        _kernel = std::make_unique<CLDepthwiseConvolutionLayer3x3NHWCKernel>();
     }
     else
     {
-        _kernel = arm_compute::support::cpp14::make_unique<CLDepthwiseConvolutionLayer3x3NCHWKernel>();
+        _kernel = std::make_unique<CLDepthwiseConvolutionLayer3x3NCHWKernel>();
     }
 
     CLTensor *output_multipliers_to_use = nullptr;
diff --git a/src/runtime/CL/functions/CLDequantizationLayer.cpp b/src/runtime/CL/functions/CLDequantizationLayer.cpp
index 6d63463906..d358813724 100644
--- a/src/runtime/CL/functions/CLDequantizationLayer.cpp
+++ b/src/runtime/CL/functions/CLDequantizationLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLDequantizationLayer.h"
 
 #include "src/core/CL/kernels/CLDequantizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -35,7 +34,7 @@ void CLDequantizationLayer::configure(const ICLTensor *input, ICLTensor *output)
 
 void CLDequantizationLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLDequantizationLayerKernel>();
+    auto k = std::make_unique<CLDequantizationLayerKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLDerivative.cpp b/src/runtime/CL/functions/CLDerivative.cpp
index a2b883ad28..2e3ecf7700 100644
--- a/src/runtime/CL/functions/CLDerivative.cpp
+++ b/src/runtime/CL/functions/CLDerivative.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLDerivativeKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ void CLDerivative::configure(ICLTensor *input, ICLTensor *output_x, ICLTensor *o
 
 void CLDerivative::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output_x, ICLTensor *output_y, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLDerivativeKernel>();
+    auto k = std::make_unique<CLDerivativeKernel>();
     k->configure(compile_context, input, output_x, output_y, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, BorderSize(1), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLDilate.cpp b/src/runtime/CL/functions/CLDilate.cpp
index c3d5f8845f..92c5cc7ab1 100644
--- a/src/runtime/CL/functions/CLDilate.cpp
+++ b/src/runtime/CL/functions/CLDilate.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLDilateKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ void CLDilate::configure(ICLTensor *input, ICLTensor *output, BorderMode border_
 
 void CLDilate::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLDilateKernel>();
+    auto k = std::make_unique<CLDilateKernel>();
     k->configure(compile_context, input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, BorderSize(1), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLDirectConvolutionLayer.cpp b/src/runtime/CL/functions/CLDirectConvolutionLayer.cpp
index bff882c28b..49e97693e4 100644
--- a/src/runtime/CL/functions/CLDirectConvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLDirectConvolutionLayer.cpp
@@ -30,12 +30,11 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLDirectConvolutionLayerKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLDirectConvolutionLayer::CLDirectConvolutionLayer()
-    : _direct_conv_kernel(support::cpp14::make_unique<CLDirectConvolutionLayerKernel>()), _input_border_handler(support::cpp14::make_unique<CLFillBorderKernel>()), _activationlayer_function(),
+    : _direct_conv_kernel(std::make_unique<CLDirectConvolutionLayerKernel>()), _input_border_handler(std::make_unique<CLFillBorderKernel>()), _activationlayer_function(),
       _is_activationlayer_enabled(false)
 {
 }
diff --git a/src/runtime/CL/functions/CLElementWiseUnaryLayer.cpp b/src/runtime/CL/functions/CLElementWiseUnaryLayer.cpp
index 35ed97d381..0ded640f51 100644
--- a/src/runtime/CL/functions/CLElementWiseUnaryLayer.cpp
+++ b/src/runtime/CL/functions/CLElementWiseUnaryLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLElementWiseUnaryLayer.h"
 
 #include "src/core/CL/kernels/CLElementWiseUnaryLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ namespace experimental
 {
 void CLRsqrt::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::RSQRT);
     _kernel = std::move(k);
 }
@@ -46,7 +45,7 @@ Status CLRsqrt::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void CLExp::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::EXP);
     _kernel = std::move(k);
 }
@@ -58,7 +57,7 @@ Status CLExp::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void CLNeg::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::NEG);
     _kernel = std::move(k);
 }
@@ -70,7 +69,7 @@ Status CLNeg::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void CLSin::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::SIN);
     _kernel = std::move(k);
 }
@@ -82,7 +81,7 @@ Status CLSin::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void CLAbs::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::ABS);
     _kernel = std::move(k);
 }
@@ -94,7 +93,7 @@ Status CLAbs::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void CLLog::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::LOG);
     _kernel = std::move(k);
 }
@@ -106,7 +105,7 @@ Status CLLog::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void CLRound::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::ROUND);
     _kernel = std::move(k);
 }
@@ -125,7 +124,7 @@ struct CLRsqrtLayer::Impl
 };
 
 CLRsqrtLayer::CLRsqrtLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -142,7 +141,7 @@ void CLRsqrtLayer::configure(const CLCompileContext &compile_context, const ICLT
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLRsqrt>();
+    _impl->op  = std::make_unique<experimental::CLRsqrt>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 
@@ -167,7 +166,7 @@ struct CLExpLayer::Impl
 };
 
 CLExpLayer::CLExpLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -184,7 +183,7 @@ void CLExpLayer::configure(const CLCompileContext &compile_context, const ICLTen
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLExp>();
+    _impl->op  = std::make_unique<experimental::CLExp>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 
@@ -209,7 +208,7 @@ struct CLNegLayer::Impl
 };
 
 CLNegLayer::CLNegLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -226,7 +225,7 @@ void CLNegLayer::configure(const CLCompileContext &compile_context, const ICLTen
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLNeg>();
+    _impl->op  = std::make_unique<experimental::CLNeg>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 Status CLNegLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
@@ -250,7 +249,7 @@ struct CLSinLayer::Impl
 };
 
 CLSinLayer::CLSinLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -267,7 +266,7 @@ void CLSinLayer::configure(const CLCompileContext &compile_context, const ICLTen
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLSin>();
+    _impl->op  = std::make_unique<experimental::CLSin>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 Status CLSinLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
@@ -291,7 +290,7 @@ struct CLAbsLayer::Impl
 };
 
 CLAbsLayer::CLAbsLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -308,7 +307,7 @@ void CLAbsLayer::configure(const CLCompileContext &compile_context, const ICLTen
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLAbs>();
+    _impl->op  = std::make_unique<experimental::CLAbs>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 Status CLAbsLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
@@ -332,7 +331,7 @@ struct CLLogLayer::Impl
 };
 
 CLLogLayer::CLLogLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -349,7 +348,7 @@ void CLLogLayer::configure(const CLCompileContext &compile_context, const ICLTen
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLLog>();
+    _impl->op  = std::make_unique<experimental::CLLog>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 Status CLLogLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
@@ -373,7 +372,7 @@ struct CLRoundLayer::Impl
 };
 
 CLRoundLayer::CLRoundLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -390,7 +389,7 @@ void CLRoundLayer::configure(const CLCompileContext &compile_context, const ICLT
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLRound>();
+    _impl->op  = std::make_unique<experimental::CLRound>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 Status CLRoundLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
diff --git a/src/runtime/CL/functions/CLElementwiseOperations.cpp b/src/runtime/CL/functions/CLElementwiseOperations.cpp
index 736cf973a1..a72e957fe6 100644
--- a/src/runtime/CL/functions/CLElementwiseOperations.cpp
+++ b/src/runtime/CL/functions/CLElementwiseOperations.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLElementwiseOperationKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -40,7 +39,7 @@ CLArithmeticAddition::CLArithmeticAddition()
 
 void CLArithmeticAddition::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, ConvertPolicy policy, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLSaturatedArithmeticOperationKernel>();
+    auto k = std::make_unique<CLSaturatedArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::ADD, input1, input2, output, policy, act_info);
     _kernel = std::move(k);
 }
@@ -61,7 +60,7 @@ CLArithmeticSubtraction::CLArithmeticSubtraction()
 void CLArithmeticSubtraction::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, ConvertPolicy policy,
                                         const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLSaturatedArithmeticOperationKernel>();
+    auto k = std::make_unique<CLSaturatedArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::SUB, input1, input2, output, policy, act_info);
     _kernel = std::move(k);
 }
@@ -83,7 +82,7 @@ CLArithmeticDivision::CLArithmeticDivision()
 
 void CLArithmeticDivision::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLArithmeticOperationKernel>();
+    auto k = std::make_unique<CLArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::DIV, input1, input2, output, act_info);
     _kernel = std::move(k);
 }
@@ -104,7 +103,7 @@ CLElementwiseMax::CLElementwiseMax()
 
 void CLElementwiseMax::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLArithmeticOperationKernel>();
+    auto k = std::make_unique<CLArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::MAX, input1, input2, output, act_info);
     _kernel = std::move(k);
 }
@@ -125,7 +124,7 @@ CLElementwiseMin::CLElementwiseMin()
 
 void CLElementwiseMin::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLArithmeticOperationKernel>();
+    auto k = std::make_unique<CLArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::MIN, input1, input2, output, act_info);
     _kernel = std::move(k);
 }
@@ -146,7 +145,7 @@ CLElementwiseSquaredDiff::CLElementwiseSquaredDiff()
 
 void CLElementwiseSquaredDiff::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLArithmeticOperationKernel>();
+    auto k = std::make_unique<CLArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::SQUARED_DIFF, input1, input2, output, act_info);
     _kernel = std::move(k);
 }
@@ -167,7 +166,7 @@ CLElementwisePower::CLElementwisePower()
 
 void CLElementwisePower::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLArithmeticOperationKernel>();
+    auto k = std::make_unique<CLArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::POWER, input1, input2, output, act_info);
     _kernel = std::move(k);
 }
@@ -192,7 +191,7 @@ struct CLArithmeticAddition::Impl
 };
 
 CLArithmeticAddition::CLArithmeticAddition()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLArithmeticAddition::CLArithmeticAddition(CLArithmeticAddition &&) = default;
@@ -210,7 +209,7 @@ void CLArithmeticAddition::configure(const CLCompileContext &compile_context, co
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLArithmeticAddition>();
+    _impl->op    = std::make_unique<experimental::CLArithmeticAddition>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), policy, act_info);
 }
 
@@ -238,7 +237,7 @@ struct CLArithmeticSubtraction::Impl
 };
 
 CLArithmeticSubtraction::CLArithmeticSubtraction()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLArithmeticSubtraction::CLArithmeticSubtraction(CLArithmeticSubtraction &&) = default;
@@ -256,7 +255,7 @@ void CLArithmeticSubtraction::configure(const CLCompileContext &compile_context,
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLArithmeticSubtraction>();
+    _impl->op    = std::make_unique<experimental::CLArithmeticSubtraction>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), policy, act_info);
 }
 
@@ -284,7 +283,7 @@ struct CLArithmeticDivision::Impl
 };
 
 CLArithmeticDivision::CLArithmeticDivision()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLArithmeticDivision::CLArithmeticDivision(CLArithmeticDivision &&) = default;
@@ -301,7 +300,7 @@ void CLArithmeticDivision::configure(const CLCompileContext &compile_context, co
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLArithmeticDivision>();
+    _impl->op    = std::make_unique<experimental::CLArithmeticDivision>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), act_info);
 }
 
@@ -329,7 +328,7 @@ struct CLElementwiseMax::Impl
 };
 
 CLElementwiseMax::CLElementwiseMax()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLElementwiseMax::CLElementwiseMax(CLElementwiseMax &&) = default;
@@ -346,7 +345,7 @@ void CLElementwiseMax::configure(const CLCompileContext &compile_context, ICLTen
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLElementwiseMax>();
+    _impl->op    = std::make_unique<experimental::CLElementwiseMax>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), act_info);
 }
 
@@ -374,7 +373,7 @@ struct CLElementwiseMin::Impl
 };
 
 CLElementwiseMin::CLElementwiseMin()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLElementwiseMin::CLElementwiseMin(CLElementwiseMin &&) = default;
@@ -391,7 +390,7 @@ void CLElementwiseMin::configure(const CLCompileContext &compile_context, ICLTen
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLElementwiseMin>();
+    _impl->op    = std::make_unique<experimental::CLElementwiseMin>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), act_info);
 }
 
@@ -419,7 +418,7 @@ struct CLElementwiseSquaredDiff::Impl
 };
 
 CLElementwiseSquaredDiff::CLElementwiseSquaredDiff()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLElementwiseSquaredDiff::CLElementwiseSquaredDiff(CLElementwiseSquaredDiff &&) = default;
@@ -436,7 +435,7 @@ void CLElementwiseSquaredDiff::configure(const CLCompileContext &compile_context
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLElementwiseSquaredDiff>();
+    _impl->op    = std::make_unique<experimental::CLElementwiseSquaredDiff>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), act_info);
 }
 
@@ -464,7 +463,7 @@ struct CLElementwisePower::Impl
 };
 
 CLElementwisePower::CLElementwisePower()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLElementwisePower::CLElementwisePower(CLElementwisePower &&) = default;
@@ -481,7 +480,7 @@ void CLElementwisePower::configure(const CLCompileContext &compile_context, ICLT
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLElementwisePower>();
+    _impl->op    = std::make_unique<experimental::CLElementwisePower>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), act_info);
 }
 
diff --git a/src/runtime/CL/functions/CLEqualizeHistogram.cpp b/src/runtime/CL/functions/CLEqualizeHistogram.cpp
index cc927a055b..11607cf71d 100644
--- a/src/runtime/CL/functions/CLEqualizeHistogram.cpp
+++ b/src/runtime/CL/functions/CLEqualizeHistogram.cpp
@@ -30,7 +30,6 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLHistogramKernel.h"
 #include "src/core/CL/kernels/CLTableLookupKernel.h"
-#include "support/MemorySupport.h"
 
 #include <algorithm>
 #include <cmath>
@@ -86,9 +85,9 @@ void calculate_cum_dist_and_lut(CLDistribution1D &dist, CLDistribution1D &cum_di
 } // namespace
 
 CLEqualizeHistogram::CLEqualizeHistogram()
-    : _histogram_kernel(support::cpp14::make_unique<CLHistogramKernel>()),
-      _border_histogram_kernel(support::cpp14::make_unique<CLHistogramBorderKernel>()),
-      _map_histogram_kernel(support::cpp14::make_unique<CLTableLookupKernel>()),
+    : _histogram_kernel(std::make_unique<CLHistogramKernel>()),
+      _border_histogram_kernel(std::make_unique<CLHistogramBorderKernel>()),
+      _map_histogram_kernel(std::make_unique<CLTableLookupKernel>()),
       _hist(nr_bins, 0, max_range),
       _cum_dist(nr_bins, 0, max_range),
       _cd_lut(nr_bins, DataType::U8)
diff --git a/src/runtime/CL/functions/CLErode.cpp b/src/runtime/CL/functions/CLErode.cpp
index 6880c4845a..29551fc6bd 100644
--- a/src/runtime/CL/functions/CLErode.cpp
+++ b/src/runtime/CL/functions/CLErode.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLErodeKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ void CLErode::configure(ICLTensor *input, ICLTensor *output, BorderMode border_m
 
 void CLErode::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLErodeKernel>();
+    auto k = std::make_unique<CLErodeKernel>();
     k->configure(compile_context, input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, BorderSize(1), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLFFT1D.cpp b/src/runtime/CL/functions/CLFFT1D.cpp
index a0078689ff..c434b4e570 100644
--- a/src/runtime/CL/functions/CLFFT1D.cpp
+++ b/src/runtime/CL/functions/CLFFT1D.cpp
@@ -30,15 +30,14 @@
 #include "src/core/CL/kernels/CLFFTRadixStageKernel.h"
 #include "src/core/CL/kernels/CLFFTScaleKernel.h"
 #include "src/core/utils/helpers/fft.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLFFT1D::CLFFT1D(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _digit_reverse_kernel(support::cpp14::make_unique<CLFFTDigitReverseKernel>()),
+      _digit_reverse_kernel(std::make_unique<CLFFTDigitReverseKernel>()),
       _fft_kernels(),
-      _scale_kernel(support::cpp14::make_unique<CLFFTScaleKernel>()),
+      _scale_kernel(std::make_unique<CLFFTScaleKernel>()),
       _digit_reversed_input(),
       _digit_reverse_indices(),
       _num_ffts(0),
@@ -90,7 +89,7 @@ void CLFFT1D::configure(const CLCompileContext &compile_context, const ICLTensor
         fft_kernel_info.radix          = radix_for_stage;
         fft_kernel_info.Nx             = Nx;
         fft_kernel_info.is_first_stage = (i == 0);
-        _fft_kernels.emplace_back(support::cpp14::make_unique<CLFFTRadixStageKernel>());
+        _fft_kernels.emplace_back(std::make_unique<CLFFTRadixStageKernel>());
         _fft_kernels.back()->configure(compile_context, &_digit_reversed_input, ((i == (_num_ffts - 1)) && !is_c2r) ? output : nullptr, fft_kernel_info);
 
         Nx *= radix_for_stage;
diff --git a/src/runtime/CL/functions/CLFFTConvolutionLayer.cpp b/src/runtime/CL/functions/CLFFTConvolutionLayer.cpp
index 5472e8469f..97b64b24f3 100644
--- a/src/runtime/CL/functions/CLFFTConvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLFFTConvolutionLayer.cpp
@@ -39,8 +39,6 @@
 #include "src/core/helpers/AutoConfiguration.h"
 #include "src/core/utils/helpers/fft.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 namespace
@@ -168,7 +166,7 @@ void CLFFTConvolutionLayer::configure(const CLCompileContext &compile_context, I
     _pad_weights_func.configure(compile_context, &_flipped_weights, &_padded_weights, padding_w);
 
     // Transform weights
-    _transform_weights_func = support::cpp14::make_unique<CLFFT2D>();
+    _transform_weights_func = std::make_unique<CLFFT2D>();
     _transform_weights_func->configure(compile_context, &_padded_weights, &_transformed_weights, FFT2DInfo());
 
     // Pad input
diff --git a/src/runtime/CL/functions/CLFastCorners.cpp b/src/runtime/CL/functions/CLFastCorners.cpp
index 110d2c3639..a3a62d6d5e 100644
--- a/src/runtime/CL/functions/CLFastCorners.cpp
+++ b/src/runtime/CL/functions/CLFastCorners.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/runtime/ITensorAllocator.h"
 #include "src/core/CL/kernels/CLFastCornersKernel.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <algorithm>
 #include <cstring>
@@ -40,9 +39,9 @@ using namespace arm_compute;
 
 CLFastCorners::CLFastCorners(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _fast_corners_kernel(support::cpp14::make_unique<CLFastCornersKernel>()),
+      _fast_corners_kernel(std::make_unique<CLFastCornersKernel>()),
       _suppr_func(),
-      _copy_array_kernel(support::cpp14::make_unique<CLCopyToArrayKernel>()),
+      _copy_array_kernel(std::make_unique<CLCopyToArrayKernel>()),
       _output(),
       _suppr(),
       _win(),
diff --git a/src/runtime/CL/functions/CLFill.cpp b/src/runtime/CL/functions/CLFill.cpp
index 855ed8380a..30843d8cc0 100644
--- a/src/runtime/CL/functions/CLFill.cpp
+++ b/src/runtime/CL/functions/CLFill.cpp
@@ -26,8 +26,6 @@
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLMemsetKernel.h"
 
-#include "support/MemorySupport.h"
-
 #include <utility>
 
 namespace arm_compute
@@ -39,7 +37,7 @@ void CLFill::configure(ICLTensor *tensor, PixelValue constant_value)
 
 void CLFill::configure(const CLCompileContext &compile_context, ICLTensor *tensor, PixelValue constant_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLMemsetKernel>();
+    auto k = std::make_unique<CLMemsetKernel>();
     k->configure(compile_context, tensor, constant_value);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLFillBorder.cpp b/src/runtime/CL/functions/CLFillBorder.cpp
index 27d132b842..2e5a29ece1 100644
--- a/src/runtime/CL/functions/CLFillBorder.cpp
+++ b/src/runtime/CL/functions/CLFillBorder.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLFillBorder.h"
 
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLFillBorder::configure(ICLTensor *tensor, unsigned int border_width, Borde
 
 void CLFillBorder::configure(const CLCompileContext &compile_context, ICLTensor *tensor, unsigned int border_width, BorderMode border_mode, const PixelValue &constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLFillBorderKernel>();
+    auto k = std::make_unique<CLFillBorderKernel>();
     k->configure(compile_context, tensor, BorderSize(border_width), border_mode, constant_border_value);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLFlattenLayer.cpp b/src/runtime/CL/functions/CLFlattenLayer.cpp
index 0646a0d3a0..c10e91bf96 100644
--- a/src/runtime/CL/functions/CLFlattenLayer.cpp
+++ b/src/runtime/CL/functions/CLFlattenLayer.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFlattenLayerKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -36,7 +35,7 @@ void CLFlattenLayer::configure(const ICLTensor *input, ICLTensor *output)
 
 void CLFlattenLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLFlattenLayerKernel>();
+    auto k = std::make_unique<CLFlattenLayerKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
     CLScheduler::get().tune_kernel_static(*_kernel);
diff --git a/src/runtime/CL/functions/CLFloor.cpp b/src/runtime/CL/functions/CLFloor.cpp
index 770e6a3781..5549d09b24 100644
--- a/src/runtime/CL/functions/CLFloor.cpp
+++ b/src/runtime/CL/functions/CLFloor.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLFloor.h"
 
 #include "src/core/CL/kernels/CLFloorKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -35,7 +34,7 @@ void CLFloor::configure(const ICLTensor *input, ICLTensor *output)
 
 void CLFloor::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLFloorKernel>();
+    auto k = std::make_unique<CLFloorKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLFullyConnectedLayer.cpp b/src/runtime/CL/functions/CLFullyConnectedLayer.cpp
index 1acf3c7a8b..46a90a54b7 100644
--- a/src/runtime/CL/functions/CLFullyConnectedLayer.cpp
+++ b/src/runtime/CL/functions/CLFullyConnectedLayer.cpp
@@ -42,7 +42,6 @@
 #include "src/core/CL/kernels/CLGEMMReshapeRHSMatrixKernel.h"
 #include "src/core/CL/kernels/CLTransposeKernel.h"
 #include "support/Cast.h"
-#include "support/MemorySupport.h"
 
 #include <algorithm>
 
@@ -149,7 +148,7 @@ void CLFullyConnectedLayerReshapeWeights::configure(const ICLTensor *input, ICLT
 
 void CLFullyConnectedLayerReshapeWeights::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLTransposeKernel>();
+    auto k = std::make_unique<CLTransposeKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLFuseBatchNormalization.cpp b/src/runtime/CL/functions/CLFuseBatchNormalization.cpp
index f018e5a8ae..2945508012 100644
--- a/src/runtime/CL/functions/CLFuseBatchNormalization.cpp
+++ b/src/runtime/CL/functions/CLFuseBatchNormalization.cpp
@@ -29,12 +29,11 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFuseBatchNormalizationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLFuseBatchNormalization::CLFuseBatchNormalization()
-    : _fuse_bn_kernel(support::cpp14::make_unique<CLFuseBatchNormalizationKernel>())
+    : _fuse_bn_kernel(std::make_unique<CLFuseBatchNormalizationKernel>())
 {
 }
 
diff --git a/src/runtime/CL/functions/CLGEMM.cpp b/src/runtime/CL/functions/CLGEMM.cpp
index 57a5f9739e..181ae2843b 100644
--- a/src/runtime/CL/functions/CLGEMM.cpp
+++ b/src/runtime/CL/functions/CLGEMM.cpp
@@ -49,8 +49,6 @@
 #include "src/runtime/CL/gemm/CLGEMMKernelSelection.h"
 #include "support/Cast.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 using namespace arm_compute::misc::shape_calculator;
@@ -60,7 +58,7 @@ using namespace arm_compute::utils::cast;
 namespace weights_transformations
 {
 CLGEMMReshapeRHSMatrixKernelManaged::CLGEMMReshapeRHSMatrixKernelManaged()
-    : _kernel(support::cpp14::make_unique<CLGEMMReshapeRHSMatrixKernel>())
+    : _kernel(std::make_unique<CLGEMMReshapeRHSMatrixKernel>())
 {
 }
 
@@ -102,13 +100,13 @@ void CLGEMMReshapeRHSMatrixKernelManaged::configure(const CLCompileContext &comp
 CLGEMM::CLGEMM(std::shared_ptr<IMemoryManager> memory_manager, IWeightsManager *weights_manager)
     : _memory_group(std::move(memory_manager)),
       _weights_manager(weights_manager),
-      _mm_kernel(support::cpp14::make_unique<CLGEMMMatrixMultiplyKernel>()),
-      _reshape_lhs_kernel(support::cpp14::make_unique<CLGEMMReshapeLHSMatrixKernel>()),
-      _reshape_rhs_kernel(support::cpp14::make_unique<CLGEMMReshapeRHSMatrixKernel>()),
-      _reshape_rhs_kernel_managed(support::cpp14::make_unique<weights_transformations::CLGEMMReshapeRHSMatrixKernelManaged>()),
-      _mm_reshaped_kernel(support::cpp14::make_unique<CLGEMMMatrixMultiplyReshapedKernel>()),
-      _mm_reshaped_only_rhs_kernel(support::cpp14::make_unique<CLGEMMMatrixMultiplyReshapedOnlyRHSKernel>()),
-      _mm_reshaped_only_rhs_fallback_kernel(support::cpp14::make_unique<CLGEMMMatrixMultiplyReshapedOnlyRHSKernel>()),
+      _mm_kernel(std::make_unique<CLGEMMMatrixMultiplyKernel>()),
+      _reshape_lhs_kernel(std::make_unique<CLGEMMReshapeLHSMatrixKernel>()),
+      _reshape_rhs_kernel(std::make_unique<CLGEMMReshapeRHSMatrixKernel>()),
+      _reshape_rhs_kernel_managed(std::make_unique<weights_transformations::CLGEMMReshapeRHSMatrixKernelManaged>()),
+      _mm_reshaped_kernel(std::make_unique<CLGEMMMatrixMultiplyReshapedKernel>()),
+      _mm_reshaped_only_rhs_kernel(std::make_unique<CLGEMMMatrixMultiplyReshapedOnlyRHSKernel>()),
+      _mm_reshaped_only_rhs_fallback_kernel(std::make_unique<CLGEMMMatrixMultiplyReshapedOnlyRHSKernel>()),
       _tmp_a(),
       _tmp_b(),
       _original_b(nullptr),
diff --git a/src/runtime/CL/functions/CLGEMMConvolutionLayer.cpp b/src/runtime/CL/functions/CLGEMMConvolutionLayer.cpp
index 4d26df5e43..f37f06b0ff 100644
--- a/src/runtime/CL/functions/CLGEMMConvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLGEMMConvolutionLayer.cpp
@@ -46,7 +46,6 @@
 #include "src/core/CL/kernels/CLWeightsReshapeKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
 #include "support/Cast.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 #include <memory>
@@ -58,7 +57,7 @@ using namespace arm_compute::misc::shape_calculator;
 using namespace arm_compute::utils::cast;
 
 CLConvolutionLayerReshapeWeights::CLConvolutionLayerReshapeWeights()
-    : _weights_reshape_kernel(support::cpp14::make_unique<CLWeightsReshapeKernel>())
+    : _weights_reshape_kernel(std::make_unique<CLWeightsReshapeKernel>())
 {
 }
 
@@ -117,9 +116,9 @@ void CLConvolutionLayerReshapeWeights::run()
 }
 
 CLGEMMConvolutionLayer::CLGEMMConvolutionLayer(std::shared_ptr<IMemoryManager> memory_manager, IWeightsManager *weights_manager)
-    : _memory_group(memory_manager), _weights_manager(weights_manager), _reshape_weights(), _reshape_weights_managed(), _im2col_kernel(support::cpp14::make_unique<CLIm2ColKernel>()),
-      _mm_gemm(memory_manager, weights_manager), _mm_gemmlowp(memory_manager), _col2im_kernel(support::cpp14::make_unique<CLCol2ImKernel>()), _activationlayer_function(), _original_weights(nullptr),
-      _im2col_output(), _weights_reshaped(), _gemm_output(), _skip_im2col(false), _skip_col2im(false), _is_quantized(false), _fuse_activation(true), _is_prepared(false)
+    : _memory_group(memory_manager), _weights_manager(weights_manager), _reshape_weights(), _reshape_weights_managed(), _im2col_kernel(std::make_unique<CLIm2ColKernel>()), _mm_gemm(memory_manager,
+            weights_manager), _mm_gemmlowp(memory_manager), _col2im_kernel(std::make_unique<CLCol2ImKernel>()), _activationlayer_function(), _original_weights(nullptr), _im2col_output(), _weights_reshaped(),
+      _gemm_output(), _skip_im2col(false), _skip_col2im(false), _is_quantized(false), _fuse_activation(true), _is_prepared(false)
 {
 }
 
diff --git a/src/runtime/CL/functions/CLGEMMDeconvolutionLayer.cpp b/src/runtime/CL/functions/CLGEMMDeconvolutionLayer.cpp
index 4d277f0982..a040e9d38e 100644
--- a/src/runtime/CL/functions/CLGEMMDeconvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLGEMMDeconvolutionLayer.cpp
@@ -43,7 +43,6 @@
 #include "src/core/CL/kernels/CLGEMMReshapeRHSMatrixKernel.h"
 #include "src/core/CL/kernels/CLIm2ColKernel.h"
 #include "src/core/CL/kernels/CLWeightsReshapeKernel.h"
-#include "support/MemorySupport.h"
 
 #include <tuple>
 
@@ -114,7 +113,7 @@ CLGEMMDeconvolutionLayer::CLGEMMDeconvolutionLayer(std::shared_ptr<IMemoryManage
       _permute_weights_to_nhwc(),
       _reshape_weights(),
       _transpose_weights(),
-      _deconv_reshape(support::cpp14::make_unique<CLDeconvolutionReshapeOutputKernel>()),
+      _deconv_reshape(std::make_unique<CLDeconvolutionReshapeOutputKernel>()),
       _slice_gemm(),
       _gemmlowp_final(),
       _reshaped_weights(),
diff --git a/src/runtime/CL/functions/CLGEMMLowpMatrixMultiplyCore.cpp b/src/runtime/CL/functions/CLGEMMLowpMatrixMultiplyCore.cpp
index d3d80a39e3..4bf5bde61e 100644
--- a/src/runtime/CL/functions/CLGEMMLowpMatrixMultiplyCore.cpp
+++ b/src/runtime/CL/functions/CLGEMMLowpMatrixMultiplyCore.cpp
@@ -44,7 +44,6 @@
 #include "src/core/CL/kernels/CLGEMMReshapeRHSMatrixKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
 #include "src/runtime/CL/gemm/CLGEMMKernelSelection.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -79,14 +78,14 @@ inline bool is_gemm_reshaped(unsigned int m, unsigned int n, unsigned int k, Dat
 
 CLGEMMLowpMatrixMultiplyCore::CLGEMMLowpMatrixMultiplyCore(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _weights_to_qasymm8(support::cpp14::make_unique<CLDepthConvertLayerKernel>()),
-      _mm_native_kernel(support::cpp14::make_unique<CLGEMMLowpMatrixMultiplyNativeKernel>()),
-      _mm_reshaped_only_rhs_kernel(support::cpp14::make_unique<CLGEMMLowpMatrixMultiplyReshapedOnlyRHSKernel>()),
-      _mtx_b_reshape_kernel(support::cpp14::make_unique<CLGEMMReshapeRHSMatrixKernel>()),
-      _mtx_a_reduction_kernel(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _mtx_b_reduction_kernel(support::cpp14::make_unique<CLGEMMLowpMatrixBReductionKernel>()),
-      _offset_contribution_kernel(support::cpp14::make_unique<CLGEMMLowpOffsetContributionKernel>()),
-      _offset_contribution_output_stage_kernel(support::cpp14::make_unique<CLGEMMLowpOffsetContributionOutputStageKernel>()),
+      _weights_to_qasymm8(std::make_unique<CLDepthConvertLayerKernel>()),
+      _mm_native_kernel(std::make_unique<CLGEMMLowpMatrixMultiplyNativeKernel>()),
+      _mm_reshaped_only_rhs_kernel(std::make_unique<CLGEMMLowpMatrixMultiplyReshapedOnlyRHSKernel>()),
+      _mtx_b_reshape_kernel(std::make_unique<CLGEMMReshapeRHSMatrixKernel>()),
+      _mtx_a_reduction_kernel(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _mtx_b_reduction_kernel(std::make_unique<CLGEMMLowpMatrixBReductionKernel>()),
+      _offset_contribution_kernel(std::make_unique<CLGEMMLowpOffsetContributionKernel>()),
+      _offset_contribution_output_stage_kernel(std::make_unique<CLGEMMLowpOffsetContributionOutputStageKernel>()),
       _qasymm8_weights(),
       _vector_sum_col(),
       _vector_sum_row(),
diff --git a/src/runtime/CL/functions/CLGEMMLowpOutputStage.cpp b/src/runtime/CL/functions/CLGEMMLowpOutputStage.cpp
index f9c5247d2d..be452aaf3d 100644
--- a/src/runtime/CL/functions/CLGEMMLowpOutputStage.cpp
+++ b/src/runtime/CL/functions/CLGEMMLowpOutputStage.cpp
@@ -28,7 +28,6 @@
 #include "src/core/CL/kernels/CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel.h"
 #include "src/core/CL/kernels/CLGEMMLowpQuantizeDownInt32ScaleByFloatKernel.h"
 #include "src/core/CL/kernels/CLGEMMLowpQuantizeDownInt32ScaleKernel.h"
-#include "support/MemorySupport.h"
 
 #include <algorithm>
 
@@ -52,7 +51,7 @@ void CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint::configure(const CLComp
     info.gemmlowp_min_bound  = min;
     info.gemmlowp_max_bound  = max;
     info.output_data_type    = DataType::QASYMM8;
-    auto k                   = arm_compute::support::cpp14::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
+    auto k                   = std::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
     k->configure(compile_context, input, bias, output, &info);
     _kernel = std::move(k);
 }
@@ -85,7 +84,7 @@ void CLGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPoint::configure(const CLCompi
     info.gemmlowp_min_bound  = min;
     info.gemmlowp_max_bound  = max;
     info.output_data_type    = DataType::QASYMM8_SIGNED;
-    auto k                   = arm_compute::support::cpp14::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
+    auto k                   = std::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
     k->configure(compile_context, input, bias, output, &info);
     _kernel = std::move(k);
 }
@@ -117,7 +116,7 @@ void CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint::configure(const CLComp
     info.gemmlowp_min_bound  = min;
     info.gemmlowp_max_bound  = max;
     info.output_data_type    = DataType::QSYMM16;
-    auto k                   = arm_compute::support::cpp14::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
+    auto k                   = std::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
     k->configure(compile_context, input, bias, output, &info);
     _kernel = std::move(k);
 }
@@ -145,21 +144,21 @@ void CLGEMMLowpOutputStage::configure(const CLCompileContext &compile_context, c
     {
         case GEMMLowpOutputStageType::QUANTIZE_DOWN_FIXEDPOINT:
         {
-            auto k = arm_compute::support::cpp14::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
+            auto k = std::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFixedPointKernel>();
             k->configure(compile_context, input, bias, output, &info);
             _kernel = std::move(k);
             break;
         }
         case GEMMLowpOutputStageType::QUANTIZE_DOWN:
         {
-            auto k = arm_compute::support::cpp14::make_unique<CLGEMMLowpQuantizeDownInt32ScaleKernel>();
+            auto k = std::make_unique<CLGEMMLowpQuantizeDownInt32ScaleKernel>();
             k->configure(compile_context, input, bias, output, &info);
             _kernel = std::move(k);
             break;
         }
         case GEMMLowpOutputStageType::QUANTIZE_DOWN_FLOAT:
         {
-            auto k = arm_compute::support::cpp14::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFloatKernel>();
+            auto k = std::make_unique<CLGEMMLowpQuantizeDownInt32ScaleByFloatKernel>();
             k->configure(compile_context, input, bias, output, &info);
             _kernel = std::move(k);
             break;
diff --git a/src/runtime/CL/functions/CLGather.cpp b/src/runtime/CL/functions/CLGather.cpp
index de6296f6a3..bde34dc4db 100644
--- a/src/runtime/CL/functions/CLGather.cpp
+++ b/src/runtime/CL/functions/CLGather.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "src/core/CL/kernels/CLGatherKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -36,7 +35,7 @@ void CLGather::configure(const ICLTensor *input, const ICLTensor *indices, ICLTe
 
 void CLGather::configure(const CLCompileContext &compile_context, const ICLTensor *input, const ICLTensor *indices, ICLTensor *output, int axis)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLGatherKernel>();
+    auto k = std::make_unique<CLGatherKernel>();
     k->configure(compile_context, input, indices, output, axis);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLGaussian3x3.cpp b/src/runtime/CL/functions/CLGaussian3x3.cpp
index 97db9ba06d..8eeade2f47 100644
--- a/src/runtime/CL/functions/CLGaussian3x3.cpp
+++ b/src/runtime/CL/functions/CLGaussian3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLGaussian3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ void CLGaussian3x3::configure(ICLTensor *input, ICLTensor *output, BorderMode bo
 
 void CLGaussian3x3::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLGaussian3x3Kernel>();
+    auto k = std::make_unique<CLGaussian3x3Kernel>();
     k->configure(compile_context, input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLGaussian5x5.cpp b/src/runtime/CL/functions/CLGaussian5x5.cpp
index f7470d4ecf..ee72fcbe11 100644
--- a/src/runtime/CL/functions/CLGaussian5x5.cpp
+++ b/src/runtime/CL/functions/CLGaussian5x5.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/runtime/ITensorAllocator.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLGaussian5x5Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,9 +38,9 @@ using namespace arm_compute;
 
 CLGaussian5x5::CLGaussian5x5(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _kernel_hor(support::cpp14::make_unique<CLGaussian5x5HorKernel>()),
-      _kernel_vert(support::cpp14::make_unique<CLGaussian5x5VertKernel>()),
-      _border_handler(support::cpp14::make_unique<CLFillBorderKernel>()),
+      _kernel_hor(std::make_unique<CLGaussian5x5HorKernel>()),
+      _kernel_vert(std::make_unique<CLGaussian5x5VertKernel>()),
+      _border_handler(std::make_unique<CLFillBorderKernel>()),
       _tmp()
 {
 }
diff --git a/src/runtime/CL/functions/CLGaussianPyramid.cpp b/src/runtime/CL/functions/CLGaussianPyramid.cpp
index 66b85352c1..9fe35f6f0e 100644
--- a/src/runtime/CL/functions/CLGaussianPyramid.cpp
+++ b/src/runtime/CL/functions/CLGaussianPyramid.cpp
@@ -38,7 +38,6 @@
 #include "src/core/CL/kernels/CLGaussian5x5Kernel.h"
 #include "src/core/CL/kernels/CLGaussianPyramidKernel.h"
 #include "src/core/CL/kernels/CLScaleKernel.h"
-#include "support/MemorySupport.h"
 
 #include <cstddef>
 
@@ -101,19 +100,19 @@ void CLGaussianPyramidHalf::configure(const CLCompileContext &compile_context, I
         for(size_t i = 0; i < num_levels - 1; ++i)
         {
             /* Configure horizontal kernel */
-            _horizontal_reduction.emplace_back(support::cpp14::make_unique<CLGaussianPyramidHorKernel>());
+            _horizontal_reduction.emplace_back(std::make_unique<CLGaussianPyramidHorKernel>());
             _horizontal_reduction.back()->configure(compile_context, _pyramid->get_pyramid_level(i), _tmp.get_pyramid_level(i));
 
             /* Configure vertical kernel */
-            _vertical_reduction.emplace_back(support::cpp14::make_unique<CLGaussianPyramidVertKernel>());
+            _vertical_reduction.emplace_back(std::make_unique<CLGaussianPyramidVertKernel>());
             _vertical_reduction.back()->configure(compile_context, _tmp.get_pyramid_level(i), _pyramid->get_pyramid_level(i + 1));
 
             /* Configure border */
-            _horizontal_border_handler.emplace_back(support::cpp14::make_unique<CLFillBorderKernel>());
+            _horizontal_border_handler.emplace_back(std::make_unique<CLFillBorderKernel>());
             _horizontal_border_handler.back()->configure(compile_context, _pyramid->get_pyramid_level(i), _horizontal_reduction.back()->border_size(), border_mode, PixelValue(constant_border_value));
 
             /* Configure border */
-            _vertical_border_handler.emplace_back(support::cpp14::make_unique<CLFillBorderKernel>());
+            _vertical_border_handler.emplace_back(std::make_unique<CLFillBorderKernel>());
             _vertical_border_handler.back()->configure(compile_context, _tmp.get_pyramid_level(i), _vertical_reduction.back()->border_size(), border_mode, PixelValue(pixel_value_u16));
         }
         _tmp.allocate();
@@ -185,7 +184,7 @@ void CLGaussianPyramidOrb::configure(const CLCompileContext &compile_context, IC
             _gauss5x5[i].configure(compile_context, _pyramid->get_pyramid_level(i), _tmp.get_pyramid_level(i), border_mode, constant_border_value);
 
             /* Configure scale image kernel */
-            _scale_nearest.emplace_back(support::cpp14::make_unique<CLScaleKernel>());
+            _scale_nearest.emplace_back(std::make_unique<CLScaleKernel>());
             _scale_nearest.back()->configure(compile_context, _tmp.get_pyramid_level(i), _pyramid->get_pyramid_level(i + 1), ScaleKernelInfo{ InterpolationPolicy::NEAREST_NEIGHBOR, border_mode, PixelValue(), SamplingPolicy::CENTER });
         }
 
diff --git a/src/runtime/CL/functions/CLGenerateProposalsLayer.cpp b/src/runtime/CL/functions/CLGenerateProposalsLayer.cpp
index 87bf39030a..e536816f97 100644
--- a/src/runtime/CL/functions/CLGenerateProposalsLayer.cpp
+++ b/src/runtime/CL/functions/CLGenerateProposalsLayer.cpp
@@ -32,22 +32,21 @@
 #include "src/core/CL/kernels/CLPermuteKernel.h"
 #include "src/core/CL/kernels/CLQuantizationLayerKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLGenerateProposalsLayer::CLGenerateProposalsLayer(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(memory_manager),
-      _permute_deltas_kernel(support::cpp14::make_unique<CLPermuteKernel>()),
+      _permute_deltas_kernel(std::make_unique<CLPermuteKernel>()),
       _flatten_deltas(),
-      _permute_scores_kernel(support::cpp14::make_unique<CLPermuteKernel>()),
+      _permute_scores_kernel(std::make_unique<CLPermuteKernel>()),
       _flatten_scores(),
-      _compute_anchors_kernel(support::cpp14::make_unique<CLComputeAllAnchorsKernel>()),
-      _bounding_box_kernel(support::cpp14::make_unique<CLBoundingBoxTransformKernel>()),
-      _pad_kernel(support::cpp14::make_unique<CLPadLayerKernel>()),
-      _dequantize_anchors(support::cpp14::make_unique<CLDequantizationLayerKernel>()),
-      _dequantize_deltas(support::cpp14::make_unique<CLDequantizationLayerKernel>()),
-      _quantize_all_proposals(support::cpp14::make_unique<CLQuantizationLayerKernel>()),
+      _compute_anchors_kernel(std::make_unique<CLComputeAllAnchorsKernel>()),
+      _bounding_box_kernel(std::make_unique<CLBoundingBoxTransformKernel>()),
+      _pad_kernel(std::make_unique<CLPadLayerKernel>()),
+      _dequantize_anchors(std::make_unique<CLDequantizationLayerKernel>()),
+      _dequantize_deltas(std::make_unique<CLDequantizationLayerKernel>()),
+      _quantize_all_proposals(std::make_unique<CLQuantizationLayerKernel>()),
       _cpp_nms(memory_manager),
       _is_nhwc(false),
       _is_qasymm8(false),
diff --git a/src/runtime/CL/functions/CLHOGDescriptor.cpp b/src/runtime/CL/functions/CLHOGDescriptor.cpp
index 80026532ab..8d9ea17d66 100644
--- a/src/runtime/CL/functions/CLHOGDescriptor.cpp
+++ b/src/runtime/CL/functions/CLHOGDescriptor.cpp
@@ -31,15 +31,14 @@
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLHOGDescriptorKernel.h"
 #include "src/core/CL/kernels/CLMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLHOGDescriptor::CLHOGDescriptor(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
       _gradient(),
-      _orient_bin(support::cpp14::make_unique<CLHOGOrientationBinningKernel>()),
-      _block_norm(support::cpp14::make_unique<CLHOGBlockNormalizationKernel>()),
+      _orient_bin(std::make_unique<CLHOGOrientationBinningKernel>()),
+      _block_norm(std::make_unique<CLHOGBlockNormalizationKernel>()),
       _mag(),
       _phase(),
       _hog_space()
diff --git a/src/runtime/CL/functions/CLHOGDetector.cpp b/src/runtime/CL/functions/CLHOGDetector.cpp
index 07ae8151c0..365021c723 100644
--- a/src/runtime/CL/functions/CLHOGDetector.cpp
+++ b/src/runtime/CL/functions/CLHOGDetector.cpp
@@ -26,14 +26,13 @@
 #include "arm_compute/core/Helpers.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLHOGDetectorKernel.h"
-#include "support/MemorySupport.h"
 
 #include <algorithm>
 
 using namespace arm_compute;
 
 CLHOGDetector::CLHOGDetector()
-    : _hog_detector_kernel(support::cpp14::make_unique<CLHOGDetectorKernel>()), _detection_windows(nullptr), _num_detection_windows()
+    : _hog_detector_kernel(std::make_unique<CLHOGDetectorKernel>()), _detection_windows(nullptr), _num_detection_windows()
 {
 }
 
diff --git a/src/runtime/CL/functions/CLHOGGradient.cpp b/src/runtime/CL/functions/CLHOGGradient.cpp
index 5f3b9cf529..f3aa527417 100644
--- a/src/runtime/CL/functions/CLHOGGradient.cpp
+++ b/src/runtime/CL/functions/CLHOGGradient.cpp
@@ -28,14 +28,13 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLHOGGradient::CLHOGGradient(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
       _derivative(),
-      _mag_phase(support::cpp14::make_unique<CLMagnitudePhaseKernel>()),
+      _mag_phase(std::make_unique<CLMagnitudePhaseKernel>()),
       _gx(),
       _gy()
 {
diff --git a/src/runtime/CL/functions/CLHOGMultiDetection.cpp b/src/runtime/CL/functions/CLHOGMultiDetection.cpp
index dfc90537cf..2464e6cf9f 100644
--- a/src/runtime/CL/functions/CLHOGMultiDetection.cpp
+++ b/src/runtime/CL/functions/CLHOGMultiDetection.cpp
@@ -34,7 +34,6 @@
 #include "src/core/CL/kernels/CLHOGDescriptorKernel.h"
 #include "src/core/CL/kernels/CLHOGDetectorKernel.h"
 #include "src/core/CL/kernels/CLMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -188,7 +187,7 @@ void CLHOGMultiDetection::configure(const CLCompileContext &compile_context, ICL
         _memory_group.manage(&_hog_space[i]);
 
         // Initialise orientation binning kernel
-        _orient_bin_kernel.emplace_back(support::cpp14::make_unique<CLHOGOrientationBinningKernel>());
+        _orient_bin_kernel.emplace_back(std::make_unique<CLHOGOrientationBinningKernel>());
         _orient_bin_kernel.back()->configure(compile_context, &_mag, &_phase, &_hog_space[i], multi_hog->model(idx_multi_hog)->info());
     }
 
@@ -210,7 +209,7 @@ void CLHOGMultiDetection::configure(const CLCompileContext &compile_context, ICL
         _memory_group.manage(&_hog_norm_space[i]);
 
         // Initialize block normalization kernel
-        _block_norm_kernel.emplace_back(support::cpp14::make_unique<CLHOGBlockNormalizationKernel>());
+        _block_norm_kernel.emplace_back(std::make_unique<CLHOGBlockNormalizationKernel>());
         _block_norm_kernel.back()->configure(compile_context, &_hog_space[idx_orient_bin], &_hog_norm_space[i], multi_hog->model(idx_multi_hog)->info());
     }
 
diff --git a/src/runtime/CL/functions/CLHarrisCorners.cpp b/src/runtime/CL/functions/CLHarrisCorners.cpp
index 9d8ebceb30..37f428c677 100644
--- a/src/runtime/CL/functions/CLHarrisCorners.cpp
+++ b/src/runtime/CL/functions/CLHarrisCorners.cpp
@@ -37,7 +37,6 @@
 #include "src/core/CL/kernels/CLHarrisCornersKernel.h"
 #include "src/core/CL/kernels/CLSobel5x5Kernel.h"
 #include "src/core/CL/kernels/CLSobel7x7Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 #include <utility>
@@ -47,12 +46,12 @@ using namespace arm_compute;
 CLHarrisCorners::CLHarrisCorners(std::shared_ptr<IMemoryManager> memory_manager) // NOLINT
     : _memory_group(std::move(memory_manager)),
       _sobel(nullptr),
-      _harris_score(support::cpp14::make_unique<CLHarrisScoreKernel>()),
+      _harris_score(std::make_unique<CLHarrisScoreKernel>()),
       _non_max_suppr(),
       _candidates(),
       _sort_euclidean(),
-      _border_gx(support::cpp14::make_unique<CLFillBorderKernel>()),
-      _border_gy(support::cpp14::make_unique<CLFillBorderKernel>()),
+      _border_gx(std::make_unique<CLFillBorderKernel>()),
+      _border_gy(std::make_unique<CLFillBorderKernel>()),
       _gx(),
       _gy(),
       _score(),
@@ -106,21 +105,21 @@ void CLHarrisCorners::configure(const CLCompileContext &compile_context, ICLImag
     {
         case 3:
         {
-            auto k = arm_compute::support::cpp14::make_unique<CLSobel3x3>();
+            auto k = std::make_unique<CLSobel3x3>();
             k->configure(compile_context, input, &_gx, &_gy, border_mode, constant_border_value);
             _sobel = std::move(k);
             break;
         }
         case 5:
         {
-            auto k = arm_compute::support::cpp14::make_unique<CLSobel5x5>();
+            auto k = std::make_unique<CLSobel5x5>();
             k->configure(compile_context, input, &_gx, &_gy, border_mode, constant_border_value);
             _sobel = std::move(k);
             break;
         }
         case 7:
         {
-            auto k = arm_compute::support::cpp14::make_unique<CLSobel7x7>();
+            auto k = std::make_unique<CLSobel7x7>();
             k->configure(compile_context, input, &_gx, &_gy, border_mode, constant_border_value);
             _sobel = std::move(k);
             break;
diff --git a/src/runtime/CL/functions/CLInstanceNormalizationLayer.cpp b/src/runtime/CL/functions/CLInstanceNormalizationLayer.cpp
index bd680f448d..9bc060e6ca 100644
--- a/src/runtime/CL/functions/CLInstanceNormalizationLayer.cpp
+++ b/src/runtime/CL/functions/CLInstanceNormalizationLayer.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLInstanceNormalizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -41,7 +40,7 @@ void CLInstanceNormalizationLayer::configure(ICLTensor *input, ICLTensor *output
 
 void CLInstanceNormalizationLayer::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, float gamma, float beta, float epsilon, bool use_mixed_precision)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLInstanceNormalizationLayerKernel>();
+    auto k = std::make_unique<CLInstanceNormalizationLayerKernel>();
     k->configure(compile_context, input, output, InstanceNormalizationLayerKernelInfo(gamma, beta, epsilon, use_mixed_precision));
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLIntegralImage.cpp b/src/runtime/CL/functions/CLIntegralImage.cpp
index 41e47e77c7..56a151a085 100644
--- a/src/runtime/CL/functions/CLIntegralImage.cpp
+++ b/src/runtime/CL/functions/CLIntegralImage.cpp
@@ -25,13 +25,12 @@
 
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLIntegralImageKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLIntegralImage::CLIntegralImage()
-    : _integral_hor(support::cpp14::make_unique<CLIntegralImageHorKernel>()),
-      _integral_vert(support::cpp14::make_unique<CLIntegralImageVertKernel>())
+    : _integral_hor(std::make_unique<CLIntegralImageHorKernel>()),
+      _integral_vert(std::make_unique<CLIntegralImageVertKernel>())
 {
 }
 
diff --git a/src/runtime/CL/functions/CLL2NormalizeLayer.cpp b/src/runtime/CL/functions/CLL2NormalizeLayer.cpp
index 64aac269cd..8c360aaa9e 100644
--- a/src/runtime/CL/functions/CLL2NormalizeLayer.cpp
+++ b/src/runtime/CL/functions/CLL2NormalizeLayer.cpp
@@ -32,7 +32,6 @@
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLL2NormalizeLayerKernel.h"
 #include "src/core/CL/kernels/CLReductionOperationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -44,7 +43,7 @@ constexpr int max_input_tensor_dim = 3;
 CLL2NormalizeLayer::CLL2NormalizeLayer(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
       _reduce_func(),
-      _normalize_kernel(support::cpp14::make_unique<CLL2NormalizeLayerKernel>()),
+      _normalize_kernel(std::make_unique<CLL2NormalizeLayerKernel>()),
       _sumsq()
 {
 }
diff --git a/src/runtime/CL/functions/CLLSTMLayer.cpp b/src/runtime/CL/functions/CLLSTMLayer.cpp
index b095c06535..77df917119 100644
--- a/src/runtime/CL/functions/CLLSTMLayer.cpp
+++ b/src/runtime/CL/functions/CLLSTMLayer.cpp
@@ -44,7 +44,6 @@
 #include "src/core/CL/kernels/CLGEMMReshapeRHSMatrixKernel.h"
 #include "src/core/CL/kernels/CLMemsetKernel.h"
 #include "src/core/CL/kernels/CLTransposeKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -54,10 +53,10 @@ using namespace arm_compute::utils::info_helpers;
 CLLSTMLayer::CLLSTMLayer(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)), _fully_connected_input_gate(), _accum_input_gate1(), _subtract_input_gate(), _pixelwise_mul_input_gate(), _activation_input_gate(),
       _fully_connected_forget_gate(), _accum_forget_gate1(), _pixelwise_mul_forget_gate(), _activation_forget_gate(), _fully_connected_cell_state(), _gemm_cell_state1(),
-      _transpose_cell_state(support::cpp14::make_unique<CLTransposeKernel>()), _accum_cell_state1(), _accum_cell_state2(), _pixelwise_mul_cell_state1(), _activation_cell_state(), _cell_clip(),
+      _transpose_cell_state(std::make_unique<CLTransposeKernel>()), _accum_cell_state1(), _accum_cell_state2(), _pixelwise_mul_cell_state1(), _activation_cell_state(), _cell_clip(),
       _pixelwise_mul_cell_state2(), _fully_connected_output(), _pixelwise_mul_output_state1(), _accum_output1(), _activation_output(), _activation_output_state(), _pixelwise_mul_output_state2(),
-      _fully_connected_output_state(), _projection_clip(), _copy_cell_state(support::cpp14::make_unique<CLCopyKernel>()), _copy_output(support::cpp14::make_unique<CLCopyKernel>()), _concat_scratch_buffer(),
-      _concat_inputs_forget_gate(), _concat_weights_forget_gate(), _concat_weights_input_gate(), _concat_weights_output(), _ones_memset_kernel(support::cpp14::make_unique<CLMemsetKernel>()),
+      _fully_connected_output_state(), _projection_clip(), _copy_cell_state(std::make_unique<CLCopyKernel>()), _copy_output(std::make_unique<CLCopyKernel>()), _concat_scratch_buffer(),
+      _concat_inputs_forget_gate(), _concat_weights_forget_gate(), _concat_weights_input_gate(), _concat_weights_output(), _ones_memset_kernel(std::make_unique<CLMemsetKernel>()),
       _mean_std_norm_input_gate(), _pixelwise_mul_input_gate_coeff(), _accum_input_gate_bias(), _mean_std_norm_forget_gate(), _pixelwise_mul_forget_gate_coeff(), _accum_forget_gate_bias(),
       _mean_std_norm_cell_gate(), _pixelwise_mul_cell_gate_coeff(), _accum_cell_gate_bias(), _mean_std_norm_output_gate(), _pixelwise_mul_output_gate_coeff(), _accum_output_gate_bias(), _input_gate_out1(),
       _input_gate_out2(), _input_gate_out3(), _input_gate_out4(), _forget_gate_out1(), _forget_gate_out2(), _forget_gate_out3(), _forget_gate_out4(), _forget_gate_out5(), _forget_gate_out6(),
diff --git a/src/runtime/CL/functions/CLLocallyConnectedLayer.cpp b/src/runtime/CL/functions/CLLocallyConnectedLayer.cpp
index 04e59ac4a6..3adae07095 100644
--- a/src/runtime/CL/functions/CLLocallyConnectedLayer.cpp
+++ b/src/runtime/CL/functions/CLLocallyConnectedLayer.cpp
@@ -31,7 +31,6 @@
 #include "src/core/CL/kernels/CLIm2ColKernel.h"
 #include "src/core/CL/kernels/CLLocallyConnectedMatrixMultiplyKernel.h"
 #include "src/core/CL/kernels/CLWeightsReshapeKernel.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 #include <tuple>
@@ -84,10 +83,10 @@ void calculate_shapes(const ITensorInfo *input, const ITensorInfo *weights, cons
 
 CLLocallyConnectedLayer::CLLocallyConnectedLayer(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _input_im2col_kernel(support::cpp14::make_unique<CLIm2ColKernel>()),
-      _weights_reshape_kernel(support::cpp14::make_unique<CLWeightsReshapeKernel>()),
-      _mm_kernel(support::cpp14::make_unique<CLLocallyConnectedMatrixMultiplyKernel>()),
-      _output_col2im_kernel(support::cpp14::make_unique<CLCol2ImKernel>()),
+      _input_im2col_kernel(std::make_unique<CLIm2ColKernel>()),
+      _weights_reshape_kernel(std::make_unique<CLWeightsReshapeKernel>()),
+      _mm_kernel(std::make_unique<CLLocallyConnectedMatrixMultiplyKernel>()),
+      _output_col2im_kernel(std::make_unique<CLCol2ImKernel>()),
       _input_im2col_reshaped(),
       _weights_reshaped(),
       _gemm_output(),
diff --git a/src/runtime/CL/functions/CLLogicalAnd.cpp b/src/runtime/CL/functions/CLLogicalAnd.cpp
index 55d3dc523b..f1c53651c7 100644
--- a/src/runtime/CL/functions/CLLogicalAnd.cpp
+++ b/src/runtime/CL/functions/CLLogicalAnd.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLLogicalAnd.h"
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "src/core/CL/kernels/CLElementwiseOperationKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ namespace experimental
 {
 void CLLogicalAnd::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLLogicalBinaryKernel>();
+    auto k = std::make_unique<CLLogicalBinaryKernel>();
     k->configure(compile_context, kernels::LogicalOperation::And, input1, input2, output);
     _kernel = std::move(k);
 }
@@ -59,7 +58,7 @@ struct CLLogicalAnd::Impl
 };
 
 CLLogicalAnd::CLLogicalAnd()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLLogicalAnd::CLLogicalAnd(CLLogicalAnd &&) = default;
@@ -76,7 +75,7 @@ void CLLogicalAnd::configure(const CLCompileContext &compile_context, ICLTensor
     _impl->src0 = input1;
     _impl->src1 = input2;
     _impl->dst  = output;
-    _impl->op   = arm_compute::support::cpp14::make_unique<experimental::CLLogicalAnd>();
+    _impl->op   = std::make_unique<experimental::CLLogicalAnd>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info());
 }
 
diff --git a/src/runtime/CL/functions/CLLogicalNot.cpp b/src/runtime/CL/functions/CLLogicalNot.cpp
index 67aa3192f8..d3774da597 100644
--- a/src/runtime/CL/functions/CLLogicalNot.cpp
+++ b/src/runtime/CL/functions/CLLogicalNot.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLLogicalNot.h"
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "src/core/CL/kernels/CLElementWiseUnaryLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ namespace experimental
 {
 void CLLogicalNot::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLElementWiseUnaryLayerKernel>();
+    auto k = std::make_unique<CLElementWiseUnaryLayerKernel>();
     k->configure(compile_context, input, output, ElementWiseUnary::LOGICAL_NOT);
     _kernel = std::move(k);
 }
@@ -58,7 +57,7 @@ struct CLLogicalNot::Impl
 };
 
 CLLogicalNot::CLLogicalNot()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLLogicalNot::CLLogicalNot(CLLogicalNot &&) = default;
@@ -74,7 +73,7 @@ void CLLogicalNot::configure(const CLCompileContext &compile_context, const ICLT
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLLogicalNot>();
+    _impl->op  = std::make_unique<experimental::CLLogicalNot>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 
diff --git a/src/runtime/CL/functions/CLLogicalOr.cpp b/src/runtime/CL/functions/CLLogicalOr.cpp
index b5be3cf816..8c6087ed7d 100644
--- a/src/runtime/CL/functions/CLLogicalOr.cpp
+++ b/src/runtime/CL/functions/CLLogicalOr.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLLogicalOr.h"
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "src/core/CL/kernels/CLElementwiseOperationKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ namespace experimental
 {
 void CLLogicalOr::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLLogicalBinaryKernel>();
+    auto k = std::make_unique<CLLogicalBinaryKernel>();
     k->configure(compile_context, kernels::LogicalOperation::Or, input1, input2, output);
     _kernel = std::move(k);
 }
@@ -59,7 +58,7 @@ struct CLLogicalOr::Impl
 };
 
 CLLogicalOr::CLLogicalOr()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLLogicalOr::CLLogicalOr(CLLogicalOr &&) = default;
@@ -76,7 +75,7 @@ void CLLogicalOr::configure(const CLCompileContext &compile_context, ICLTensor *
     _impl->src0 = input1;
     _impl->src1 = input2;
     _impl->dst  = output;
-    _impl->op   = arm_compute::support::cpp14::make_unique<experimental::CLLogicalOr>();
+    _impl->op   = std::make_unique<experimental::CLLogicalOr>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info());
 }
 
diff --git a/src/runtime/CL/functions/CLMagnitude.cpp b/src/runtime/CL/functions/CLMagnitude.cpp
index fb3ebdaa96..0599a11fa1 100644
--- a/src/runtime/CL/functions/CLMagnitude.cpp
+++ b/src/runtime/CL/functions/CLMagnitude.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLMagnitude.h"
 
 #include "src/core/CL/kernels/CLMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLMagnitude::configure(const ICLTensor *input1, const ICLTensor *input2, IC
 
 void CLMagnitude::configure(const CLCompileContext &compile_context, const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, MagnitudeType mag_type)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLMagnitudePhaseKernel>();
+    auto k = std::make_unique<CLMagnitudePhaseKernel>();
     k->configure(compile_context, input1, input2, output, nullptr, mag_type);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLMaxUnpoolingLayer.cpp b/src/runtime/CL/functions/CLMaxUnpoolingLayer.cpp
index 392bff2b4e..c9deb301ef 100644
--- a/src/runtime/CL/functions/CLMaxUnpoolingLayer.cpp
+++ b/src/runtime/CL/functions/CLMaxUnpoolingLayer.cpp
@@ -29,13 +29,12 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLMaxUnpoolingLayerKernel.h"
 #include "src/core/CL/kernels/CLMemsetKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLMaxUnpoolingLayer::CLMaxUnpoolingLayer()
-    : _memset_kernel(support::cpp14::make_unique<CLMemsetKernel>()),
-      _unpooling_layer_kernel(support::cpp14::make_unique<CLMaxUnpoolingLayerKernel>())
+    : _memset_kernel(std::make_unique<CLMemsetKernel>()),
+      _unpooling_layer_kernel(std::make_unique<CLMaxUnpoolingLayerKernel>())
 {
 }
 
diff --git a/src/runtime/CL/functions/CLMeanStdDev.cpp b/src/runtime/CL/functions/CLMeanStdDev.cpp
index c91bc954b8..d8cd41d45f 100644
--- a/src/runtime/CL/functions/CLMeanStdDev.cpp
+++ b/src/runtime/CL/functions/CLMeanStdDev.cpp
@@ -28,7 +28,6 @@
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLMeanStdDevKernel.h"
 #include "src/core/CL/kernels/CLReductionOperationKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -43,8 +42,8 @@ CLMeanStdDev::CLMeanStdDev(std::shared_ptr<IMemoryManager> memory_manager) // NO
       _reduction_output_stddev(),
       _mean(nullptr),
       _stddev(nullptr),
-      _mean_stddev_kernel(support::cpp14::make_unique<CLMeanStdDevKernel>()),
-      _fill_border_kernel(support::cpp14::make_unique<CLFillBorderKernel>()),
+      _mean_stddev_kernel(std::make_unique<CLMeanStdDevKernel>()),
+      _fill_border_kernel(std::make_unique<CLFillBorderKernel>()),
       _global_sum(),
       _global_sum_squared()
 {
diff --git a/src/runtime/CL/functions/CLMeanStdDevNormalizationLayer.cpp b/src/runtime/CL/functions/CLMeanStdDevNormalizationLayer.cpp
index 5b5ff49ecb..0f6a0e47a4 100644
--- a/src/runtime/CL/functions/CLMeanStdDevNormalizationLayer.cpp
+++ b/src/runtime/CL/functions/CLMeanStdDevNormalizationLayer.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLMeanStdDevNormalizationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -36,7 +35,7 @@ void CLMeanStdDevNormalizationLayer::configure(ICLTensor *input, ICLTensor *outp
 
 void CLMeanStdDevNormalizationLayer::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, float epsilon)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLMeanStdDevNormalizationKernel>();
+    auto k = std::make_unique<CLMeanStdDevNormalizationKernel>();
     k->configure(compile_context, input, output, epsilon);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLMedian3x3.cpp b/src/runtime/CL/functions/CLMedian3x3.cpp
index 2040ebd4f5..b32063a8fe 100644
--- a/src/runtime/CL/functions/CLMedian3x3.cpp
+++ b/src/runtime/CL/functions/CLMedian3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLMedian3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ void CLMedian3x3::configure(ICLTensor *input, ICLTensor *output, BorderMode bord
 
 void CLMedian3x3::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLMedian3x3Kernel>();
+    auto k = std::make_unique<CLMedian3x3Kernel>();
     k->configure(compile_context, input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLMinMaxLocation.cpp b/src/runtime/CL/functions/CLMinMaxLocation.cpp
index 3ddd4d04ed..ace6a1cb21 100644
--- a/src/runtime/CL/functions/CLMinMaxLocation.cpp
+++ b/src/runtime/CL/functions/CLMinMaxLocation.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/CL/functions/CLMinMaxLocation.h"
 #include "arm_compute/core/CL/CLHelpers.h"
 #include "src/core/CL/kernels/CLMinMaxLocationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLMinMaxLocation::CLMinMaxLocation()
-    : _min_max_kernel(support::cpp14::make_unique<CLMinMaxKernel>()),
-      _min_max_loc_kernel(support::cpp14::make_unique<CLMinMaxLocationKernel>()),
+    : _min_max_kernel(std::make_unique<CLMinMaxKernel>()),
+      _min_max_loc_kernel(std::make_unique<CLMinMaxLocationKernel>()),
       _min_max_vals(),
       _min_max_count_vals(),
       _min(nullptr),
diff --git a/src/runtime/CL/functions/CLNonLinearFilter.cpp b/src/runtime/CL/functions/CLNonLinearFilter.cpp
index 3312f6f9a7..ec88f879b7 100644
--- a/src/runtime/CL/functions/CLNonLinearFilter.cpp
+++ b/src/runtime/CL/functions/CLNonLinearFilter.cpp
@@ -25,7 +25,6 @@
 
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLNonLinearFilterKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -40,7 +39,7 @@ void CLNonLinearFilter::configure(ICLTensor *input, ICLTensor *output, NonLinear
 void CLNonLinearFilter::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, NonLinearFilterFunction function, unsigned int mask_size, MatrixPattern pattern,
                                   const uint8_t *mask, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLNonLinearFilterKernel>();
+    auto k = std::make_unique<CLNonLinearFilterKernel>();
     k->configure(compile_context, input, output, function, mask_size, pattern, mask, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLNonMaximaSuppression3x3.cpp b/src/runtime/CL/functions/CLNonMaximaSuppression3x3.cpp
index 22ca176a71..5906ea5a4b 100644
--- a/src/runtime/CL/functions/CLNonMaximaSuppression3x3.cpp
+++ b/src/runtime/CL/functions/CLNonMaximaSuppression3x3.cpp
@@ -25,7 +25,6 @@
 
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLNonMaximaSuppression3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -38,7 +37,7 @@ void CLNonMaximaSuppression3x3::configure(ICLTensor *input, ICLTensor *output, B
 
 void CLNonMaximaSuppression3x3::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, BorderMode border_mode)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLNonMaximaSuppression3x3Kernel>();
+    auto k = std::make_unique<CLNonMaximaSuppression3x3Kernel>();
     k->configure(compile_context, input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
diff --git a/src/runtime/CL/functions/CLNormalizationLayer.cpp b/src/runtime/CL/functions/CLNormalizationLayer.cpp
index 40a6cdd2f4..ec6fa803f5 100644
--- a/src/runtime/CL/functions/CLNormalizationLayer.cpp
+++ b/src/runtime/CL/functions/CLNormalizationLayer.cpp
@@ -32,13 +32,12 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLNormalizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLNormalizationLayer::CLNormalizationLayer()
-    : _norm_kernel(support::cpp14::make_unique<CLNormalizationLayerKernel>()),
-      _border_handler(support::cpp14::make_unique<CLFillBorderKernel>())
+    : _norm_kernel(std::make_unique<CLNormalizationLayerKernel>()),
+      _border_handler(std::make_unique<CLFillBorderKernel>())
 {
 }
 
diff --git a/src/runtime/CL/functions/CLNormalizePlanarYUVLayer.cpp b/src/runtime/CL/functions/CLNormalizePlanarYUVLayer.cpp
index 9576486db0..70189a2cb6 100644
--- a/src/runtime/CL/functions/CLNormalizePlanarYUVLayer.cpp
+++ b/src/runtime/CL/functions/CLNormalizePlanarYUVLayer.cpp
@@ -25,7 +25,6 @@
 #include "arm_compute/runtime/CL/functions/CLNormalizePlanarYUVLayer.h"
 
 #include "src/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -38,7 +37,7 @@ void CLNormalizePlanarYUVLayer::configure(const ICLTensor *input, ICLTensor *out
 
 void CLNormalizePlanarYUVLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, const ICLTensor *mean, const ICLTensor *std)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLNormalizePlanarYUVLayerKernel>();
+    auto k = std::make_unique<CLNormalizePlanarYUVLayerKernel>();
     k->configure(compile_context, input, output, mean, std);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLOpticalFlow.cpp b/src/runtime/CL/functions/CLOpticalFlow.cpp
index fca6192296..76e0ac5f0b 100644
--- a/src/runtime/CL/functions/CLOpticalFlow.cpp
+++ b/src/runtime/CL/functions/CLOpticalFlow.cpp
@@ -34,7 +34,6 @@
 #include "arm_compute/runtime/CL/functions/CLScharr3x3.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLLKTrackerKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -43,7 +42,7 @@ CLOpticalFlow::CLOpticalFlow(std::shared_ptr<IMemoryManager> memory_manager) //
       _tracker_init_kernel(),
       _tracker_stage0_kernel(),
       _tracker_stage1_kernel(),
-      _tracker_finalize_kernel(support::cpp14::make_unique<CLLKTrackerFinalizeKernel>()),
+      _tracker_finalize_kernel(std::make_unique<CLLKTrackerFinalizeKernel>()),
       _func_scharr(),
       _scharr_gx(),
       _scharr_gy(),
@@ -104,13 +103,13 @@ void CLOpticalFlow::configure(const CLCompileContext &compile_context, const CLP
     _scharr_gy.resize(_num_levels);
 
     // Create internal keypoint arrays
-    _old_points_internal = arm_compute::support::cpp14::make_unique<CLLKInternalKeypointArray>(list_length);
+    _old_points_internal = std::make_unique<CLLKInternalKeypointArray>(list_length);
     _old_points_internal->resize(list_length);
-    _new_points_internal = arm_compute::support::cpp14::make_unique<CLLKInternalKeypointArray>(list_length);
+    _new_points_internal = std::make_unique<CLLKInternalKeypointArray>(list_length);
     _new_points_internal->resize(list_length);
-    _coefficient_table = arm_compute::support::cpp14::make_unique<CLCoefficientTableArray>(list_length);
+    _coefficient_table = std::make_unique<CLCoefficientTableArray>(list_length);
     _coefficient_table->resize(list_length);
-    _old_values = arm_compute::support::cpp14::make_unique<CLOldValueArray>(old_values_list_length);
+    _old_values = std::make_unique<CLOldValueArray>(old_values_list_length);
     _old_values->resize(old_values_list_length);
     _new_points->resize(list_length);
 
@@ -137,17 +136,17 @@ void CLOpticalFlow::configure(const CLCompileContext &compile_context, const CLP
         _func_scharr[i].configure(compile_context, old_ith_input, &_scharr_gx[i], &_scharr_gy[i], border_mode, constant_border_value);
 
         // Init Lucas-Kanade init kernel
-        _tracker_init_kernel.emplace_back(support::cpp14::make_unique<CLLKTrackerInitKernel>());
+        _tracker_init_kernel.emplace_back(std::make_unique<CLLKTrackerInitKernel>());
         _tracker_init_kernel.back()->configure(compile_context, old_points, new_points_estimates, _old_points_internal.get(), _new_points_internal.get(), use_initial_estimate, i, _num_levels, pyr_scale);
 
         // Init Lucas-Kanade stage0 kernel
-        _tracker_stage0_kernel.emplace_back(support::cpp14::make_unique<CLLKTrackerStage0Kernel>());
+        _tracker_stage0_kernel.emplace_back(std::make_unique<CLLKTrackerStage0Kernel>());
         _tracker_stage0_kernel.back()->configure(compile_context, old_ith_input, &_scharr_gx[i], &_scharr_gy[i],
                                                  _old_points_internal.get(), _new_points_internal.get(), _coefficient_table.get(), _old_values.get(),
                                                  window_dimension, i);
 
         // Init Lucas-Kanade stage1 kernel
-        _tracker_stage1_kernel.emplace_back(support::cpp14::make_unique<CLLKTrackerStage1Kernel>());
+        _tracker_stage1_kernel.emplace_back(std::make_unique<CLLKTrackerStage1Kernel>());
         _tracker_stage1_kernel.back()->configure(compile_context, new_ith_input, _new_points_internal.get(), _coefficient_table.get(), _old_values.get(),
                                                  termination, epsilon, num_iterations, window_dimension, i);
 
diff --git a/src/runtime/CL/functions/CLPReluLayer.cpp b/src/runtime/CL/functions/CLPReluLayer.cpp
index 60cf4d1a2d..876b5de0f7 100644
--- a/src/runtime/CL/functions/CLPReluLayer.cpp
+++ b/src/runtime/CL/functions/CLPReluLayer.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "arm_compute/runtime/CL/functions/CLPReluLayer.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -38,7 +37,7 @@ CLPReluLayer::CLPReluLayer()
 
 void CLPReluLayer::configure(const CLCompileContext &compile_context, ITensorInfo *input, ITensorInfo *alpha, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLArithmeticOperationKernel>();
+    auto k = std::make_unique<CLArithmeticOperationKernel>();
     k->configure(compile_context, ArithmeticOperation::PRELU, input, alpha, output);
     _kernel = std::move(k);
 }
@@ -63,7 +62,7 @@ struct CLPReluLayer::Impl
 };
 
 CLPReluLayer::CLPReluLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLPReluLayer::CLPReluLayer(CLPReluLayer &&) = default;
@@ -80,7 +79,7 @@ void CLPReluLayer::configure(const CLCompileContext &compile_context, ICLTensor
     _impl->src_0 = input;
     _impl->src_1 = alpha;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLPReluLayer>();
+    _impl->op    = std::make_unique<experimental::CLPReluLayer>();
     _impl->op->configure(compile_context, input->info(), alpha->info(), output->info());
 }
 
diff --git a/src/runtime/CL/functions/CLPadLayer.cpp b/src/runtime/CL/functions/CLPadLayer.cpp
index 388b07b76e..8c5d529117 100644
--- a/src/runtime/CL/functions/CLPadLayer.cpp
+++ b/src/runtime/CL/functions/CLPadLayer.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/CL/functions/CLPadLayer.h"
 #include "src/core/CL/kernels/CLCopyKernel.h"
 #include "src/core/CL/kernels/CLPadLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLPadLayer::CLPadLayer()
-    : _pad_kernel(support::cpp14::make_unique<CLPadLayerKernel>()),
-      _copy_kernel(support::cpp14::make_unique<CLCopyKernel>()),
+    : _pad_kernel(std::make_unique<CLPadLayerKernel>()),
+      _copy_kernel(std::make_unique<CLCopyKernel>()),
       _perform_pad(false)
 {
 }
diff --git a/src/runtime/CL/functions/CLPermute.cpp b/src/runtime/CL/functions/CLPermute.cpp
index f7f0bc4f5d..31b152c553 100644
--- a/src/runtime/CL/functions/CLPermute.cpp
+++ b/src/runtime/CL/functions/CLPermute.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "arm_compute/core/Error.h"
 #include "src/core/CL/kernels/CLPermuteKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -37,7 +36,7 @@ void CLPermute::configure(const ICLTensor *input, ICLTensor *output, const Permu
 
 void CLPermute::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, const PermutationVector &perm)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLPermuteKernel>();
+    auto k = std::make_unique<CLPermuteKernel>();
     k->configure(compile_context, input, output, perm);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLPhase.cpp b/src/runtime/CL/functions/CLPhase.cpp
index 6594cd5bac..b2ff5d05ca 100644
--- a/src/runtime/CL/functions/CLPhase.cpp
+++ b/src/runtime/CL/functions/CLPhase.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLPhase.h"
 
 #include "src/core/CL/kernels/CLMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLPhase::configure(const ICLTensor *input1, const ICLTensor *input2, ICLTen
 
 void CLPhase::configure(const CLCompileContext &compile_context, const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, PhaseType phase_type)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLMagnitudePhaseKernel>();
+    auto k = std::make_unique<CLMagnitudePhaseKernel>();
     k->configure(compile_context, input1, input2, nullptr, output, MagnitudeType::L1NORM, phase_type);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLPixelWiseMultiplication.cpp b/src/runtime/CL/functions/CLPixelWiseMultiplication.cpp
index 12cc5d60af..a56018b397 100644
--- a/src/runtime/CL/functions/CLPixelWiseMultiplication.cpp
+++ b/src/runtime/CL/functions/CLPixelWiseMultiplication.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLPixelWiseMultiplicationKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -56,14 +55,14 @@ ITensorPack select_border_input(ITensorPack &tensors)
 namespace experimental
 {
 CLPixelWiseMultiplication::CLPixelWiseMultiplication()
-    : _border_handler(support::cpp14::make_unique<CLFillBorderKernel>())
+    : _border_handler(std::make_unique<CLFillBorderKernel>())
 {
 }
 
 void CLPixelWiseMultiplication::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, float scale,
                                           ConvertPolicy overflow_policy, RoundingPolicy rounding_policy, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLPixelWiseMultiplicationKernel>();
+    auto k = std::make_unique<CLPixelWiseMultiplicationKernel>();
     k->configure(compile_context, input1, input2, output, scale, overflow_policy, rounding_policy, act_info);
     _kernel = std::move(k);
 
@@ -92,13 +91,13 @@ void CLPixelWiseMultiplication::run(ITensorPack &tensors)
 }
 
 CLComplexPixelWiseMultiplication::CLComplexPixelWiseMultiplication()
-    : _border_handler(support::cpp14::make_unique<CLFillBorderKernel>())
+    : _border_handler(std::make_unique<CLFillBorderKernel>())
 {
 }
 
 void CLComplexPixelWiseMultiplication::configure(const CLCompileContext &compile_context, ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, const ActivationLayerInfo &act_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLComplexPixelWiseMultiplicationKernel>();
+    auto k = std::make_unique<CLComplexPixelWiseMultiplicationKernel>();
     k->configure(compile_context, input1, input2, output, act_info);
     _kernel = std::move(k);
 
@@ -135,7 +134,7 @@ struct CLPixelWiseMultiplication::Impl
 };
 
 CLPixelWiseMultiplication::CLPixelWiseMultiplication()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLPixelWiseMultiplication::CLPixelWiseMultiplication(CLPixelWiseMultiplication &&) = default;
@@ -154,7 +153,7 @@ void CLPixelWiseMultiplication::configure(const CLCompileContext &compile_contex
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLPixelWiseMultiplication>();
+    _impl->op    = std::make_unique<experimental::CLPixelWiseMultiplication>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), scale, overflow_policy, rounding_policy, act_info);
 }
 
@@ -183,7 +182,7 @@ struct CLComplexPixelWiseMultiplication::Impl
 };
 
 CLComplexPixelWiseMultiplication::CLComplexPixelWiseMultiplication()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLComplexPixelWiseMultiplication::CLComplexPixelWiseMultiplication(CLComplexPixelWiseMultiplication &&) = default;
@@ -200,7 +199,7 @@ void CLComplexPixelWiseMultiplication::configure(const CLCompileContext &compile
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::CLComplexPixelWiseMultiplication>();
+    _impl->op    = std::make_unique<experimental::CLComplexPixelWiseMultiplication>();
     _impl->op->configure(compile_context, input1->info(), input2->info(), output->info(), act_info);
 }
 
diff --git a/src/runtime/CL/functions/CLPoolingLayer.cpp b/src/runtime/CL/functions/CLPoolingLayer.cpp
index 7f99aee9ba..f3a2dbdd51 100644
--- a/src/runtime/CL/functions/CLPoolingLayer.cpp
+++ b/src/runtime/CL/functions/CLPoolingLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLPoolingLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -40,7 +39,7 @@ void CLPoolingLayer::configure(const CLCompileContext &compile_context, ICLTenso
 {
     ARM_COMPUTE_ERROR_ON_NULLPTR(input);
     // Configure pooling kernel
-    auto k = arm_compute::support::cpp14::make_unique<CLPoolingLayerKernel>();
+    auto k = std::make_unique<CLPoolingLayerKernel>();
     k->set_target(CLScheduler::get().target());
     k->configure(compile_context, input, output, pool_info, indices);
     _kernel = std::move(k);
diff --git a/src/runtime/CL/functions/CLPriorBoxLayer.cpp b/src/runtime/CL/functions/CLPriorBoxLayer.cpp
index 8cb971793e..5ace7c6d7a 100644
--- a/src/runtime/CL/functions/CLPriorBoxLayer.cpp
+++ b/src/runtime/CL/functions/CLPriorBoxLayer.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLPriorBoxLayerKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -54,7 +53,7 @@ void CLPriorBoxLayer::configure(const CLCompileContext &compile_context, const I
         _max = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE, info.max_sizes().size() * sizeof(float));
     }
 
-    auto k = arm_compute::support::cpp14::make_unique<CLPriorBoxLayerKernel>();
+    auto k = std::make_unique<CLPriorBoxLayerKernel>();
     k->configure(compile_context, input1, input2, output, info, &_min, &_max, &_aspect_ratios);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLQLSTMLayer.cpp b/src/runtime/CL/functions/CLQLSTMLayer.cpp
index 54df5a0a5e..4395a39060 100644
--- a/src/runtime/CL/functions/CLQLSTMLayer.cpp
+++ b/src/runtime/CL/functions/CLQLSTMLayer.cpp
@@ -41,7 +41,6 @@
 #include "src/core/CL/kernels/CLGEMMReshapeRHSMatrixKernel.h"
 #include "src/core/CL/kernels/CLQLSTMLayerNormalizationKernel.h"
 #include "src/core/helpers/WindowHelpers.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -97,21 +96,21 @@ void CLQLSTMLayer::TensorCopyKernel::run()
 }
 
 CLQLSTMLayer::CLQLSTMLayer(std::shared_ptr<IMemoryManager> memory_manager)
-    : _input_to_input_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _recurrent_to_input_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _input_to_forget_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _recurrent_to_forget_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _input_to_cell_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _recurrent_to_cell_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _input_to_output_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _recurrent_to_output_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
-      _projection_reduction(support::cpp14::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+    : _input_to_input_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _recurrent_to_input_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _input_to_forget_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _recurrent_to_forget_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _input_to_cell_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _recurrent_to_cell_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _input_to_output_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _recurrent_to_output_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
+      _projection_reduction(std::make_unique<CLGEMMLowpMatrixAReductionKernel>()),
       _layer_norms(),
-      _copy_output(support::cpp14::make_unique<CLCopyKernel>())
+      _copy_output(std::make_unique<CLCopyKernel>())
 {
     for(auto &norm : _layer_norms)
     {
-        norm = support::cpp14::make_unique<CLQLSTMLayerNormalizationKernel>();
+        norm = std::make_unique<CLQLSTMLayerNormalizationKernel>();
     }
 
     _memory_group = MemoryGroup(std::move(memory_manager));
diff --git a/src/runtime/CL/functions/CLQuantizationLayer.cpp b/src/runtime/CL/functions/CLQuantizationLayer.cpp
index f132547eb9..cb8cabef87 100644
--- a/src/runtime/CL/functions/CLQuantizationLayer.cpp
+++ b/src/runtime/CL/functions/CLQuantizationLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLQuantizationLayer.h"
 
 #include "src/core/CL/kernels/CLQuantizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -35,7 +34,7 @@ void CLQuantizationLayer::configure(const ICLTensor *input, ICLTensor *output)
 
 void CLQuantizationLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLQuantizationLayerKernel>();
+    auto k = std::make_unique<CLQuantizationLayerKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLRNNLayer.cpp b/src/runtime/CL/functions/CLRNNLayer.cpp
index be3e539f98..2a99ece388 100644
--- a/src/runtime/CL/functions/CLRNNLayer.cpp
+++ b/src/runtime/CL/functions/CLRNNLayer.cpp
@@ -41,14 +41,13 @@
 #include "src/core/CL/kernels/CLGEMMMatrixMultiplyReshapedOnlyRHSKernel.h"
 #include "src/core/CL/kernels/CLGEMMReshapeLHSMatrixKernel.h"
 #include "src/core/CL/kernels/CLGEMMReshapeRHSMatrixKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 using namespace arm_compute::misc::shape_calculator;
 
 CLRNNLayer::CLRNNLayer(std::shared_ptr<IMemoryManager> memory_manager)
-    : _memory_group(std::move(memory_manager)), _gemm_state_f(), _add_kernel(), _activation(), _fully_connected_kernel(), _copy_kernel(support::cpp14::make_unique<CLCopyKernel>()), _fully_connected_out(),
+    : _memory_group(std::move(memory_manager)), _gemm_state_f(), _add_kernel(), _activation(), _fully_connected_kernel(), _copy_kernel(std::make_unique<CLCopyKernel>()), _fully_connected_out(),
       _gemm_output(), _add_output(), _is_prepared(false)
 {
 }
diff --git a/src/runtime/CL/functions/CLROIAlignLayer.cpp b/src/runtime/CL/functions/CLROIAlignLayer.cpp
index cf28a1a0fb..291ccff958 100644
--- a/src/runtime/CL/functions/CLROIAlignLayer.cpp
+++ b/src/runtime/CL/functions/CLROIAlignLayer.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/CL/ICLArray.h"
 #include "src/core/CL/kernels/CLROIAlignLayerKernel.h"
 #include "src/core/CL/kernels/CLROIPoolingLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -45,7 +44,7 @@ void CLROIAlignLayer::configure(const ICLTensor *input, const ICLTensor *rois, I
 void CLROIAlignLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, const ICLTensor *rois, ICLTensor *output, const ROIPoolingLayerInfo &pool_info)
 {
     // Configure ROI pooling kernel
-    auto k = arm_compute::support::cpp14::make_unique<CLROIAlignLayerKernel>();
+    auto k = std::make_unique<CLROIAlignLayerKernel>();
     k->configure(compile_context, input, rois, output, pool_info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLROIPoolingLayer.cpp b/src/runtime/CL/functions/CLROIPoolingLayer.cpp
index b0e6716cce..debc5eb24c 100644
--- a/src/runtime/CL/functions/CLROIPoolingLayer.cpp
+++ b/src/runtime/CL/functions/CLROIPoolingLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLROIPoolingLayer.h"
 #include "arm_compute/core/CL/ICLArray.h"
 #include "src/core/CL/kernels/CLROIPoolingLayerKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -36,7 +35,7 @@ void CLROIPoolingLayer::configure(const ICLTensor *input, const ICLTensor *rois,
 void CLROIPoolingLayer::configure(const CLCompileContext &compile_context, const ICLTensor *input, const ICLTensor *rois, ICLTensor *output, const ROIPoolingLayerInfo &pool_info)
 {
     // Configure ROI pooling kernel
-    auto k = arm_compute::support::cpp14::make_unique<CLROIPoolingLayerKernel>();
+    auto k = std::make_unique<CLROIPoolingLayerKernel>();
     k->configure(compile_context, input, rois, output, pool_info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLRange.cpp b/src/runtime/CL/functions/CLRange.cpp
index 57b57bd305..d4735c875d 100644
--- a/src/runtime/CL/functions/CLRange.cpp
+++ b/src/runtime/CL/functions/CLRange.cpp
@@ -28,7 +28,6 @@
 #include "arm_compute/core/Validate.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLRangeKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -39,7 +38,7 @@ void CLRange::configure(ICLTensor *output, const float start, const float end, c
 
 void CLRange::configure(const CLCompileContext &compile_context, ICLTensor *output, const float start, const float end, const float step)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLRangeKernel>();
+    auto k = std::make_unique<CLRangeKernel>();
     k->set_target(CLScheduler::get().target());
     k->configure(compile_context, output, start, end, step);
     _kernel = std::move(k);
diff --git a/src/runtime/CL/functions/CLReductionOperation.cpp b/src/runtime/CL/functions/CLReductionOperation.cpp
index 7423f4bc87..f40d945944 100644
--- a/src/runtime/CL/functions/CLReductionOperation.cpp
+++ b/src/runtime/CL/functions/CLReductionOperation.cpp
@@ -34,7 +34,6 @@
 #include "src/core/CL/kernels/CLReductionOperationKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
 #include "src/runtime/Utils.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -224,7 +223,7 @@ void CLReductionOperation::configure(const CLCompileContext &compile_context, IC
             _memory_group.manage(&_results_vector.back());
         }
 
-        _reduction_kernels_vector.emplace_back(support::cpp14::make_unique<CLReductionOperationKernel>());
+        _reduction_kernels_vector.emplace_back(std::make_unique<CLReductionOperationKernel>());
         _reduction_kernels_vector[0]->configure(compile_context, input, output_internal, axis, op, 0);
     }
     else
@@ -273,10 +272,10 @@ void CLReductionOperation::configure(const CLCompileContext &compile_context, IC
                 ARM_COMPUTE_ERROR("Not supported");
         }
 
-        _reduction_kernels_vector.emplace_back(support::cpp14::make_unique<CLReductionOperationKernel>());
+        _reduction_kernels_vector.emplace_back(std::make_unique<CLReductionOperationKernel>());
         _reduction_kernels_vector[0]->configure(compile_context, input, &_results_vector[0], axis, first_kernel_op);
 
-        _border_handlers_vector.emplace_back(support::cpp14::make_unique<CLFillBorderKernel>());
+        _border_handlers_vector.emplace_back(std::make_unique<CLFillBorderKernel>());
         _border_handlers_vector[0]->configure(compile_context, input, _reduction_kernels_vector[0]->border_size(), BorderMode::CONSTANT, pixelValue);
 
         // Apply ReductionOperation on intermediate stages
@@ -284,10 +283,10 @@ void CLReductionOperation::configure(const CLCompileContext &compile_context, IC
         {
             _memory_group.manage(&_results_vector[i]);
 
-            _reduction_kernels_vector.emplace_back(support::cpp14::make_unique<CLReductionOperationKernel>());
+            _reduction_kernels_vector.emplace_back(std::make_unique<CLReductionOperationKernel>());
             _reduction_kernels_vector[i]->configure(compile_context, &_results_vector[i - 1], &_results_vector[i], axis, intermediate_kernel_op);
 
-            _border_handlers_vector.emplace_back(support::cpp14::make_unique<CLFillBorderKernel>());
+            _border_handlers_vector.emplace_back(std::make_unique<CLFillBorderKernel>());
             _border_handlers_vector[i]->configure(compile_context, &_results_vector[i - 1], _reduction_kernels_vector[i]->border_size(), BorderMode::CONSTANT, pixelValue);
 
             _results_vector[i - 1].allocator()->allocate();
@@ -302,10 +301,10 @@ void CLReductionOperation::configure(const CLCompileContext &compile_context, IC
             _memory_group.manage(&_results_vector.back());
         }
 
-        _reduction_kernels_vector.emplace_back(support::cpp14::make_unique<CLReductionOperationKernel>());
+        _reduction_kernels_vector.emplace_back(std::make_unique<CLReductionOperationKernel>());
         _reduction_kernels_vector[last_stage]->configure(compile_context, &_results_vector[last_stage - 1], output_internal, axis, last_kernel_op, input_width);
 
-        _border_handlers_vector.emplace_back(support::cpp14::make_unique<CLFillBorderKernel>());
+        _border_handlers_vector.emplace_back(std::make_unique<CLFillBorderKernel>());
         _border_handlers_vector[last_stage]->configure(compile_context, &_results_vector[last_stage - 1], _reduction_kernels_vector[last_stage]->border_size(), BorderMode::CONSTANT, pixelValue);
 
         _results_vector[last_stage - 1].allocator()->allocate();
diff --git a/src/runtime/CL/functions/CLRemap.cpp b/src/runtime/CL/functions/CLRemap.cpp
index 6466c2843b..a4cfc60368 100644
--- a/src/runtime/CL/functions/CLRemap.cpp
+++ b/src/runtime/CL/functions/CLRemap.cpp
@@ -30,7 +30,6 @@
 #include "arm_compute/core/Validate.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLRemapKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -51,7 +50,7 @@ void CLRemap::configure(const CLCompileContext &compile_context, ICLTensor *inpu
     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(map_y, 1, DataType::F32);
     ARM_COMPUTE_ERROR_ON_MSG(policy == InterpolationPolicy::AREA, "Area interpolation is not supported");
 
-    auto k = arm_compute::support::cpp14::make_unique<CLRemapKernel>();
+    auto k = std::make_unique<CLRemapKernel>();
     k->configure(compile_context, input, map_x, map_y, output, policy, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLReorgLayer.cpp b/src/runtime/CL/functions/CLReorgLayer.cpp
index 4b2f70334f..69b28abab3 100644
--- a/src/runtime/CL/functions/CLReorgLayer.cpp
+++ b/src/runtime/CL/functions/CLReorgLayer.cpp
@@ -28,7 +28,6 @@
 #include "arm_compute/core/TensorInfo.h"
 #include "arm_compute/core/Validate.h"
 #include "src/core/CL/kernels/CLReorgLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -41,7 +40,7 @@ void CLReorgLayer::configure(ICLTensor *input, ICLTensor *output, int32_t stride
 
 void CLReorgLayer::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, int32_t stride)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLReorgLayerKernel>();
+    auto k = std::make_unique<CLReorgLayerKernel>();
     k->configure(compile_context, input, output, stride);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLReshapeLayer.cpp b/src/runtime/CL/functions/CLReshapeLayer.cpp
index 5112064b23..9abaa1b4e1 100644
--- a/src/runtime/CL/functions/CLReshapeLayer.cpp
+++ b/src/runtime/CL/functions/CLReshapeLayer.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "src/core/CL/kernels/CLReshapeLayerKernel.h"
-#include "support/MemorySupport.h"
 
 /** [CLReshapeLayer snippet] **/
 namespace arm_compute
@@ -34,7 +33,7 @@ namespace experimental
 {
 void CLReshape::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLReshapeLayerKernel>();
+    auto k = std::make_unique<CLReshapeLayerKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
@@ -53,7 +52,7 @@ struct CLReshapeLayer::Impl
 };
 
 CLReshapeLayer::CLReshapeLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -70,7 +69,7 @@ void CLReshapeLayer::configure(const CLCompileContext &compile_context, const IC
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLReshape>();
+    _impl->op  = std::make_unique<experimental::CLReshape>();
     _impl->op->configure(compile_context, input->info(), output->info());
 }
 
diff --git a/src/runtime/CL/functions/CLReverse.cpp b/src/runtime/CL/functions/CLReverse.cpp
index b73d8de62e..2a845bae13 100644
--- a/src/runtime/CL/functions/CLReverse.cpp
+++ b/src/runtime/CL/functions/CLReverse.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLReverseKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -36,7 +35,7 @@ void CLReverse::configure(const ICLTensor *input, ICLTensor *output, const ICLTe
 
 void CLReverse::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, const ICLTensor *axis)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLReverseKernel>();
+    auto k = std::make_unique<CLReverseKernel>();
     k->configure(compile_context, input, output, axis);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLScale.cpp b/src/runtime/CL/functions/CLScale.cpp
index 383b0cc305..6658957e07 100644
--- a/src/runtime/CL/functions/CLScale.cpp
+++ b/src/runtime/CL/functions/CLScale.cpp
@@ -29,7 +29,6 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLScaleKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -46,7 +45,7 @@ void CLScale::configure(ICLTensor *input, ICLTensor *output, InterpolationPolicy
 
 void CLScale::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const ScaleKernelInfo &info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLScaleKernel>();
+    auto k = std::make_unique<CLScaleKernel>();
     k->set_target(CLScheduler::get().target());
     k->configure(compile_context, input, output, info);
     _kernel = std::move(k);
diff --git a/src/runtime/CL/functions/CLScharr3x3.cpp b/src/runtime/CL/functions/CLScharr3x3.cpp
index e5d0d2d630..563ec19266 100644
--- a/src/runtime/CL/functions/CLScharr3x3.cpp
+++ b/src/runtime/CL/functions/CLScharr3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLScharr3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ void CLScharr3x3::configure(ICLTensor *input, ICLTensor *output_x, ICLTensor *ou
 
 void CLScharr3x3::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output_x, ICLTensor *output_y, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLScharr3x3Kernel>();
+    auto k = std::make_unique<CLScharr3x3Kernel>();
     k->configure(compile_context, input, output_x, output_y, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLSelect.cpp b/src/runtime/CL/functions/CLSelect.cpp
index 374da91b78..5ec18a032f 100644
--- a/src/runtime/CL/functions/CLSelect.cpp
+++ b/src/runtime/CL/functions/CLSelect.cpp
@@ -27,8 +27,6 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLSelectKernel.h"
 
-#include "support/MemorySupport.h"
-
 using namespace arm_compute;
 
 namespace arm_compute
@@ -40,7 +38,7 @@ void CLSelect::configure(const ICLTensor *c, const ICLTensor *x, const ICLTensor
 
 void CLSelect::configure(const CLCompileContext &compile_context, const ICLTensor *c, const ICLTensor *x, const ICLTensor *y, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLSelectKernel>();
+    auto k = std::make_unique<CLSelectKernel>();
     k->configure(compile_context, c, x, y, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLSlice.cpp b/src/runtime/CL/functions/CLSlice.cpp
index 940540563a..7f39143dc7 100644
--- a/src/runtime/CL/functions/CLSlice.cpp
+++ b/src/runtime/CL/functions/CLSlice.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/utils/helpers/tensor_transform.h"
 #include "src/core/CL/kernels/CLStridedSliceKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -40,7 +39,7 @@ void CLSlice::configure(const CLCompileContext &compile_context, const ITensorIn
     // Get absolute end coordinates
     const int32_t slice_end_mask = arm_compute::helpers::tensor_transform::construct_slice_end_mask(ends);
 
-    auto k = arm_compute::support::cpp14::make_unique<CLStridedSliceKernel>();
+    auto k = std::make_unique<CLStridedSliceKernel>();
     k->configure(compile_context, input, output, starts, ends, BiStrides(), 0, slice_end_mask, 0);
     _kernel = std::move(k);
 }
@@ -70,7 +69,7 @@ struct CLSlice::Impl
 };
 
 CLSlice::CLSlice()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 CLSlice::CLSlice(CLSlice &&) = default;
@@ -91,7 +90,7 @@ void CLSlice::configure(const CLCompileContext &compile_context, const ICLTensor
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::CLSlice>();
+    _impl->op  = std::make_unique<experimental::CLSlice>();
     _impl->op->configure(compile_context, input->info(), output->info(), starts, ends);
 }
 
diff --git a/src/runtime/CL/functions/CLSobel3x3.cpp b/src/runtime/CL/functions/CLSobel3x3.cpp
index 78376f935a..6724c12a72 100644
--- a/src/runtime/CL/functions/CLSobel3x3.cpp
+++ b/src/runtime/CL/functions/CLSobel3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLSobel3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -41,7 +40,7 @@ void CLSobel3x3::configure(ICLTensor *input, ICLTensor *output_x, ICLTensor *out
 
 void CLSobel3x3::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output_x, ICLTensor *output_y, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLSobel3x3Kernel>();
+    auto k = std::make_unique<CLSobel3x3Kernel>();
     k->configure(compile_context, input, output_x, output_y, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLSobel5x5.cpp b/src/runtime/CL/functions/CLSobel5x5.cpp
index fa5d8945fb..98f215794c 100644
--- a/src/runtime/CL/functions/CLSobel5x5.cpp
+++ b/src/runtime/CL/functions/CLSobel5x5.cpp
@@ -31,15 +31,14 @@
 #include "arm_compute/runtime/ITensorAllocator.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLSobel5x5Kernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLSobel5x5::CLSobel5x5(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _sobel_hor(support::cpp14::make_unique<CLSobel5x5HorKernel>()),
-      _sobel_vert(support::cpp14::make_unique<CLSobel5x5VertKernel>()),
-      _border_handler(support::cpp14::make_unique<CLFillBorderKernel>()),
+      _sobel_hor(std::make_unique<CLSobel5x5HorKernel>()),
+      _sobel_vert(std::make_unique<CLSobel5x5VertKernel>()),
+      _border_handler(std::make_unique<CLFillBorderKernel>()),
       _tmp_x(),
       _tmp_y()
 {
diff --git a/src/runtime/CL/functions/CLSobel7x7.cpp b/src/runtime/CL/functions/CLSobel7x7.cpp
index f462adb0ed..a3d63f98dd 100644
--- a/src/runtime/CL/functions/CLSobel7x7.cpp
+++ b/src/runtime/CL/functions/CLSobel7x7.cpp
@@ -31,15 +31,14 @@
 #include "arm_compute/runtime/ITensorAllocator.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLSobel7x7Kernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
 CLSobel7x7::CLSobel7x7(std::shared_ptr<IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)),
-      _sobel_hor(support::cpp14::make_unique<CLSobel7x7HorKernel>()),
-      _sobel_vert(support::cpp14::make_unique<CLSobel7x7VertKernel>()),
-      _border_handler(support::cpp14::make_unique<CLFillBorderKernel>()),
+      _sobel_hor(std::make_unique<CLSobel7x7HorKernel>()),
+      _sobel_vert(std::make_unique<CLSobel7x7VertKernel>()),
+      _border_handler(std::make_unique<CLFillBorderKernel>()),
       _tmp_x(),
       _tmp_y()
 {
diff --git a/src/runtime/CL/functions/CLSoftmaxLayer.cpp b/src/runtime/CL/functions/CLSoftmaxLayer.cpp
index 4caf91488e..93e63dd779 100644
--- a/src/runtime/CL/functions/CLSoftmaxLayer.cpp
+++ b/src/runtime/CL/functions/CLSoftmaxLayer.cpp
@@ -33,7 +33,6 @@
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLSoftmaxLayerKernel.h"
 #include "src/core/helpers/SoftmaxHelpers.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -42,8 +41,8 @@ CLSoftmaxLayerGeneric<IS_LOG>::CLSoftmaxLayerGeneric(std::shared_ptr<IMemoryMana
     : _memory_group(std::move(memory_manager)),
       _permute_input(),
       _permute_output(),
-      _max_shift_exp_sum_kernel(support::cpp14::make_unique<CLLogits1DMaxShiftExpSumKernel>()),
-      _norm_kernel(support::cpp14::make_unique<CLLogits1DNormKernel>()),
+      _max_shift_exp_sum_kernel(std::make_unique<CLLogits1DMaxShiftExpSumKernel>()),
+      _norm_kernel(std::make_unique<CLLogits1DNormKernel>()),
       _max(),
       _sum(),
       _tmp(),
diff --git a/src/runtime/CL/functions/CLSpaceToBatchLayer.cpp b/src/runtime/CL/functions/CLSpaceToBatchLayer.cpp
index e83def5677..2db064af44 100644
--- a/src/runtime/CL/functions/CLSpaceToBatchLayer.cpp
+++ b/src/runtime/CL/functions/CLSpaceToBatchLayer.cpp
@@ -31,13 +31,12 @@
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLMemsetKernel.h"
 #include "src/core/CL/kernels/CLSpaceToBatchLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLSpaceToBatchLayer::CLSpaceToBatchLayer()
-    : _space_to_batch_kernel(support::cpp14::make_unique<CLSpaceToBatchLayerKernel>()),
-      _memset_kernel(support::cpp14::make_unique<CLMemsetKernel>()),
+    : _space_to_batch_kernel(std::make_unique<CLSpaceToBatchLayerKernel>()),
+      _memset_kernel(std::make_unique<CLMemsetKernel>()),
       _has_padding(false)
 {
 }
diff --git a/src/runtime/CL/functions/CLSpaceToDepthLayer.cpp b/src/runtime/CL/functions/CLSpaceToDepthLayer.cpp
index db8c4953cc..842d5bc5cc 100644
--- a/src/runtime/CL/functions/CLSpaceToDepthLayer.cpp
+++ b/src/runtime/CL/functions/CLSpaceToDepthLayer.cpp
@@ -30,12 +30,11 @@
 #include "arm_compute/core/Validate.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLSpaceToDepthLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLSpaceToDepthLayer::CLSpaceToDepthLayer()
-    : _space_to_depth_kernel(support::cpp14::make_unique<CLSpaceToDepthLayerKernel>())
+    : _space_to_depth_kernel(std::make_unique<CLSpaceToDepthLayerKernel>())
 {
 }
 
diff --git a/src/runtime/CL/functions/CLStackLayer.cpp b/src/runtime/CL/functions/CLStackLayer.cpp
index f4aa78a72d..3ef6a27675 100644
--- a/src/runtime/CL/functions/CLStackLayer.cpp
+++ b/src/runtime/CL/functions/CLStackLayer.cpp
@@ -33,7 +33,6 @@
 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLStackLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -61,7 +60,7 @@ void CLStackLayer::configure(const CLCompileContext &compile_context, const std:
 
     for(unsigned int i = 0; i < _num_inputs; i++)
     {
-        _stack_kernels.emplace_back(support::cpp14::make_unique<CLStackLayerKernel>());
+        _stack_kernels.emplace_back(std::make_unique<CLStackLayerKernel>());
         _stack_kernels.back()->configure(compile_context, input[i], axis_u, i, _num_inputs, output);
     }
 }
diff --git a/src/runtime/CL/functions/CLStridedSlice.cpp b/src/runtime/CL/functions/CLStridedSlice.cpp
index 3f6814f5ce..fd3db9341a 100644
--- a/src/runtime/CL/functions/CLStridedSlice.cpp
+++ b/src/runtime/CL/functions/CLStridedSlice.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/CL/ICLTensor.h"
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLStridedSliceKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -36,7 +35,7 @@ void CLStridedSlice::configure(const CLCompileContext &compile_context, const IT
                                const Coordinates &starts, const Coordinates &ends, const BiStrides &strides,
                                int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLStridedSliceKernel>();
+    auto k = std::make_unique<CLStridedSliceKernel>();
     k->configure(compile_context, input, output, starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
     _kernel = std::move(k);
 }
@@ -58,7 +57,7 @@ struct CLStridedSlice::Impl
 };
 
 CLStridedSlice::CLStridedSlice(CLRuntimeContext *ctx)
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
     _impl->ctx = ctx;
 }
@@ -83,7 +82,7 @@ void CLStridedSlice::configure(const CLCompileContext &compile_context, const IC
     _impl->src = input;
     _impl->dst = output;
 
-    _impl->op = arm_compute::support::cpp14::make_unique<experimental::CLStridedSlice>();
+    _impl->op = std::make_unique<experimental::CLStridedSlice>();
     _impl->op->configure(compile_context, _impl->src->info(), _impl->dst->info(), starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
 }
 
diff --git a/src/runtime/CL/functions/CLTableLookup.cpp b/src/runtime/CL/functions/CLTableLookup.cpp
index 8282f37e4b..a4671f51bd 100644
--- a/src/runtime/CL/functions/CLTableLookup.cpp
+++ b/src/runtime/CL/functions/CLTableLookup.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLTableLookup.h"
 
 #include "src/core/CL/kernels/CLTableLookupKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLTableLookup::configure(const ICLTensor *input, const ICLLut *lut, ICLTens
 
 void CLTableLookup::configure(const CLCompileContext &compile_context, const ICLTensor *input, const ICLLut *lut, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLTableLookupKernel>();
+    auto k = std::make_unique<CLTableLookupKernel>();
     k->configure(compile_context, input, lut, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLThreshold.cpp b/src/runtime/CL/functions/CLThreshold.cpp
index 250f6f034f..901cfd8993 100644
--- a/src/runtime/CL/functions/CLThreshold.cpp
+++ b/src/runtime/CL/functions/CLThreshold.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLThreshold.h"
 
 #include "src/core/CL/kernels/CLThresholdKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -42,7 +41,7 @@ void CLThreshold::configure(const ICLTensor *input, ICLTensor *output, const Thr
 
 void CLThreshold::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, const ThresholdKernelInfo &info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLThresholdKernel>();
+    auto k = std::make_unique<CLThresholdKernel>();
     k->configure(compile_context, input, output, info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLTile.cpp b/src/runtime/CL/functions/CLTile.cpp
index 8384e48baf..818f10f1ac 100644
--- a/src/runtime/CL/functions/CLTile.cpp
+++ b/src/runtime/CL/functions/CLTile.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLTile.h"
 
 #include "src/core/CL/kernels/CLTileKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -35,7 +34,7 @@ void CLTile::configure(const ICLTensor *input, ICLTensor *output, const Multiple
 
 void CLTile::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, const Multiples &multiples)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLTileKernel>();
+    auto k = std::make_unique<CLTileKernel>();
     k->configure(compile_context, input, output, multiples);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLTranspose.cpp b/src/runtime/CL/functions/CLTranspose.cpp
index 43fa7a012a..c74503f4c0 100644
--- a/src/runtime/CL/functions/CLTranspose.cpp
+++ b/src/runtime/CL/functions/CLTranspose.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/CL/functions/CLTranspose.h"
 
 #include "src/core/CL/kernels/CLTransposeKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void CLTranspose::configure(const ICLTensor *input, ICLTensor *output)
 
 void CLTranspose::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLTransposeKernel>();
+    auto k = std::make_unique<CLTransposeKernel>();
     k->configure(compile_context, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/functions/CLUpsampleLayer.cpp b/src/runtime/CL/functions/CLUpsampleLayer.cpp
index 10b4b76a5e..538f27f565 100644
--- a/src/runtime/CL/functions/CLUpsampleLayer.cpp
+++ b/src/runtime/CL/functions/CLUpsampleLayer.cpp
@@ -27,12 +27,11 @@
 #include "arm_compute/core/Utils.h"
 #include "arm_compute/runtime/CL/CLScheduler.h"
 #include "src/core/CL/kernels/CLUpsampleLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 CLUpsampleLayer::CLUpsampleLayer() // NOLINT
-    : _upsample(support::cpp14::make_unique<CLUpsampleLayerKernel>()),
+    : _upsample(std::make_unique<CLUpsampleLayerKernel>()),
       _output(nullptr)
 {
 }
diff --git a/src/runtime/CL/functions/CLWarpAffine.cpp b/src/runtime/CL/functions/CLWarpAffine.cpp
index 86e5a7bd86..9a22446cf6 100644
--- a/src/runtime/CL/functions/CLWarpAffine.cpp
+++ b/src/runtime/CL/functions/CLWarpAffine.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLWarpAffineKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -40,7 +39,7 @@ void CLWarpAffine::configure(ICLTensor *input, ICLTensor *output, const std::arr
 void CLWarpAffine::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const std::array<float, 9> &matrix, InterpolationPolicy policy, BorderMode border_mode,
                              uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLWarpAffineKernel>();
+    auto k = std::make_unique<CLWarpAffineKernel>();
     k->configure(compile_context, input, output, matrix, policy);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLWarpPerspective.cpp b/src/runtime/CL/functions/CLWarpPerspective.cpp
index 7e8bc5cdff..0ec6b42e75 100644
--- a/src/runtime/CL/functions/CLWarpPerspective.cpp
+++ b/src/runtime/CL/functions/CLWarpPerspective.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLWarpPerspectiveKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -40,7 +39,7 @@ void CLWarpPerspective::configure(ICLTensor *input, ICLTensor *output, const std
 void CLWarpPerspective::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const std::array<float, 9> &matrix, InterpolationPolicy policy, BorderMode border_mode,
                                   uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLWarpPerspectiveKernel>();
+    auto k = std::make_unique<CLWarpPerspectiveKernel>();
     k->configure(compile_context, input, output, matrix, policy);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/CL/functions/CLWinogradConvolutionLayer.cpp b/src/runtime/CL/functions/CLWinogradConvolutionLayer.cpp
index 7af42904e8..321466f05f 100644
--- a/src/runtime/CL/functions/CLWinogradConvolutionLayer.cpp
+++ b/src/runtime/CL/functions/CLWinogradConvolutionLayer.cpp
@@ -36,7 +36,6 @@
 #include "src/core/CL/kernels/CLGEMMReshapeRHSMatrixKernel.h"
 #include "src/core/CL/kernels/CLWinogradFilterTransformKernel.h"
 #include "src/core/CL/kernels/CLWinogradOutputTransformKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -99,8 +98,8 @@ bool check_support_fast_math(const Size2D &output_tile, const Size2D &kernel_siz
 } // namespace
 
 CLWinogradConvolutionLayer::CLWinogradConvolutionLayer(std::shared_ptr<IMemoryManager> memory_manager)
-    : _memory_group(memory_manager), _batched_mm(memory_manager), _input_transform(), _filter_transform(support::cpp14::make_unique<CLWinogradFilterTransformKernel>()),
-      _output_transform(support::cpp14::make_unique<CLWinogradOutputTransformKernel>()), _input0(), _input1(), _batched_mm_output(), _original_weights(nullptr), _is_prepared(false)
+    : _memory_group(memory_manager), _batched_mm(memory_manager), _input_transform(), _filter_transform(std::make_unique<CLWinogradFilterTransformKernel>()),
+      _output_transform(std::make_unique<CLWinogradOutputTransformKernel>()), _input0(), _input1(), _batched_mm_output(), _original_weights(nullptr), _is_prepared(false)
 {
 }
 
diff --git a/src/runtime/CL/functions/CLWinogradInputTransform.cpp b/src/runtime/CL/functions/CLWinogradInputTransform.cpp
index 308c41f714..6d5a692bc3 100644
--- a/src/runtime/CL/functions/CLWinogradInputTransform.cpp
+++ b/src/runtime/CL/functions/CLWinogradInputTransform.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/Error.h"
 #include "src/core/CL/kernels/CLFillBorderKernel.h"
 #include "src/core/CL/kernels/CLWinogradInputTransformKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -38,7 +37,7 @@ void CLWinogradInputTransform::configure(ICLTensor *input, ICLTensor *output, co
 
 void CLWinogradInputTransform::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const WinogradInfo &winograd_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLWinogradInputTransformKernel>();
+    auto k = std::make_unique<CLWinogradInputTransformKernel>();
     k->configure(compile_context, input, output, winograd_info);
     _kernel = std::move(k);
     _border_handler->configure(compile_context, input, _kernel->border_size(), BorderMode::CONSTANT, PixelValue());
diff --git a/src/runtime/CL/functions/CLYOLOLayer.cpp b/src/runtime/CL/functions/CLYOLOLayer.cpp
index 46bf220b0c..e21d9a7fbb 100644
--- a/src/runtime/CL/functions/CLYOLOLayer.cpp
+++ b/src/runtime/CL/functions/CLYOLOLayer.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/Types.h"
 #include "src/core/CL/kernels/CLYOLOLayerKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute;
 
@@ -36,7 +35,7 @@ void CLYOLOLayer::configure(ICLTensor *input, ICLTensor *output, const Activatio
 
 void CLYOLOLayer::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const ActivationLayerInfo &act_info, int32_t num_classes)
 {
-    auto k = arm_compute::support::cpp14::make_unique<CLYOLOLayerKernel>();
+    auto k = std::make_unique<CLYOLOLayerKernel>();
     k->configure(compile_context, input, output, act_info, num_classes);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/CL/gemm/CLGEMMKernelSelection.h b/src/runtime/CL/gemm/CLGEMMKernelSelection.h
index f6fad7e4ff..69f8349d27 100644
--- a/src/runtime/CL/gemm/CLGEMMKernelSelection.h
+++ b/src/runtime/CL/gemm/CLGEMMKernelSelection.h
@@ -29,8 +29,6 @@
 #include "src/runtime/CL/gemm/CLGEMMKernelSelectionMidgard.h"
 #include "src/runtime/CL/gemm/CLGEMMKernelSelectionValhall.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 namespace cl_gemm
@@ -50,11 +48,11 @@ public:
         switch(get_arch_from_target(gpu))
         {
             case GPUTarget::MIDGARD:
-                return support::cpp14::make_unique<CLGEMMKernelSelectionMidgard>(gpu);
+                return std::make_unique<CLGEMMKernelSelectionMidgard>(gpu);
             case GPUTarget::BIFROST:
-                return support::cpp14::make_unique<CLGEMMKernelSelectionBifrost>(gpu);
+                return std::make_unique<CLGEMMKernelSelectionBifrost>(gpu);
             case GPUTarget::VALHALL:
-                return support::cpp14::make_unique<CLGEMMKernelSelectionValhall>(gpu);
+                return std::make_unique<CLGEMMKernelSelectionValhall>(gpu);
             default:
                 ARM_COMPUTE_ERROR("Not supported GPU target");
         }