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>
author: Georgios Pinitas <georgios.pinitas@arm.com> 2020-11-21 03:04:18 +0000
committer: Georgios Pinitas <georgios.pinitas@arm.com> 2020-12-01 10:41:54 +0000
commit: 40f51a63c8e7258db15269427ae4fe1ad199c550 (patch)
tree: 353253a41863966995a45556731e7181a643c003 /src/runtime/NEON
parent: 327800401c4185d98fcc01b9c9efbc038a4228ed (diff)
download: ComputeLibrary-40f51a63c8e7258db15269427ae4fe1ad199c550.tar.gz
121 files changed, 341 insertions, 473 deletions
diff --git a/src/runtime/NEON/functions/NEAbsoluteDifference.cpp b/src/runtime/NEON/functions/NEAbsoluteDifference.cpp
index df2bc7d72e..1c37af980e 100644
--- a/src/runtime/NEON/functions/NEAbsoluteDifference.cpp
+++ b/src/runtime/NEON/functions/NEAbsoluteDifference.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEAbsoluteDifference.h"
 
 #include "src/core/NEON/kernels/NEAbsoluteDifferenceKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ NEAbsoluteDifference::~NEAbsoluteDifference() = default;
 
 void NEAbsoluteDifference::configure(const ITensor *input1, const ITensor *input2, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEAbsoluteDifferenceKernel>();
+    auto k = std::make_unique<NEAbsoluteDifferenceKernel>();
     k->configure(input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEAccumulate.cpp b/src/runtime/NEON/functions/NEAccumulate.cpp
index 20eefd9d2d..b81ec24a39 100644
--- a/src/runtime/NEON/functions/NEAccumulate.cpp
+++ b/src/runtime/NEON/functions/NEAccumulate.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEAccumulate.h"
 
 #include "src/core/NEON/kernels/NEAccumulateKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ NEAccumulate::~NEAccumulate() = default;
 
 void NEAccumulate::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEAccumulateKernel>();
+    auto k = std::make_unique<NEAccumulateKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
@@ -45,13 +44,13 @@ void NEAccumulateWeighted::configure(const ITensor *input, float alpha, ITensor
 {
     if(use_fp16)
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEAccumulateWeightedFP16Kernel>();
+        auto k = std::make_unique<NEAccumulateWeightedFP16Kernel>();
         k->configure(input, alpha, output);
         _kernel = std::move(k);
     }
     else
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEAccumulateWeightedKernel>();
+        auto k = std::make_unique<NEAccumulateWeightedKernel>();
         k->configure(input, alpha, output);
         _kernel = std::move(k);
     }
@@ -61,7 +60,7 @@ NEAccumulateSquared::~NEAccumulateSquared() = default;
 
 void NEAccumulateSquared::configure(const ITensor *input, uint32_t shift, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEAccumulateSquaredKernel>();
+    auto k = std::make_unique<NEAccumulateSquaredKernel>();
     k->configure(input, shift, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEActivationLayer.cpp b/src/runtime/NEON/functions/NEActivationLayer.cpp
index f9ad298e4d..27f01f67ce 100644
--- a/src/runtime/NEON/functions/NEActivationLayer.cpp
+++ b/src/runtime/NEON/functions/NEActivationLayer.cpp
@@ -28,7 +28,6 @@
 #include "arm_compute/runtime/IRuntimeContext.h"
 #include "arm_compute/runtime/Tensor.h"
 #include "src/core/NEON/kernels/NEActivationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -38,7 +37,7 @@ NEActivationLayer::~NEActivationLayer() = default;
 
 void NEActivationLayer::configure(const ITensorInfo *input, ITensorInfo *output, const ActivationLayerInfo &activation_info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEActivationLayerKernel>();
+    auto k = std::make_unique<NEActivationLayerKernel>();
     k->configure(input, output, activation_info);
     _kernel = std::move(k);
 }
@@ -58,7 +57,7 @@ struct NEActivationLayer::Impl
 };
 
 NEActivationLayer::NEActivationLayer(IRuntimeContext *ctx)
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
     _impl->ctx = ctx;
 }
@@ -76,7 +75,7 @@ void NEActivationLayer::configure(ITensor *input, ITensor *output, ActivationLay
     _impl->src = input;
     _impl->dst = output == nullptr ? input : output;
 
-    _impl->op = arm_compute::support::cpp14::make_unique<experimental::NEActivationLayer>();
+    _impl->op = std::make_unique<experimental::NEActivationLayer>();
     _impl->op->configure(_impl->src->info(), _impl->dst->info(), activation_info);
 }
 
diff --git a/src/runtime/NEON/functions/NEArgMinMaxLayer.cpp b/src/runtime/NEON/functions/NEArgMinMaxLayer.cpp
index 2a9bb76c7f..7bca20d46c 100644
--- a/src/runtime/NEON/functions/NEArgMinMaxLayer.cpp
+++ b/src/runtime/NEON/functions/NEArgMinMaxLayer.cpp
@@ -31,14 +31,12 @@
 #include "arm_compute/core/Validate.h"
 #include "src/core/NEON/kernels/NEReductionOperationKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 NEArgMinMaxLayer::~NEArgMinMaxLayer() = default;
 
 NEArgMinMaxLayer::NEArgMinMaxLayer(std::shared_ptr<IMemoryManager> memory_manager)
-    : _reduction_function(support::cpp14::make_unique<NEReductionOperation>())
+    : _reduction_function(std::make_unique<NEReductionOperation>())
 {
     ARM_COMPUTE_UNUSED(memory_manager);
 }
diff --git a/src/runtime/NEON/functions/NEArithmeticAddition.cpp b/src/runtime/NEON/functions/NEArithmeticAddition.cpp
index 0bf9a09333..1eaccf3396 100644
--- a/src/runtime/NEON/functions/NEArithmeticAddition.cpp
+++ b/src/runtime/NEON/functions/NEArithmeticAddition.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/ITensor.h"
 #include "src/core/NEON/kernels/NEArithmeticAdditionKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -38,7 +37,7 @@ NEArithmeticAddition::~NEArithmeticAddition() = default;
 void NEArithmeticAddition::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output, ConvertPolicy policy, const ActivationLayerInfo &act_info)
 {
     ARM_COMPUTE_UNUSED(act_info);
-    auto k = arm_compute::support::cpp14::make_unique<NEArithmeticAdditionKernel>();
+    auto k = std::make_unique<NEArithmeticAdditionKernel>();
     k->configure(input1, input2, output, policy);
     _kernel = std::move(k);
 }
@@ -58,7 +57,7 @@ struct NEArithmeticAddition::Impl
 };
 
 NEArithmeticAddition::NEArithmeticAddition()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEArithmeticAddition::NEArithmeticAddition(NEArithmeticAddition &&) = default;
@@ -75,7 +74,7 @@ void NEArithmeticAddition::configure(const ITensor *input1, const ITensor *input
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEArithmeticAddition>();
+    _impl->op    = std::make_unique<experimental::NEArithmeticAddition>();
     _impl->op->configure(input1->info(), input2->info(), output->info(), policy, act_info);
 }
 
diff --git a/src/runtime/NEON/functions/NEArithmeticSubtraction.cpp b/src/runtime/NEON/functions/NEArithmeticSubtraction.cpp
index ba3f426269..512cfd6f70 100644
--- a/src/runtime/NEON/functions/NEArithmeticSubtraction.cpp
+++ b/src/runtime/NEON/functions/NEArithmeticSubtraction.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/ITensor.h"
 #include "src/core/NEON/kernels/NEArithmeticSubtractionKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -36,7 +35,7 @@ namespace experimental
 void NEArithmeticSubtraction::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output, ConvertPolicy policy, const ActivationLayerInfo &act_info)
 {
     ARM_COMPUTE_UNUSED(act_info);
-    auto k = arm_compute::support::cpp14::make_unique<NEArithmeticSubtractionKernel>();
+    auto k = std::make_unique<NEArithmeticSubtractionKernel>();
     k->configure(input1, input2, output, policy);
     _kernel = std::move(k);
 }
@@ -57,7 +56,7 @@ struct NEArithmeticSubtraction::Impl
 };
 
 NEArithmeticSubtraction::NEArithmeticSubtraction()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEArithmeticSubtraction::NEArithmeticSubtraction(NEArithmeticSubtraction &&) = default;
@@ -74,7 +73,7 @@ void NEArithmeticSubtraction::configure(const ITensor *input1, const ITensor *in
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEArithmeticSubtraction>();
+    _impl->op    = std::make_unique<experimental::NEArithmeticSubtraction>();
     _impl->op->configure(input1->info(), input2->info(), output->info(), policy, act_info);
 }
 
diff --git a/src/runtime/NEON/functions/NEBatchNormalizationLayer.cpp b/src/runtime/NEON/functions/NEBatchNormalizationLayer.cpp
index d0fdfcf101..b90a38b47f 100644
--- a/src/runtime/NEON/functions/NEBatchNormalizationLayer.cpp
+++ b/src/runtime/NEON/functions/NEBatchNormalizationLayer.cpp
@@ -31,8 +31,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEBatchNormalizationLayerKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 NEBatchNormalizationLayer::~NEBatchNormalizationLayer() = default;
@@ -46,7 +44,7 @@ void NEBatchNormalizationLayer::configure(ITensor *input, ITensor *output, const
                                           ActivationLayerInfo act_info)
 {
     // Configure kernel
-    _norm_kernel = arm_compute::support::cpp14::make_unique<NEBatchNormalizationLayerKernel>();
+    _norm_kernel = std::make_unique<NEBatchNormalizationLayerKernel>();
     _norm_kernel->configure(input, output, mean, var, beta, gamma, epsilon, act_info);
 }
 
diff --git a/src/runtime/NEON/functions/NEBatchToSpaceLayer.cpp b/src/runtime/NEON/functions/NEBatchToSpaceLayer.cpp
index 77a63c0f63..8f537a650a 100644
--- a/src/runtime/NEON/functions/NEBatchToSpaceLayer.cpp
+++ b/src/runtime/NEON/functions/NEBatchToSpaceLayer.cpp
@@ -30,20 +30,18 @@
 #include "arm_compute/core/Validate.h"
 #include "src/core/NEON/kernels/NEBatchToSpaceLayerKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 void NEBatchToSpaceLayer::configure(const ITensor *input, const ITensor *block_shape, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEBatchToSpaceLayerKernel>();
+    auto k = std::make_unique<NEBatchToSpaceLayerKernel>();
     k->configure(input, block_shape, output);
     _kernel = std::move(k);
 }
 
 void NEBatchToSpaceLayer::configure(const ITensor *input, int32_t block_shape_x, int32_t block_shape_y, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEBatchToSpaceLayerKernel>();
+    auto k = std::make_unique<NEBatchToSpaceLayerKernel>();
     k->configure(input, block_shape_x, block_shape_y, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEBitwiseAnd.cpp b/src/runtime/NEON/functions/NEBitwiseAnd.cpp
index f3b5220ccf..81c087988a 100644
--- a/src/runtime/NEON/functions/NEBitwiseAnd.cpp
+++ b/src/runtime/NEON/functions/NEBitwiseAnd.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEBitwiseAnd.h"
 
 #include "src/core/NEON/kernels/NEBitwiseAndKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ using namespace arm_compute;
 
 void NEBitwiseAnd::configure(const ITensor *input1, const ITensor *input2, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEBitwiseAndKernel>();
+    auto k = std::make_unique<NEBitwiseAndKernel>();
     k->configure(input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEBitwiseNot.cpp b/src/runtime/NEON/functions/NEBitwiseNot.cpp
index 036584ea1a..3155df5db3 100644
--- a/src/runtime/NEON/functions/NEBitwiseNot.cpp
+++ b/src/runtime/NEON/functions/NEBitwiseNot.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEBitwiseNot.h"
 
 #include "src/core/NEON/kernels/NEBitwiseNotKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ using namespace arm_compute;
 
 void NEBitwiseNot::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEBitwiseNotKernel>();
+    auto k = std::make_unique<NEBitwiseNotKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEBitwiseOr.cpp b/src/runtime/NEON/functions/NEBitwiseOr.cpp
index fc905a0919..793eb25d80 100644
--- a/src/runtime/NEON/functions/NEBitwiseOr.cpp
+++ b/src/runtime/NEON/functions/NEBitwiseOr.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEBitwiseOr.h"
 
 #include "src/core/NEON/kernels/NEBitwiseOrKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ using namespace arm_compute;
 
 void NEBitwiseOr::configure(const ITensor *input1, const ITensor *input2, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEBitwiseOrKernel>();
+    auto k = std::make_unique<NEBitwiseOrKernel>();
     k->configure(input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEBitwiseXor.cpp b/src/runtime/NEON/functions/NEBitwiseXor.cpp
index 301a0c4659..2d0af63e35 100644
--- a/src/runtime/NEON/functions/NEBitwiseXor.cpp
+++ b/src/runtime/NEON/functions/NEBitwiseXor.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEBitwiseXor.h"
 
 #include "src/core/NEON/kernels/NEBitwiseXorKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ using namespace arm_compute;
 
 void NEBitwiseXor::configure(const ITensor *input1, const ITensor *input2, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEBitwiseXorKernel>();
+    auto k = std::make_unique<NEBitwiseXorKernel>();
     k->configure(input1, input2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEBoundingBoxTransform.cpp b/src/runtime/NEON/functions/NEBoundingBoxTransform.cpp
index 0b639430b1..cfd14faca0 100644
--- a/src/runtime/NEON/functions/NEBoundingBoxTransform.cpp
+++ b/src/runtime/NEON/functions/NEBoundingBoxTransform.cpp
@@ -24,14 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NEBoundingBoxTransform.h"
 #include "src/core/NEON/kernels/NEBoundingBoxTransformKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 void NEBoundingBoxTransform::configure(const ITensor *boxes, ITensor *pred_boxes, const ITensor *deltas, const BoundingBoxTransformInfo &info)
 {
     // Configure Bounding Box kernel
-    auto k = arm_compute::support::cpp14::make_unique<NEBoundingBoxTransformKernel>();
+    auto k = std::make_unique<NEBoundingBoxTransformKernel>();
     k->configure(boxes, pred_boxes, deltas, info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEBox3x3.cpp b/src/runtime/NEON/functions/NEBox3x3.cpp
index 01d2356a4c..ee40e2c475 100644
--- a/src/runtime/NEON/functions/NEBox3x3.cpp
+++ b/src/runtime/NEON/functions/NEBox3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEBox3x3Kernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -36,17 +35,17 @@ void NEBox3x3::configure(ITensor *input, ITensor *output, BorderMode border_mode
 {
     if(use_fp16)
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEBox3x3FP16Kernel>();
+        auto k = std::make_unique<NEBox3x3FP16Kernel>();
         k->configure(input, output, border_mode == BorderMode::UNDEFINED);
         _kernel = std::move(k);
     }
     else
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEBox3x3Kernel>();
+        auto k = std::make_unique<NEBox3x3Kernel>();
         k->configure(input, output, border_mode == BorderMode::UNDEFINED);
         _kernel = std::move(k);
     }
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NECannyEdge.cpp b/src/runtime/NEON/functions/NECannyEdge.cpp
index bf4f7d7933..52bc81e001 100644
--- a/src/runtime/NEON/functions/NECannyEdge.cpp
+++ b/src/runtime/NEON/functions/NECannyEdge.cpp
@@ -36,7 +36,6 @@
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NESobel5x5Kernel.h"
 #include "src/core/NEON/kernels/NESobel7x7Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <cstring>
 #include <inttypes.h>
@@ -105,19 +104,19 @@ void NECannyEdge::configure(ITensor *input, ITensor *output, int32_t upper_thr,
     // Configure/Init sobelNxN
     if(gradient_size == 3)
     {
-        auto k = arm_compute::support::cpp14::make_unique<NESobel3x3>();
+        auto k = std::make_unique<NESobel3x3>();
         k->configure(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<NESobel5x5>();
+        auto k = std::make_unique<NESobel5x5>();
         k->configure(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<NESobel7x7>();
+        auto k = std::make_unique<NESobel7x7>();
         k->configure(input, &_gx, &_gy, border_mode, constant_border_value);
         _sobel = std::move(k);
     }
@@ -131,7 +130,7 @@ void NECannyEdge::configure(ITensor *input, ITensor *output, int32_t upper_thr,
     _memory_group.manage(&_phase);
 
     // Configure gradient
-    auto k = arm_compute::support::cpp14::make_unique<NEGradientKernel>();
+    auto k = std::make_unique<NEGradientKernel>();
     k->configure(&_gx, &_gy, &_magnitude, &_phase, norm_type);
     _gradient = std::move(k);
 
@@ -143,12 +142,12 @@ void NECannyEdge::configure(ITensor *input, ITensor *output, int32_t upper_thr,
     _memory_group.manage(&_nonmax);
 
     // Configure non-maxima suppression
-    _non_max_suppr = arm_compute::support::cpp14::make_unique<NEEdgeNonMaxSuppressionKernel>();
+    _non_max_suppr = std::make_unique<NEEdgeNonMaxSuppressionKernel>();
     _non_max_suppr->configure(&_magnitude, &_phase, &_nonmax, upper_thr, lower_thr, border_mode == BorderMode::UNDEFINED);
 
     // Fill border around magnitude image as non-maxima suppression will access
     // it. If border mode is undefined filling the border is a nop.
-    _border_mag_gradient = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _border_mag_gradient = std::make_unique<NEFillBorderKernel>();
     _border_mag_gradient->configure(&_magnitude, _non_max_suppr->border_size(), border_mode, constant_border_value);
 
     // Allocate intermediate tensors
@@ -156,11 +155,11 @@ void NECannyEdge::configure(ITensor *input, ITensor *output, int32_t upper_thr,
     _magnitude.allocator()->allocate();
 
     // Configure edge tracing
-    _edge_trace = arm_compute::support::cpp14::make_unique<NEEdgeTraceKernel>();
+    _edge_trace = std::make_unique<NEEdgeTraceKernel>();
     _edge_trace->configure(&_nonmax, output);
 
     // Fill border with "No edge" to stop recursion in edge trace
-    _border_edge_trace = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _border_edge_trace = std::make_unique<NEFillBorderKernel>();
     _border_edge_trace->configure(&_nonmax, _edge_trace->border_size(), BorderMode::CONSTANT, static_cast<float>(0.f));
 
     // Allocate intermediate tensors
diff --git a/src/runtime/NEON/functions/NECast.cpp b/src/runtime/NEON/functions/NECast.cpp
index 7fd2605fd2..a42f512ce6 100644
--- a/src/runtime/NEON/functions/NECast.cpp
+++ b/src/runtime/NEON/functions/NECast.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/ITensor.h"
 #include "arm_compute/core/TensorInfo.h"
 #include "src/core/NEON/kernels/NEDepthConvertLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ namespace arm_compute
 {
 void NECast::configure(ITensor *input, ITensor *output, ConvertPolicy policy)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEDepthConvertLayerKernel>();
+    auto k = std::make_unique<NEDepthConvertLayerKernel>();
     k->configure(input, output, policy, 0);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEChannelCombine.cpp b/src/runtime/NEON/functions/NEChannelCombine.cpp
index f8a9be0313..b566153bf4 100644
--- a/src/runtime/NEON/functions/NEChannelCombine.cpp
+++ b/src/runtime/NEON/functions/NEChannelCombine.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEChannelCombine.h"
 
 #include "src/core/NEON/kernels/NEChannelCombineKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,14 +31,14 @@ using namespace arm_compute;
 
 void NEChannelCombine::configure(const ITensor *plane0, const ITensor *plane1, const ITensor *plane2, const ITensor *plane3, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEChannelCombineKernel>();
+    auto k = std::make_unique<NEChannelCombineKernel>();
     k->configure(plane0, plane1, plane2, plane3, output);
     _kernel = std::move(k);
 }
 
 void NEChannelCombine::configure(const IImage *plane0, const IImage *plane1, const IImage *plane2, IMultiImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEChannelCombineKernel>();
+    auto k = std::make_unique<NEChannelCombineKernel>();
     k->configure(plane0, plane1, plane2, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEChannelExtract.cpp b/src/runtime/NEON/functions/NEChannelExtract.cpp
index 8f5e4d47d9..a43dc28896 100644
--- a/src/runtime/NEON/functions/NEChannelExtract.cpp
+++ b/src/runtime/NEON/functions/NEChannelExtract.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEChannelExtract.h"
 
 #include "src/core/NEON/kernels/NEChannelExtractKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,14 +31,14 @@ using namespace arm_compute;
 
 void NEChannelExtract::configure(const ITensor *input, Channel channel, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEChannelExtractKernel>();
+    auto k = std::make_unique<NEChannelExtractKernel>();
     k->configure(input, channel, output);
     _kernel = std::move(k);
 }
 
 void NEChannelExtract::configure(const IMultiImage *input, Channel channel, IImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEChannelExtractKernel>();
+    auto k = std::make_unique<NEChannelExtractKernel>();
     k->configure(input, channel, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEChannelShuffleLayer.cpp b/src/runtime/NEON/functions/NEChannelShuffleLayer.cpp
index c72dec67ee..bf4af83a0d 100644
--- a/src/runtime/NEON/functions/NEChannelShuffleLayer.cpp
+++ b/src/runtime/NEON/functions/NEChannelShuffleLayer.cpp
@@ -25,13 +25,12 @@
 
 #include "arm_compute/core/Types.h"
 #include "src/core/NEON/kernels/NEChannelShuffleLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEChannelShuffleLayer::configure(const ITensor *input, ITensor *output, unsigned int num_groups)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEChannelShuffleLayerKernel>();
+    auto k = std::make_unique<NEChannelShuffleLayerKernel>();
     k->configure(input, output, num_groups);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NECol2Im.cpp b/src/runtime/NEON/functions/NECol2Im.cpp
index 0706125157..fc61520f47 100644
--- a/src/runtime/NEON/functions/NECol2Im.cpp
+++ b/src/runtime/NEON/functions/NECol2Im.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NECol2Im.h"
 
 #include "src/core/NEON/kernels/NECol2ImKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NECol2Im::configure(const ITensor *input, ITensor *output, const Size2D &convolved_dims)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NECol2ImKernel>();
+    auto k = std::make_unique<NECol2ImKernel>();
     k->configure(input, output, convolved_dims);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEColorConvert.cpp b/src/runtime/NEON/functions/NEColorConvert.cpp
index ebdd1046ce..c7c9cdd923 100644
--- a/src/runtime/NEON/functions/NEColorConvert.cpp
+++ b/src/runtime/NEON/functions/NEColorConvert.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEColorConvert.h"
 
 #include "src/core/NEON/kernels/NEColorConvertKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,28 +31,28 @@ using namespace arm_compute;
 
 void NEColorConvert::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEColorConvertKernel>();
+    auto k = std::make_unique<NEColorConvertKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
 
 void NEColorConvert::configure(const IMultiImage *input, IImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEColorConvertKernel>();
+    auto k = std::make_unique<NEColorConvertKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
 
 void NEColorConvert::configure(const IImage *input, IMultiImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEColorConvertKernel>();
+    auto k = std::make_unique<NEColorConvertKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
 
 void NEColorConvert::configure(const IMultiImage *input, IMultiImage *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEColorConvertKernel>();
+    auto k = std::make_unique<NEColorConvertKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEComputeAllAnchors.cpp b/src/runtime/NEON/functions/NEComputeAllAnchors.cpp
index 3f5712dd3a..a305ca0708 100644
--- a/src/runtime/NEON/functions/NEComputeAllAnchors.cpp
+++ b/src/runtime/NEON/functions/NEComputeAllAnchors.cpp
@@ -24,14 +24,13 @@
 #include "arm_compute/runtime/NEON/functions/NEComputeAllAnchors.h"
 
 #include "src/core/NEON/kernels/NEGenerateProposalsLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEComputeAllAnchors::configure(const ITensor *anchors, ITensor *all_anchors, const ComputeAnchorsInfo &info)
 {
     // Configure ComputeAllAnchors kernel
-    auto k = arm_compute::support::cpp14::make_unique<NEComputeAllAnchorsKernel>();
+    auto k = std::make_unique<NEComputeAllAnchorsKernel>();
     k->configure(anchors, all_anchors, info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEConcatenateLayer.cpp b/src/runtime/NEON/functions/NEConcatenateLayer.cpp
index 03a01aec6b..782f8f1ff7 100644
--- a/src/runtime/NEON/functions/NEConcatenateLayer.cpp
+++ b/src/runtime/NEON/functions/NEConcatenateLayer.cpp
@@ -36,7 +36,6 @@
 #include "arm_compute/core/TensorInfo.h"
 #include "arm_compute/core/Types.h"
 #include "src/core/helpers/AutoConfiguration.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -68,28 +67,28 @@ void NEConcatenation::configure(const std::vector<const ITensorInfo *> &inputs_v
         {
             case Window::DimX:
             {
-                auto kernel = support::cpp14::make_unique<NEWidthConcatenateLayerKernel>();
+                auto kernel = std::make_unique<NEWidthConcatenateLayerKernel>();
                 kernel->configure(inputs_vector.at(i), offset, output);
                 _concat_kernels.emplace_back(std::move(kernel));
                 break;
             }
             case Window::DimY:
             {
-                auto kernel = support::cpp14::make_unique<NEHeightConcatenateLayerKernel>();
+                auto kernel = std::make_unique<NEHeightConcatenateLayerKernel>();
                 kernel->configure(inputs_vector.at(i), offset, output);
                 _concat_kernels.emplace_back(std::move(kernel));
                 break;
             }
             case Window::DimZ:
             {
-                auto kernel = support::cpp14::make_unique<NEDepthConcatenateLayerKernel>();
+                auto kernel = std::make_unique<NEDepthConcatenateLayerKernel>();
                 kernel->configure(inputs_vector.at(i), offset, output);
                 _concat_kernels.emplace_back(std::move(kernel));
                 break;
             }
             case 3:
             {
-                auto kernel = support::cpp14::make_unique<NEBatchConcatenateLayerKernel>();
+                auto kernel = std::make_unique<NEBatchConcatenateLayerKernel>();
                 kernel->configure(inputs_vector.at(i), offset, output);
                 _concat_kernels.emplace_back(std::move(kernel));
                 break;
@@ -181,7 +180,7 @@ struct NEConcatenateLayer::Impl
 };
 
 NEConcatenateLayer::NEConcatenateLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -199,7 +198,7 @@ void NEConcatenateLayer::configure(std::vector<const ITensor *> inputs_vector, I
     _impl->dst        = output;
     _impl->axis       = axis;
     _impl->num_inputs = inputs_vector.size();
-    _impl->op         = arm_compute::support::cpp14::make_unique<experimental::NEConcatenation>();
+    _impl->op         = std::make_unique<experimental::NEConcatenation>();
 
     std::vector<const ITensorInfo *> inputs_vector_info;
     for(unsigned int i = 0; i < inputs_vector.size(); ++i)
diff --git a/src/runtime/NEON/functions/NEConvertFullyConnectedWeights.cpp b/src/runtime/NEON/functions/NEConvertFullyConnectedWeights.cpp
index 291afe0273..a6a7746830 100644
--- a/src/runtime/NEON/functions/NEConvertFullyConnectedWeights.cpp
+++ b/src/runtime/NEON/functions/NEConvertFullyConnectedWeights.cpp
@@ -23,7 +23,6 @@
  */
 #include "arm_compute/runtime/NEON/functions/NEConvertFullyConnectedWeights.h"
 #include "src/core/NEON/kernels/NEConvertFullyConnectedWeightsKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -37,7 +36,7 @@ NEConvertFullyConnectedWeights::NEConvertFullyConnectedWeights()
 void NEConvertFullyConnectedWeights::configure(const ITensor *input, ITensor *output, const TensorShape &original_input_shape,
                                                DataLayout data_layout)
 {
-    _kernel = arm_compute::support::cpp14::make_unique<NEConvertFullyConnectedWeightsKernel>();
+    _kernel = std::make_unique<NEConvertFullyConnectedWeightsKernel>();
     _kernel->configure(input, output, original_input_shape, data_layout);
 }
 
diff --git a/src/runtime/NEON/functions/NEConvolution.cpp b/src/runtime/NEON/functions/NEConvolution.cpp
index 07ac8bd42b..680d8f628f 100644
--- a/src/runtime/NEON/functions/NEConvolution.cpp
+++ b/src/runtime/NEON/functions/NEConvolution.cpp
@@ -34,7 +34,6 @@
 #include "src/core/NEON/kernels/NEConvolutionKernel.h"
 #include "src/core/NEON/kernels/NEConvolutionKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <array>
 #include <utility>
@@ -45,11 +44,11 @@ NEConvolution3x3::~NEConvolution3x3() = default;
 
 void NEConvolution3x3::configure(ITensor *input, ITensor *output, const int16_t *conv, uint32_t scale, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEConvolution3x3Kernel>();
+    auto k = std::make_unique<NEConvolution3x3Kernel>();
     k->configure(input, output, conv, scale, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
@@ -76,7 +75,7 @@ void NEConvolutionSquare<matrix_size>::configure(ITensor *input, ITensor *output
 
     _is_separable = separate_matrix(conv, conv_col.data(), conv_row.data(), matrix_size);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     if(_is_separable)
     {
         DataType intermediate_type = DataType::UNKNOWN;
@@ -93,8 +92,8 @@ void NEConvolutionSquare<matrix_size>::configure(ITensor *input, ITensor *output
             scale = calculate_matrix_scale(conv, matrix_size);
         }
 
-        _kernel_hor  = arm_compute::support::cpp14::make_unique<NESeparableConvolutionHorKernel<matrix_size>>();
-        _kernel_vert = arm_compute::support::cpp14::make_unique<NESeparableConvolutionVertKernel<matrix_size>>();
+        _kernel_hor  = std::make_unique<NESeparableConvolutionHorKernel<matrix_size>>();
+        _kernel_vert = std::make_unique<NESeparableConvolutionVertKernel<matrix_size>>();
 
         _kernel_hor->configure(input, &_tmp, conv_row.data(), border_mode == BorderMode::UNDEFINED);
         _kernel_vert->configure(&_tmp, output, conv_col.data(), scale, border_mode == BorderMode::UNDEFINED);
@@ -105,7 +104,7 @@ void NEConvolutionSquare<matrix_size>::configure(ITensor *input, ITensor *output
     }
     else
     {
-        _kernel = arm_compute::support::cpp14::make_unique<NEConvolutionKernel<matrix_size>>();
+        _kernel = std::make_unique<NEConvolutionKernel<matrix_size>>();
         _kernel->configure(input, output, conv, scale, border_mode == BorderMode::UNDEFINED);
         b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     }
@@ -138,11 +137,11 @@ NEConvolutionRectangle::~NEConvolutionRectangle() = default;
 
 void NEConvolutionRectangle::configure(ITensor *input, ITensor *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<NEConvolutionRectangleKernel>();
+    auto k = std::make_unique<NEConvolutionRectangleKernel>();
     k->configure(input, output, conv, rows, cols, scale, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEConvolutionLayer.cpp b/src/runtime/NEON/functions/NEConvolutionLayer.cpp
index cc5f160787..cc549ca31b 100644
--- a/src/runtime/NEON/functions/NEConvolutionLayer.cpp
+++ b/src/runtime/NEON/functions/NEConvolutionLayer.cpp
@@ -33,8 +33,6 @@
 #include "arm_compute/runtime/NEON/functions/NEGEMMConvolutionLayer.h"
 #include "arm_compute/runtime/NEON/functions/NEWinogradConvolutionLayer.h"
 
-#include "support/MemorySupport.h"
-
 #include <cmath>
 #include <tuple>
 #include <utility>
@@ -61,35 +59,35 @@ void NEConvolutionLayer::configure(ITensor *input, const ITensor *weights, const
     {
         case ConvolutionMethod::WINOGRAD:
         {
-            auto f = arm_compute::support::cpp14::make_unique<NEWinogradConvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<NEWinogradConvolutionLayer>(_memory_manager);
             f->configure(input, weights, biases, output, conv_info, act_info, enable_fast_math);
             _function = std::move(f);
             break;
         }
         case ConvolutionMethod::GEMM:
         {
-            auto f = arm_compute::support::cpp14::make_unique<NEGEMMConvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<NEGEMMConvolutionLayer>(_memory_manager);
             f->configure(input, weights, biases, output, conv_info, weights_info, dilation, act_info);
             _function = std::move(f);
             break;
         }
         case ConvolutionMethod::GEMM_CONV2D:
         {
-            auto f = arm_compute::support::cpp14::make_unique<NEGEMMConv2d>(_memory_manager);
+            auto f = std::make_unique<NEGEMMConv2d>(_memory_manager);
             f->configure(input, weights, biases, output, info);
             _function = std::move(f);
             break;
         }
         case ConvolutionMethod::DIRECT:
         {
-            auto f = arm_compute::support::cpp14::make_unique<NEDirectConvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<NEDirectConvolutionLayer>(_memory_manager);
             f->configure(input, weights, biases, output, conv_info, act_info);
             _function = std::move(f);
             break;
         }
         case ConvolutionMethod::FFT:
         {
-            auto f = arm_compute::support::cpp14::make_unique<NEFFTConvolutionLayer>(_memory_manager);
+            auto f = std::make_unique<NEFFTConvolutionLayer>(_memory_manager);
             f->configure(input, weights, biases, output, conv_info, act_info);
             _function = std::move(f);
             break;
diff --git a/src/runtime/NEON/functions/NECopy.cpp b/src/runtime/NEON/functions/NECopy.cpp
index 9e7bf40559..11707cbd4c 100644
--- a/src/runtime/NEON/functions/NECopy.cpp
+++ b/src/runtime/NEON/functions/NECopy.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NECopy.h"
 
 #include "src/core/NEON/kernels/NECopyKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ NECopy::~NECopy() = default;
 
 void NECopy::configure(ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NECopyKernel>();
+    auto k = std::make_unique<NECopyKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NECropResize.cpp b/src/runtime/NEON/functions/NECropResize.cpp
index 2e2d2251b6..af85cac7da 100644
--- a/src/runtime/NEON/functions/NECropResize.cpp
+++ b/src/runtime/NEON/functions/NECropResize.cpp
@@ -26,8 +26,6 @@
 #include "arm_compute/runtime/NEON/functions/NECropResize.h"
 #include "src/core/NEON/kernels/NECropKernel.h"
 
-#include "support/MemorySupport.h"
-
 #include <cstddef>
 
 namespace arm_compute
@@ -82,18 +80,18 @@ void NECropResize::configure(const ITensor *input, const ITensor *boxes, const I
 
     for(unsigned int i = 0; i < _num_boxes; ++i)
     {
-        auto       crop_tensor = support::cpp14::make_unique<Tensor>();
+        auto       crop_tensor = std::make_unique<Tensor>();
         TensorInfo crop_result_info(1, DataType::F32);
         crop_result_info.set_data_layout(DataLayout::NHWC);
         crop_tensor->allocator()->init(crop_result_info);
 
-        auto       scale_tensor = support::cpp14::make_unique<Tensor>();
+        auto       scale_tensor = std::make_unique<Tensor>();
         TensorInfo scaled_result_info(out_shape, 1, DataType::F32);
         scaled_result_info.set_data_layout(DataLayout::NHWC);
         scale_tensor->allocator()->init(scaled_result_info);
 
-        auto crop_kernel  = support::cpp14::make_unique<NECropKernel>();
-        auto scale_kernel = support::cpp14::make_unique<NEScale>();
+        auto crop_kernel  = std::make_unique<NECropKernel>();
+        auto scale_kernel = std::make_unique<NEScale>();
         crop_kernel->configure(input, boxes, box_ind, crop_tensor.get(), i, _extrapolation_value);
 
         _crop.emplace_back(std::move(crop_kernel));
diff --git a/src/runtime/NEON/functions/NEDepthConvertLayer.cpp b/src/runtime/NEON/functions/NEDepthConvertLayer.cpp
index af0f5efb69..761de8eb60 100644
--- a/src/runtime/NEON/functions/NEDepthConvertLayer.cpp
+++ b/src/runtime/NEON/functions/NEDepthConvertLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEDepthConvertLayer.h"
 
 #include "src/core/NEON/kernels/NEDepthConvertLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ using namespace arm_compute;
 
 void NEDepthConvertLayer::configure(const ITensor *input, ITensor *output, ConvertPolicy policy, uint32_t shift)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEDepthConvertLayerKernel>();
+    auto k = std::make_unique<NEDepthConvertLayerKernel>();
     k->configure(input, output, policy, shift);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEDepthToSpaceLayer.cpp b/src/runtime/NEON/functions/NEDepthToSpaceLayer.cpp
index c4f15e3b68..2793c3f27e 100644
--- a/src/runtime/NEON/functions/NEDepthToSpaceLayer.cpp
+++ b/src/runtime/NEON/functions/NEDepthToSpaceLayer.cpp
@@ -30,13 +30,11 @@
 #include "arm_compute/core/Validate.h"
 #include "src/core/NEON/kernels/NEDepthToSpaceLayerKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 void NEDepthToSpaceLayer::configure(const ITensor *input, ITensor *output, int32_t block_shape)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEDepthToSpaceLayerKernel>();
+    auto k = std::make_unique<NEDepthToSpaceLayerKernel>();
     k->configure(input, output, block_shape);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEDepthwiseConvolutionLayer.cpp b/src/runtime/NEON/functions/NEDepthwiseConvolutionLayer.cpp
index fc97279211..d17f6b5cd9 100644
--- a/src/runtime/NEON/functions/NEDepthwiseConvolutionLayer.cpp
+++ b/src/runtime/NEON/functions/NEDepthwiseConvolutionLayer.cpp
@@ -28,7 +28,6 @@
 #include "arm_compute/core/utils/quantization/AsymmHelpers.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEDepthwiseConvolutionLayerNativeKernel.h"
-#include "support/MemorySupport.h"
 
 using namespace arm_compute::misc;
 using namespace arm_compute::misc::shape_calculator;
@@ -246,7 +245,7 @@ void NEDepthwiseConvolutionLayer::NEDepthwiseConvolutionLayerGeneric::configure(
     }
     _original_weights = weights_to_use;
 
-    _depthwise_conv_kernel = arm_compute::support::cpp14::make_unique<NEDepthwiseConvolutionLayerNativeKernel>();
+    _depthwise_conv_kernel = std::make_unique<NEDepthwiseConvolutionLayerNativeKernel>();
     _depthwise_conv_kernel->configure(input_to_use, weights_to_use, biases, output_to_use, conv_info, depth_multiplier, dilation);
 
     if(_is_nchw)
diff --git a/src/runtime/NEON/functions/NEDequantizationLayer.cpp b/src/runtime/NEON/functions/NEDequantizationLayer.cpp
index 0c0f86c82b..a345840f4f 100644
--- a/src/runtime/NEON/functions/NEDequantizationLayer.cpp
+++ b/src/runtime/NEON/functions/NEDequantizationLayer.cpp
@@ -25,13 +25,12 @@
 #include "arm_compute/runtime/NEON/functions/NEDequantizationLayer.h"
 
 #include "src/core/NEON/kernels/NEDequantizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEDequantizationLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEDequantizationLayerKernel>();
+    auto k = std::make_unique<NEDequantizationLayerKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEDerivative.cpp b/src/runtime/NEON/functions/NEDerivative.cpp
index f007e9fda3..8ef42123db 100644
--- a/src/runtime/NEON/functions/NEDerivative.cpp
+++ b/src/runtime/NEON/functions/NEDerivative.cpp
@@ -29,7 +29,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEDerivativeKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -45,8 +44,8 @@ void NEDerivative::configure(ITensor *input, ITensor *output_x, ITensor *output_
     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8);
     ARM_COMPUTE_ERROR_ON((output_x == nullptr) && (output_y == nullptr));
 
-    _kernel         = arm_compute::support::cpp14::make_unique<NEDerivativeKernel>();
-    _border_handler = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _kernel         = std::make_unique<NEDerivativeKernel>();
+    _border_handler = std::make_unique<NEFillBorderKernel>();
 
     _kernel->configure(input, output_x, output_y, border_mode == BorderMode::UNDEFINED);
     _border_handler->configure(input, BorderSize(1), border_mode, PixelValue(constant_border_value));
diff --git a/src/runtime/NEON/functions/NEDilate.cpp b/src/runtime/NEON/functions/NEDilate.cpp
index 70c0b61639..56523abd8a 100644
--- a/src/runtime/NEON/functions/NEDilate.cpp
+++ b/src/runtime/NEON/functions/NEDilate.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEDilateKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,11 +33,11 @@ using namespace arm_compute;
 
 void NEDilate::configure(ITensor *input, ITensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEDilateKernel>();
+    auto k = std::make_unique<NEDilateKernel>();
     k->configure(input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEDirectConvolutionLayer.cpp b/src/runtime/NEON/functions/NEDirectConvolutionLayer.cpp
index 98d6386ffe..a953edc78f 100644
--- a/src/runtime/NEON/functions/NEDirectConvolutionLayer.cpp
+++ b/src/runtime/NEON/functions/NEDirectConvolutionLayer.cpp
@@ -30,7 +30,6 @@
 #include "src/core/NEON/kernels/NEDirectConvolutionLayerKernel.h"
 #include "src/core/NEON/kernels/NEDirectConvolutionLayerOutputStageKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -45,9 +44,9 @@ NEDirectConvolutionLayer::NEDirectConvolutionLayer(std::shared_ptr<IMemoryManage
 void NEDirectConvolutionLayer::configure(ITensor *input, const ITensor *weights, const ITensor *bias, ITensor *output, const PadStrideInfo &conv_info, const ActivationLayerInfo &act_info)
 {
     ARM_COMPUTE_ERROR_ON(input->info()->data_layout() == DataLayout::UNKNOWN);
-    _output_stage_kernel  = arm_compute::support::cpp14::make_unique<NEDirectConvolutionLayerOutputStageKernel>();
-    _conv_kernel          = arm_compute::support::cpp14::make_unique<NEDirectConvolutionLayerKernel>();
-    _input_border_handler = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _output_stage_kernel  = std::make_unique<NEDirectConvolutionLayerOutputStageKernel>();
+    _conv_kernel          = std::make_unique<NEDirectConvolutionLayerKernel>();
+    _input_border_handler = std::make_unique<NEFillBorderKernel>();
 
     // Free accumulator
     if(_accumulator.buffer() != nullptr)
diff --git a/src/runtime/NEON/functions/NEElementwiseOperators.cpp b/src/runtime/NEON/functions/NEElementwiseOperators.cpp
index 7f3fe8b30b..badcf2e997 100644
--- a/src/runtime/NEON/functions/NEElementwiseOperators.cpp
+++ b/src/runtime/NEON/functions/NEElementwiseOperators.cpp
@@ -26,7 +26,6 @@
 #include <src/core/NEON/kernels/NEElementwiseOperationKernel.h>
 
 #include "arm_compute/core/ITensor.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -36,7 +35,7 @@ namespace experimental
 {
 void NEElementwiseMax::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEArithmeticOperationKernel>();
+    auto k = std::make_unique<NEArithmeticOperationKernel>();
     k->configure(ArithmeticOperation::MAX, input1, input2, output);
     _kernel = std::move(k);
 }
@@ -48,7 +47,7 @@ Status NEElementwiseMax::validate(const ITensorInfo *input1, const ITensorInfo *
 
 void NEElementwiseMin::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEArithmeticOperationKernel>();
+    auto k = std::make_unique<NEArithmeticOperationKernel>();
     k->configure(ArithmeticOperation::MIN, input1, input2, output);
     _kernel = std::move(k);
 }
@@ -60,7 +59,7 @@ Status NEElementwiseMin::validate(const ITensorInfo *input1, const ITensorInfo *
 
 void NEElementwiseSquaredDiff::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEArithmeticOperationKernel>();
+    auto k = std::make_unique<NEArithmeticOperationKernel>();
     k->configure(ArithmeticOperation::SQUARED_DIFF, input1, input2, output);
     _kernel = std::move(k);
 }
@@ -72,7 +71,7 @@ Status NEElementwiseSquaredDiff::validate(const ITensorInfo *input1, const ITens
 
 void NEElementwiseDivision::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEDivisionOperationKernel>();
+    auto k = std::make_unique<NEDivisionOperationKernel>();
     k->configure(input1, input2, output);
     _kernel = std::move(k);
 }
@@ -84,7 +83,7 @@ Status NEElementwiseDivision::validate(const ITensorInfo *input1, const ITensorI
 
 void NEElementwisePower::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEPowerOperationKernel>();
+    auto k = std::make_unique<NEPowerOperationKernel>();
     k->configure(input1, input2, output);
     _kernel = std::move(k);
 }
@@ -97,7 +96,7 @@ Status NEElementwisePower::validate(const ITensorInfo *input1, const ITensorInfo
 template <ComparisonOperation COP>
 void NEElementwiseComparisonStatic<COP>::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEComparisonOperationKernel>();
+    auto k = std::make_unique<NEComparisonOperationKernel>();
     k->configure(COP, input1, input2, output);
     _kernel = std::move(k);
 }
@@ -110,7 +109,7 @@ Status NEElementwiseComparisonStatic<COP>::validate(const ITensorInfo *input1, c
 
 void NEElementwiseComparison::configure(const ITensorInfo *input1, const ITensorInfo *input2, ITensorInfo *output, ComparisonOperation op)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEComparisonOperationKernel>();
+    auto k = std::make_unique<NEComparisonOperationKernel>();
     k->configure(op, input1, input2, output);
     _kernel = std::move(k);
 }
@@ -138,7 +137,7 @@ struct NEElementwiseMax::Impl
 };
 
 NEElementwiseMax::NEElementwiseMax()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEElementwiseMax::NEElementwiseMax(NEElementwiseMax &&) = default;
@@ -151,7 +150,7 @@ void NEElementwiseMax::configure(ITensor *input1, ITensor *input2, ITensor *outp
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEElementwiseMax>();
+    _impl->op    = std::make_unique<experimental::NEElementwiseMax>();
     _impl->op->configure(input1->info(), input2->info(), output->info());
 }
 
@@ -179,7 +178,7 @@ struct NEElementwiseMin::Impl
 };
 
 NEElementwiseMin::NEElementwiseMin()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEElementwiseMin::NEElementwiseMin(NEElementwiseMin &&) = default;
@@ -192,7 +191,7 @@ void NEElementwiseMin::configure(ITensor *input1, ITensor *input2, ITensor *outp
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEElementwiseMin>();
+    _impl->op    = std::make_unique<experimental::NEElementwiseMin>();
     _impl->op->configure(input1->info(), input2->info(), output->info());
 }
 
@@ -220,7 +219,7 @@ struct NEElementwiseSquaredDiff::Impl
 };
 
 NEElementwiseSquaredDiff::NEElementwiseSquaredDiff()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEElementwiseSquaredDiff::NEElementwiseSquaredDiff(NEElementwiseSquaredDiff &&) = default;
@@ -233,7 +232,7 @@ void NEElementwiseSquaredDiff::configure(ITensor *input1, ITensor *input2, ITens
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEElementwiseSquaredDiff>();
+    _impl->op    = std::make_unique<experimental::NEElementwiseSquaredDiff>();
     _impl->op->configure(input1->info(), input2->info(), output->info());
 }
 
@@ -261,7 +260,7 @@ struct NEElementwiseDivision::Impl
 };
 
 NEElementwiseDivision::NEElementwiseDivision()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEElementwiseDivision::NEElementwiseDivision(NEElementwiseDivision &&) = default;
@@ -274,7 +273,7 @@ void NEElementwiseDivision::configure(ITensor *input1, ITensor *input2, ITensor
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEElementwiseDivision>();
+    _impl->op    = std::make_unique<experimental::NEElementwiseDivision>();
     _impl->op->configure(input1->info(), input2->info(), output->info());
 }
 
@@ -302,7 +301,7 @@ struct NEElementwisePower::Impl
 };
 
 NEElementwisePower::NEElementwisePower()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEElementwisePower::NEElementwisePower(NEElementwisePower &&) = default;
@@ -315,7 +314,7 @@ void NEElementwisePower::configure(ITensor *input1, ITensor *input2, ITensor *ou
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEElementwisePower>();
+    _impl->op    = std::make_unique<experimental::NEElementwisePower>();
     _impl->op->configure(input1->info(), input2->info(), output->info());
 }
 
@@ -345,7 +344,7 @@ struct NEElementwiseComparisonStatic<COP>::Impl
 
 template <ComparisonOperation COP>
 NEElementwiseComparisonStatic<COP>::NEElementwiseComparisonStatic()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 template <ComparisonOperation COP>
@@ -361,7 +360,7 @@ void NEElementwiseComparisonStatic<COP>::configure(ITensor *input1, ITensor *inp
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEElementwiseComparisonStatic<COP>>();
+    _impl->op    = std::make_unique<experimental::NEElementwiseComparisonStatic<COP>>();
     _impl->op->configure(input1->info(), input2->info(), output->info());
 }
 
@@ -390,7 +389,7 @@ struct NEElementwiseComparison::Impl
 };
 
 NEElementwiseComparison::NEElementwiseComparison()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEElementwiseComparison::NEElementwiseComparison(NEElementwiseComparison &&) = default;
@@ -402,7 +401,7 @@ void NEElementwiseComparison::configure(ITensor *input1, ITensor *input2, ITenso
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEElementwiseComparison>();
+    _impl->op    = std::make_unique<experimental::NEElementwiseComparison>();
     _impl->op->configure(input1->info(), input2->info(), output->info(), op);
 }
 
diff --git a/src/runtime/NEON/functions/NEElementwiseUnaryLayer.cpp b/src/runtime/NEON/functions/NEElementwiseUnaryLayer.cpp
index 5e130205d2..5c779f1489 100644
--- a/src/runtime/NEON/functions/NEElementwiseUnaryLayer.cpp
+++ b/src/runtime/NEON/functions/NEElementwiseUnaryLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEElementwiseUnaryLayer.h"
 
 #include "src/core/NEON/kernels/NEElementwiseUnaryKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ namespace arm_compute
 {
 void NERsqrtLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEElementwiseUnaryKernel>();
+    auto k = std::make_unique<NEElementwiseUnaryKernel>();
     k->configure(ElementWiseUnary::RSQRT, input, output);
     _kernel = std::move(k);
 }
@@ -43,7 +42,7 @@ Status NERsqrtLayer::validate(const ITensorInfo *input, const ITensorInfo *outpu
 
 void NEExpLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEElementwiseUnaryKernel>();
+    auto k = std::make_unique<NEElementwiseUnaryKernel>();
     k->configure(ElementWiseUnary::EXP, input, output);
     _kernel = std::move(k);
 }
@@ -54,7 +53,7 @@ Status NEExpLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void NENegLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEElementwiseUnaryKernel>();
+    auto k = std::make_unique<NEElementwiseUnaryKernel>();
     k->configure(ElementWiseUnary::NEG, input, output);
     _kernel = std::move(k);
 }
@@ -65,7 +64,7 @@ Status NENegLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void NELogLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEElementwiseUnaryKernel>();
+    auto k = std::make_unique<NEElementwiseUnaryKernel>();
     k->configure(ElementWiseUnary::LOG, input, output);
     _kernel = std::move(k);
 }
@@ -76,7 +75,7 @@ Status NELogLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void NEAbsLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEElementwiseUnaryKernel>();
+    auto k = std::make_unique<NEElementwiseUnaryKernel>();
     k->configure(ElementWiseUnary::ABS, input, output);
     _kernel = std::move(k);
 }
@@ -87,7 +86,7 @@ Status NEAbsLayer::validate(const ITensorInfo *input, const ITensorInfo *output)
 
 void NERoundLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEElementwiseUnaryKernel>();
+    auto k = std::make_unique<NEElementwiseUnaryKernel>();
     k->configure(ElementWiseUnary::ROUND, input, output);
     _kernel = std::move(k);
 }
@@ -98,7 +97,7 @@ Status NERoundLayer::validate(const ITensorInfo *input, const ITensorInfo *outpu
 
 void NESinLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEElementwiseUnaryKernel>();
+    auto k = std::make_unique<NEElementwiseUnaryKernel>();
     k->configure(ElementWiseUnary::SIN, input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEEqualizeHistogram.cpp b/src/runtime/NEON/functions/NEEqualizeHistogram.cpp
index d3ff171323..0b83b7dac7 100644
--- a/src/runtime/NEON/functions/NEEqualizeHistogram.cpp
+++ b/src/runtime/NEON/functions/NEEqualizeHistogram.cpp
@@ -32,7 +32,6 @@
 #include "src/core/NEON/kernels/NEHistogramKernel.h"
 #include "src/core/NEON/kernels/NEHistogramKernel.h"
 #include "src/core/NEON/kernels/NETableLookupKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -50,9 +49,9 @@ void NEEqualizeHistogram::configure(const IImage *input, IImage *output)
     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8);
     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8);
 
-    _histogram_kernel     = arm_compute::support::cpp14::make_unique<NEHistogramKernel>();
-    _cd_histogram_kernel  = arm_compute::support::cpp14::make_unique<NECumulativeDistributionKernel>();
-    _map_histogram_kernel = arm_compute::support::cpp14::make_unique<NETableLookupKernel>();
+    _histogram_kernel     = std::make_unique<NEHistogramKernel>();
+    _cd_histogram_kernel  = std::make_unique<NECumulativeDistributionKernel>();
+    _map_histogram_kernel = std::make_unique<NETableLookupKernel>();
 
     // Configure kernels
     _histogram_kernel->configure(input, &_hist);
diff --git a/src/runtime/NEON/functions/NEErode.cpp b/src/runtime/NEON/functions/NEErode.cpp
index 748694fe3f..83e266140a 100644
--- a/src/runtime/NEON/functions/NEErode.cpp
+++ b/src/runtime/NEON/functions/NEErode.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEErodeKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,11 +33,11 @@ namespace arm_compute
 {
 void NEErode::configure(ITensor *input, ITensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEErodeKernel>();
+    auto k = std::make_unique<NEErodeKernel>();
     k->configure(input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEFFT1D.cpp b/src/runtime/NEON/functions/NEFFT1D.cpp
index b94c25832a..e72488f0f6 100644
--- a/src/runtime/NEON/functions/NEFFT1D.cpp
+++ b/src/runtime/NEON/functions/NEFFT1D.cpp
@@ -30,7 +30,6 @@
 #include "src/core/NEON/kernels/NEFFTRadixStageKernel.h"
 #include "src/core/NEON/kernels/NEFFTScaleKernel.h"
 #include "src/core/utils/helpers/fft.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -64,7 +63,7 @@ void NEFFT1D::configure(const ITensor *input, ITensor *output, const FFT1DInfo &
     TensorInfo digit_reverse_indices_info(TensorShape(input->info()->tensor_shape()[config.axis]), 1, DataType::U32);
     _digit_reverse_indices.allocator()->init(digit_reverse_indices_info);
     _memory_group.manage(&_digit_reversed_input);
-    _digit_reverse_kernel = arm_compute::support::cpp14::make_unique<NEFFTDigitReverseKernel>();
+    _digit_reverse_kernel = std::make_unique<NEFFTDigitReverseKernel>();
     _digit_reverse_kernel->configure(input, &_digit_reversed_input, &_digit_reverse_indices, digit_reverse_config);
 
     // Create and configure FFT kernels
@@ -82,7 +81,7 @@ void NEFFT1D::configure(const ITensor *input, ITensor *output, const FFT1DInfo &
         fft_kernel_info.radix          = radix_for_stage;
         fft_kernel_info.Nx             = Nx;
         fft_kernel_info.is_first_stage = (i == 0);
-        _fft_kernels[i]                = arm_compute::support::cpp14::make_unique<NEFFTRadixStageKernel>();
+        _fft_kernels[i]                = std::make_unique<NEFFTRadixStageKernel>();
         _fft_kernels[i]->configure(&_digit_reversed_input, ((i == (_num_ffts - 1)) && !is_c2r) ? output : nullptr, fft_kernel_info);
 
         Nx *= radix_for_stage;
@@ -94,7 +93,7 @@ void NEFFT1D::configure(const ITensor *input, ITensor *output, const FFT1DInfo &
         FFTScaleKernelInfo scale_config;
         scale_config.scale     = static_cast<float>(N);
         scale_config.conjugate = config.direction == FFTDirection::Inverse;
-        _scale_kernel          = arm_compute::support::cpp14::make_unique<NEFFTScaleKernel>();
+        _scale_kernel          = std::make_unique<NEFFTScaleKernel>();
         is_c2r ? _scale_kernel->configure(&_digit_reversed_input, output, scale_config) : _scale_kernel->configure(output, nullptr, scale_config);
     }
 
diff --git a/src/runtime/NEON/functions/NEFFTConvolutionLayer.cpp b/src/runtime/NEON/functions/NEFFTConvolutionLayer.cpp
index 23788b7c39..bb6b5ed6b4 100644
--- a/src/runtime/NEON/functions/NEFFTConvolutionLayer.cpp
+++ b/src/runtime/NEON/functions/NEFFTConvolutionLayer.cpp
@@ -36,8 +36,6 @@
 #include "src/core/helpers/AutoConfiguration.h"
 #include "src/core/utils/helpers/fft.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 namespace
@@ -161,7 +159,7 @@ void NEFFTConvolutionLayer::configure(ITensor *input, const ITensor *weights, co
     _pad_weights_func.configure(&_flipped_weights, &_padded_weights, padding_w);
 
     // Transform weights
-    _transform_weights_func = support::cpp14::make_unique<NEFFT2D>();
+    _transform_weights_func = std::make_unique<NEFFT2D>();
     _transform_weights_func->configure(&_padded_weights, &_transformed_weights, FFT2DInfo());
 
     // Pad input
diff --git a/src/runtime/NEON/functions/NEFastCorners.cpp b/src/runtime/NEON/functions/NEFastCorners.cpp
index 1bde3cc508..5164d80947 100644
--- a/src/runtime/NEON/functions/NEFastCorners.cpp
+++ b/src/runtime/NEON/functions/NEFastCorners.cpp
@@ -35,7 +35,6 @@
 #include "src/core/NEON/kernels/NEFillArrayKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NENonMaximaSuppression3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -68,9 +67,9 @@ void NEFastCorners::configure(IImage *input, float threshold, bool nonmax_suppre
     _output.allocator()->init(tensor_info);
     _memory_group.manage(&_output);
 
-    _fast_corners_kernel = arm_compute::support::cpp14::make_unique<NEFastCornersKernel>();
-    _border_handler      = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
-    _fill_kernel         = arm_compute::support::cpp14::make_unique<NEFillArrayKernel>();
+    _fast_corners_kernel = std::make_unique<NEFastCornersKernel>();
+    _border_handler      = std::make_unique<NEFillBorderKernel>();
+    _fill_kernel         = std::make_unique<NEFillArrayKernel>();
     // If border is UNDEFINED _fast_corners_kernel will operate in xwindow (3,
     // width - 3) and ywindow (3, height -3) so the output image will leave the
     // pixels on the borders unchanged. This is reflected in the valid region
@@ -87,7 +86,7 @@ void NEFastCorners::configure(IImage *input, float threshold, bool nonmax_suppre
     {
         _suppressed.allocator()->init(tensor_info);
         _memory_group.manage(&_suppressed);
-        _nonmax_kernel = arm_compute::support::cpp14::make_unique<NENonMaximaSuppression3x3Kernel>();
+        _nonmax_kernel = std::make_unique<NENonMaximaSuppression3x3Kernel>();
         _nonmax_kernel->configure(&_output, &_suppressed, BorderMode::UNDEFINED == border_mode);
         _fill_kernel->configure(&_suppressed, 1 /* we keep all texels >0 */, corners);
 
diff --git a/src/runtime/NEON/functions/NEFill.cpp b/src/runtime/NEON/functions/NEFill.cpp
index 68292c9ee0..74e366ab49 100644
--- a/src/runtime/NEON/functions/NEFill.cpp
+++ b/src/runtime/NEON/functions/NEFill.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/Window.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEMemsetKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,7 +33,7 @@ namespace arm_compute
 {
 void NEFill::configure(ITensor *tensor, PixelValue constant_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEMemsetKernel>();
+    auto k = std::make_unique<NEMemsetKernel>();
     k->configure(tensor, constant_value);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEFillBorder.cpp b/src/runtime/NEON/functions/NEFillBorder.cpp
index e96069f97c..bb57222eb4 100644
--- a/src/runtime/NEON/functions/NEFillBorder.cpp
+++ b/src/runtime/NEON/functions/NEFillBorder.cpp
@@ -26,13 +26,12 @@
 #include "arm_compute/core/Window.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEFillBorder::configure(ITensor *input, unsigned int border_width, BorderMode border_mode, const PixelValue &constant_border_value)
 {
-    _border_handler = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _border_handler = std::make_unique<NEFillBorderKernel>();
     _border_handler->configure(input, BorderSize(border_width), border_mode, constant_border_value);
 }
 
diff --git a/src/runtime/NEON/functions/NEFlattenLayer.cpp b/src/runtime/NEON/functions/NEFlattenLayer.cpp
index 4dfe96325e..21e55665cd 100644
--- a/src/runtime/NEON/functions/NEFlattenLayer.cpp
+++ b/src/runtime/NEON/functions/NEFlattenLayer.cpp
@@ -25,13 +25,12 @@
 
 #include "arm_compute/core/Size2D.h"
 #include "src/core/NEON/kernels/NEFlattenLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEFlattenLayer::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEFlattenLayerKernel>();
+    auto k = std::make_unique<NEFlattenLayerKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEFloor.cpp b/src/runtime/NEON/functions/NEFloor.cpp
index 5f6bd61017..74149e6f24 100644
--- a/src/runtime/NEON/functions/NEFloor.cpp
+++ b/src/runtime/NEON/functions/NEFloor.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NEFloor.h"
 
 #include "src/core/NEON/kernels/NEFloorKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEFloor::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEFloorKernel>();
+    auto k = std::make_unique<NEFloorKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEFullyConnectedLayer.cpp b/src/runtime/NEON/functions/NEFullyConnectedLayer.cpp
index 6b0c27cf65..f12c410a59 100644
--- a/src/runtime/NEON/functions/NEFullyConnectedLayer.cpp
+++ b/src/runtime/NEON/functions/NEFullyConnectedLayer.cpp
@@ -43,8 +43,6 @@
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
 #include "src/core/NEON/kernels/NETransposeKernel.h"
 
-#include "support/MemorySupport.h"
-
 #include <algorithm>
 #include <cmath>
 
@@ -148,7 +146,7 @@ Status validate_mm(const ITensorInfo *input, const ITensorInfo *weights, const I
 
 void NEFullyConnectedLayerReshapeWeights::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NETransposeKernel>();
+    auto k = std::make_unique<NETransposeKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
@@ -215,7 +213,7 @@ void NEFullyConnectedLayer::configure_conv_fc(const ITensor *input, const ITenso
     // Configure flatten kernel
     _memory_group.manage(&_flatten_output);
 
-    _flatten_kernel = arm_compute::support::cpp14::make_unique<NEFlattenLayerKernel>();
+    _flatten_kernel = std::make_unique<NEFlattenLayerKernel>();
     _flatten_kernel->configure(input, &_flatten_output);
 
     // Configure matrix multiply kernel
diff --git a/src/runtime/NEON/functions/NEFuseBatchNormalization.cpp b/src/runtime/NEON/functions/NEFuseBatchNormalization.cpp
index c64fde050e..a8ce6b2bfc 100644
--- a/src/runtime/NEON/functions/NEFuseBatchNormalization.cpp
+++ b/src/runtime/NEON/functions/NEFuseBatchNormalization.cpp
@@ -29,7 +29,6 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEFuseBatchNormalizationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -45,7 +44,7 @@ void NEFuseBatchNormalization::configure(const ITensor *input_weights, const ITe
                                          const ITensor *input_bias, const ITensor *bn_beta, const ITensor *bn_gamma,
                                          float epsilon, FuseBatchNormalizationType fbn_type)
 {
-    _fuse_bn_kernel = arm_compute::support::cpp14::make_unique<NEFuseBatchNormalizationKernel>();
+    _fuse_bn_kernel = std::make_unique<NEFuseBatchNormalizationKernel>();
     _fuse_bn_kernel->configure(input_weights, bn_mean, bn_var, fused_weights, fused_bias, input_bias, bn_beta, bn_gamma, epsilon, fbn_type);
 }
 
diff --git a/src/runtime/NEON/functions/NEGEMM.cpp b/src/runtime/NEON/functions/NEGEMM.cpp
index 9f52e458d2..03f5aa37c1 100644
--- a/src/runtime/NEON/functions/NEGEMM.cpp
+++ b/src/runtime/NEON/functions/NEGEMM.cpp
@@ -39,7 +39,6 @@
 #include "src/core/NEON/kernels/NEGEMMMatrixMultiplyKernel.h"
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 
@@ -110,7 +109,7 @@ void NEGEMM::configure(const ITensor *a, const ITensor *b, const ITensor *c, ITe
             _memory_group.manage(&_tmp_d);
         }
 
-        _mm_kernel = arm_compute::support::cpp14::make_unique<NEGEMMMatrixMultiplyKernel>();
+        _mm_kernel = std::make_unique<NEGEMMMatrixMultiplyKernel>();
 
         // Select between GEMV and GEMM
         if(_run_vector_matrix_multiplication)
@@ -148,11 +147,11 @@ void NEGEMM::configure(const ITensor *a, const ITensor *b, const ITensor *c, ITe
             int k = a->info()->dimension(0);
 
             // Configure interleave kernel
-            _interleave_kernel = arm_compute::support::cpp14::make_unique<NEGEMMInterleave4x4Kernel>();
+            _interleave_kernel = std::make_unique<NEGEMMInterleave4x4Kernel>();
             _interleave_kernel->configure(a, &_tmp_a);
 
             // Configure transpose kernel
-            _transpose_kernel = arm_compute::support::cpp14::make_unique<NEGEMMTranspose1xWKernel>();
+            _transpose_kernel = std::make_unique<NEGEMMTranspose1xWKernel>();
             _transpose_kernel->configure(b, &_tmp_b);
 
             // Configure matrix multiplication kernel
@@ -176,7 +175,7 @@ void NEGEMM::configure(const ITensor *a, const ITensor *b, const ITensor *c, ITe
     // Configure matrix addition kernel
     if(_run_addition)
     {
-        _ma_kernel = arm_compute::support::cpp14::make_unique<NEGEMMMatrixAdditionKernel>();
+        _ma_kernel = std::make_unique<NEGEMMMatrixAdditionKernel>();
         _ma_kernel->configure(c, d, beta);
     }
 
diff --git a/src/runtime/NEON/functions/NEGEMMAssemblyDispatch.cpp b/src/runtime/NEON/functions/NEGEMMAssemblyDispatch.cpp
index f6739ee925..394f970e54 100644
--- a/src/runtime/NEON/functions/NEGEMMAssemblyDispatch.cpp
+++ b/src/runtime/NEON/functions/NEGEMMAssemblyDispatch.cpp
@@ -28,8 +28,6 @@
 #include "src/core/NEON/kernels/assembly/NEGEMMAssemblyWrapperKernel.h"
 #include "src/core/NEON/kernels/assembly/arm_gemm.hpp"
 
-#include "support/MemorySupport.h"
-
 #include <arm_neon.h>
 #include <cstdlib>
 
@@ -485,7 +483,7 @@ void Fallback<TypeInput, TypeOutput, OutputStage>::configure(const ITensor *a, c
     }
 
     // arm_compute wrapper for the Gemm object (see above)
-    std::unique_ptr<NEGEMMAssemblyWrapperKernel<TypeInput, TypeOutput>> acl_gemm_wrapper = support::cpp14::make_unique<NEGEMMAssemblyWrapperKernel<TypeInput, TypeOutput>>();
+    std::unique_ptr<NEGEMMAssemblyWrapperKernel<TypeInput, TypeOutput>> acl_gemm_wrapper = std::make_unique<NEGEMMAssemblyWrapperKernel<TypeInput, TypeOutput>>();
     ARM_COMPUTE_ERROR_ON(acl_gemm_wrapper == nullptr);
     acl_gemm_wrapper->configure(_gemm_kernel_asm.get(), gemm_cfg.filter);
     const size_t workspace_size = _gemm_kernel_asm->get_working_size();
@@ -691,7 +689,7 @@ void create_arm_gemm(std::unique_ptr<NEGEMMAssemblyDispatch::IFallback> &arm_gem
     arm_gemm::GemmArgs args(&ci, p.M, p.N, p.K, p.sections, p.batches, p.multis, p.indirect, activation, num_threads);
 
     // Create arm_gemm fallback
-    auto fallback = support::cpp14::make_unique<Fallback<TypeInput, TypeOutput>>();
+    auto fallback = std::make_unique<Fallback<TypeInput, TypeOutput>>();
     fallback->configure(a, b, c, d, args, info, memory_group, weights_manager);
     arm_gemm = std::move(fallback);
 }
@@ -709,7 +707,7 @@ void create_arm_gemm_quant(std::unique_ptr<NEGEMMAssemblyDispatch::IFallback> &a
     arm_gemm::GemmArgs args(&ci, p.M, p.N, p.K, p.sections, p.batches, p.multis, p.indirect, activation, num_threads);
 
     // Create arm_gemm fallback
-    auto fallback = support::cpp14::make_unique<Fallback<TypeInput, TypeOutput, arm_gemm::Requantize32>>();
+    auto fallback = std::make_unique<Fallback<TypeInput, TypeOutput, arm_gemm::Requantize32>>();
 
     // Configure requantization info
     const int32_t                 negation = info.negated_offsets ? 1 : -1;
diff --git a/src/runtime/NEON/functions/NEGEMMConv2d.cpp b/src/runtime/NEON/functions/NEGEMMConv2d.cpp
index 642b084fb4..860b6bb4e1 100644
--- a/src/runtime/NEON/functions/NEGEMMConv2d.cpp
+++ b/src/runtime/NEON/functions/NEGEMMConv2d.cpp
@@ -25,7 +25,9 @@
 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
 #include "arm_compute/core/utils/quantization/AsymmHelpers.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
+
 #include <set>
+
 namespace arm_compute
 {
 namespace
diff --git a/src/runtime/NEON/functions/NEGEMMConvolutionLayer.cpp b/src/runtime/NEON/functions/NEGEMMConvolutionLayer.cpp
index 3f50f81af2..a3bdde24b0 100644
--- a/src/runtime/NEON/functions/NEGEMMConvolutionLayer.cpp
+++ b/src/runtime/NEON/functions/NEGEMMConvolutionLayer.cpp
@@ -43,7 +43,6 @@
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
 #include "src/core/NEON/kernels/NEIm2ColKernel.h"
 #include "src/core/NEON/kernels/NEWeightsReshapeKernel.h"
-#include "support/MemorySupport.h"
 
 #include <set>
 #include <tuple>
@@ -68,7 +67,7 @@ void NEConvolutionLayerReshapeWeights::configure(const ITensor *weights, const I
     const bool     append_biases = (biases != nullptr) && !is_data_type_quantized_asymmetric(weights->info()->data_type());
     const ITensor *biases_to_use = (append_biases) ? biases : nullptr;
 
-    _weights_reshape_kernel = arm_compute::support::cpp14::make_unique<NEWeightsReshapeKernel>();
+    _weights_reshape_kernel = std::make_unique<NEWeightsReshapeKernel>();
     _weights_reshape_kernel->configure(weights, biases_to_use, output);
 
     output->info()->set_quantization_info(weights->info()->quantization_info());
@@ -342,7 +341,7 @@ void NEGEMMConvolutionLayer::configure(const ITensor *input, const ITensor *weig
         _memory_group.manage(&_im2col_output);
 
         // Configure
-        _im2col_kernel = arm_compute::support::cpp14::make_unique<NEIm2ColKernel>();
+        _im2col_kernel = std::make_unique<NEIm2ColKernel>();
         _im2col_kernel->configure(input, &_im2col_output, Size2D(kernel_width, kernel_height), conv_info, false, dilation);
 
         // Update GEMM input
@@ -385,7 +384,7 @@ void NEGEMMConvolutionLayer::configure(const ITensor *input, const ITensor *weig
         if(_data_layout == DataLayout::NCHW)
         {
             // Configure col2im
-            _col2im_kernel = arm_compute::support::cpp14::make_unique<NECol2ImKernel>();
+            _col2im_kernel = std::make_unique<NECol2ImKernel>();
             _col2im_kernel->configure(gemm_output_to_use, output, Size2D(conv_w, conv_h));
         }
         else
diff --git a/src/runtime/NEON/functions/NEGEMMInterleave4x4.cpp b/src/runtime/NEON/functions/NEGEMMInterleave4x4.cpp
index 70fdcf492d..1e7a34bb35 100644
--- a/src/runtime/NEON/functions/NEGEMMInterleave4x4.cpp
+++ b/src/runtime/NEON/functions/NEGEMMInterleave4x4.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NEGEMMInterleave4x4.h"
 
 #include "src/core/NEON/kernels/NEGEMMInterleave4x4Kernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEGEMMInterleave4x4::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEGEMMInterleave4x4Kernel>();
+    auto k = std::make_unique<NEGEMMInterleave4x4Kernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEGEMMLowpMatrixMultiplyCore.cpp b/src/runtime/NEON/functions/NEGEMMLowpMatrixMultiplyCore.cpp
index df8eaacf47..d8f9d08c13 100644
--- a/src/runtime/NEON/functions/NEGEMMLowpMatrixMultiplyCore.cpp
+++ b/src/runtime/NEON/functions/NEGEMMLowpMatrixMultiplyCore.cpp
@@ -43,8 +43,6 @@
 #include "src/core/NEON/kernels/NEGEMMLowpReductionKernel.h"
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 namespace
@@ -106,7 +104,7 @@ void NEGEMMLowpMatrixMultiplyCore::configure(const ITensor *a, const ITensor *b,
 
         _signed_a.allocator()->init(a_to_use->info()->clone()->set_data_type(dt).set_quantization_info(QuantizationInfo(iqinfo.scale, iqinfo.offset + offset_correction)));
         _memory_group.manage(&_signed_a);
-        _convert_to_signed_asymm = arm_compute::support::cpp14::make_unique<NEConvertQuantizedSignednessKernel>();
+        _convert_to_signed_asymm = std::make_unique<NEConvertQuantizedSignednessKernel>();
         _convert_to_signed_asymm->configure(a_to_use, &_signed_a);
         a_to_use  = &_signed_a;
         _a_offset = _signed_a.info()->quantization_info().uniform().offset;
@@ -182,11 +180,11 @@ void NEGEMMLowpMatrixMultiplyCore::configure(const ITensor *a, const ITensor *b,
         }
 
         // Configure interleave kernel
-        _mtx_a_reshape_kernel = arm_compute::support::cpp14::make_unique<NEGEMMInterleave4x4Kernel>();
+        _mtx_a_reshape_kernel = std::make_unique<NEGEMMInterleave4x4Kernel>();
         _mtx_a_reshape_kernel->configure(a_to_use, &_tmp_a);
 
         // Configure transpose kernel
-        _mtx_b_reshape_kernel = arm_compute::support::cpp14::make_unique<NEGEMMTranspose1xWKernel>();
+        _mtx_b_reshape_kernel = std::make_unique<NEGEMMTranspose1xWKernel>();
         _mtx_b_reshape_kernel->configure(b, &_tmp_b);
     }
 
@@ -207,7 +205,7 @@ void NEGEMMLowpMatrixMultiplyCore::configure(const ITensor *a, const ITensor *b,
             }
 
             // Configure Matrix B reduction kernel
-            _mtx_b_reduction_kernel = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixBReductionKernel>();
+            _mtx_b_reduction_kernel = std::make_unique<NEGEMMLowpMatrixBReductionKernel>();
             _mtx_b_reduction_kernel->configure(b, &_vector_sum_col, reduction_info);
         }
 
@@ -220,7 +218,7 @@ void NEGEMMLowpMatrixMultiplyCore::configure(const ITensor *a, const ITensor *b,
             _memory_group.manage(&_vector_sum_row);
 
             // Configure matrix A reduction kernel
-            _mtx_a_reduction_kernel = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+            _mtx_a_reduction_kernel = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
             _mtx_a_reduction_kernel->configure(a_to_use, &_vector_sum_row, reduction_info);
         }
 
@@ -229,11 +227,11 @@ void NEGEMMLowpMatrixMultiplyCore::configure(const ITensor *a, const ITensor *b,
             // Configure matrix multiply kernel
             if(!_assembly_path)
             {
-                _mm_kernel = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixMultiplyKernel>();
+                _mm_kernel = std::make_unique<NEGEMMLowpMatrixMultiplyKernel>();
                 _mm_kernel->configure(matrix_a, matrix_b, &_mm_result_s32);
             }
 
-            _offset_contribution_output_stage_kernel = arm_compute::support::cpp14::make_unique<NEGEMMLowpOffsetContributionOutputStageKernel>();
+            _offset_contribution_output_stage_kernel = std::make_unique<NEGEMMLowpOffsetContributionOutputStageKernel>();
             _offset_contribution_output_stage_kernel->configure(&_mm_result_s32,
                                                                 _a_offset == 0 ? nullptr : &_vector_sum_col,
                                                                 _b_offset == 0 ? nullptr : &_vector_sum_row, c,
@@ -243,7 +241,7 @@ void NEGEMMLowpMatrixMultiplyCore::configure(const ITensor *a, const ITensor *b,
 
             if(_flip_signedness)
             {
-                _convert_from_signed_asymm = arm_compute::support::cpp14::make_unique<NEConvertQuantizedSignednessKernel>();
+                _convert_from_signed_asymm = std::make_unique<NEConvertQuantizedSignednessKernel>();
                 _convert_from_signed_asymm->configure(&_signed_output, output);
             }
         }
@@ -252,11 +250,11 @@ void NEGEMMLowpMatrixMultiplyCore::configure(const ITensor *a, const ITensor *b,
             // Configure matrix multiply kernel
             if(!_assembly_path)
             {
-                _mm_kernel = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixMultiplyKernel>();
+                _mm_kernel = std::make_unique<NEGEMMLowpMatrixMultiplyKernel>();
                 _mm_kernel->configure(matrix_a, matrix_b, output);
             }
             // Configure offset contribution kernel
-            _offset_contribution_kernel = arm_compute::support::cpp14::make_unique<NEGEMMLowpOffsetContributionKernel>();
+            _offset_contribution_kernel = std::make_unique<NEGEMMLowpOffsetContributionKernel>();
             _offset_contribution_kernel->configure(output, _a_offset == 0 ? nullptr : &_vector_sum_col, _b_offset == 0 ? nullptr : &_vector_sum_row, a_to_use->info()->dimension(0), _a_offset, _b_offset);
         }
 
diff --git a/src/runtime/NEON/functions/NEGEMMLowpOutputStage.cpp b/src/runtime/NEON/functions/NEGEMMLowpOutputStage.cpp
index 9fb8851d7a..807785a534 100644
--- a/src/runtime/NEON/functions/NEGEMMLowpOutputStage.cpp
+++ b/src/runtime/NEON/functions/NEGEMMLowpOutputStage.cpp
@@ -29,7 +29,6 @@
 #include "src/core/NEON/kernels/NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointKernel.h"
 #include "src/core/NEON/kernels/NEGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPointKernel.h"
 #include "src/core/NEON/kernels/NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -38,7 +37,7 @@ NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint::~NEGEMMLowpQuantizeDownInt3
 void NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint::configure(const ITensor *input, const ITensor *bias, ITensor *output, int result_fixedpoint_multiplier, int result_shift,
                                                                     int result_offset_after_shift, int min, int max)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointKernel>();
+    auto k = std::make_unique<NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointKernel>();
     k->configure(input, bias, output, result_fixedpoint_multiplier, result_shift, result_offset_after_shift, min, max);
     _kernel = std::move(k);
 }
@@ -53,7 +52,7 @@ NEGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPoint::~NEGEMMLowpQuantizeDownInt32
 void NEGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPoint::configure(const ITensor *input, const ITensor *bias, ITensor *output, int result_fixedpoint_multiplier, int result_shift,
                                                                    int result_offset_after_shift, int min, int max)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPointKernel>();
+    auto k = std::make_unique<NEGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPointKernel>();
     k->configure(input, bias, output, result_fixedpoint_multiplier, result_shift, result_offset_after_shift, min, max);
     _kernel = std::move(k);
 }
@@ -67,7 +66,7 @@ NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint::~NEGEMMLowpQuantizeDownInt3
 
 void NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint::configure(const ITensor *input, const ITensor *bias, ITensor *output, int result_fixedpoint_multiplier, int result_shift, int min, int max)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointKernel>();
+    auto k = std::make_unique<NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointKernel>();
     k->configure(input, bias, output, result_fixedpoint_multiplier, result_shift, min, max);
     _kernel = std::move(k);
 }
@@ -93,21 +92,21 @@ void NEGEMMLowpOutputStage::configure(const ITensor *input, const ITensor *bias,
             {
                 case DataType::QASYMM8:
                 {
-                    auto k = arm_compute::support::cpp14::make_unique<NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointKernel>();
+                    auto k = std::make_unique<NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointKernel>();
                     k->configure(input, bias, output, info.gemmlowp_multiplier, info.gemmlowp_shift, info.gemmlowp_offset, info.gemmlowp_min_bound, info.gemmlowp_max_bound);
                     _kernel = std::move(k);
                     break;
                 }
                 case DataType::QASYMM8_SIGNED:
                 {
-                    auto k = arm_compute::support::cpp14::make_unique<NEGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPointKernel>();
+                    auto k = std::make_unique<NEGEMMLowpQuantizeDownInt32ToInt8ScaleByFixedPointKernel>();
                     k->configure(input, bias, output, info.gemmlowp_multiplier, info.gemmlowp_shift, info.gemmlowp_offset, info.gemmlowp_min_bound, info.gemmlowp_max_bound);
                     _kernel = std::move(k);
                     break;
                 }
                 case DataType::QSYMM16:
                 {
-                    auto k = arm_compute::support::cpp14::make_unique<NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointKernel>();
+                    auto k = std::make_unique<NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointKernel>();
                     k->configure(input, bias, output, info.gemmlowp_multiplier, info.gemmlowp_shift, info.gemmlowp_min_bound, info.gemmlowp_max_bound);
                     _kernel = std::move(k);
                     break;
@@ -127,7 +126,7 @@ void NEGEMMLowpOutputStage::configure(const ITensor *input, const ITensor *bias,
                 case DataType::QASYMM8:
                 case DataType::QASYMM8_SIGNED:
                 {
-                    auto k = arm_compute::support::cpp14::make_unique<NEGEMMLowpQuantizeDownInt32ScaleKernel>();
+                    auto k = std::make_unique<NEGEMMLowpQuantizeDownInt32ScaleKernel>();
                     k->configure(input, bias, output, &info);
                     _kernel = std::move(k);
                     break;
diff --git a/src/runtime/NEON/functions/NEGEMMTranspose1xW.cpp b/src/runtime/NEON/functions/NEGEMMTranspose1xW.cpp
index 90cf0bab07..0408cfa585 100644
--- a/src/runtime/NEON/functions/NEGEMMTranspose1xW.cpp
+++ b/src/runtime/NEON/functions/NEGEMMTranspose1xW.cpp
@@ -28,13 +28,12 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/Validate.h"
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEGEMMTranspose1xW::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEGEMMTranspose1xWKernel>();
+    auto k = std::make_unique<NEGEMMTranspose1xWKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEGather.cpp b/src/runtime/NEON/functions/NEGather.cpp
index 5c0dae1507..86cbfd187a 100644
--- a/src/runtime/NEON/functions/NEGather.cpp
+++ b/src/runtime/NEON/functions/NEGather.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEGather.h"
 
 #include "src/core/NEON/kernels/NEGatherKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ namespace arm_compute
 {
 void NEGather::configure(const ITensor *input, const ITensor *indices, ITensor *output, int axis)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEGatherKernel>();
+    auto k = std::make_unique<NEGatherKernel>();
     k->configure(input, indices, output, axis);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEGaussian3x3.cpp b/src/runtime/NEON/functions/NEGaussian3x3.cpp
index 5290de1348..93e813c052 100644
--- a/src/runtime/NEON/functions/NEGaussian3x3.cpp
+++ b/src/runtime/NEON/functions/NEGaussian3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEGaussian3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,11 +33,11 @@ namespace arm_compute
 {
 void NEGaussian3x3::configure(ITensor *input, ITensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEGaussian3x3Kernel>();
+    auto k = std::make_unique<NEGaussian3x3Kernel>();
     k->configure(input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEGaussian5x5.cpp b/src/runtime/NEON/functions/NEGaussian5x5.cpp
index 7857710462..ed7e83b937 100644
--- a/src/runtime/NEON/functions/NEGaussian5x5.cpp
+++ b/src/runtime/NEON/functions/NEGaussian5x5.cpp
@@ -30,7 +30,6 @@
 #include "arm_compute/runtime/TensorAllocator.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEGaussian5x5Kernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -50,9 +49,9 @@ void NEGaussian5x5::configure(ITensor *input, ITensor *output, BorderMode border
     // Manage intermediate buffers
     _memory_group.manage(&_tmp);
 
-    _kernel_hor     = arm_compute::support::cpp14::make_unique<NEGaussian5x5HorKernel>();
-    _kernel_vert    = arm_compute::support::cpp14::make_unique<NEGaussian5x5VertKernel>();
-    _border_handler = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _kernel_hor     = std::make_unique<NEGaussian5x5HorKernel>();
+    _kernel_vert    = std::make_unique<NEGaussian5x5VertKernel>();
+    _border_handler = std::make_unique<NEFillBorderKernel>();
 
     // Create and configure kernels for the two passes
     _kernel_hor->configure(input, &_tmp, border_mode == BorderMode::UNDEFINED);
diff --git a/src/runtime/NEON/functions/NEGaussianPyramid.cpp b/src/runtime/NEON/functions/NEGaussianPyramid.cpp
index 30fe70f0ab..c9a36fc466 100644
--- a/src/runtime/NEON/functions/NEGaussianPyramid.cpp
+++ b/src/runtime/NEON/functions/NEGaussianPyramid.cpp
@@ -36,7 +36,6 @@
 #include "src/core/NEON/kernels/NEGaussian5x5Kernel.h"
 #include "src/core/NEON/kernels/NEGaussianPyramidKernel.h"
 #include "src/core/NEON/kernels/NEScaleKernel.h"
-#include "support/MemorySupport.h"
 
 #include <cstddef>
 
@@ -98,19 +97,19 @@ void NEGaussianPyramidHalf::configure(const ITensor *input, IPyramid *pyramid, B
         for(size_t i = 0; i < num_stages; ++i)
         {
             /* Configure horizontal kernel */
-            _horizontal_reduction[i] = arm_compute::support::cpp14::make_unique<NEGaussianPyramidHorKernel>();
+            _horizontal_reduction[i] = std::make_unique<NEGaussianPyramidHorKernel>();
             _horizontal_reduction[i]->configure(_pyramid->get_pyramid_level(i), _tmp.get_pyramid_level(i));
 
             /* Configure vertical kernel */
-            _vertical_reduction[i] = arm_compute::support::cpp14::make_unique<NEGaussianPyramidVertKernel>();
+            _vertical_reduction[i] = std::make_unique<NEGaussianPyramidVertKernel>();
             _vertical_reduction[i]->configure(_tmp.get_pyramid_level(i), _pyramid->get_pyramid_level(i + 1));
 
             /* Configure border */
-            _horizontal_border_handler[i] = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+            _horizontal_border_handler[i] = std::make_unique<NEFillBorderKernel>();
             _horizontal_border_handler[i]->configure(_pyramid->get_pyramid_level(i), _horizontal_reduction[i]->border_size(), border_mode, PixelValue(constant_border_value));
 
             /* Configure border */
-            _vertical_border_handler[i] = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+            _vertical_border_handler[i] = std::make_unique<NEFillBorderKernel>();
             _vertical_border_handler[i]->configure(_tmp.get_pyramid_level(i), _vertical_reduction[i]->border_size(), border_mode, PixelValue(pixel_value_u16));
         }
 
diff --git a/src/runtime/NEON/functions/NEHOGDescriptor.cpp b/src/runtime/NEON/functions/NEHOGDescriptor.cpp
index 689e64fae7..bb125a1eae 100644
--- a/src/runtime/NEON/functions/NEHOGDescriptor.cpp
+++ b/src/runtime/NEON/functions/NEHOGDescriptor.cpp
@@ -31,7 +31,6 @@
 #include "src/core/NEON/kernels/NEDerivativeKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEHOGDescriptorKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -88,11 +87,11 @@ void NEHOGDescriptor::configure(ITensor *input, ITensor *output, const IHOG *hog
     _memory_group.manage(&_hog_space);
 
     // Initialise orientation binning kernel
-    _orient_bin = arm_compute::support::cpp14::make_unique<NEHOGOrientationBinningKernel>();
+    _orient_bin = std::make_unique<NEHOGOrientationBinningKernel>();
     _orient_bin->configure(&_mag, &_phase, &_hog_space, hog->info());
 
     // Initialize HOG norm kernel
-    _block_norm = arm_compute::support::cpp14::make_unique<NEHOGBlockNormalizationKernel>();
+    _block_norm = std::make_unique<NEHOGBlockNormalizationKernel>();
     _block_norm->configure(&_hog_space, output, hog->info());
 
     // Allocate intermediate tensors
diff --git a/src/runtime/NEON/functions/NEHOGDetector.cpp b/src/runtime/NEON/functions/NEHOGDetector.cpp
index 8468b75f4e..3eda1b0ce0 100644
--- a/src/runtime/NEON/functions/NEHOGDetector.cpp
+++ b/src/runtime/NEON/functions/NEHOGDetector.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEHOGDetector.h"
 
 #include "src/core/NEON/kernels/NEHOGDetectorKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -32,7 +31,7 @@ NEHOGDetector::~NEHOGDetector() = default;
 
 void NEHOGDetector::configure(const ITensor *input, const IHOG *hog, IDetectionWindowArray *detection_windows, const Size2D &detection_window_stride, float threshold, size_t idx_class)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEHOGDetectorKernel>();
+    auto k = std::make_unique<NEHOGDetectorKernel>();
     k->configure(input, hog, detection_windows, detection_window_stride, threshold, idx_class);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEHOGGradient.cpp b/src/runtime/NEON/functions/NEHOGGradient.cpp
index 7d794bc1a0..f5a47735a9 100644
--- a/src/runtime/NEON/functions/NEHOGGradient.cpp
+++ b/src/runtime/NEON/functions/NEHOGGradient.cpp
@@ -28,7 +28,6 @@
 #include "src/core/NEON/kernels/NEDerivativeKernel.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -66,13 +65,13 @@ void NEHOGGradient::configure(ITensor *input, ITensor *output_magnitude, ITensor
     // Initialise magnitude/phase kernel
     if(PhaseType::UNSIGNED == phase_type)
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::UNSIGNED>>();
+        auto k = std::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::UNSIGNED>>();
         k->configure(&_gx, &_gy, output_magnitude, output_phase);
         _mag_phase = std::move(k);
     }
     else
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::SIGNED>>();
+        auto k = std::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::SIGNED>>();
         k->configure(&_gx, &_gy, output_magnitude, output_phase);
         _mag_phase = std::move(k);
     }
diff --git a/src/runtime/NEON/functions/NEHarrisCorners.cpp b/src/runtime/NEON/functions/NEHarrisCorners.cpp
index 23fcf8c805..6b15596f8a 100644
--- a/src/runtime/NEON/functions/NEHarrisCorners.cpp
+++ b/src/runtime/NEON/functions/NEHarrisCorners.cpp
@@ -37,7 +37,6 @@
 #include "src/core/NEON/kernels/NEHarrisCornersKernel.h"
 #include "src/core/NEON/kernels/NESobel5x5Kernel.h"
 #include "src/core/NEON/kernels/NESobel7x7Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 #include <utility>
@@ -102,21 +101,21 @@ void NEHarrisCorners::configure(IImage *input, float threshold, float min_dist,
     {
         case 3:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NESobel3x3>();
+            auto k = std::make_unique<NESobel3x3>();
             k->configure(input, &_gx, &_gy, border_mode, constant_border_value);
             _sobel = std::move(k);
             break;
         }
         case 5:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NESobel5x5>();
+            auto k = std::make_unique<NESobel5x5>();
             k->configure(input, &_gx, &_gy, border_mode, constant_border_value);
             _sobel = std::move(k);
             break;
         }
         case 7:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NESobel7x7>();
+            auto k = std::make_unique<NESobel7x7>();
             k->configure(input, &_gx, &_gy, border_mode, constant_border_value);
             _sobel = std::move(k);
             break;
@@ -136,21 +135,21 @@ void NEHarrisCorners::configure(IImage *input, float threshold, float min_dist,
     {
         case 3:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NEHarrisScoreKernel<3>>();
+            auto k = std::make_unique<NEHarrisScoreKernel<3>>();
             k->configure(&_gx, &_gy, &_score, norm_factor, threshold, sensitivity, border_mode == BorderMode::UNDEFINED);
             _harris_score = std::move(k);
         }
         break;
         case 5:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NEHarrisScoreKernel<5>>();
+            auto k = std::make_unique<NEHarrisScoreKernel<5>>();
             k->configure(&_gx, &_gy, &_score, norm_factor, threshold, sensitivity, border_mode == BorderMode::UNDEFINED);
             _harris_score = std::move(k);
         }
         break;
         case 7:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NEHarrisScoreKernel<7>>();
+            auto k = std::make_unique<NEHarrisScoreKernel<7>>();
             k->configure(&_gx, &_gy, &_score, norm_factor, threshold, sensitivity, border_mode == BorderMode::UNDEFINED);
             _harris_score = std::move(k);
         }
@@ -159,8 +158,8 @@ void NEHarrisCorners::configure(IImage *input, float threshold, float min_dist,
     }
 
     // Configure border filling before harris score
-    _border_gx = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
-    _border_gy = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _border_gx = std::make_unique<NEFillBorderKernel>();
+    _border_gy = std::make_unique<NEFillBorderKernel>();
     _border_gx->configure(&_gx, _harris_score->border_size(), border_mode, constant_border_value);
     _border_gy->configure(&_gy, _harris_score->border_size(), border_mode, constant_border_value);
 
diff --git a/src/runtime/NEON/functions/NEHistogram.cpp b/src/runtime/NEON/functions/NEHistogram.cpp
index 40ea3a16c6..1b093d60e5 100644
--- a/src/runtime/NEON/functions/NEHistogram.cpp
+++ b/src/runtime/NEON/functions/NEHistogram.cpp
@@ -30,7 +30,6 @@
 #include "arm_compute/core/Validate.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEHistogramKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -51,7 +50,7 @@ void NEHistogram::configure(const IImage *input, IDistribution1D *output)
     _local_hist.resize(_local_hist_size);
 
     // Configure kernel
-    _histogram_kernel = arm_compute::support::cpp14::make_unique<NEHistogramKernel>();
+    _histogram_kernel = std::make_unique<NEHistogramKernel>();
     _histogram_kernel->configure(input, output, _local_hist.data(), _window_lut.data());
 }
 
diff --git a/src/runtime/NEON/functions/NEIm2Col.cpp b/src/runtime/NEON/functions/NEIm2Col.cpp
index bc0c60112e..d6d72aa712 100644
--- a/src/runtime/NEON/functions/NEIm2Col.cpp
+++ b/src/runtime/NEON/functions/NEIm2Col.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/TensorInfo.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEIm2ColKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -41,7 +40,7 @@ void NEIm2Col::configure(const ITensor *input, ITensor *output, const Size2D &ke
 {
     _y_dim = get_data_layout_dimension_index(input->info()->data_layout(), DataLayoutDimension::HEIGHT);
 
-    _kernel = arm_compute::support::cpp14::make_unique<NEIm2ColKernel>();
+    _kernel = std::make_unique<NEIm2ColKernel>();
     _kernel->configure(input, output, kernel_dims, conv_info, has_bias, dilation, num_groups);
 }
 
diff --git a/src/runtime/NEON/functions/NEInstanceNormalizationLayer.cpp b/src/runtime/NEON/functions/NEInstanceNormalizationLayer.cpp
index e3fb284796..5965b9722f 100644
--- a/src/runtime/NEON/functions/NEInstanceNormalizationLayer.cpp
+++ b/src/runtime/NEON/functions/NEInstanceNormalizationLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/KernelDescriptors.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEInstanceNormalizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -46,7 +45,7 @@ void NEInstanceNormalizationLayer::configure(ITensor *input, ITensor *output, fl
     // Configure Kernels
     _is_nchw = data_layout == DataLayout::NCHW;
 
-    _normalization_kernel = arm_compute::support::cpp14::make_unique<NEInstanceNormalizationLayerKernel>();
+    _normalization_kernel = std::make_unique<NEInstanceNormalizationLayerKernel>();
 
     if(!_is_nchw)
     {
diff --git a/src/runtime/NEON/functions/NEIntegralImage.cpp b/src/runtime/NEON/functions/NEIntegralImage.cpp
index 63bcd53373..38f04247f6 100644
--- a/src/runtime/NEON/functions/NEIntegralImage.cpp
+++ b/src/runtime/NEON/functions/NEIntegralImage.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/Types.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEIntegralImageKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -36,11 +35,11 @@ NEIntegralImage::~NEIntegralImage() = default;
 
 void NEIntegralImage::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEIntegralImageKernel>();
+    auto k = std::make_unique<NEIntegralImageKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(output, _kernel->border_size(), BorderMode::CONSTANT, PixelValue());
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEL2NormalizeLayer.cpp b/src/runtime/NEON/functions/NEL2NormalizeLayer.cpp
index 4a99968cc3..505ee0a962 100644
--- a/src/runtime/NEON/functions/NEL2NormalizeLayer.cpp
+++ b/src/runtime/NEON/functions/NEL2NormalizeLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEL2NormalizeLayerKernel.h"
 #include "src/core/NEON/kernels/NEReductionOperationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -50,7 +49,7 @@ void NEL2NormalizeLayer::configure(ITensor *input, ITensor *output, int axis, fl
     // Configure Kernels
     const uint32_t actual_axis = wrap_around(axis, max_input_tensor_dim);
     _reduce_func.configure(input, &_sumsq, actual_axis, ReductionOperation::SUM_SQUARE);
-    _normalize_kernel = arm_compute::support::cpp14::make_unique<NEL2NormalizeLayerKernel>();
+    _normalize_kernel = std::make_unique<NEL2NormalizeLayerKernel>();
     _normalize_kernel->configure(input, &_sumsq, output, axis, epsilon);
 
     // Allocate intermediate tensors
diff --git a/src/runtime/NEON/functions/NELocallyConnectedLayer.cpp b/src/runtime/NEON/functions/NELocallyConnectedLayer.cpp
index 131ac82ba8..c1164c3bee 100644
--- a/src/runtime/NEON/functions/NELocallyConnectedLayer.cpp
+++ b/src/runtime/NEON/functions/NELocallyConnectedLayer.cpp
@@ -30,7 +30,6 @@
 #include "src/core/NEON/kernels/NEIm2ColKernel.h"
 #include "src/core/NEON/kernels/NELocallyConnectedMatrixMultiplyKernel.h"
 #include "src/core/NEON/kernels/NEWeightsReshapeKernel.h"
-#include "support/MemorySupport.h"
 
 #include <cmath>
 #include <tuple>
@@ -160,9 +159,9 @@ void NELocallyConnectedLayer::configure(const ITensor *input, const ITensor *wei
 
     // Configure kernels
     _input_im2col.configure(input, &_input_im2col_reshaped, Size2D(kernel_width, kernel_height), conv_info, _has_bias);
-    _weights_reshape_kernel = arm_compute::support::cpp14::make_unique<NEWeightsReshapeKernel>();
+    _weights_reshape_kernel = std::make_unique<NEWeightsReshapeKernel>();
     _weights_reshape_kernel->configure(weights, biases, &_weights_reshaped);
-    _mm_kernel = arm_compute::support::cpp14::make_unique<NELocallyConnectedMatrixMultiplyKernel>();
+    _mm_kernel = std::make_unique<NELocallyConnectedMatrixMultiplyKernel>();
     _mm_kernel->configure(&_input_im2col_reshaped, &_weights_reshaped, &_gemm_output);
     _output_col2im.configure(&_gemm_output, output, Size2D(conv_w, conv_h));
 
diff --git a/src/runtime/NEON/functions/NELogical.cpp b/src/runtime/NEON/functions/NELogical.cpp
index 8e43d60bef..2c9ebd5f29 100644
--- a/src/runtime/NEON/functions/NELogical.cpp
+++ b/src/runtime/NEON/functions/NELogical.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "arm_compute/runtime/Tensor.h"
 #include "src/core/NEON/kernels/NELogicalKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -40,7 +39,7 @@ struct NELogicalAnd::Impl : public LogicalArgs
 {
 };
 NELogicalAnd::NELogicalAnd()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NELogicalAnd &NELogicalAnd::operator=(NELogicalAnd &&) = default;
@@ -50,7 +49,7 @@ void NELogicalAnd::configure(const ITensor *input1, const ITensor *input2, ITens
 {
     ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
 
-    _impl->kernel = arm_compute::support::cpp14::make_unique<kernels::NELogicalKernel>();
+    _impl->kernel = std::make_unique<kernels::NELogicalKernel>();
     _impl->kernel->configure(input1->info(), input2->info(), output->info(), kernels::LogicalOperation::And);
 
     _impl->pack = ITensorPack();
@@ -73,7 +72,7 @@ struct NELogicalOr::Impl : public LogicalArgs
 {
 };
 NELogicalOr::NELogicalOr()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NELogicalOr &NELogicalOr::operator=(NELogicalOr &&) = default;
@@ -83,7 +82,7 @@ void NELogicalOr::configure(const ITensor *input1, const ITensor *input2, ITenso
 {
     ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
 
-    _impl->kernel = arm_compute::support::cpp14::make_unique<kernels::NELogicalKernel>();
+    _impl->kernel = std::make_unique<kernels::NELogicalKernel>();
     _impl->kernel->configure(input1->info(), input2->info(), output->info(), kernels::LogicalOperation::Or);
 
     _impl->pack = ITensorPack();
@@ -106,7 +105,7 @@ struct NELogicalNot::Impl : public LogicalArgs
 {
 };
 NELogicalNot::NELogicalNot()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NELogicalNot &NELogicalNot::operator=(NELogicalNot &&) = default;
@@ -116,7 +115,7 @@ void NELogicalNot::configure(const ITensor *input, ITensor *output)
 {
     ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
 
-    _impl->kernel = arm_compute::support::cpp14::make_unique<kernels::NELogicalKernel>();
+    _impl->kernel = std::make_unique<kernels::NELogicalKernel>();
     _impl->kernel->configure(input->info(), nullptr, output->info(), kernels::LogicalOperation::Not);
 
     _impl->pack = ITensorPack();
diff --git a/src/runtime/NEON/functions/NEMagnitude.cpp b/src/runtime/NEON/functions/NEMagnitude.cpp
index 06ed8d46c9..34d9a7fb0b 100644
--- a/src/runtime/NEON/functions/NEMagnitude.cpp
+++ b/src/runtime/NEON/functions/NEMagnitude.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/Types.h"
 #include "src/core/NEON/kernels/NEMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,13 +36,13 @@ void NEMagnitude::configure(const ITensor *input1, const ITensor *input2, ITenso
 {
     if(mag_type == MagnitudeType::L1NORM)
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L1NORM, PhaseType::SIGNED>>();
+        auto k = std::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L1NORM, PhaseType::SIGNED>>();
         k->configure(input1, input2, output, nullptr);
         _kernel = std::move(k);
     }
     else
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::SIGNED>>();
+        auto k = std::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::SIGNED>>();
         k->configure(input1, input2, output, nullptr);
         _kernel = std::move(k);
     }
diff --git a/src/runtime/NEON/functions/NEMaxUnpoolingLayer.cpp b/src/runtime/NEON/functions/NEMaxUnpoolingLayer.cpp
index e8c9d09d95..da6260b0c5 100644
--- a/src/runtime/NEON/functions/NEMaxUnpoolingLayer.cpp
+++ b/src/runtime/NEON/functions/NEMaxUnpoolingLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEMaxUnpoolingLayerKernel.h"
 #include "src/core/NEON/kernels/NEMemsetKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -42,8 +41,8 @@ NEMaxUnpoolingLayer::NEMaxUnpoolingLayer()
 void NEMaxUnpoolingLayer::configure(ITensor *input, ITensor *indices, ITensor *output, const PoolingLayerInfo &pool_info)
 {
     const PixelValue zero_value(0.f);
-    _memset_kernel          = arm_compute::support::cpp14::make_unique<NEMemsetKernel>();
-    _unpooling_layer_kernel = arm_compute::support::cpp14::make_unique<NEMaxUnpoolingLayerKernel>();
+    _memset_kernel          = std::make_unique<NEMemsetKernel>();
+    _unpooling_layer_kernel = std::make_unique<NEMaxUnpoolingLayerKernel>();
     _memset_kernel->configure(output, zero_value);
     _unpooling_layer_kernel->configure(input, indices, output, pool_info);
 }
diff --git a/src/runtime/NEON/functions/NEMeanStdDev.cpp b/src/runtime/NEON/functions/NEMeanStdDev.cpp
index e073420114..6e2d7fc81d 100644
--- a/src/runtime/NEON/functions/NEMeanStdDev.cpp
+++ b/src/runtime/NEON/functions/NEMeanStdDev.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEMeanStdDevKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -39,8 +38,8 @@ NEMeanStdDev::NEMeanStdDev()
 
 void NEMeanStdDev::configure(IImage *input, float *mean, float *stddev)
 {
-    _mean_stddev_kernel = arm_compute::support::cpp14::make_unique<NEMeanStdDevKernel>();
-    _fill_border_kernel = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _mean_stddev_kernel = std::make_unique<NEMeanStdDevKernel>();
+    _fill_border_kernel = std::make_unique<NEFillBorderKernel>();
 
     _mean_stddev_kernel->configure(input, mean, &_global_sum, stddev, &_global_sum_squared);
     _fill_border_kernel->configure(input, _mean_stddev_kernel->border_size(), BorderMode::CONSTANT, PixelValue(static_cast<uint8_t>(0)));
diff --git a/src/runtime/NEON/functions/NEMeanStdDevNormalizationLayer.cpp b/src/runtime/NEON/functions/NEMeanStdDevNormalizationLayer.cpp
index d128c4456a..02de983b77 100644
--- a/src/runtime/NEON/functions/NEMeanStdDevNormalizationLayer.cpp
+++ b/src/runtime/NEON/functions/NEMeanStdDevNormalizationLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEMeanStdDevNormalizationLayer.h"
 
 #include "src/core/NEON/kernels/NEMeanStdDevNormalizationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -32,7 +31,7 @@ NEMeanStdDevNormalizationLayer::~NEMeanStdDevNormalizationLayer() = default;
 
 void NEMeanStdDevNormalizationLayer::configure(ITensor *input, ITensor *output, float epsilon)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEMeanStdDevNormalizationKernel>();
+    auto k = std::make_unique<NEMeanStdDevNormalizationKernel>();
     k->configure(input, output, epsilon);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEMedian3x3.cpp b/src/runtime/NEON/functions/NEMedian3x3.cpp
index b7b7c2cb47..4d117783ed 100644
--- a/src/runtime/NEON/functions/NEMedian3x3.cpp
+++ b/src/runtime/NEON/functions/NEMedian3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEMedian3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,11 +33,11 @@ namespace arm_compute
 {
 void NEMedian3x3::configure(ITensor *input, ITensor *output, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEMedian3x3Kernel>();
+    auto k = std::make_unique<NEMedian3x3Kernel>();
     k->configure(input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEMinMaxLocation.cpp b/src/runtime/NEON/functions/NEMinMaxLocation.cpp
index 3c2219ca07..ffbc33bc2e 100644
--- a/src/runtime/NEON/functions/NEMinMaxLocation.cpp
+++ b/src/runtime/NEON/functions/NEMinMaxLocation.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEMinMaxLocationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -38,10 +37,10 @@ NEMinMaxLocation::NEMinMaxLocation()
 
 void NEMinMaxLocation::configure(const IImage *input, void *min, void *max, ICoordinates2DArray *min_loc, ICoordinates2DArray *max_loc, uint32_t *min_count, uint32_t *max_count)
 {
-    _min_max = arm_compute::support::cpp14::make_unique<NEMinMaxKernel>();
+    _min_max = std::make_unique<NEMinMaxKernel>();
     _min_max->configure(input, min, max);
 
-    _min_max_loc = arm_compute::support::cpp14::make_unique<NEMinMaxLocationKernel>();
+    _min_max_loc = std::make_unique<NEMinMaxLocationKernel>();
     _min_max_loc->configure(input, min, max, min_loc, max_loc, min_count, max_count);
 }
 
diff --git a/src/runtime/NEON/functions/NENonLinearFilter.cpp b/src/runtime/NEON/functions/NENonLinearFilter.cpp
index 4d8fd00cbd..f3acabfa6d 100644
--- a/src/runtime/NEON/functions/NENonLinearFilter.cpp
+++ b/src/runtime/NEON/functions/NENonLinearFilter.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NENonLinearFilterKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -36,11 +35,11 @@ void NENonLinearFilter::configure(ITensor *input, ITensor *output, NonLinearFilt
                                   BorderMode border_mode,
                                   uint8_t    constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NENonLinearFilterKernel>();
+    auto k = std::make_unique<NENonLinearFilterKernel>();
     k->configure(input, output, function, mask_size, pattern, mask, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NENonMaximaSuppression3x3.cpp b/src/runtime/NEON/functions/NENonMaximaSuppression3x3.cpp
index b8f5c251b7..a34be71ea0 100644
--- a/src/runtime/NEON/functions/NENonMaximaSuppression3x3.cpp
+++ b/src/runtime/NEON/functions/NENonMaximaSuppression3x3.cpp
@@ -25,7 +25,6 @@
 
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NENonMaximaSuppression3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -33,11 +32,11 @@ namespace arm_compute
 {
 void NENonMaximaSuppression3x3::configure(ITensor *input, ITensor *output, BorderMode border_mode)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NENonMaximaSuppression3x3Kernel>();
+    auto k = std::make_unique<NENonMaximaSuppression3x3Kernel>();
     k->configure(input, output, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     if(border_mode != BorderMode::UNDEFINED)
     {
         b->configure(input, BorderSize(1), BorderMode::CONSTANT, static_cast<float>(0.f));
diff --git a/src/runtime/NEON/functions/NENormalizationLayer.cpp b/src/runtime/NEON/functions/NENormalizationLayer.cpp
index dfc73b2a57..9dcb157c03 100644
--- a/src/runtime/NEON/functions/NENormalizationLayer.cpp
+++ b/src/runtime/NEON/functions/NENormalizationLayer.cpp
@@ -30,7 +30,6 @@
 #include "arm_compute/core/Validate.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NENormalizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -52,7 +51,7 @@ void NENormalizationLayer::configure(const ITensor *input, ITensor *output, cons
     _memory_group.manage(&_input_squared);
 
     // Configure kernels
-    _norm_kernel = arm_compute::support::cpp14::make_unique<NENormalizationLayerKernel>();
+    _norm_kernel = std::make_unique<NENormalizationLayerKernel>();
     _norm_kernel->configure(input, &_input_squared, output, norm_info);
     _multiply_f.configure(input, input, &_input_squared, 1.0f, ConvertPolicy::SATURATE, RoundingPolicy::TO_ZERO);
 
diff --git a/src/runtime/NEON/functions/NEOpticalFlow.cpp b/src/runtime/NEON/functions/NEOpticalFlow.cpp
index 565346bfce..a868208aaf 100644
--- a/src/runtime/NEON/functions/NEOpticalFlow.cpp
+++ b/src/runtime/NEON/functions/NEOpticalFlow.cpp
@@ -34,7 +34,6 @@
 #include "arm_compute/runtime/TensorAllocator.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NELKTrackerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -114,7 +113,7 @@ void NEOpticalFlow::configure(const Pyramid *old_pyramid, const Pyramid *new_pyr
         _func_scharr[i].configure(old_ith_input, &_scharr_gx[i], &_scharr_gy[i], border_mode, constant_border_value);
 
         // Init Lucas-Kanade kernel
-        _kernel_tracker[i] = arm_compute::support::cpp14::make_unique<NELKTrackerKernel>();
+        _kernel_tracker[i] = std::make_unique<NELKTrackerKernel>();
         _kernel_tracker[i]->configure(old_ith_input, new_ith_input, &_scharr_gx[i], &_scharr_gy[i],
                                       old_points, new_points_estimates, new_points,
                                       &_old_points_internal, &_new_points_internal,
diff --git a/src/runtime/NEON/functions/NEPReluLayer.cpp b/src/runtime/NEON/functions/NEPReluLayer.cpp
index 00a1a4257a..fe656c0be0 100644
--- a/src/runtime/NEON/functions/NEPReluLayer.cpp
+++ b/src/runtime/NEON/functions/NEPReluLayer.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/ITensor.h"
 #include "src/core/NEON/kernels/NEElementwiseOperationKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -33,7 +32,7 @@ namespace experimental
 {
 void NEPRelu::configure(const ITensorInfo *input, const ITensorInfo *alpha, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEArithmeticOperationKernel>();
+    auto k = std::make_unique<NEArithmeticOperationKernel>();
     k->configure(ArithmeticOperation::PRELU, input, alpha, output);
     _kernel = std::move(k);
 }
@@ -53,7 +52,7 @@ struct NEPReluLayer::Impl
 };
 
 NEPReluLayer::NEPReluLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEPReluLayer::NEPReluLayer(NEPReluLayer &&) = default;
@@ -65,7 +64,7 @@ void NEPReluLayer::configure(const ITensor *input, const ITensor *alpha, ITensor
     _impl->src_0 = input;
     _impl->src_1 = alpha;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEPRelu>();
+    _impl->op    = std::make_unique<experimental::NEPRelu>();
     _impl->op->configure(input->info(), alpha->info(), output->info());
 }
 
diff --git a/src/runtime/NEON/functions/NEPadLayer.cpp b/src/runtime/NEON/functions/NEPadLayer.cpp
index 92659f39a2..88a73b8b0d 100644
--- a/src/runtime/NEON/functions/NEPadLayer.cpp
+++ b/src/runtime/NEON/functions/NEPadLayer.cpp
@@ -30,7 +30,6 @@
 #include "src/core/NEON/kernels/NECopyKernel.h"
 #include "src/core/NEON/kernels/NEPadLayerKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -59,7 +58,7 @@ NEPadLayer::NEPadLayer()
 
 void NEPadLayer::configure_constant_mode(ITensor *input, ITensor *output, const PaddingList &padding, const PixelValue constant_value)
 {
-    _pad_kernel = arm_compute::support::cpp14::make_unique<NEPadLayerKernel>();
+    _pad_kernel = std::make_unique<NEPadLayerKernel>();
     _pad_kernel->configure(input, output, padding, constant_value, PaddingMode::CONSTANT);
 }
 
@@ -201,7 +200,7 @@ void NEPadLayer::configure(ITensor *input, ITensor *output, const PaddingList &p
     else
     {
         // Copy the input to the whole output if no padding is applied
-        _copy_kernel = arm_compute::support::cpp14::make_unique<NECopyKernel>();
+        _copy_kernel = std::make_unique<NECopyKernel>();
         _copy_kernel->configure(input, output);
     }
 }
diff --git a/src/runtime/NEON/functions/NEPermute.cpp b/src/runtime/NEON/functions/NEPermute.cpp
index d2a115fdc8..cceb22f8c6 100644
--- a/src/runtime/NEON/functions/NEPermute.cpp
+++ b/src/runtime/NEON/functions/NEPermute.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NEPermute.h"
 
 #include "src/core/NEON/kernels/NEPermuteKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEPermute::configure(const ITensor *input, ITensor *output, const PermutationVector &perm)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEPermuteKernel>();
+    auto k = std::make_unique<NEPermuteKernel>();
     k->configure(input, output, perm);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEPhase.cpp b/src/runtime/NEON/functions/NEPhase.cpp
index 3b6182a269..3b69a10e7f 100644
--- a/src/runtime/NEON/functions/NEPhase.cpp
+++ b/src/runtime/NEON/functions/NEPhase.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEPhase.h"
 
 #include "src/core/NEON/kernels/NEMagnitudePhaseKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,13 +33,13 @@ void NEPhase::configure(const ITensor *input1, const ITensor *input2, ITensor *o
 {
     if(phase_type == PhaseType::UNSIGNED)
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::UNSIGNED>>();
+        auto k = std::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::UNSIGNED>>();
         k->configure(input1, input2, nullptr, output);
         _kernel = std::move(k);
     }
     else
     {
-        auto k = arm_compute::support::cpp14::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::SIGNED>>();
+        auto k = std::make_unique<NEMagnitudePhaseKernel<MagnitudeType::L2NORM, PhaseType::SIGNED>>();
         k->configure(input1, input2, nullptr, output);
         _kernel = std::move(k);
     }
diff --git a/src/runtime/NEON/functions/NEPixelWiseMultiplication.cpp b/src/runtime/NEON/functions/NEPixelWiseMultiplication.cpp
index f7f4437554..179bcdaf3e 100644
--- a/src/runtime/NEON/functions/NEPixelWiseMultiplication.cpp
+++ b/src/runtime/NEON/functions/NEPixelWiseMultiplication.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/core/ITensor.h"
 #include "src/core/NEON/kernels/NEPixelWiseMultiplicationKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void NEPixelWiseMultiplication::configure(ITensorInfo *input1, ITensorInfo *inpu
                                           const ActivationLayerInfo &act_info)
 {
     ARM_COMPUTE_UNUSED(act_info);
-    auto k = arm_compute::support::cpp14::make_unique<NEPixelWiseMultiplicationKernel>();
+    auto k = std::make_unique<NEPixelWiseMultiplicationKernel>();
     k->configure(input1, input2, output, scale, overflow_policy, rounding_policy);
     _kernel = std::move(k);
 }
@@ -51,7 +50,7 @@ Status NEPixelWiseMultiplication::validate(const ITensorInfo *input1, const ITen
 void NEComplexPixelWiseMultiplication::configure(ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output, const ActivationLayerInfo &act_info)
 {
     ARM_COMPUTE_UNUSED(act_info);
-    auto k = arm_compute::support::cpp14::make_unique<NEComplexPixelWiseMultiplicationKernel>();
+    auto k = std::make_unique<NEComplexPixelWiseMultiplicationKernel>();
     k->configure(input1, input2, output);
     _kernel = std::move(k);
 }
@@ -72,7 +71,7 @@ struct NEPixelWiseMultiplication::Impl
 };
 
 NEPixelWiseMultiplication::NEPixelWiseMultiplication()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEPixelWiseMultiplication::NEPixelWiseMultiplication(NEPixelWiseMultiplication &&) = default;
@@ -91,7 +90,7 @@ void NEPixelWiseMultiplication::configure(const ITensor *input1, const ITensor *
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEPixelWiseMultiplication>();
+    _impl->op    = std::make_unique<experimental::NEPixelWiseMultiplication>();
     _impl->op->configure(input1->info(), input2->info(), output->info(), scale, overflow_policy, rounding_policy, act_info);
 }
 
@@ -113,7 +112,7 @@ struct NEComplexPixelWiseMultiplication::Impl
 };
 
 NEComplexPixelWiseMultiplication::NEComplexPixelWiseMultiplication()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEComplexPixelWiseMultiplication::NEComplexPixelWiseMultiplication(NEComplexPixelWiseMultiplication &&) = default;
@@ -130,7 +129,7 @@ void NEComplexPixelWiseMultiplication::configure(ITensor *input1, ITensor *input
     _impl->src_0 = input1;
     _impl->src_1 = input2;
     _impl->dst   = output;
-    _impl->op    = arm_compute::support::cpp14::make_unique<experimental::NEComplexPixelWiseMultiplication>();
+    _impl->op    = std::make_unique<experimental::NEComplexPixelWiseMultiplication>();
     _impl->op->configure(input1->info(), input2->info(), output->info(), act_info);
 }
 
diff --git a/src/runtime/NEON/functions/NEPoolingLayer.cpp b/src/runtime/NEON/functions/NEPoolingLayer.cpp
index 12ac8d6d7d..887f00de24 100644
--- a/src/runtime/NEON/functions/NEPoolingLayer.cpp
+++ b/src/runtime/NEON/functions/NEPoolingLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEPoolingLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -47,7 +46,7 @@ void NEPoolingLayer::configure(ITensor *input, ITensor *output, const PoolingLay
     _data_layout = pool_info.data_layout == DataLayout::UNKNOWN ? input->info()->data_layout() : pool_info.data_layout;
 
     // Configure pooling kernel
-    _pooling_layer_kernel = arm_compute::support::cpp14::make_unique<NEPoolingLayerKernel>();
+    _pooling_layer_kernel = std::make_unique<NEPoolingLayerKernel>();
     _pooling_layer_kernel->configure(input, output, pool_info, indices);
 
     switch(_data_layout)
@@ -61,7 +60,7 @@ void NEPoolingLayer::configure(ITensor *input, ITensor *output, const PoolingLay
             {
                 zero_value = PixelValue(0, input->info()->data_type(), input->info()->quantization_info());
             }
-            _border_handler = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+            _border_handler = std::make_unique<NEFillBorderKernel>();
             _border_handler->configure(input, _pooling_layer_kernel->border_size(), border_mode, zero_value);
             break;
         }
diff --git a/src/runtime/NEON/functions/NEPriorBoxLayer.cpp b/src/runtime/NEON/functions/NEPriorBoxLayer.cpp
index bfa06da04e..0c71706586 100644
--- a/src/runtime/NEON/functions/NEPriorBoxLayer.cpp
+++ b/src/runtime/NEON/functions/NEPriorBoxLayer.cpp
@@ -32,13 +32,11 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEPriorBoxLayerKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 void NEPriorBoxLayer::configure(const ITensor *input1, const ITensor *input2, ITensor *output, const PriorBoxLayerInfo &info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEPriorBoxLayerKernel>();
+    auto k = std::make_unique<NEPriorBoxLayerKernel>();
     k->configure(input1, input2, output, info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEQLSTMLayer.cpp b/src/runtime/NEON/functions/NEQLSTMLayer.cpp
index 1013730235..85d62ac058 100644
--- a/src/runtime/NEON/functions/NEQLSTMLayer.cpp
+++ b/src/runtime/NEON/functions/NEQLSTMLayer.cpp
@@ -39,7 +39,6 @@
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
 #include "src/core/NEON/kernels/NEQLSTMLayerNormalizationKernel.h"
 #include "src/core/helpers/WindowHelpers.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -75,7 +74,7 @@ void NEQLSTMLayer::configure_layer_norm(NEQLSTMLayer::LayerNormGate g, const ITe
     _memory_group.manage(&out);
     out.allocator()->init(*(in->info()));
 
-    get_layer_norm(g) = arm_compute::support::cpp14::make_unique<NEQLSTMLayerNormalizationKernel>();
+    get_layer_norm(g) = std::make_unique<NEQLSTMLayerNormalizationKernel>();
     get_layer_norm(g)->configure(in, &out, get_layer_norm_weight(g), get_layer_norm_bias(g));
 }
 
@@ -226,18 +225,18 @@ void NEQLSTMLayer::configure(const ITensor *input,
         _input_to_input_weights     = lstm_params.input_to_input_weights();
         _recurrent_to_input_weights = lstm_params.recurrent_to_input_weights();
 
-        _input_to_input_reduction     = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
-        _recurrent_to_input_reduction = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+        _input_to_input_reduction     = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+        _recurrent_to_input_reduction = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
         _input_to_input_reduction->configure(_input_to_input_weights, &_input_to_input_eff_bias, GEMMLowpReductionKernelInfo(num_units, false, -qinput.offset, true));
         _recurrent_to_input_reduction->configure(_recurrent_to_input_weights, &_recurrent_to_input_eff_bias, GEMMLowpReductionKernelInfo(num_units, false, -qoutput_state_in.offset, true));
     }
 
-    _input_to_forget_reduction     = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
-    _recurrent_to_forget_reduction = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
-    _input_to_cell_reduction       = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
-    _recurrent_to_cell_reduction   = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
-    _input_to_output_reduction     = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
-    _recurrent_to_output_reduction = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+    _input_to_forget_reduction     = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+    _recurrent_to_forget_reduction = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+    _input_to_cell_reduction       = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+    _recurrent_to_cell_reduction   = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+    _input_to_output_reduction     = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+    _recurrent_to_output_reduction = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
 
     _recurrent_to_cell_reduction->configure(input_to_forget_weights, &_input_to_forget_eff_bias, GEMMLowpReductionKernelInfo(num_units, false, -qinput.offset, true));
     _recurrent_to_forget_reduction->configure(recurrent_to_forget_weights, &_recurrent_to_forget_eff_bias, GEMMLowpReductionKernelInfo(num_units, false, -qoutput_state_in.offset, true));
@@ -247,7 +246,7 @@ void NEQLSTMLayer::configure(const ITensor *input,
     _recurrent_to_output_reduction->configure(recurrent_to_output_weights, &_recurrent_to_output_eff_bias, GEMMLowpReductionKernelInfo(num_units, false, -qoutput_state_in.offset, true));
     if(_has_projection)
     {
-        _projection_reduction = arm_compute::support::cpp14::make_unique<NEGEMMLowpMatrixAReductionKernel>();
+        _projection_reduction = std::make_unique<NEGEMMLowpMatrixAReductionKernel>();
         _projection_reduction->configure(_projection_weights, &_projection_eff_bias, GEMMLowpReductionKernelInfo(output_size, false, lstm_params.hidden_state_zero(), true));
         if(_projection_bias != nullptr)
         {
diff --git a/src/runtime/NEON/functions/NEQuantizationLayer.cpp b/src/runtime/NEON/functions/NEQuantizationLayer.cpp
index a20ffb8858..42eb12d05d 100644
--- a/src/runtime/NEON/functions/NEQuantizationLayer.cpp
+++ b/src/runtime/NEON/functions/NEQuantizationLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/Validate.h"
 #include "src/core/NEON/kernels/NEQuantizationLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -44,7 +43,7 @@ void NEQuantizationLayer::configure(const ITensor *input, ITensor *output)
     ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
 
     // Configure quantize kernel
-    auto k = arm_compute::support::cpp14::make_unique<NEQuantizationLayerKernel>();
+    auto k = std::make_unique<NEQuantizationLayerKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NERNNLayer.cpp b/src/runtime/NEON/functions/NERNNLayer.cpp
index a8e10482a7..c16d09f60c 100644
--- a/src/runtime/NEON/functions/NERNNLayer.cpp
+++ b/src/runtime/NEON/functions/NERNNLayer.cpp
@@ -42,7 +42,6 @@
 #include "src/core/NEON/kernels/NEGEMMMatrixAdditionKernel.h"
 #include "src/core/NEON/kernels/NEGEMMMatrixMultiplyKernel.h"
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -114,7 +113,7 @@ void NERNNLayer::configure(const ITensor *input, const ITensor *weights, const I
     _activation.configure(&_add_output, hidden_state, info);
     _add_output.allocator()->allocate();
 
-    _copy_kernel = arm_compute::support::cpp14::make_unique<NECopyKernel>();
+    _copy_kernel = std::make_unique<NECopyKernel>();
     _copy_kernel->configure(hidden_state, output);
 }
 
diff --git a/src/runtime/NEON/functions/NEROIAlignLayer.cpp b/src/runtime/NEON/functions/NEROIAlignLayer.cpp
index a046140551..a946358e18 100644
--- a/src/runtime/NEON/functions/NEROIAlignLayer.cpp
+++ b/src/runtime/NEON/functions/NEROIAlignLayer.cpp
@@ -25,7 +25,6 @@
 
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEROIAlignLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -39,7 +38,7 @@ Status NEROIAlignLayer::validate(const ITensorInfo *input, const ITensorInfo *ro
 void NEROIAlignLayer::configure(const ITensor *input, const ITensor *rois, ITensor *output, const ROIPoolingLayerInfo &pool_info)
 {
     // Configure ROI pooling kernel
-    auto k = arm_compute::support::cpp14::make_unique<NEROIAlignLayerKernel>();
+    auto k = std::make_unique<NEROIAlignLayerKernel>();
     k->configure(input, rois, output, pool_info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEROIPoolingLayer.cpp b/src/runtime/NEON/functions/NEROIPoolingLayer.cpp
index 8bcf152881..7ca6ecc737 100644
--- a/src/runtime/NEON/functions/NEROIPoolingLayer.cpp
+++ b/src/runtime/NEON/functions/NEROIPoolingLayer.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/Helpers.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEROIPoolingLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -39,7 +38,7 @@ NEROIPoolingLayer::NEROIPoolingLayer()
 
 void NEROIPoolingLayer::configure(const ITensor *input, const ITensor *rois, ITensor *output, const ROIPoolingLayerInfo &pool_info)
 {
-    _roi_kernel = arm_compute::support::cpp14::make_unique<NEROIPoolingLayerKernel>();
+    _roi_kernel = std::make_unique<NEROIPoolingLayerKernel>();
     _roi_kernel->configure(input, rois, output, pool_info);
 }
 
diff --git a/src/runtime/NEON/functions/NERange.cpp b/src/runtime/NEON/functions/NERange.cpp
index ba166b2d58..56ef2bf657 100644
--- a/src/runtime/NEON/functions/NERange.cpp
+++ b/src/runtime/NEON/functions/NERange.cpp
@@ -25,7 +25,6 @@
 
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NERangeKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -38,7 +37,7 @@ NERange::NERange()
 
 void NERange::configure(ITensor *output, const float start, const float end, const float step)
 {
-    _kernel = arm_compute::support::cpp14::make_unique<NERangeKernel>();
+    _kernel = std::make_unique<NERangeKernel>();
     _kernel->configure(output, start, end, step);
 }
 
diff --git a/src/runtime/NEON/functions/NEReductionOperation.cpp b/src/runtime/NEON/functions/NEReductionOperation.cpp
index 463b65ec28..5d6f520a52 100644
--- a/src/runtime/NEON/functions/NEReductionOperation.cpp
+++ b/src/runtime/NEON/functions/NEReductionOperation.cpp
@@ -28,7 +28,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEReductionOperationKernel.h"
 #include "src/core/helpers/AutoConfiguration.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -129,7 +128,7 @@ void NEReductionOperation::configure(ITensor *input, ITensor *output, unsigned i
     ARM_COMPUTE_ERROR_THROW_ON(NEReductionOperation::validate(input->info(), output->info(), axis, op, keep_dims));
 
     // Configure reduction kernel
-    _reduction_kernel = arm_compute::support::cpp14::make_unique<NEReductionOperationKernel>();
+    _reduction_kernel = std::make_unique<NEReductionOperationKernel>();
     _reduction_kernel->configure(input, output_internal, axis, op);
     _window_split   = reduction_window_split_dimension(axis);
     _reduction_axis = axis;
diff --git a/src/runtime/NEON/functions/NERemap.cpp b/src/runtime/NEON/functions/NERemap.cpp
index 9276d49cf5..f2f57aa599 100644
--- a/src/runtime/NEON/functions/NERemap.cpp
+++ b/src/runtime/NEON/functions/NERemap.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/runtime/TensorAllocator.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NERemapKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -45,11 +44,11 @@ void NERemap::configure(ITensor *input, const ITensor *map_x, const ITensor *map
     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<NERemapKernel>();
+    auto k = std::make_unique<NERemapKernel>();
     k->configure(input, map_x, map_y, output, policy);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEReorgLayer.cpp b/src/runtime/NEON/functions/NEReorgLayer.cpp
index 77ec7fbfb1..23ca3a4eea 100644
--- a/src/runtime/NEON/functions/NEReorgLayer.cpp
+++ b/src/runtime/NEON/functions/NEReorgLayer.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NEReorgLayer.h"
 
 #include "src/core/NEON/kernels/NEReorgLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEReorgLayer::configure(const ITensor *input, ITensor *output, int32_t stride)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEReorgLayerKernel>();
+    auto k = std::make_unique<NEReorgLayerKernel>();
     k->configure(input, output, stride);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEReshapeLayer.cpp b/src/runtime/NEON/functions/NEReshapeLayer.cpp
index 915d5d408f..9ad6a35cc3 100644
--- a/src/runtime/NEON/functions/NEReshapeLayer.cpp
+++ b/src/runtime/NEON/functions/NEReshapeLayer.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "arm_compute/runtime/Types.h"
 #include "src/core/NEON/kernels/NEReshapeLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -39,7 +38,7 @@ NEReshape::~NEReshape() = default;
 
 void NEReshape::configure(const ITensorInfo *input, ITensorInfo *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEReshapeLayerKernel>();
+    auto k = std::make_unique<NEReshapeLayerKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
@@ -58,7 +57,7 @@ struct NEReshapeLayer::Impl
 };
 
 NEReshapeLayer::NEReshapeLayer()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 
@@ -72,7 +71,7 @@ void NEReshapeLayer::configure(const ITensor *input, ITensor *output)
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::NEReshape>();
+    _impl->op  = std::make_unique<experimental::NEReshape>();
     _impl->op->configure(input->info(), output->info());
 }
 
diff --git a/src/runtime/NEON/functions/NEReverse.cpp b/src/runtime/NEON/functions/NEReverse.cpp
index 3ed0688386..36127ef83c 100644
--- a/src/runtime/NEON/functions/NEReverse.cpp
+++ b/src/runtime/NEON/functions/NEReverse.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NEReverse.h"
 
 #include "src/core/NEON/kernels/NEReverseKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEReverse::configure(const ITensor *input, ITensor *output, const ITensor *axis)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEReverseKernel>();
+    auto k = std::make_unique<NEReverseKernel>();
     k->configure(input, output, axis);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEScale.cpp b/src/runtime/NEON/functions/NEScale.cpp
index 0290fe5a01..9d6e2ca754 100644
--- a/src/runtime/NEON/functions/NEScale.cpp
+++ b/src/runtime/NEON/functions/NEScale.cpp
@@ -36,7 +36,6 @@
 
 #include "src/core/utils/ScaleUtils.h"
 
-#include "support/MemorySupport.h"
 #include "support/Rounding.h"
 
 #include <cmath>
@@ -125,7 +124,7 @@ void NEScale::configure(ITensor *input, ITensor *output, const ScaleKernelInfo &
     // Area interpolation behaves as Nearest Neighbour in case of up-sampling
     const auto policy_to_use = (info.interpolation_policy == InterpolationPolicy::AREA && wr <= 1.f && hr <= 1.f) ? InterpolationPolicy::NEAREST_NEIGHBOR : info.interpolation_policy;
 
-    auto scale_kernel = arm_compute::support::cpp14::make_unique<NEScaleKernel>();
+    auto scale_kernel = std::make_unique<NEScaleKernel>();
     switch(policy_to_use)
     {
         case InterpolationPolicy::NEAREST_NEIGHBOR:
diff --git a/src/runtime/NEON/functions/NEScharr3x3.cpp b/src/runtime/NEON/functions/NEScharr3x3.cpp
index cea0eefdb0..414e9470ea 100644
--- a/src/runtime/NEON/functions/NEScharr3x3.cpp
+++ b/src/runtime/NEON/functions/NEScharr3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEScharr3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,11 +33,11 @@ using namespace arm_compute;
 
 void NEScharr3x3::configure(ITensor *input, ITensor *output_x, ITensor *output_y, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEScharr3x3Kernel>();
+    auto k = std::make_unique<NEScharr3x3Kernel>();
     k->configure(input, output_x, output_y, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NESelect.cpp b/src/runtime/NEON/functions/NESelect.cpp
index 0d1f490767..f8ba9f03ed 100644
--- a/src/runtime/NEON/functions/NESelect.cpp
+++ b/src/runtime/NEON/functions/NESelect.cpp
@@ -25,13 +25,12 @@
 
 #include "arm_compute/core/Types.h"
 #include "src/core/NEON/kernels/NESelectKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NESelect::configure(const ITensor *c, const ITensor *x, const ITensor *y, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NESelectKernel>();
+    auto k = std::make_unique<NESelectKernel>();
     k->configure(c, x, y, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NESlice.cpp b/src/runtime/NEON/functions/NESlice.cpp
index dd56eaba8b..9b08bca38a 100644
--- a/src/runtime/NEON/functions/NESlice.cpp
+++ b/src/runtime/NEON/functions/NESlice.cpp
@@ -29,8 +29,6 @@
 #include "arm_compute/core/utils/helpers/tensor_transform.h"
 #include "src/core/NEON/kernels/NEStridedSliceKernel.h"
 
-#include "support/MemorySupport.h"
-
 namespace arm_compute
 {
 namespace experimental
@@ -42,7 +40,7 @@ void NESlice::configure(const ITensorInfo *input, ITensorInfo *output, const Coo
     // 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<NEStridedSliceKernel>();
+    auto k = std::make_unique<NEStridedSliceKernel>();
     k->configure(input, output, starts, ends, BiStrides(), 0, slice_end_mask, 0);
     _kernel = std::move(k);
 }
@@ -72,7 +70,7 @@ struct NESlice::Impl
 };
 
 NESlice::NESlice()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NESlice::NESlice(NESlice &&) = default;
@@ -88,7 +86,7 @@ void NESlice::configure(const ITensor *input, ITensor *output, const Coordinates
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::NESlice>();
+    _impl->op  = std::make_unique<experimental::NESlice>();
     _impl->op->configure(input->info(), output->info(), starts, ends);
 }
 
diff --git a/src/runtime/NEON/functions/NESobel3x3.cpp b/src/runtime/NEON/functions/NESobel3x3.cpp
index 38d2dc227e..1a57bc3fc6 100644
--- a/src/runtime/NEON/functions/NESobel3x3.cpp
+++ b/src/runtime/NEON/functions/NESobel3x3.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/PixelValue.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NESobel3x3Kernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -34,11 +33,11 @@ namespace arm_compute
 {
 void NESobel3x3::configure(ITensor *input, ITensor *output_x, ITensor *output_y, BorderMode border_mode, uint8_t constant_border_value)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NESobel3x3Kernel>();
+    auto k = std::make_unique<NESobel3x3Kernel>();
     k->configure(input, output_x, output_y, border_mode == BorderMode::UNDEFINED);
     _kernel = std::move(k);
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, PixelValue(constant_border_value));
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NESobel5x5.cpp b/src/runtime/NEON/functions/NESobel5x5.cpp
index e631fb3ed7..e587981fa9 100644
--- a/src/runtime/NEON/functions/NESobel5x5.cpp
+++ b/src/runtime/NEON/functions/NESobel5x5.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/runtime/TensorAllocator.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NESobel5x5Kernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -51,9 +50,9 @@ void NESobel5x5::configure(ITensor *input, ITensor *output_x, ITensor *output_y,
 
     TensorInfo tensor_info(input->info()->tensor_shape(), Format::S16);
 
-    _sobel_hor      = arm_compute::support::cpp14::make_unique<NESobel5x5HorKernel>();
-    _sobel_vert     = arm_compute::support::cpp14::make_unique<NESobel5x5VertKernel>();
-    _border_handler = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _sobel_hor      = std::make_unique<NESobel5x5HorKernel>();
+    _sobel_vert     = std::make_unique<NESobel5x5VertKernel>();
+    _border_handler = std::make_unique<NEFillBorderKernel>();
 
     if(run_sobel_x && run_sobel_y)
     {
diff --git a/src/runtime/NEON/functions/NESobel7x7.cpp b/src/runtime/NEON/functions/NESobel7x7.cpp
index bc5f87c1ec..7b1a975951 100644
--- a/src/runtime/NEON/functions/NESobel7x7.cpp
+++ b/src/runtime/NEON/functions/NESobel7x7.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/runtime/TensorAllocator.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NESobel7x7Kernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -50,9 +49,9 @@ void NESobel7x7::configure(ITensor *input, ITensor *output_x, ITensor *output_y,
     const bool run_sobel_y = output_y != nullptr;
 
     TensorInfo tensor_info(input->info()->tensor_shape(), Format::S32);
-    _sobel_hor      = arm_compute::support::cpp14::make_unique<NESobel7x7HorKernel>();
-    _sobel_vert     = arm_compute::support::cpp14::make_unique<NESobel7x7VertKernel>();
-    _border_handler = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    _sobel_hor      = std::make_unique<NESobel7x7HorKernel>();
+    _sobel_vert     = std::make_unique<NESobel7x7VertKernel>();
+    _border_handler = std::make_unique<NEFillBorderKernel>();
 
     if(run_sobel_x && run_sobel_y)
     {
diff --git a/src/runtime/NEON/functions/NESoftmaxLayer.cpp b/src/runtime/NEON/functions/NESoftmaxLayer.cpp
index e79ab0ee2d..6be34ad1a4 100644
--- a/src/runtime/NEON/functions/NESoftmaxLayer.cpp
+++ b/src/runtime/NEON/functions/NESoftmaxLayer.cpp
@@ -30,7 +30,6 @@
 #include "src/core/NEON/kernels/NESoftmaxLayerKernel.h"
 #include "src/core/NEON/kernels/NESoftmaxLayerKernel.h"
 #include "src/core/helpers/SoftmaxHelpers.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -83,8 +82,8 @@ void NESoftmaxLayerGeneric<IS_LOG>::configure(ITensor *input, ITensor *output, f
     _memory_group.manage(&_tmp);
 
     // Configure kernels
-    _max_kernel     = arm_compute::support::cpp14::make_unique<NELogits1DMaxKernel>();
-    _softmax_kernel = arm_compute::support::cpp14::make_unique<NELogits1DSoftmaxKernel<IS_LOG>>();
+    _max_kernel     = std::make_unique<NELogits1DMaxKernel>();
+    _softmax_kernel = std::make_unique<NELogits1DSoftmaxKernel<IS_LOG>>();
     _max_kernel->configure(tmp_input, &_max);
     if(_needs_permute)
     {
@@ -104,7 +103,7 @@ void NESoftmaxLayerGeneric<IS_LOG>::configure(ITensor *input, ITensor *output, f
     else
     {
         // Softmax 2D case
-        _fill_border_kernel = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+        _fill_border_kernel = std::make_unique<NEFillBorderKernel>();
         _fill_border_kernel->configure(tmp_input, _max_kernel->border_size(), BorderMode::REPLICATE);
         _softmax_kernel->configure(tmp_input, &_max, output, beta, &_tmp);
     }
diff --git a/src/runtime/NEON/functions/NESpaceToBatchLayer.cpp b/src/runtime/NEON/functions/NESpaceToBatchLayer.cpp
index 516e8d604c..10b384157d 100644
--- a/src/runtime/NEON/functions/NESpaceToBatchLayer.cpp
+++ b/src/runtime/NEON/functions/NESpaceToBatchLayer.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEMemsetKernel.h"
 #include "src/core/NEON/kernels/NESpaceToBatchLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -49,10 +48,10 @@ void NESpaceToBatchLayer::configure(const ITensor *input, const ITensor *block_s
     if(input->info()->tensor_shape().total_size() != output->info()->tensor_shape().total_size())
     {
         _has_padding   = true;
-        _memset_kernel = arm_compute::support::cpp14::make_unique<NEMemsetKernel>();
+        _memset_kernel = std::make_unique<NEMemsetKernel>();
         _memset_kernel->configure(output, PixelValue(0, input->info()->data_type(), input->info()->quantization_info()));
     }
-    _space_to_batch_kernel = arm_compute::support::cpp14::make_unique<NESpaceToBatchLayerKernel>();
+    _space_to_batch_kernel = std::make_unique<NESpaceToBatchLayerKernel>();
     _space_to_batch_kernel->configure(input, block_shape, paddings, output);
 }
 
@@ -63,10 +62,10 @@ void NESpaceToBatchLayer::configure(const ITensor *input, const int block_shape_
     if(input->info()->tensor_shape().total_size() != output->info()->tensor_shape().total_size())
     {
         _has_padding   = true;
-        _memset_kernel = arm_compute::support::cpp14::make_unique<NEMemsetKernel>();
+        _memset_kernel = std::make_unique<NEMemsetKernel>();
         _memset_kernel->configure(output, PixelValue(0, input->info()->data_type(), input->info()->quantization_info()));
     }
-    _space_to_batch_kernel = arm_compute::support::cpp14::make_unique<NESpaceToBatchLayerKernel>();
+    _space_to_batch_kernel = std::make_unique<NESpaceToBatchLayerKernel>();
     _space_to_batch_kernel->configure(input, block_shape_x, block_shape_y, padding_left, padding_right, output);
 }
 
diff --git a/src/runtime/NEON/functions/NESpaceToDepthLayer.cpp b/src/runtime/NEON/functions/NESpaceToDepthLayer.cpp
index a834600199..1e3776c448 100644
--- a/src/runtime/NEON/functions/NESpaceToDepthLayer.cpp
+++ b/src/runtime/NEON/functions/NESpaceToDepthLayer.cpp
@@ -30,7 +30,6 @@
 #include "arm_compute/core/Validate.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NESpaceToDepthLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -44,7 +43,7 @@ NESpaceToDepthLayer::NESpaceToDepthLayer()
 void NESpaceToDepthLayer::configure(const ITensor *input, ITensor *output, int32_t block_shape)
 {
     ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
-    _space_to_depth_kernel = arm_compute::support::cpp14::make_unique<NESpaceToDepthLayerKernel>();
+    _space_to_depth_kernel = std::make_unique<NESpaceToDepthLayerKernel>();
     _space_to_depth_kernel->configure(input, output, block_shape);
 }
 
diff --git a/src/runtime/NEON/functions/NEStackLayer.cpp b/src/runtime/NEON/functions/NEStackLayer.cpp
index e38ff6bee7..af5c80d036 100644
--- a/src/runtime/NEON/functions/NEStackLayer.cpp
+++ b/src/runtime/NEON/functions/NEStackLayer.cpp
@@ -31,7 +31,6 @@
 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 #include "src/core/NEON/kernels/NEStackLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -54,7 +53,7 @@ void NEStackLayer::configure(const std::vector<ITensor *> &input, int axis, ITen
 
     for(unsigned int i = 0; i < _num_inputs; i++)
     {
-        _stack_kernels[i] = arm_compute::support::cpp14::make_unique<NEStackLayerKernel>();
+        _stack_kernels[i] = std::make_unique<NEStackLayerKernel>();
         _stack_kernels[i]->configure(input[i], axis_u, i, _num_inputs, output);
     }
 }
diff --git a/src/runtime/NEON/functions/NEStridedSlice.cpp b/src/runtime/NEON/functions/NEStridedSlice.cpp
index 308b856ec6..fffb38c3ca 100644
--- a/src/runtime/NEON/functions/NEStridedSlice.cpp
+++ b/src/runtime/NEON/functions/NEStridedSlice.cpp
@@ -26,7 +26,6 @@
 #include "arm_compute/core/ITensor.h"
 #include "arm_compute/core/Types.h"
 #include "src/core/NEON/kernels/NEStridedSliceKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -36,7 +35,7 @@ void NEStridedSlice::configure(const ITensorInfo *input, ITensorInfo *output,
                                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<NEStridedSliceKernel>();
+    auto k = std::make_unique<NEStridedSliceKernel>();
     k->configure(input, output, starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
     _kernel = std::move(k);
 }
@@ -57,7 +56,7 @@ struct NEStridedSlice::Impl
 };
 
 NEStridedSlice::NEStridedSlice()
-    : _impl(support::cpp14::make_unique<Impl>())
+    : _impl(std::make_unique<Impl>())
 {
 }
 NEStridedSlice::NEStridedSlice(NEStridedSlice &&) = default;
@@ -70,7 +69,7 @@ void NEStridedSlice::configure(const ITensor *input, ITensor *output,
 {
     _impl->src = input;
     _impl->dst = output;
-    _impl->op  = arm_compute::support::cpp14::make_unique<experimental::NEStridedSlice>();
+    _impl->op  = std::make_unique<experimental::NEStridedSlice>();
     _impl->op->configure(input->info(), output->info(), starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
 }
 
diff --git a/src/runtime/NEON/functions/NETableLookup.cpp b/src/runtime/NEON/functions/NETableLookup.cpp
index 9295bf0ece..fde3908c81 100644
--- a/src/runtime/NEON/functions/NETableLookup.cpp
+++ b/src/runtime/NEON/functions/NETableLookup.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NETableLookup.h"
 
 #include "src/core/NEON/kernels/NETableLookupKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ using namespace arm_compute;
 
 void NETableLookup::configure(const ITensor *input, const ILut *lut, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NETableLookupKernel>();
+    auto k = std::make_unique<NETableLookupKernel>();
     k->configure(input, lut, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEThreshold.cpp b/src/runtime/NEON/functions/NEThreshold.cpp
index 2f1e3047b5..4d382d6fab 100644
--- a/src/runtime/NEON/functions/NEThreshold.cpp
+++ b/src/runtime/NEON/functions/NEThreshold.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEThreshold.h"
 
 #include "src/core/NEON/kernels/NEThresholdKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -37,7 +36,7 @@ void NEThreshold::configure(const ITensor *input, ITensor *output, uint8_t thres
 
 void NEThreshold::configure(const ITensor *input, ITensor *output, const ThresholdKernelInfo &info)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEThresholdKernel>();
+    auto k = std::make_unique<NEThresholdKernel>();
     k->configure(input, output, info);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NETile.cpp b/src/runtime/NEON/functions/NETile.cpp
index 6a1e20ddf8..088816eb95 100644
--- a/src/runtime/NEON/functions/NETile.cpp
+++ b/src/runtime/NEON/functions/NETile.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NETile.h"
 
 #include "src/core/NEON/kernels/NETileKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NETile::configure(const ITensor *input, ITensor *output, const Multiples &multiples)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NETileKernel>();
+    auto k = std::make_unique<NETileKernel>();
     k->configure(input, output, multiples);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NETranspose.cpp b/src/runtime/NEON/functions/NETranspose.cpp
index 5af417f4ed..aaa52e36b9 100644
--- a/src/runtime/NEON/functions/NETranspose.cpp
+++ b/src/runtime/NEON/functions/NETranspose.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NETranspose.h"
 
 #include "src/core/NEON/kernels/NETransposeKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -32,7 +31,7 @@ namespace arm_compute
 {
 void NETranspose::configure(const ITensor *input, ITensor *output)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NETransposeKernel>();
+    auto k = std::make_unique<NETransposeKernel>();
     k->configure(input, output);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/NEUpsampleLayer.cpp b/src/runtime/NEON/functions/NEUpsampleLayer.cpp
index aae58387e2..1a08494c63 100644
--- a/src/runtime/NEON/functions/NEUpsampleLayer.cpp
+++ b/src/runtime/NEON/functions/NEUpsampleLayer.cpp
@@ -24,7 +24,6 @@
 #include "arm_compute/runtime/NEON/functions/NEUpsampleLayer.h"
 
 #include "src/core/NEON/kernels/NEUpsampleLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
@@ -44,7 +43,7 @@ Status NEUpsampleLayer::validate(const ITensorInfo *input, const ITensorInfo *ou
 void NEUpsampleLayer::configure(const ITensor *input, ITensor *output, const Size2D &info, const InterpolationPolicy &policy)
 {
     _data_layout = input->info()->data_layout();
-    _kernel      = arm_compute::support::cpp14::make_unique<NEUpsampleLayerKernel>();
+    _kernel      = std::make_unique<NEUpsampleLayerKernel>();
     _kernel->configure(input, output, info, policy);
 }
 
diff --git a/src/runtime/NEON/functions/NEWarpAffine.cpp b/src/runtime/NEON/functions/NEWarpAffine.cpp
index b5dbfe0d5c..1e8907b895 100644
--- a/src/runtime/NEON/functions/NEWarpAffine.cpp
+++ b/src/runtime/NEON/functions/NEWarpAffine.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/Validate.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEWarpKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -42,14 +41,14 @@ void NEWarpAffine::configure(ITensor *input, ITensor *output, const std::array<f
     {
         case InterpolationPolicy::NEAREST_NEIGHBOR:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NEWarpAffineKernel<InterpolationPolicy::NEAREST_NEIGHBOR>>();
+            auto k = std::make_unique<NEWarpAffineKernel<InterpolationPolicy::NEAREST_NEIGHBOR>>();
             k->configure(input, output, matrix, border_mode, constant_border_value);
             _kernel = std::move(k);
             break;
         }
         case InterpolationPolicy::BILINEAR:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NEWarpAffineKernel<InterpolationPolicy::BILINEAR>>();
+            auto k = std::make_unique<NEWarpAffineKernel<InterpolationPolicy::BILINEAR>>();
             k->configure(input, output, matrix, border_mode, constant_border_value);
             _kernel = std::move(k);
             break;
@@ -59,7 +58,7 @@ void NEWarpAffine::configure(ITensor *input, ITensor *output, const std::array<f
             ARM_COMPUTE_ERROR("Interpolation type not supported");
     }
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, constant_border_value);
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEWarpPerspective.cpp b/src/runtime/NEON/functions/NEWarpPerspective.cpp
index 8d42121005..d546da89b8 100644
--- a/src/runtime/NEON/functions/NEWarpPerspective.cpp
+++ b/src/runtime/NEON/functions/NEWarpPerspective.cpp
@@ -27,7 +27,6 @@
 #include "arm_compute/core/Validate.h"
 #include "src/core/NEON/kernels/NEFillBorderKernel.h"
 #include "src/core/NEON/kernels/NEWarpKernel.h"
-#include "support/MemorySupport.h"
 
 #include <utility>
 
@@ -42,14 +41,14 @@ void NEWarpPerspective::configure(ITensor *input, ITensor *output, const std::ar
     {
         case InterpolationPolicy::NEAREST_NEIGHBOR:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NEWarpPerspectiveKernel<InterpolationPolicy::NEAREST_NEIGHBOR>>();
+            auto k = std::make_unique<NEWarpPerspectiveKernel<InterpolationPolicy::NEAREST_NEIGHBOR>>();
             k->configure(input, output, matrix, border_mode, constant_border_value);
             _kernel = std::move(k);
             break;
         }
         case InterpolationPolicy::BILINEAR:
         {
-            auto k = arm_compute::support::cpp14::make_unique<NEWarpPerspectiveKernel<InterpolationPolicy::BILINEAR>>();
+            auto k = std::make_unique<NEWarpPerspectiveKernel<InterpolationPolicy::BILINEAR>>();
             k->configure(input, output, matrix, border_mode, constant_border_value);
             _kernel = std::move(k);
             break;
@@ -59,7 +58,7 @@ void NEWarpPerspective::configure(ITensor *input, ITensor *output, const std::ar
             ARM_COMPUTE_ERROR("Interpolation type not supported");
     }
 
-    auto b = arm_compute::support::cpp14::make_unique<NEFillBorderKernel>();
+    auto b = std::make_unique<NEFillBorderKernel>();
     b->configure(input, _kernel->border_size(), border_mode, constant_border_value);
     _border_handler = std::move(b);
 }
diff --git a/src/runtime/NEON/functions/NEWinogradConvolutionLayer.cpp b/src/runtime/NEON/functions/NEWinogradConvolutionLayer.cpp
index 1cb2458e13..265df9246f 100644
--- a/src/runtime/NEON/functions/NEWinogradConvolutionLayer.cpp
+++ b/src/runtime/NEON/functions/NEWinogradConvolutionLayer.cpp
@@ -35,7 +35,6 @@
 #include "src/core/NEON/kernels/NEGEMMMatrixMultiplyKernel.h"
 #include "src/core/NEON/kernels/NEGEMMTranspose1xWKernel.h"
 #include "src/core/NEON/kernels/NEWinogradConvolutionLayerKernel.h"
-#include "support/MemorySupport.h"
 
 #include "src/core/NEON/kernels/convolution/common/utils.hpp"
 #include "src/core/NEON/kernels/convolution/winograd/winograd.hpp"
@@ -351,18 +350,18 @@ void NEWinogradConvolutionLayer::configure(const ITensor *input, const ITensor *
             if(input->info()->dimension(width_idx) > 4 && input->info()->dimension(height_idx) > 4)
             {
                 using config             = NEWinogradLayerConfiguration<float, float, 4, 4, 3, 3>;
-                transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-                transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-                transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+                transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+                transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+                transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
                 n_gemms                  = config::WinogradBase::N_GEMMS;
                 N_BLOCK                  = config::WinogradConv::N_BLOCK;
             }
             else
             {
                 using config             = NEWinogradLayerConfiguration<float, float, 2, 2, 3, 3>;
-                transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-                transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-                transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+                transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+                transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+                transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
                 n_gemms                  = config::WinogradBase::N_GEMMS;
                 N_BLOCK                  = config::WinogradConv::N_BLOCK;
             }
@@ -370,63 +369,63 @@ void NEWinogradConvolutionLayer::configure(const ITensor *input, const ITensor *
         else if(kernel_size == Size2D(5, 5))
         {
             using config             = NEWinogradLayerConfiguration<float, float, 2, 2, 5, 5>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
         else if(kernel_size == Size2D(1, 3))
         {
             using config             = NEWinogradLayerConfiguration<float, float, 6, 1, 3, 1>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
         else if(kernel_size == Size2D(3, 1))
         {
             using config             = NEWinogradLayerConfiguration<float, float, 1, 6, 1, 3>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
         else if(kernel_size == Size2D(1, 5))
         {
             using config             = NEWinogradLayerConfiguration<float, float, 4, 1, 5, 1>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
         else if(kernel_size == Size2D(5, 1))
         {
             using config             = NEWinogradLayerConfiguration<float, float, 1, 4, 1, 5>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
         else if(kernel_size == Size2D(1, 7))
         {
             using config             = NEWinogradLayerConfiguration<float, float, 2, 1, 7, 1>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
         else if(kernel_size == Size2D(7, 1))
         {
             using config             = NEWinogradLayerConfiguration<float, float, 1, 2, 1, 7>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
@@ -441,9 +440,9 @@ void NEWinogradConvolutionLayer::configure(const ITensor *input, const ITensor *
         if(kernel_size == Size2D(3, 3))
         {
             using config             = NEWinogradLayerConfiguration<__fp16, __fp16, 4, 4, 3, 3>;
-            transform_input_kernel   = support::cpp14::make_unique<config::TransformInputKernel>();
-            transform_weights_kernel = support::cpp14::make_unique<config::TransformWeightsKernel>();
-            transform_output_kernel  = support::cpp14::make_unique<config::TransformOutputKernel>();
+            transform_input_kernel   = std::make_unique<config::TransformInputKernel>();
+            transform_weights_kernel = std::make_unique<config::TransformWeightsKernel>();
+            transform_output_kernel  = std::make_unique<config::TransformOutputKernel>();
             n_gemms                  = config::WinogradBase::N_GEMMS;
             N_BLOCK                  = config::WinogradConv::N_BLOCK;
         }
diff --git a/src/runtime/NEON/functions/NEYOLOLayer.cpp b/src/runtime/NEON/functions/NEYOLOLayer.cpp
index 5cad53bffd..515b177060 100644
--- a/src/runtime/NEON/functions/NEYOLOLayer.cpp
+++ b/src/runtime/NEON/functions/NEYOLOLayer.cpp
@@ -24,13 +24,12 @@
 #include "arm_compute/runtime/NEON/functions/NEYOLOLayer.h"
 
 #include "src/core/NEON/kernels/NEYOLOLayerKernel.h"
-#include "support/MemorySupport.h"
 
 namespace arm_compute
 {
 void NEYOLOLayer::configure(ITensor *input, ITensor *output, const ActivationLayerInfo &act_info, int32_t num_classes)
 {
-    auto k = arm_compute::support::cpp14::make_unique<NEYOLOLayerKernel>();
+    auto k = std::make_unique<NEYOLOLayerKernel>();
     k->configure(input, output, act_info, num_classes);
     _kernel = std::move(k);
 }
diff --git a/src/runtime/NEON/functions/assembly/NEDepthwiseConvolutionAssemblyDispatch.cpp b/src/runtime/NEON/functions/assembly/NEDepthwiseConvolutionAssemblyDispatch.cpp
index 11e89cb23b..101df98b7d 100644
--- a/src/runtime/NEON/functions/assembly/NEDepthwiseConvolutionAssemblyDispatch.cpp
+++ b/src/runtime/NEON/functions/assembly/NEDepthwiseConvolutionAssemblyDispatch.cpp
@@ -37,8 +37,6 @@
 
 #include "arm_compute/runtime/NEON/NEScheduler.h"
 
-#include "support/MemorySupport.h"
-
 #include <set>
 
 namespace arm_compute
@@ -59,10 +57,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_qasymm8_convolver(int kern
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 3, 3, 1, 1>>(
+                    return std::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 3, 3, 1, 1>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 3, 3, 2, 2>>(
+                    return std::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 3, 3, 2, 2>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -73,10 +71,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_qasymm8_convolver(int kern
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 5, 5, 1, 1>>(
+                    return std::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 5, 5, 1, 1>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 5, 5, 2, 2>>(
+                    return std::make_unique<depthwise::QAsymm8DilatedDepthwiseConvolution<2, 2, 5, 5, 2, 2>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -101,10 +99,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_qsymm8_perchannel_convolve
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 3, 3, 1, 1>>(
+                    return std::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 3, 3, 1, 1>>(
                                n_batches, in_rows, in_cols, n_channels, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 3, 3, 2, 2>>(
+                    return std::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 3, 3, 2, 2>>(
                                n_batches, in_rows, in_cols, n_channels, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -115,10 +113,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_qsymm8_perchannel_convolve
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 5, 5, 1, 1>>(
+                    return std::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 5, 5, 1, 1>>(
                                n_batches, in_rows, in_cols, n_channels, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 5, 5, 2, 2>>(
+                    return std::make_unique<depthwise::QSymm8HybridPerChannelDepthwiseConvolution<2, 2, 5, 5, 2, 2>>(
                                n_batches, in_rows, in_cols, n_channels, activation, wqinfo, iqinfo, oqinfo, rescale_params, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -142,10 +140,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_fp16_convolver(int kernel_
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 3, 3, 1, 1, float16_t, float16_t, float16_t>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 3, 3, 1, 1, float16_t, float16_t, float16_t>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 3, 3, 2, 2, float16_t, float16_t, float16_t>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 3, 3, 2, 2, float16_t, float16_t, float16_t>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -156,10 +154,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_fp16_convolver(int kernel_
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 5, 5, 1, 1, float16_t, float16_t, float16_t>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 5, 5, 1, 1, float16_t, float16_t, float16_t>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 5, 5, 2, 2, float16_t, float16_t, float16_t>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 5, 5, 2, 2, float16_t, float16_t, float16_t>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -183,10 +181,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_fp32_convolver(int kernel_
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<4, 4, 3, 3, 1, 1, float, float, float>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<4, 4, 3, 3, 1, 1, float, float, float>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 3, 3, 2, 2, float, float, float>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 3, 3, 2, 2, float, float, float>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -197,10 +195,10 @@ std::unique_ptr<depthwise::IDepthwiseConvolution> get_fp32_convolver(int kernel_
             switch(stride_x)
             {
                 case 1:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<4, 4, 5, 5, 1, 1, float, float, float>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<4, 4, 5, 5, 1, 1, float, float, float>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 case 2:
-                    return arm_compute::support::cpp14::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 5, 5, 2, 2, float, float, float>>(
+                    return std::make_unique<depthwise::DilatedDepthwiseConvolution<3, 3, 5, 5, 2, 2, float, float, float>>(
                                n_batches, in_rows, in_cols, n_channels, dilation_factor, activation, padding_top, padding_left, padding_bottom, padding_right);
                 default:
                     return nullptr;
@@ -339,7 +337,7 @@ struct NEDepthwiseConvolutionAssemblyDispatch::LocalImpl
 #ifndef DOXYGEN_SKIP_THIS
 NEDepthwiseConvolutionAssemblyDispatch::NEDepthwiseConvolutionAssemblyDispatch(std::shared_ptr<arm_compute::IMemoryManager> memory_manager)
     : _memory_group(std::move(memory_manager)), _input(nullptr), _weights(nullptr), _bias(nullptr), _output(nullptr), _packed_weights(), _workspace(), _is_prepared(false),
-      _pImpl(support::cpp14::make_unique<LocalImpl>())
+      _pImpl(std::make_unique<LocalImpl>())
 {
 }
 #endif /* DOXYGEN_SKIP_THIS */
author	Georgios Pinitas <georgios.pinitas@arm.com>	2020-11-21 03:04:18 +0000
committer	Georgios Pinitas <georgios.pinitas@arm.com>	2020-12-01 10:41:54 +0000
commit	40f51a63c8e7258db15269427ae4fe1ad199c550 (patch)
tree	353253a41863966995a45556731e7181a643c003 /src/runtime/NEON
parent	327800401c4185d98fcc01b9c9efbc038a4228ed (diff)
download	ComputeLibrary-40f51a63c8e7258db15269427ae4fe1ad199c550.tar.gz