packaging: add gbs build support for Tizen

Change-Id: I961315e7bb17e071deae469fc26b3a151eb1b0e4
Signed-off-by: Inki Dae <inki.dae@samsung.com>

3 files changed, 7189 insertions, 0 deletions

diff --git a/packaging/libarmcl.manifest b/packaging/libarmcl.manifest
new file mode 100644
index 000000000..017d22d3a
--- /dev/null
+++ b/packaging/libarmcl.manifest
@@ -0,0 +1,5 @@
+<manifest>
+ <request>
+    <domain name="_"/>
+ </request>
+</manifest>
diff --git a/packaging/libarmcl.spec b/packaging/libarmcl.spec
new file mode 100644
index 000000000..cf6e4b976
--- /dev/null
+++ b/packaging/libarmcl.spec
@@ -0,0 +1,159 @@
+Name:           libarmcl
+Version:        v19.02
+Release:        0
+License:        MIT
+Url:            https://github.com/ARM-software/ComputeLibrary
+Summary:        The ARM Computer Vision and Machine Learning library
+Group:          Graphics & UI Framework/Libraries
+Source0:        %{name}-%{version}.tar.bz2
+Source1001:	%name.manifest
+ExclusiveArch:	%{arm} aarch64
+
+BuildRequires: python3-base
+BuildRequires:	python
+BuildRequires: scons
+
+%define OPEN_CL_SUPPORT		1
+%define NEON_SUPPORT		1
+%define BENCHMARK_TEST		1
+
+%description
+The ARM Computer Vision and Machine Learning library is a set of functions optimised for both ARM CPUs and GPUs using SIMD technologies
+
+%package -n %{name}-release
+Summary:        ARM Compute Library file
+
+%description -n %{name}-release
+Summary:        ARM Compute Library file
+
+%package -n %{name}-devel
+Summary:        Userspace interface to ARM Compute Library
+
+%description -n %{name}-devel
+Summary:        Userspace interface to ARM Compute Library
+
+%package -n %{name}-tools
+Summary:	Sample application and benchmark binaries to test ARM Compute Library
+
+%description -n %{name}-tools
+Summary:	Sample application and benchmark binaries to test ARM Compute Library
+
+%prep
+%setup -q
+cp %{SOURCE1001} .
+
+%build
+echo %{_builddir}
+scons -j8 		\
+	Werror=0 	\
+	debug=0  	\
+%if 0%{?NEON_SUPPORT} == 1
+	neon=1		\
+%endif
+%if 0%{?OPEN_CL_SUPPORT} == 1
+	opencl=1	\
+%endif
+	os=linux	\
+%ifarch aarch64
+	arch=arm64-v8.2-a	\
+%else
+	arch=armv7a	\
+%endif
+	embed_kernels=1 \
+%if 0%{?BENCHMARK_TEST} == 1
+	benchmark_tests=1
+%endif
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%install
+mkdir -p %{buildroot}%{_libdir}
+mkdir -p %{buildroot}%{_libdir}/data
+mkdir -p %{buildroot}%{_bindir}
+mkdir -p %{buildroot}/usr/include/arm_compute
+mkdir -p %{buildroot}/usr/include/support
+mkdir -p %{buildroot}/usr/include/CL
+mkdir -p %{buildroot}/usr/include/half
+mkdir -p %{buildroot}/usr/include/libnpy
+
+install -m 644 build/libarm_compute_core.so %{buildroot}%{_libdir}
+install -m 644 build/libarm_compute.so %{buildroot}%{_libdir}
+install -m 644 build/libarm_compute_graph.so %{buildroot}%{_libdir}
+install -m 644 build/opencl-1.2-stubs/libOpenCL.so %{buildroot}%{_libdir}
+
+install -m 644 build/examples/cl_convolution %{buildroot}%{_bindir}
+install -m 644 build/examples/cl_events %{buildroot}%{_bindir}
+install -m 644 build/examples/cl_sgemm %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_alexnet %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_googlenet %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_inception_v3 %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_inception_v4 %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_lenet %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_mobilenet %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_resnet50 %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_resnext50 %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_squeezenet %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_squeezenet_v1_1 %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_vgg16 %{buildroot}%{_bindir}
+install -m 644 build/examples/graph_vgg19 %{buildroot}%{_bindir}
+install -m 644 build/examples/neon_cartoon_effect %{buildroot}%{_bindir}
+install -m 644 build/examples/neoncl_scale_median_gaussian %{buildroot}%{_bindir}
+install -m 644 build/examples/neon_cnn %{buildroot}%{_bindir}
+install -m 644 build/examples/neon_convolution %{buildroot}%{_bindir}
+install -m 644 build/examples/neon_copy_objects %{buildroot}%{_bindir}
+install -m 644 build/examples/neon_scale %{buildroot}%{_bindir}
+
+cp -r %{_builddir}/%{name}-%{version}/arm_compute/* %{buildroot}/usr/include/arm_compute/
+cp -r %{_builddir}/%{name}-%{version}/support/* %{buildroot}/usr/include/support/
+cp -r %{_builddir}/%{name}-%{version}/include/CL/* %{buildroot}/usr/include/CL/
+cp -r %{_builddir}/%{name}-%{version}/include/half/* %{buildroot}/usr/include/half/
+cp -r %{_builddir}/%{name}-%{version}/include/libnpy/* %{buildroot}/usr/include/libnpy/
+
+%if 0%{?BENCHMARK_TEST} == 1
+install -m 644 %{_builddir}/%{name}-%{version}/build/tests/arm_compute_benchmark %{buildroot}%{_bindir}
+cp -r %{_builddir}/%{name}-%{version}/data/* %{buildroot}%{_libdir}/data/
+%endif
+
+%files -n %{name}-release
+%manifest %{name}.manifest
+%{_libdir}/libarm_compute*.so
+
+%files -n %{name}-devel
+%manifest %{name}.manifest
+%{_libdir}/libarm_compute*.so
+%{_libdir}/libOpenCL.so
+%{_includedir}/arm_compute/*
+%{_includedir}/support/*
+%{_includedir}/CL/*
+%{_includedir}/half/*
+%{_includedir}/libnpy/*
+
+%files -n %{name}-tools
+%manifest %{name}.manifest
+%{_bindir}/cl_convolution
+%{_bindir}/cl_events
+%{_bindir}/cl_sgemm
+%{_bindir}/graph_alexnet
+%{_bindir}/graph_googlenet
+%{_bindir}/graph_inception_v3
+%{_bindir}/graph_inception_v4
+%{_bindir}/graph_lenet
+%{_bindir}/graph_mobilenet
+%{_bindir}/graph_resnet50
+%{_bindir}/graph_resnext50
+%{_bindir}/graph_squeezenet
+%{_bindir}/graph_squeezenet_v1_1
+%{_bindir}/graph_vgg16
+%{_bindir}/graph_vgg19
+%{_bindir}/neon_cartoon_effect
+%{_bindir}/neoncl_scale_median_gaussian
+%{_bindir}/neon_cnn
+%{_bindir}/neon_convolution
+%{_bindir}/neon_copy_objects
+%{_bindir}/neon_scale
+%if 0%{?BENCHMARK_TEST} == 1
+%{_bindir}/arm_compute_benchmark
+%{_libdir}/data/*
+%endif
diff --git a/packaging/patch.patch b/packaging/patch.patch
new file mode 100644
index 000000000..86a046cd4
--- /dev/null
+++ b/packaging/patch.patch
@@ -0,0 +1,7025 @@
+From eb0682abf46a5d1ee1c4bfc780815f948c912aca Mon Sep 17 00:00:00 2001
+From: Chunseok Lee <chunseok.lee@samsung.com>
+Date: Thu, 23 Aug 2018 17:42:09 +0900
+Subject: [PATCH] Patch for NNFW M2 Release
+
+1. Add new operations
+2. Fix some issue on existing ops
+
+Change-Id: I8da858291993ba474c8d285d8c63e75f5cf37083
+Signed-off-by: Chunseok Lee <chunseok.lee@samsung.com>
+---
+ .../core/CL/kernels/CLArithmeticAdditionKernel.h   |  12 +-
+ .../CL/kernels/CLArithmeticSubtractionKernel.h     |   2 +
+ arm_compute/core/CL/kernels/CLCastKernel.h         |  65 +++
+ arm_compute/core/CL/kernels/CLGatherKernel.h       |  77 ++++
+ .../core/CL/kernels/CLPixelWiseDivisionKernel.h    |  88 ++++
+ .../CL/kernels/CLPixelWiseMultiplicationKernel.h   |   8 +-
+ arm_compute/core/CL/kernels/CLReduceMaxKernel.h    |  78 ++++
+ .../core/CL/kernels/CLReductionMeanKernel.h        |  83 ++++
+ arm_compute/core/CL/kernels/CLStridedSliceKernel.h | 106 +++++
+ arm_compute/core/CL/kernels/CLTopKV2Kernel.h       | 309 +++++++++++++
+ arm_compute/core/Helpers.inl                       |  33 ++
+ arm_compute/runtime/CL/CLFunctions.h               |   8 +
+ .../runtime/CL/functions/CLArithmeticAddition.h    |  12 +-
+ .../runtime/CL/functions/CLArithmeticSubtraction.h |  13 +-
+ arm_compute/runtime/CL/functions/CLCast.h          |  52 +++
+ arm_compute/runtime/CL/functions/CLGather.h        |  56 +++
+ .../runtime/CL/functions/CLPixelWiseDivision.h     |  71 +++
+ .../CL/functions/CLPixelWiseMultiplication.h       |   8 +-
+ arm_compute/runtime/CL/functions/CLReduceMax.h     |  89 ++++
+ arm_compute/runtime/CL/functions/CLReductionMean.h |  76 ++++
+ arm_compute/runtime/CL/functions/CLStridedSlice.h  |  73 ++++
+ arm_compute/runtime/CL/functions/CLTopKV2.h        | 115 +++++
+ src/core/CL/CLKernelLibrary.cpp                    |  72 ++++
+ src/core/CL/cl_kernels/activation_layer_qa8.cl     | 107 ++++-
+ src/core/CL/cl_kernels/arithmetic_op_quantized.cl  | 138 ++++++
+ src/core/CL/cl_kernels/cast.cl                     | 148 +++++++
+ src/core/CL/cl_kernels/fixed_point.h               |  24 ++
+ src/core/CL/cl_kernels/gather.cl                   | 106 +++++
+ src/core/CL/cl_kernels/pixelwise_div_float.cl      |  96 +++++
+ src/core/CL/cl_kernels/pixelwise_div_int.cl        | 103 +++++
+ src/core/CL/cl_kernels/pixelwise_mul_quantized.cl  | 119 +++++
+ src/core/CL/cl_kernels/reduce_max.cl               |  60 +++
+ src/core/CL/cl_kernels/reduction_mean.cl           |  69 +++
+ src/core/CL/cl_kernels/strided_slice.cl            | 104 +++++
+ src/core/CL/cl_kernels/topkv2.cl                   | 111 +++++
+ src/core/CL/cl_kernels/topkv2_quicksort.cl         | 138 ++++++
+ src/core/CL/cl_kernels/topkv2_radixsort.cl         | 279 ++++++++++++
+ src/core/CL/kernels/CLActivationLayerKernel.cpp    |  53 ++-
+ src/core/CL/kernels/CLArithmeticAdditionKernel.cpp |  46 +-
+ .../CL/kernels/CLArithmeticSubtractionKernel.cpp   | 125 ++++--
+ src/core/CL/kernels/CLCastKernel.cpp               | 115 +++++
+ src/core/CL/kernels/CLGatherKernel.cpp             | 147 +++++++
+ src/core/CL/kernels/CLPixelWiseDivisionKernel.cpp  | 284 ++++++++++++
+ .../CL/kernels/CLPixelWiseMultiplicationKernel.cpp |  37 +-
+ src/core/CL/kernels/CLReduceMaxKernel.cpp          | 135 ++++++
+ src/core/CL/kernels/CLReductionMeanKernel.cpp      | 190 ++++++++
+ src/core/CL/kernels/CLStridedSliceKernel.cpp       | 316 ++++++++++++++
+ src/core/CL/kernels/CLTopKV2Kernel.cpp             | 479 +++++++++++++++++++++
+ src/core/Validate.cpp                              |   2 +-
+ .../CL/functions/CLArithmeticSubtraction.cpp       |  14 +-
+ src/runtime/CL/functions/CLCast.cpp                |  37 ++
+ src/runtime/CL/functions/CLGather.cpp              |  45 ++
+ src/runtime/CL/functions/CLPixelWiseDivision.cpp   |  57 +++
+ src/runtime/CL/functions/CLReduceMax.cpp           | 132 ++++++
+ src/runtime/CL/functions/CLReductionMean.cpp       |  60 +++
+ src/runtime/CL/functions/CLStridedSlice.cpp        | 288 +++++++++++++
+ src/runtime/CL/functions/CLTopKV2.cpp              | 310 +++++++++++++
+ src/runtime/topk_v2.h                              | 141 ++++++
+ 58 files changed, 6038 insertions(+), 83 deletions(-)
+ create mode 100644 arm_compute/core/CL/kernels/CLCastKernel.h
+ create mode 100644 arm_compute/core/CL/kernels/CLGatherKernel.h
+ create mode 100644 arm_compute/core/CL/kernels/CLPixelWiseDivisionKernel.h
+ create mode 100644 arm_compute/core/CL/kernels/CLReduceMaxKernel.h
+ create mode 100644 arm_compute/core/CL/kernels/CLReductionMeanKernel.h
+ create mode 100644 arm_compute/core/CL/kernels/CLStridedSliceKernel.h
+ create mode 100644 arm_compute/core/CL/kernels/CLTopKV2Kernel.h
+ create mode 100644 arm_compute/runtime/CL/functions/CLCast.h
+ create mode 100644 arm_compute/runtime/CL/functions/CLGather.h
+ create mode 100644 arm_compute/runtime/CL/functions/CLPixelWiseDivision.h
+ create mode 100644 arm_compute/runtime/CL/functions/CLReduceMax.h
+ create mode 100644 arm_compute/runtime/CL/functions/CLReductionMean.h
+ create mode 100644 arm_compute/runtime/CL/functions/CLStridedSlice.h
+ create mode 100644 arm_compute/runtime/CL/functions/CLTopKV2.h
+ create mode 100644 src/core/CL/cl_kernels/arithmetic_op_quantized.cl
+ create mode 100644 src/core/CL/cl_kernels/cast.cl
+ create mode 100644 src/core/CL/cl_kernels/gather.cl
+ create mode 100644 src/core/CL/cl_kernels/pixelwise_div_float.cl
+ create mode 100644 src/core/CL/cl_kernels/pixelwise_div_int.cl
+ create mode 100644 src/core/CL/cl_kernels/pixelwise_mul_quantized.cl
+ create mode 100644 src/core/CL/cl_kernels/reduce_max.cl
+ create mode 100644 src/core/CL/cl_kernels/reduction_mean.cl
+ create mode 100644 src/core/CL/cl_kernels/strided_slice.cl
+ create mode 100644 src/core/CL/cl_kernels/topkv2.cl
+ create mode 100644 src/core/CL/cl_kernels/topkv2_quicksort.cl
+ create mode 100644 src/core/CL/cl_kernels/topkv2_radixsort.cl
+ create mode 100644 src/core/CL/kernels/CLCastKernel.cpp
+ create mode 100644 src/core/CL/kernels/CLGatherKernel.cpp
+ create mode 100644 src/core/CL/kernels/CLPixelWiseDivisionKernel.cpp
+ create mode 100644 src/core/CL/kernels/CLReduceMaxKernel.cpp
+ create mode 100644 src/core/CL/kernels/CLReductionMeanKernel.cpp
+ create mode 100644 src/core/CL/kernels/CLStridedSliceKernel.cpp
+ create mode 100644 src/core/CL/kernels/CLTopKV2Kernel.cpp
+ create mode 100644 src/runtime/CL/functions/CLCast.cpp
+ create mode 100644 src/runtime/CL/functions/CLGather.cpp
+ create mode 100644 src/runtime/CL/functions/CLPixelWiseDivision.cpp
+ create mode 100644 src/runtime/CL/functions/CLReduceMax.cpp
+ create mode 100644 src/runtime/CL/functions/CLReductionMean.cpp
+ create mode 100644 src/runtime/CL/functions/CLStridedSlice.cpp
+ create mode 100644 src/runtime/CL/functions/CLTopKV2.cpp
+ create mode 100644 src/runtime/topk_v2.h
+
+diff --git a/arm_compute/core/CL/kernels/CLArithmeticAdditionKernel.h b/arm_compute/core/CL/kernels/CLArithmeticAdditionKernel.h
+index 5112476..017650f 100644
+--- a/arm_compute/core/CL/kernels/CLArithmeticAdditionKernel.h
++++ b/arm_compute/core/CL/kernels/CLArithmeticAdditionKernel.h
+@@ -53,17 +53,17 @@ public:
+     ~CLArithmeticAdditionKernel() = default;
+     /** Initialise the kernel's inputs, output and convertion policy.
+      *
+-     * @param[in]  input1 First tensor input. Data types supported: U8/QS8/QS16/S16/F16/F32.
+-     * @param[in]  input2 Second tensor input. Data types supported: U8/QS8 (only if @p input1 is QS8), QS16 (only if @p input1 is QS16), S16/F16/F32.
+-     * @param[out] output Output tensor. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QS16 (only if both inputs are QS16), S16/F16/F32.
++     * @param[in]  input1 First tensor input. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
++     * @param[in]  input2 Second tensor input. Data types supported: U8/QS8 (only if @p input1 is QS8), QASYMM8(only if @p input1 is QASYMM8), QS16 (only if @p input1 is QS16), S16/F16/F32.
++     * @param[out] output Output tensor. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QASYMM8 (only if both inputs are QASYMM8), QS16 (only if both inputs are QS16), S16/F16/F32.
+      * @param[in]  policy Policy to use to handle overflow.
+      */
+     void configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, ConvertPolicy policy);
+     /** Static function to check if given info will lead to a valid configuration of @ref CLArithmeticAdditionKernel
+      *
+-     * @param[in] input1 First tensor input info. Data types supported: U8/QS8/QS16/S16/F16/F32.
+-     * @param[in] input2 Second tensor input info. Data types supported: U8/QS8 (only if @p input1 is QS8), QS16 (only if @p input1 is QS16), S16/F16/F32.
+-     * @param[in] output Output tensor info. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QS16 (only if both inputs are QS16), S16/F16/F32.
++     * @param[in] input1 First tensor input info. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
++     * @param[in] input2 Second tensor input info. Data types supported: U8/QS8 (only if @p input1 is QS8), QASYMM8(only if @p input1 is QASYMM8), QS16 (only if @p input1 is QS16), S16/F16/F32.
++     * @param[in] output Output tensor info. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QASYMM8 (only if both inputs are QASYMM8), QS16 (only if both inputs are QS16), S16/F16/F32.
+      * @param[in] policy Policy to use to handle overflow.
+      *
+      * @return a status
+diff --git a/arm_compute/core/CL/kernels/CLArithmeticSubtractionKernel.h b/arm_compute/core/CL/kernels/CLArithmeticSubtractionKernel.h
+index c5f862a..5e374a5 100644
+--- a/arm_compute/core/CL/kernels/CLArithmeticSubtractionKernel.h
++++ b/arm_compute/core/CL/kernels/CLArithmeticSubtractionKernel.h
+@@ -1,4 +1,5 @@
+ /*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+  * Copyright (c) 2016, 2017 ARM Limited.
+  *
+  * SPDX-License-Identifier: MIT
+@@ -74,6 +75,7 @@ public:
+ 
+     // Inherited methods overridden:
+     void run(const Window &window, cl::CommandQueue &queue) override;
++    BorderSize border_size() const override;
+ 
+ private:
+     const ICLTensor *_input1; /**< Source tensor 1 */
+diff --git a/arm_compute/core/CL/kernels/CLCastKernel.h b/arm_compute/core/CL/kernels/CLCastKernel.h
+new file mode 100644
+index 0000000..19e482f
+--- /dev/null
++++ b/arm_compute/core/CL/kernels/CLCastKernel.h
+@@ -0,0 +1,65 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLCASTKERNEL_H__
++#define __ARM_COMPUTE_CLCASTKERNEL_H__
++
++#include "arm_compute/core/CL/ICLKernel.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** OpenCL kernel to perform a cast operation */
++class CLCastKernel : public ICLKernel
++{
++public:
++    /** Default constructor */
++    CLCastKernel();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLCastKernel(const CLCastKernel &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLCastKernel &operator=(const CLCastKernel &) = delete;
++    /** Allow instances of this class to be moved */
++    CLCastKernel(CLCastKernel &&) = default;
++    /** Allow instances of this class to be moved */
++    CLCastKernel &operator=(CLCastKernel &&) = default;
++    /** Default destructor */
++    ~CLCastKernel() = default;
++    /** Initialise the kernel's input and output.
++     *
++     * @param[in]  input  Input tensor. Data types supported: U8/QASYMM8/S16/S32/F16/F32.
++     * @param[in]  output Output tensor. Data types supported: U8/QASYMM8/S16/S32/F16/F32.
++     */
++    void configure(const ICLTensor *input, ICLTensor *output);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    const ICLTensor *_input; /**< Source tensor */
++    ICLTensor       *_output; /**< Destination tensor */
++};
++} // namespace arm_compute
++#endif /* __ARM_COMPUTE_CLCASTKERNEL_H__ */
+diff --git a/arm_compute/core/CL/kernels/CLGatherKernel.h b/arm_compute/core/CL/kernels/CLGatherKernel.h
+new file mode 100644
+index 0000000..530491a
+--- /dev/null
++++ b/arm_compute/core/CL/kernels/CLGatherKernel.h
+@@ -0,0 +1,77 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLGATHERKERNEL_H__
++#define __ARM_COMPUTE_CLGATHERKERNEL_H__
++
++#include "arm_compute/core/CL/ICLKernel.h"
++#include "arm_compute/core/Types.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Interface for the gather kernel.
++ *
++ */
++class CLGatherKernel : public ICLKernel
++{
++public:
++    /** Default constructor.*/
++    CLGatherKernel();
++    /** Prevent instances of this class from being copied (As this class contains pointers). */
++    CLGatherKernel(const CLGatherKernel &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers). */
++    CLGatherKernel &operator=(const CLGatherKernel &) = delete;
++    /** Allow instances of this class to be moved */
++    CLGatherKernel(CLGatherKernel &&) = default;
++    /** Allow instances of this class to be moved */
++    CLGatherKernel &operator=(CLGatherKernel &&) = default;
++    /** Initialise the kernel's input, output and border mode.
++     *
++     * @param[in]  input1          An input tensor. Data types supported: U8/S32/F32.
++     * @param[in]  input2          An input tensor. Data types supported: S32.
++     * @param[out] output          The output tensor, Data types supported: same as @p input1.
++     */
++    void configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output);
++    /** Static function to check if given info will lead to a valid configuration of @ref CLGatherKernel
++     *
++     * @param[in]  input1          An input tensor. Data types supported: U8/S32/F32.
++     * @param[in]  input2          An input tensor. Data types supported: S32.
++     * @param[out] output          The output tensor, Data types supported: same as @p input1.
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    const ICLTensor *_input1;
++    const ICLTensor *_input2;
++    ICLTensor       *_output;
++};
++} // namespace arm_compute
++#endif /*__ARM_COMPUTE_CLGATHERKERNEL_H__ */
+diff --git a/arm_compute/core/CL/kernels/CLPixelWiseDivisionKernel.h b/arm_compute/core/CL/kernels/CLPixelWiseDivisionKernel.h
+new file mode 100644
+index 0000000..2e542b3
+--- /dev/null
++++ b/arm_compute/core/CL/kernels/CLPixelWiseDivisionKernel.h
+@@ -0,0 +1,88 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLPIXELWISEDIVISIONKERNEL_H__
++#define __ARM_COMPUTE_CLPIXELWISEDIVISIONKERNEL_H__
++
++#include "arm_compute/core/CL/ICLKernel.h"
++#include "arm_compute/core/Types.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Interface for the pixelwise division kernel.
++ *
++ */
++class CLPixelWiseDivisionKernel : public ICLKernel
++{
++public:
++    /** Default constructor.*/
++    CLPixelWiseDivisionKernel();
++    /** Prevent instances of this class from being copied (As this class contains pointers). */
++    CLPixelWiseDivisionKernel(const CLPixelWiseDivisionKernel &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers). */
++    CLPixelWiseDivisionKernel &operator=(const CLPixelWiseDivisionKernel &) = delete;
++    /** Allow instances of this class to be moved */
++    CLPixelWiseDivisionKernel(CLPixelWiseDivisionKernel &&) = default;
++    /** Allow instances of this class to be moved */
++    CLPixelWiseDivisionKernel &operator=(CLPixelWiseDivisionKernel &&) = default;
++    /** Initialise the kernel's input, output and border mode.
++     *
++     * @param[in]  input1          An input tensor. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in]  input2          An input tensor. Data types supported: same as @p input1.
++     * @param[out] output          The output tensor, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[in]  scale           Scale to apply after division.
++     *                             Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
++     * @param[in]  overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
++     * @param[in]  rounding_policy Rounding policy. Supported rounding modes: to zero, to nearest even.
++     */
++    void configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, float scale,
++                   ConvertPolicy overflow_policy, RoundingPolicy rounding_policy);
++    /** Static function to check if given info will lead to a valid configuration of @ref CLPixelWiseDivisionKernel
++     *
++     * @param[in] input1          An input tensor info. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in] input2          An input tensor info. Data types supported: same as @p input1.
++     * @param[in] output          The output tensor info, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[in] scale           Scale to apply after division.
++     *                            Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
++     * @param[in] overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
++     * @param[in] rounding_policy Rounding policy. Supported rounding modes: to zero, to nearest even.
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, float scale,
++                           ConvertPolicy overflow_policy, RoundingPolicy rounding_policy);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++    BorderSize border_size() const override;
++
++private:
++    const ICLTensor *_input1;
++    const ICLTensor *_input2;
++    ICLTensor       *_output;
++};
++} // namespace arm_compute
++#endif /*__ARM_COMPUTE_CLPIXELWISEDIVISIONKERNEL_H__ */
+diff --git a/arm_compute/core/CL/kernels/CLPixelWiseMultiplicationKernel.h b/arm_compute/core/CL/kernels/CLPixelWiseMultiplicationKernel.h
+index fcabb61..66c0b36 100644
+--- a/arm_compute/core/CL/kernels/CLPixelWiseMultiplicationKernel.h
++++ b/arm_compute/core/CL/kernels/CLPixelWiseMultiplicationKernel.h
+@@ -49,9 +49,9 @@ public:
+     CLPixelWiseMultiplicationKernel &operator=(CLPixelWiseMultiplicationKernel &&) = default;
+     /** Initialise the kernel's input, output and border mode.
+      *
+-     * @param[in]  input1          An input tensor. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in]  input1          An input tensor. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
+      * @param[in]  input2          An input tensor. Data types supported: same as @p input1.
+-     * @param[out] output          The output tensor, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[out] output          The output tensor, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16). QASYMM8 requires both inputs are QASYMM8.
+      * @param[in]  scale           Scale to apply after multiplication.
+      *                             Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
+      * @param[in]  overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
+@@ -61,9 +61,9 @@ public:
+                    ConvertPolicy overflow_policy, RoundingPolicy rounding_policy);
+     /** Static function to check if given info will lead to a valid configuration of @ref CLPixelWiseMultiplicationKernel
+      *
+-     * @param[in] input1          An input tensor info. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in] input1          An input tensor info. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
+      * @param[in] input2          An input tensor info. Data types supported: same as @p input1.
+-     * @param[in] output          The output tensor info, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[in] output          The output tensor info, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16). QASYMM8 requires both inputs are QASYMM8.
+      * @param[in] scale           Scale to apply after multiplication.
+      *                            Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
+      * @param[in] overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
+diff --git a/arm_compute/core/CL/kernels/CLReduceMaxKernel.h b/arm_compute/core/CL/kernels/CLReduceMaxKernel.h
+new file mode 100644
+index 0000000..184389a
+--- /dev/null
++++ b/arm_compute/core/CL/kernels/CLReduceMaxKernel.h
+@@ -0,0 +1,78 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLREDUCEMAXKERNEL_H__
++#define __ARM_COMPUTE_CLREDUCEMAXKERNEL_H__
++
++#include "arm_compute/core/CL/ICLKernel.h"
++#include "arm_compute/core/Types.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Interface for the pixelwise division kernel.
++ *
++ */
++class CLReduceMaxKernel : public ICLKernel
++{
++public:
++    /** Default constructor.*/
++    CLReduceMaxKernel();
++    /** Prevent instances of this class from being copied (As this class contains pointers). */
++    CLReduceMaxKernel(const CLReduceMaxKernel &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers). */
++    CLReduceMaxKernel &operator=(const CLReduceMaxKernel &) = delete;
++    /** Allow instances of this class to be moved */
++    CLReduceMaxKernel(CLReduceMaxKernel &&) = default;
++    /** Allow instances of this class to be moved */
++    CLReduceMaxKernel &operator=(CLReduceMaxKernel &&) = default;
++    /** Initialise the kernel's input, output and border mode.
++     *
++     * @param[in]  input          An input tensor. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in] axis            Axis to reduce
++     * @param[out] output          The output tensor, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     */
++    void configure(const ICLTensor *input, int32_t axis, ICLTensor *output);
++    /** Static function to check if given info will lead to a valid configuration of @ref CLReduceMaxKernel
++     *
++     * @param[in] input           An input tensor info. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in] axis            Axis to reduce
++     * @param[in] output          The output tensor info, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input, int32_t axis, const ITensorInfo *output);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++    void run_on_cpu(cl::CommandQueue &queue);
++
++private:
++    const ICLTensor *_input;
++    ICLTensor       *_output;
++    int32_t         _axis;
++};
++} // namespace arm_compute
++#endif /*__ARM_COMPUTE_CLREDUCEMAXKERNEL_H__ */
+diff --git a/arm_compute/core/CL/kernels/CLReductionMeanKernel.h b/arm_compute/core/CL/kernels/CLReductionMeanKernel.h
+new file mode 100644
+index 0000000..687fdb5
+--- /dev/null
++++ b/arm_compute/core/CL/kernels/CLReductionMeanKernel.h
+@@ -0,0 +1,83 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLREDUCTIONMEANKERNEL_H__
++#define __ARM_COMPUTE_CLREDUCTIONMEANKERNEL_H__
++
++#include "arm_compute/core/CL/ICLKernel.h"
++#include "arm_compute/core/Types.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Interface for the reduction operation kernel */
++class CLReductionMeanKernel : public ICLKernel
++{
++public:
++    /** Default constructor */
++    CLReductionMeanKernel();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLReductionMeanKernel(const CLReductionMeanKernel &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLReductionMeanKernel &operator=(const CLReductionMeanKernel &) = delete;
++    /** Allow instances of this class to be moved */
++    CLReductionMeanKernel(CLReductionMeanKernel &&) = default;
++    /** Allow instances of this class to be moved */
++    CLReductionMeanKernel &operator=(CLReductionMeanKernel &&) = default;
++    /** Default destructor */
++    ~CLReductionMeanKernel() = default;
++
++    /** Set the input and output tensors.
++     *
++     * @param[in]  input  Source tensor. Data types supported: F32. Data layouts supported: NCHW.
++     * @param[out] output Destination tensor. Data types and data layouts supported: Same as @p input.
++     *                    Output will have the same number of dimensions as input.
++     * @param[in]  axis   Axis along which to reduce. Supported reduction axis : 0, 1
++     */
++    void configure(const ICLTensor *input, ICLTensor *output, std::vector<uint32_t> axis);
++
++    /** Static function to check if given info will lead to a valid configuration of @ref CLReductionMeanKernel.
++     *
++     * @param[in] input  Source tensor info. Data types supported: F32. Data layouts supported: NCHW.
++     * @param[in] output Destination tensor info. Data types and data layouts supported: Same as @p input.
++     *                   Output will have the same number of dimensions as input.
++     * @param[in] axis   Axis along which to reduce. Supported reduction axis : 0, 1
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input, const ITensorInfo *output, std::vector<uint32_t> axis);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++    BorderSize border_size() const override;
++
++private:
++    const ICLTensor   *_input;
++    ICLTensor         *_output;
++    std::vector<uint32_t> _reduction_axis;
++    BorderSize         _border_size;
++};
++} // namespace arm_compute
++#endif /*__ARM_COMPUTE_CLREDUCTIONMEANKERNEL_H__ */
+diff --git a/arm_compute/core/CL/kernels/CLStridedSliceKernel.h b/arm_compute/core/CL/kernels/CLStridedSliceKernel.h
+new file mode 100644
+index 0000000..456c27d
+--- /dev/null
++++ b/arm_compute/core/CL/kernels/CLStridedSliceKernel.h
+@@ -0,0 +1,106 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLSTRIDEDSLICEKERNEL_H__
++#define __ARM_COMPUTE_CLSTRIDEDSLICEKERNEL_H__
++
++#include "arm_compute/core/CL/ICLKernel.h"
++#include "arm_compute/core/Types.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Interface for the kernel to extract a strided slice of a tensor */
++class CLStridedSliceKernel : public ICLKernel
++{
++public:
++    /** Default constructor */
++    CLStridedSliceKernel();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLStridedSliceKernel(const CLStridedSliceKernel &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLStridedSliceKernel &operator=(const CLStridedSliceKernel &) = delete;
++    /** Allow instances of this class to be moved */
++    CLStridedSliceKernel(CLStridedSliceKernel &&) = default;
++    /** Allow instances of this class to be moved */
++    CLStridedSliceKernel &operator=(CLStridedSliceKernel &&) = default;
++    /** Default destructor */
++    ~CLStridedSliceKernel() = default;
++    /** Set the input and output of the kernel
++     *
++     * @param[in]  input          Source tensor. Data type supported: U8/S8/QS8/QASYMM8/U16/S16/QS16/U32/S32/F16/F32
++     * @param[out] output         Destination tensor. Data type supported: Same as @p input
++     * @param[in]  beginData      The begin tensor. Data types supported: S32.
++     *                            The number of dimensions must be 1.
++     *                            The length must be the same as the number of dimensions of input.
++     * @param[in]  endData        The end tensor. Data types supported: S32.
++     *                            The number of dimensions must be 1.
++     *                            The length must be the same as the number of dimensions of input.
++     * @param[in]  strideData     The stride tensor. Data types supported: S32.
++     *                            The number of dimensions must be 1.
++     *                            The length must be the same as the number of dimensions of input.
++     * @param[in]  beginMask      Mask for begin
++     * @param[in]  endMask        Mask for end
++     * @param[in]  shrinkAxisMask Mask for shrink axis.
++     *
++     */
++    void configure(const ICLTensor *input, ICLTensor *output, ICLTensor *beginData, ICLTensor *endData, ICLTensor *stridesData, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask);
++
++    /** Static function to check if given info will lead to a valid configuration of @ref CLStridedSliceKernel
++     *
++     * @param[in]  input          The input tensor info. Data types supported: U8/S8/QS8/QASYMM8/U16/S16/QS16/U32/S32/F16/F32
++     * @param[in]  output         The output tensor info, Data types supported: same as @p input1.
++     * @param[in]  begin          The begin tensor info. Data types supported: S32.
++     *                            The number of dimensions must be 1.
++     *                            The length must be the same as the number of dimensions of input.
++     * @param[in]  end            The end tensor info. Data types supported: S32.
++     *                            The number of dimensions must be 1.
++     *                            The length must be the same as the number of dimensions of input.
++     * @param[in]  stride         The stride tensor info. Data types supported: S32.
++     *                            The number of dimensions must be 1.
++     *                            The length must be the same as the number of dimensions of input.
++     * @param[in]  beginMask      Mask for begin
++     * @param[in]  endMask        Mask for end
++     * @param[in]  shrinkAxisMask Mask for shrink axis.
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *begin, const ITensorInfo *end, const ITensorInfo *stride, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    const ICLTensor *_input;      /** Source tensor */
++    ICLTensor       *_output;     /** Destination tensor */
++    ICLTensor *_beginData;        /** Start indices of input tensor */
++    ICLTensor *_endData;          /** Stop indices of input tensor */
++    ICLTensor *_stridesData;      /** Strides tensor */
++    int32_t _beginMask;           /** Begin mask */
++    int32_t _endMask;             /** End mask */
++    int32_t _shrinkAxisMask;      /** Shrink axis mask */
++};
++} // namespace arm_compute
++#endif /*__ARM_COMPUTE_CLSTRIDEDSLICEKERNEL_H__ */
+diff --git a/arm_compute/core/CL/kernels/CLTopKV2Kernel.h b/arm_compute/core/CL/kernels/CLTopKV2Kernel.h
+new file mode 100644
+index 0000000..09bcfe5
+--- /dev/null
++++ b/arm_compute/core/CL/kernels/CLTopKV2Kernel.h
+@@ -0,0 +1,309 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLTOPKV2KERNEL_H__
++#define __ARM_COMPUTE_CLTOPKV2KERNEL_H__
++
++#include "arm_compute/core/CL/ICLArray.h"
++#include "arm_compute/core/CL/ICLKernel.h"
++
++#include <array>
++
++// these parameters can be changed
++#define _ITEMS  16 // number of items in a group
++#define _GROUPS 4 // the number of virtual processors is _ITEMS * _GROUPS
++#define _HISTOSPLIT (_ITEMS*_GROUPS/2) // number of splits of the histogram
++#define PERMUT  // store the final permutation
++////////////////////////////////////////////////////////
++
++namespace arm_compute
++{
++class ICLTensor;
++
++class CLTopKV2Single : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLTopKV2Single();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2Single(const CLTopKV2Single &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2Single &operator=(const CLTopKV2Single &) = delete;
++    /** Allow instances of this class to be moved */
++    CLTopKV2Single(CLTopKV2Single &&) = default;
++    /** Allow instances of this class to be moved */
++    CLTopKV2Single &operator=(CLTopKV2Single &&) = default;
++
++    void configure(ICLTensor *input, ICLTensor *topk_values,
++        ICLTensor *topk_indices, cl::Buffer *indices,
++        cl::Buffer *temp_stack, int k, int n);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    ICLTensor *_input;
++    ICLTensor *_topk_values;
++    ICLTensor *_topk_indices;
++};
++
++class CLTopKV2Init : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLTopKV2Init();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2Init(const CLTopKV2Init &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2Init &operator=(const CLTopKV2Init &) = delete;
++    /** Allow instances of this class to be moved */
++    CLTopKV2Init(CLTopKV2Init &&) = default;
++    /** Allow instances of this class to be moved */
++    CLTopKV2Init &operator=(CLTopKV2Init &&) = default;
++
++    void configure(ICLTensor *input, cl::Buffer* in_key_buf,
++        cl::Buffer* in_ind_buf, int n);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    ICLTensor *_input;
++};
++
++class CLRadixSortHistogram : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLRadixSortHistogram();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortHistogram(const CLRadixSortHistogram &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortHistogram &operator=(const CLRadixSortHistogram &) = delete;
++    /** Allow instances of this class to be moved */
++    CLRadixSortHistogram(CLRadixSortHistogram &&) = default;
++    /** Allow instances of this class to be moved */
++    CLRadixSortHistogram &operator=(CLRadixSortHistogram &&) = default;
++
++    void configure(cl::Buffer* hist_buf, int bits, int n);
++
++    void setPass(int pass, cl::Buffer *in_key_buf) {
++      _pass = pass;
++      _in_key_buf = in_key_buf;
++    }
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    int _pass;
++    cl::Buffer *_in_key_buf;
++};
++
++class CLRadixSortScanHistogram : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLRadixSortScanHistogram();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortScanHistogram(const CLRadixSortScanHistogram &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortScanHistogram &operator=(const CLRadixSortScanHistogram &) = delete;
++    /** Allow instances of this class to be moved */
++    CLRadixSortScanHistogram(CLRadixSortScanHistogram &&) = default;
++    /** Allow instances of this class to be moved */
++    CLRadixSortScanHistogram &operator=(CLRadixSortScanHistogram &&) = default;
++
++    void configure(cl::Buffer* hist_buf, cl::Buffer* glob_sum_buf, int bits);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++};
++
++class CLRadixSortGlobalScanHistogram : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLRadixSortGlobalScanHistogram();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortGlobalScanHistogram(const CLRadixSortGlobalScanHistogram &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortGlobalScanHistogram &operator=(const CLRadixSortGlobalScanHistogram &) = delete;
++    /** Allow instances of this class to be moved */
++    CLRadixSortGlobalScanHistogram(CLRadixSortGlobalScanHistogram &&) = default;
++    /** Allow instances of this class to be moved */
++    CLRadixSortGlobalScanHistogram &operator=(CLRadixSortGlobalScanHistogram &&) = default;
++
++    void configure(cl::Buffer* glob_sum_buf, cl::Buffer* temp_buf, int bits);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++};
++
++class CLRadixSortPasteHistogram : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLRadixSortPasteHistogram();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortPasteHistogram(const CLRadixSortPasteHistogram &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortPasteHistogram &operator=(const CLRadixSortPasteHistogram &) = delete;
++    /** Allow instances of this class to be moved */
++    CLRadixSortPasteHistogram(CLRadixSortPasteHistogram &&) = default;
++    /** Allow instances of this class to be moved */
++    CLRadixSortPasteHistogram &operator=(CLRadixSortPasteHistogram &&) = default;
++
++    void configure(cl::Buffer* hist_buf, cl::Buffer* glob_sum_buf, int bits);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++};
++
++class CLRadixSortReorder : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLRadixSortReorder();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortReorder(const CLRadixSortReorder &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLRadixSortReorder &operator=(const CLRadixSortReorder &) = delete;
++    /** Allow instances of this class to be moved */
++    CLRadixSortReorder(CLRadixSortReorder &&) = default;
++    /** Allow instances of this class to be moved */
++    CLRadixSortReorder &operator=(CLRadixSortReorder &&) = default;
++
++    void configure( cl::Buffer *hist_buf, int bits, int n);
++
++    void setPass(int pass, cl::Buffer *in_key_buf, cl::Buffer *out_key_buf,
++        cl::Buffer *in_ind_buf, cl::Buffer *out_ind_buf) {
++      _pass = pass;
++      _in_key_buf = in_key_buf;
++      _out_key_buf = out_key_buf;
++      _in_ind_buf = in_ind_buf;
++      _out_ind_buf = out_ind_buf;
++    }
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    int _pass;
++    cl::Buffer *_in_key_buf;
++    cl::Buffer *_out_key_buf;
++    cl::Buffer *_in_ind_buf;
++    cl::Buffer *_out_ind_buf;
++};
++
++class CLTopKV2FindFirstNegative : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLTopKV2FindFirstNegative();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2FindFirstNegative(const CLTopKV2FindFirstNegative &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2FindFirstNegative &operator=(const CLTopKV2FindFirstNegative &) = delete;
++    /** Allow instances of this class to be moved */
++    CLTopKV2FindFirstNegative(CLTopKV2FindFirstNegative &&) = default;
++    /** Allow instances of this class to be moved */
++    CLTopKV2FindFirstNegative &operator=(CLTopKV2FindFirstNegative &&) = default;
++
++    void configure(cl::Buffer *first_negative_idx_buf, int n);
++
++    void setOutputBuffer(cl::Buffer* out_key_buf) {
++      _out_key_buf = out_key_buf;
++    }
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    cl::Buffer *_out_key_buf;
++};
++
++class CLTopKV2ReorderNegatives : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLTopKV2ReorderNegatives();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2ReorderNegatives(const CLTopKV2ReorderNegatives &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2ReorderNegatives &operator=(const CLTopKV2ReorderNegatives &) = delete;
++    /** Allow instances of this class to be moved */
++    CLTopKV2ReorderNegatives(CLTopKV2ReorderNegatives &&) = default;
++    /** Allow instances of this class to be moved */
++    CLTopKV2ReorderNegatives &operator=(CLTopKV2ReorderNegatives &&) = default;
++
++    void configure(cl::Buffer *first_negative_idx_buf, int n);
++
++    void setBuffers(cl::Buffer *in_key_buf, cl::Buffer* out_key_buf,
++        cl::Buffer *in_ind_buf, cl::Buffer *out_ind_buf) {
++      _in_key_buf = in_key_buf;
++      _out_key_buf = out_key_buf;
++      _in_ind_buf = in_ind_buf;
++      _out_ind_buf = out_ind_buf;
++    }
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++
++private:
++    cl::Buffer *_in_key_buf;
++    cl::Buffer *_out_key_buf;
++    cl::Buffer *_in_ind_buf;
++    cl::Buffer *_out_ind_buf;
++};
++
++class CLTopKV2Store : public ICLKernel
++{
++public:
++    /** Constructor */
++    CLTopKV2Store();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2Store(const CLTopKV2Store &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2Store &operator=(const CLTopKV2Store &) = delete;
++    /** Allow instances of this class to be moved */
++    CLTopKV2Store(CLTopKV2Store &&) = default;
++    /** Allow instances of this class to be moved */
++    CLTopKV2Store &operator=(CLTopKV2Store &&) = default;
++
++    void configure(ICLTensor *values, ICLTensor *indices, int k, int n);
++
++    void setOutputBuffers(cl::Buffer *out_key_buf, cl::Buffer *out_ind_buf);
++
++    // Inherited methods overridden:
++    void run(const Window &window, cl::CommandQueue &queue) override;
++private:
++    ICLTensor *_values;
++    ICLTensor *_indices;
++    cl::Buffer *_out_key_buf;
++    cl::Buffer *_out_ind_buf;
++};
++
++} // namespace arm_compute
++
++#endif // __ARM_COMPUTE_CLTOPKV2KERNEL_H__
+diff --git a/arm_compute/core/Helpers.inl b/arm_compute/core/Helpers.inl
+index b359811..b588d08 100644
+--- a/arm_compute/core/Helpers.inl
++++ b/arm_compute/core/Helpers.inl
+@@ -300,6 +300,39 @@ inline bool set_quantization_info_if_empty(ITensorInfo &info, QuantizationInfo q
+     return false;
+ }
+ 
++inline ValidRegion calculate_valid_region_scale(const ITensorInfo &src_info, const TensorShape &dst_shape, InterpolationPolicy policy, BorderSize border_size, bool border_undefined)
++{
++    const auto wr = static_cast<float>(dst_shape[0]) / static_cast<float>(src_info.tensor_shape()[0]);
++    const auto hr = static_cast<float>(dst_shape[1]) / static_cast<float>(src_info.tensor_shape()[1]);
++
++    ValidRegion valid_region{ Coordinates(), dst_shape, src_info.tensor_shape().num_dimensions() };
++
++    Coordinates &anchor = valid_region.anchor;
++    TensorShape &shape  = valid_region.shape;
++
++    anchor.set(0, (policy == InterpolationPolicy::BILINEAR
++                   && border_undefined) ?
++               ((static_cast<int>(src_info.valid_region().anchor[0] + border_size.left + 0.5f)) * wr - 0.5f) :
++               ((static_cast<int>(src_info.valid_region().anchor[0] + 0.5f)) * wr - 0.5f));
++    anchor.set(1, (policy == InterpolationPolicy::BILINEAR
++                   && border_undefined) ?
++               ((static_cast<int>(src_info.valid_region().anchor[1] + border_size.top + 0.5f)) * hr - 0.5f) :
++               ((static_cast<int>(src_info.valid_region().anchor[1] + 0.5f)) * hr - 0.5f));
++    float shape_out_x = (policy == InterpolationPolicy::BILINEAR
++                         && border_undefined) ?
++                        ((static_cast<int>(src_info.valid_region().anchor[0]) + static_cast<int>(src_info.valid_region().shape[0]) - 1) - 1 + 0.5f) * wr - 0.5f :
++                        ((static_cast<int>(src_info.valid_region().anchor[0]) + static_cast<int>(src_info.valid_region().shape[0])) + 0.5f) * wr - 0.5f;
++    float shape_out_y = (policy == InterpolationPolicy::BILINEAR
++                         && border_undefined) ?
++                        ((static_cast<int>(src_info.valid_region().anchor[1]) + static_cast<int>(src_info.valid_region().shape[1]) - 1) - 1 + 0.5f) * hr - 0.5f :
++                        ((static_cast<int>(src_info.valid_region().anchor[1]) + static_cast<int>(src_info.valid_region().shape[1])) + 0.5f) * hr - 0.5f;
++
++    shape.set(0, shape_out_x - anchor[0]);
++    shape.set(1, shape_out_y - anchor[1]);
++
++    return valid_region;
++}
++
+ inline Coordinates index2coords(const TensorShape &shape, int index)
+ {
+     int num_elements = shape.total_size();
+diff --git a/arm_compute/runtime/CL/CLFunctions.h b/arm_compute/runtime/CL/CLFunctions.h
+index fe90b09..8396b9f 100644
+--- a/arm_compute/runtime/CL/CLFunctions.h
++++ b/arm_compute/runtime/CL/CLFunctions.h
+@@ -1,4 +1,5 @@
+ /*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+  * Copyright (c) 2016-2018 ARM Limited.
+  *
+  * SPDX-License-Identifier: MIT
+@@ -37,6 +38,7 @@
+ #include "arm_compute/runtime/CL/functions/CLBitwiseXor.h"
+ #include "arm_compute/runtime/CL/functions/CLBox3x3.h"
+ #include "arm_compute/runtime/CL/functions/CLCannyEdge.h"
++#include "arm_compute/runtime/CL/functions/CLCast.h"
+ #include "arm_compute/runtime/CL/functions/CLChannelCombine.h"
+ #include "arm_compute/runtime/CL/functions/CLChannelExtract.h"
+ #include "arm_compute/runtime/CL/functions/CLChannelShuffleLayer.h"
+@@ -62,6 +64,7 @@
+ #include "arm_compute/runtime/CL/functions/CLFlattenLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLFloor.h"
+ #include "arm_compute/runtime/CL/functions/CLFullyConnectedLayer.h"
++#include "arm_compute/runtime/CL/functions/CLGather.h"
+ #include "arm_compute/runtime/CL/functions/CLGEMM.h"
+ #include "arm_compute/runtime/CL/functions/CLGEMMConvolutionLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLGEMMInterleave4x4.h"
+@@ -94,11 +97,14 @@
+ #include "arm_compute/runtime/CL/functions/CLPermute.h"
+ #include "arm_compute/runtime/CL/functions/CLPhase.h"
+ #include "arm_compute/runtime/CL/functions/CLPixelWiseMultiplication.h"
++#include "arm_compute/runtime/CL/functions/CLPixelWiseDivision.h"
+ #include "arm_compute/runtime/CL/functions/CLPoolingLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLQuantizationLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLRNNLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLROIPoolingLayer.h"
++#include "arm_compute/runtime/CL/functions/CLReduceMax.h"
+ #include "arm_compute/runtime/CL/functions/CLReductionOperation.h"
++#include "arm_compute/runtime/CL/functions/CLReductionMean.h"
+ #include "arm_compute/runtime/CL/functions/CLRemap.h"
+ #include "arm_compute/runtime/CL/functions/CLReshapeLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLScale.h"
+@@ -107,6 +113,7 @@
+ #include "arm_compute/runtime/CL/functions/CLSobel5x5.h"
+ #include "arm_compute/runtime/CL/functions/CLSobel7x7.h"
+ #include "arm_compute/runtime/CL/functions/CLSoftmaxLayer.h"
++#include "arm_compute/runtime/CL/functions/CLStridedSlice.h"
+ #include "arm_compute/runtime/CL/functions/CLTableLookup.h"
+ #include "arm_compute/runtime/CL/functions/CLThreshold.h"
+ #include "arm_compute/runtime/CL/functions/CLTranspose.h"
+@@ -115,5 +122,6 @@
+ #include "arm_compute/runtime/CL/functions/CLWidthConcatenateLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLWinogradConvolutionLayer.h"
+ #include "arm_compute/runtime/CL/functions/CLWinogradInputTransform.h"
++#include "arm_compute/runtime/CL/functions/CLTopKV2.h"
+ 
+ #endif /* __ARM_COMPUTE_CLFUNCTIONS_H__ */
+diff --git a/arm_compute/runtime/CL/functions/CLArithmeticAddition.h b/arm_compute/runtime/CL/functions/CLArithmeticAddition.h
+index 5b2fc8c..86dc2ef 100644
+--- a/arm_compute/runtime/CL/functions/CLArithmeticAddition.h
++++ b/arm_compute/runtime/CL/functions/CLArithmeticAddition.h
+@@ -41,19 +41,19 @@ class CLArithmeticAddition : public ICLSimpleFunction
+ public:
+     /** Initialise the kernel's inputs, output and convertion policy.
+      *
+-     * @param[in, out] input1 First tensor input. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in, out] input1 First tensor input. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
+      *                        The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
+-     * @param[in, out] input2 Second tensor input. Data types supported: U8, QS8 (only if @p input1 is QS8), QS16 (only if @p input1 is QS16), S16/F16/F32.
++     * @param[in, out] input2 Second tensor input. Data types supported: U8, QS8 (only if @p input1 is QS8), QASYMM8 (only if @p input1 is QASYMM8), QS16 (only if @p input1 is QS16), S16/F16/F32.
+      *                        The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
+-     * @param[out]     output Output tensor. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QS16 (only if both inputs are QS16), S16/F16/F32.
++     * @param[out]     output Output tensor. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QASYMM8 (only if both inputs are QASYMM8), QS16 (only if both inputs are QS16), S16/F16/F32.
+      * @param[in]      policy Policy to use to handle overflow.
+      */
+     void configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *output, ConvertPolicy policy);
+     /** Static function to check if given info will lead to a valid configuration of @ref CLArithmeticAddition
+      *
+-     * @param[in] input1 First tensor input info. Data types supported: U8/QS8/QS16/S16/F16/F32.
+-     * @param[in] input2 Second tensor input info. Data types supported: U8/QS8 (only if @p input1 is QS8), QS16 (only if @p input1 is QS16), S16/F16/F32.
+-     * @param[in] output Output tensor info. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QS16 (only if both inputs are QS16), S16/F16/F32.
++     * @param[in] input1 First tensor input info. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
++     * @param[in] input2 Second tensor input info. Data types supported: U8/QS8 (only if @p input1 is QS8), QASYMM8 (only if @p input1 is QASYMM8), QS16 (only if @p input1 is QS16), S16/F16/F32.
++     * @param[in] output Output tensor info. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QASYMM8 (only if both inputs are QASYMM8), QS16 (only if both inputs are QS16), S16/F16/F32.
+      * @param[in] policy Policy to use to handle overflow.
+      *
+      * @return a status
+diff --git a/arm_compute/runtime/CL/functions/CLArithmeticSubtraction.h b/arm_compute/runtime/CL/functions/CLArithmeticSubtraction.h
+index 0d3f5bc..6d76c70 100644
+--- a/arm_compute/runtime/CL/functions/CLArithmeticSubtraction.h
++++ b/arm_compute/runtime/CL/functions/CLArithmeticSubtraction.h
+@@ -1,4 +1,5 @@
+ /*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+  * Copyright (c) 2016, 2017 ARM Limited.
+  *
+  * SPDX-License-Identifier: MIT
+@@ -42,12 +43,14 @@ class CLArithmeticSubtraction : public ICLSimpleFunction
+ public:
+     /** Initialise the kernel's inputs, output and convertion policy.
+      *
+-     * @param[in]  input1 First tensor input. Data types supported: U8/QS8/QS16/S16/F16/F32.
+-     * @param[in]  input2 Second tensor input. Data types supported: U8/QS8 (only if @p input1 is QS8), QS16 (only if @p input1 is QS16), S16/F16/F32.
+-     * @param[out] output Output tensor. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QS16 (only if both inputs are QS16), S16/F16/F32.
+-     * @param[in]  policy Policy to use to handle overflow.
++     * @param[in, out] input1 An input tensor. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     *                        The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
++     * @param[in, out] input2 An input tensor. Data types supported: same as @p input1.
++     *                        The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
++     * @param[out]     output Output tensor. Data types supported: U8 (Only if both inputs are U8), QS8 (only if both inputs are QS8), QS16 (only if both inputs are QS16), S16/F16/F32.
++     * @param[in]      policy Policy to use to handle overflow.
+      */
+-    void configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, ConvertPolicy policy);
++    void configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *output, ConvertPolicy policy);
+     /** Static function to check if given info will lead to a valid configuration of @ref CLArithmeticSubtraction
+      *
+      * @param[in] input1 First tensor input info. Data types supported: U8/QS8/QS16/S16/F16/F32.
+diff --git a/arm_compute/runtime/CL/functions/CLCast.h b/arm_compute/runtime/CL/functions/CLCast.h
+new file mode 100644
+index 0000000..49fd342
+--- /dev/null
++++ b/arm_compute/runtime/CL/functions/CLCast.h
+@@ -0,0 +1,52 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLCAST_H__
++#define __ARM_COMPUTE_CLCAST_H__
++
++#include "arm_compute/core/Types.h"
++#include "arm_compute/runtime/CL/ICLSimpleFunction.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Basic function to run @ref CLCastKernel
++ *
++ * @note The tensor data type for the inputs must be U8/QASYMM8/S16/S32/F16/F32.
++ * @note The function converts the input tensor to the tensor of the output tensor's type.
++ */
++class CLCast : public ICLSimpleFunction
++{
++public:
++    /** Initialise the kernel's input and output.
++     *
++     * @param[in, out] input Input tensor. Data types supported: U8/QASYMM8/S16/S32/F16/F32.
++     *                       The input tensor is [in, out] because its TensorInfo might be modified inside the kernel.
++     * @param[out]     output Output tensor. Data types supported: U8/QASYMM8/S16/S32/F16/F32.
++     */
++    void configure(ICLTensor *input, ICLTensor *output);
++};
++}
++#endif /* __ARM_COMPUTE_CLCAST_H__ */
+diff --git a/arm_compute/runtime/CL/functions/CLGather.h b/arm_compute/runtime/CL/functions/CLGather.h
+new file mode 100644
+index 0000000..1aae32e
+--- /dev/null
++++ b/arm_compute/runtime/CL/functions/CLGather.h
+@@ -0,0 +1,56 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLGATHER_H__
++#define __ARM_COMPUTE_CLGATHER_H__
++
++#include "arm_compute/core/Types.h"
++#include "arm_compute/runtime/CL/ICLSimpleFunction.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Basic function to run @ref CLGatherKernel. */
++class CLGather : public ICLSimpleFunction
++{
++public:
++    /** Initialise the kernel's inputs, output and convertion policy.
++     *
++     * @param[in] input1          An input tensor. Data types supported: U8/S32/F32.
++     * @param[in] input2          An indexes tensor. Data types supported: S32.
++     * @param[out]     output          The output tensor, Data types supported: same as @p input1. 
++     */
++    void configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *output);
++    /** Static function to check if given info will lead to a valid configuration of @ref CLGather
++     *
++     * @param[in] input1          An input tensor. Data types supported: U8/S32/F32.
++     * @param[in] input2          An indexes tensor. Data types supported: S32.
++     * @param[out]     output          The output tensor, Data types supported: same as @p input1. 
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output);
++};
++}
++#endif /*__ARM_COMPUTE_CLGATHER_H__ */
+diff --git a/arm_compute/runtime/CL/functions/CLPixelWiseDivision.h b/arm_compute/runtime/CL/functions/CLPixelWiseDivision.h
+new file mode 100644
+index 0000000..5008159
+--- /dev/null
++++ b/arm_compute/runtime/CL/functions/CLPixelWiseDivision.h
+@@ -0,0 +1,71 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLPIXELWISEDIVISION_H__
++#define __ARM_COMPUTE_CLPIXELWISEDIVISION_H__
++
++#include "arm_compute/core/Types.h"
++#include "arm_compute/runtime/CL/ICLSimpleFunction.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Basic function to run @ref CLPixelWiseDivisionKernel. */
++class CLPixelWiseDivision : public ICLSimpleFunction
++{
++public:
++    /** Initialise the kernel's inputs, output and convertion policy.
++     *
++     * @param[in, out] input1          An input tensor. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     *                                 The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
++     * @param[in, out] input2          An input tensor. Data types supported: same as @p input1.
++     *                                 The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
++     * @param[out]     output          The output tensor, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[in]      scale           Scale to apply after multiplication.
++     *                                 Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
++     * @param[in]      overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
++     * @param[in]      rounding_policy Rounding policy. Supported rounding modes: to zero, to nearest even.
++     */
++    void configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *output, float scale = 1.f,
++                   ConvertPolicy overflow_policy = ConvertPolicy::WRAP,
++                   RoundingPolicy rounding_policy = RoundingPolicy::TO_ZERO);
++    /** Static function to check if given info will lead to a valid configuration of @ref CLPixelWiseDivision
++     *
++     * @param[in] input1          An input tensor info. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in] input2          An input tensor info. Data types supported: same as @p input1.
++     * @param[in] output          The output tensor info, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[in] scale           Scale to apply after multiplication.
++     *                            Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
++     * @param[in] overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
++     * @param[in] rounding_policy Rounding policy. Supported rounding modes: to zero, to nearest even.
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output,
++        float scale = 1.f, ConvertPolicy overflow_policy = ConvertPolicy::WRAP,
++        RoundingPolicy rounding_policy = RoundingPolicy::TO_ZERO);
++};
++}
++#endif /*__ARM_COMPUTE_CLPIXELWISEDIVISION_H__ */
+diff --git a/arm_compute/runtime/CL/functions/CLPixelWiseMultiplication.h b/arm_compute/runtime/CL/functions/CLPixelWiseMultiplication.h
+index 75b67cd..3f2ffcd 100644
+--- a/arm_compute/runtime/CL/functions/CLPixelWiseMultiplication.h
++++ b/arm_compute/runtime/CL/functions/CLPixelWiseMultiplication.h
+@@ -37,11 +37,11 @@ class CLPixelWiseMultiplication : public ICLSimpleFunction
+ public:
+     /** Initialise the kernel's inputs, output and convertion policy.
+      *
+-     * @param[in, out] input1          An input tensor. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in, out] input1          An input tensor. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
+      *                                 The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
+      * @param[in, out] input2          An input tensor. Data types supported: same as @p input1.
+      *                                 The input tensor is [in, out] because its TensorInfo might be modified inside the kernel in case of broadcasting of dimension 0.
+-     * @param[out]     output          The output tensor, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[out]     output          The output tensor, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16). QASYMM8 requires both inputs are QASYMM8.
+      * @param[in]      scale           Scale to apply after multiplication.
+      *                                 Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
+      * @param[in]      overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
+@@ -51,9 +51,9 @@ public:
+                    ConvertPolicy overflow_policy, RoundingPolicy rounding_policy);
+     /** Static function to check if given info will lead to a valid configuration of @ref CLPixelWiseMultiplication
+      *
+-     * @param[in] input1          An input tensor info. Data types supported: U8/QS8/QS16/S16/F16/F32.
++     * @param[in] input1          An input tensor info. Data types supported: U8/QS8/QASYMM8/QS16/S16/F16/F32.
+      * @param[in] input2          An input tensor info. Data types supported: same as @p input1.
+-     * @param[in] output          The output tensor info, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16).
++     * @param[in] output          The output tensor info, Data types supported: same as @p input1. Note: U8 (QS8, QS16) requires both inputs to be U8 (QS8, QS16). QASYMM8 requires both inputs are QASYMM8.
+      * @param[in] scale           Scale to apply after multiplication.
+      *                            Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1.
+      * @param[in] overflow_policy Overflow policy. Supported overflow policies: Wrap, Saturate
+diff --git a/arm_compute/runtime/CL/functions/CLReduceMax.h b/arm_compute/runtime/CL/functions/CLReduceMax.h
+new file mode 100644
+index 0000000..9cce054
+--- /dev/null
++++ b/arm_compute/runtime/CL/functions/CLReduceMax.h
+@@ -0,0 +1,89 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLREDUCE_MAX_H__
++#define __ARM_COMPUTE_CLREDUCE_MAX_H__
++
++#include "arm_compute/runtime/CL/CLArray.h"
++#include "arm_compute/runtime/IFunction.h"
++#include "arm_compute/core/Types.h"
++#include "arm_compute/core/CL/ICLKernel.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Basic function to execute TopK operation. This function calls the following OpenCL kernels:
++ *
++ * -# @ref CLTopKV2Kernel
++ */
++class CLReduceMax : public IFunction
++{
++public:
++    /** Constructor */
++    CLReduceMax();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLReduceMax(const CLReduceMax &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLReduceMax &operator=(const CLReduceMax &) = delete;
++    /** Allow instances of this class to be moved */
++    CLReduceMax(CLReduceMax &&) = default;
++    /** Allow instances of this class to be moved */
++    CLReduceMax &operator=(CLReduceMax &&) = default;
++    /** Initialise the kernel's inputs and outputs.
++     *
++     * @note When locations of min and max occurrences are requested, the reported number of locations is limited to the given array size.
++     *
++     * @param[in]  input     Input image. Data types supported: F32
++     * @param[in]  axis      Axis to reduce. Data type supported: S32
++     * @param[out] output    indices related to top k values. Data types supported: F32.
++     */
++    void configure(ICLTensor *input, int32_t axis, ICLTensor *output);
++    /** Static function to check if given info will lead to a valid configuration of @ref CLPixelWiseDivision
++     *
++     * @param[in]  input     Input image. Data types supported: F32
++     * @param[in]  axis      Axis to reduce. Data type supported: S32
++     * @param[out] output    indices related to top k values. Data types supported: F32.     *
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input, int32_t axis, const ITensorInfo *output);
++
++    // Inherited methods overridden:
++    void run() override;
++
++private:
++
++    void run_on_cpu();
++
++    int32_t   _axis;
++
++    ICLTensor *_input;
++    ICLTensor *_output;
++
++    std::unique_ptr<ICLKernel> _kernel;
++
++};
++}
++#endif /*__ARM_COMPUTE_CLREDUCE_MAX_H__ */
+diff --git a/arm_compute/runtime/CL/functions/CLReductionMean.h b/arm_compute/runtime/CL/functions/CLReductionMean.h
+new file mode 100644
+index 0000000..1f2a8b5
+--- /dev/null
++++ b/arm_compute/runtime/CL/functions/CLReductionMean.h
+@@ -0,0 +1,76 @@
++/*
++ * Copyright (c) 2017-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLREDUCTIONMEAN_H__
++#define __ARM_COMPUTE_CLREDUCTIONMEAN_H__
++
++#include "arm_compute/core/CL/kernels/CLFillBorderKernel.h"
++#include "arm_compute/core/CL/kernels/CLReductionMeanKernel.h"
++#include "arm_compute/core/Types.h"
++#include "arm_compute/runtime/CL/CLTensor.h"
++#include "arm_compute/runtime/IFunction.h"
++
++#include <cstdint>
++#include <memory>
++#include <vector>
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Perform reduction operation.
++ */
++class CLReductionMean : public IFunction
++{
++public:
++    /** Default Constructor.
++     */
++    CLReductionMean();
++
++    /** Set the input and output tensors.
++     *
++     * @param[in]  input  Source tensor. Data types supported: F32. Data layouts supported: NCHW.
++     * @param[out] output Destination tensor. Data types and data layouts supported: Same as @p input.
++     * @param[in]  axis   Axis along which to reduce. Supported reduction axis : 0,1 
++     */
++    void configure(ICLTensor *input, ICLTensor *output, std::vector<uint32_t> axis);
++
++    /** Static function to check if given info will lead to a valid configuration of @ref CLReductionMean.
++     *
++     * @param[in] input  Source tensor info. Data types supported: F32. Data layouts supported: NCHW.
++     * @param[in] output Destination tensor info. Data types and data layouts supported: Same as @p input.
++     * @param[in] axis   Axis along which to reduce. Supported reduction axis : 0,1
++     *
++     * @return a status
++     */
++    static Status validate(const ITensorInfo *input, const ITensorInfo *output, std::vector<uint32_t> axis);
++
++    // Inherited methods overridden:
++    void run() override;
++
++private:
++    CLReductionMeanKernel _reduction_mean_kernel;
++    CLFillBorderKernel _fill_border_kernel;
++};
++}
++#endif /*__ARM_COMPUTE_CLREDUCTIONMEAN_H__ */
+diff --git a/arm_compute/runtime/CL/functions/CLStridedSlice.h b/arm_compute/runtime/CL/functions/CLStridedSlice.h
+new file mode 100644
+index 0000000..4f765bd
+--- /dev/null
++++ b/arm_compute/runtime/CL/functions/CLStridedSlice.h
+@@ -0,0 +1,73 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLSTRIDEDSLICE_H__
++#define __ARM_COMPUTE_CLSTRIDEDSLICE_H__
++
++#include "arm_compute/runtime/IFunction.h"
++#include "arm_compute/runtime/CL/ICLSimpleFunction.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Basic function to run @ref CLStridedSliceKernel */
++class CLStridedSlice : public ICLSimpleFunction
++{
++public:
++    /** Initialise the kernel's inputs and outputs
++     *
++     * @param[in]  input  First tensor input. Data type supported: U8/S8/QS8/QASYMM8/U16/S16/QS16/U32/S32/F16/F32
++     * @param[out] output Output tensor. Data type supported: Same as @p input
++     */
++    void configure(const ICLTensor *input, ICLTensor *output, ICLTensor *beginData, ICLTensor *endData, ICLTensor *stridesData, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask);
++};
++
++class CLStridedSliceCPU : public IFunction
++{
++public:
++  /** Initialise inputs and outputs
++   *
++   * @param[in]  input  First tensor input.
++   * @param[out] output Output tensor.
++   */
++  void configure(ICLTensor *input, ICLTensor *output, ICLTensor *beginData, ICLTensor *endData, ICLTensor *stridesData, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask);
++
++  void run() override;
++
++private:
++  void run_on_cpu();
++
++  ICLTensor *_input;
++  ICLTensor *_output;
++  ICLTensor *_beginData;
++  ICLTensor *_endData;
++  ICLTensor *_stridesData;
++  int32_t _beginMask;
++  int32_t _endMask;
++  int32_t _shrinkAxisMask;
++};
++
++}
++#endif /*__ARM_COMPUTE_CLSTRIDEDSLICE_H__ */
+diff --git a/arm_compute/runtime/CL/functions/CLTopKV2.h b/arm_compute/runtime/CL/functions/CLTopKV2.h
+new file mode 100644
+index 0000000..0dd4287
+--- /dev/null
++++ b/arm_compute/runtime/CL/functions/CLTopKV2.h
+@@ -0,0 +1,115 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#ifndef __ARM_COMPUTE_CLTOPK_V2_H__
++#define __ARM_COMPUTE_CLTOPK_V2_H__
++
++#include "arm_compute/core/CL/kernels/CLTopKV2Kernel.h"
++
++#include "arm_compute/runtime/CL/CLArray.h"
++#include "arm_compute/runtime/IFunction.h"
++
++namespace arm_compute
++{
++class ICLTensor;
++
++/** Basic function to execute TopK operation. This function calls the following OpenCL kernels:
++ *
++ * -# @ref CLTopKV2Kernel
++ */
++class CLTopKV2 : public IFunction
++{
++public:
++    /** Constructor */
++    CLTopKV2();
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2(const CLTopKV2 &) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++    CLTopKV2 &operator=(const CLTopKV2 &) = delete;
++    /** Allow instances of this class to be moved */
++    CLTopKV2(CLTopKV2 &&) = default;
++    /** Allow instances of this class to be moved */
++    CLTopKV2 &operator=(CLTopKV2 &&) = default;
++    /** Initialise the kernel's inputs and outputs.
++     *
++     * @note When locations of min and max occurrences are requested, the reported number of locations is limited to the given array size.
++     *
++     * @param[in]  input     Input image. Data types supported: U8/S16/F32.
++     * @param[in]  k         The value of `k`.
++     * @param[out] values    Top k values. Data types supported: S32 if input type is U8/S16, F32 if input type is F32.
++     * @param[out] indices   indices related to top k values. Data types supported: S32 if input type is U8/S16, F32 if input type is F32.
++     */
++    void configure(ICLTensor *input, int k, ICLTensor *values, ICLTensor *indices,
++        int total_bits = 32, int bits = 4);
++
++    // Inherited methods overridden:
++    void run() override;
++
++private:
++
++    void run_on_cpu();
++    void run_on_gpu();
++    void run_on_gpu_single_quicksort();
++
++    uint32_t   _k;
++    uint32_t   _total_bits;
++    uint32_t   _bits;
++    uint32_t   _radix;
++    uint32_t   _hist_buf_size;
++    uint32_t   _glob_sum_buf_size;
++    uint32_t   _n;
++
++    ICLTensor *_input;
++    ICLTensor *_values;
++    ICLTensor *_indices;
++
++    cl::Buffer _qs_idx_buf;
++    cl::Buffer _qs_temp_buf;
++    cl::Buffer _hist_buf;
++    cl::Buffer _glob_sum_buf;
++    cl::Buffer _temp_buf;
++    cl::Buffer _first_negative_idx_buf;
++    cl::Buffer _in_key_buf;
++    cl::Buffer _out_key_buf;
++    cl::Buffer _in_ind_buf;
++    cl::Buffer _out_ind_buf;
++
++    cl::Buffer *_p_in_key_buf;
++    cl::Buffer *_p_out_key_buf;
++    cl::Buffer *_p_in_ind_buf;
++    cl::Buffer *_p_out_ind_buf;
++
++    CLTopKV2Single                 _qs_kernel;
++    CLTopKV2Init                   _init_kernel;
++    CLRadixSortHistogram           _hist_kernel;
++    CLRadixSortScanHistogram       _scan_hist_kernel;
++    CLRadixSortGlobalScanHistogram _glob_scan_hist_kernel;
++    CLRadixSortPasteHistogram      _paste_hist_kernel;
++    CLRadixSortReorder             _reorder_kernel;
++    CLTopKV2FindFirstNegative      _find_first_negative_kernel;
++    CLTopKV2ReorderNegatives       _reorder_negatives_kernel;
++    CLTopKV2Store                  _store_kernel;
++};
++}
++#endif // __ARM_COMPUTE_CLTOPK_V2_H__
+diff --git a/src/core/CL/CLKernelLibrary.cpp b/src/core/CL/CLKernelLibrary.cpp
+index bdb26f8..0c9f108 100644
+--- a/src/core/CL/CLKernelLibrary.cpp
++++ b/src/core/CL/CLKernelLibrary.cpp
+@@ -1,4 +1,5 @@
+ /*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+  * Copyright (c) 2016-2018 ARM Limited.
+  *
+  * SPDX-License-Identifier: MIT
+@@ -149,14 +150,19 @@ const std::map<std::string, std::string> CLKernelLibrary::_kernel_program_map =
+     { "accumulate_weighted", "accumulate.cl" },
+     { "activation_layer", "activation_layer.cl" },
+     { "activation_layer_qa8", "activation_layer_qa8.cl" },
++    { "activation_layer_logistic_qa8", "activation_layer_qa8.cl" },
+     { "arithmetic_add", "arithmetic_op.cl" },
+     { "arithmetic_sub", "arithmetic_op.cl" },
++    { "arithmetic_add_qasymm8", "arithmetic_op_quantized.cl" },
+     { "batchnormalization_layer_nchw", "batchnormalization_layer.cl" },
+     { "batchnormalization_layer_nhwc", "batchnormalization_layer.cl" },
+     { "bitwise_or", "bitwise_op.cl" },
+     { "bitwise_and", "bitwise_op.cl" },
+     { "bitwise_xor", "bitwise_op.cl" },
+     { "bitwise_not", "bitwise_op.cl" },
++    { "cast", "cast.cl" },
++    { "cast_qasymm_in", "cast.cl" },
++    { "cast_qasymm_out", "cast.cl" },
+     { "channel_combine_NV", "channel_combine.cl" },
+     { "channel_combine_RGB888", "channel_combine.cl" },
+     { "channel_combine_RGBA8888", "channel_combine.cl" },
+@@ -221,6 +227,9 @@ const std::map<std::string, std::string> CLKernelLibrary::_kernel_program_map =
+     { "fill_image_borders_replicate", "fill_border.cl" },
+     { "finalize", "optical_flow_pyramid_lk.cl" },
+     { "floor_layer", "floor.cl" },
++    { "gather", "gather.cl" },
++    { "gather_1d", "gather.cl" },
++    { "gather_1d_out", "gather.cl" },
+     { "gaussian1x5_sub_x", "gaussian_pyramid.cl" },
+     { "gaussian5x1_sub_y", "gaussian_pyramid.cl" },
+     { "gemm_accumulate_biases", "gemm.cl" },
+@@ -313,6 +322,9 @@ const std::map<std::string, std::string> CLKernelLibrary::_kernel_program_map =
+     { "permute_3201", "permute.cl" },
+     { "pixelwise_mul_float", "pixelwise_mul_float.cl" },
+     { "pixelwise_mul_int", "pixelwise_mul_int.cl" },
++    { "pixelwise_mul_qasymm8", "pixelwise_mul_quantized.cl" },
++    { "pixelwise_div_float", "pixelwise_div_float.cl" },
++    { "pixelwise_div_int", "pixelwise_div_int.cl" },
+     { "pooling_layer_2", "pooling_layer.cl" },
+     { "pooling_layer_3", "pooling_layer.cl" },
+     { "pooling_layer_optimized_3", "pooling_layer.cl" },
+@@ -322,7 +334,9 @@ const std::map<std::string, std::string> CLKernelLibrary::_kernel_program_map =
+     { "pooling_layer_MxN_quantized_nhwc", "pooling_layer_quantized.cl" },
+     { "pooling_layer_MxN_quantized_nchw", "pooling_layer_quantized.cl" },
+     { "quantization_layer", "quantization_layer.cl" },
++    { "reduce_max", "reduce_max.cl"},
+     { "reduction_operation", "reduction_operation.cl" },
++    { "reduction_mean", "reduction_mean.cl" },
+     { "remap_nearest_neighbour", "remap.cl" },
+     { "remap_bilinear", "remap.cl" },
+     { "reshape_layer", "reshape_layer.cl" },
+@@ -350,6 +364,7 @@ const std::map<std::string, std::string> CLKernelLibrary::_kernel_program_map =
+     { "softmax_layer_max_shift_exp_sum_quantized_parallel", "softmax_layer_quantized.cl" },
+     { "softmax_layer_max_shift_exp_sum_serial", "softmax_layer.cl" },
+     { "softmax_layer_max_shift_exp_sum_parallel", "softmax_layer.cl" },
++    { "strided_slice", "strided_slice.cl" },
+     { "suppress_non_maximum", "canny.cl" },
+     { "tablelookup_U8", "tablelookup.cl" },
+     { "tablelookup_S16", "tablelookup.cl" },
+@@ -378,6 +393,15 @@ const std::map<std::string, std::string> CLKernelLibrary::_kernel_program_map =
+     { "YUYV422_to_NV12_bt709", "color_convert.cl" },
+     { "YUYV422_to_RGB888_bt709", "color_convert.cl" },
+     { "YUYV422_to_RGBA8888_bt709", "color_convert.cl" },
++    { "topkv2_init", "topkv2.cl" },
++    { "topkv2_find_first_negative", "topkv2.cl" },
++    { "topkv2_reorder_negatives", "topkv2.cl" },
++    { "topkv2_store", "topkv2.cl" },
++    { "radixsort_histogram", "topkv2_radixsort.cl" },
++    { "radixsort_scanhistograms", "topkv2_radixsort.cl" },
++    { "radixsort_pastehistograms", "topkv2_radixsort.cl" },
++    { "radixsort_reorder", "topkv2_radixsort.cl" },
++    { "topkv2_quicksort", "topkv2_quicksort.cl" },
+ };
+ 
+ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+@@ -404,6 +428,10 @@ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+ #include "./cl_kernels/arithmetic_op.clembed"
+     },
+     {
++        "arithmetic_op_quantized.cl",
++#include "./cl_kernels/arithmetic_op_quantized.clembed"
++    },
++    {
+         "bitwise_op.cl",
+ #include "./cl_kernels/bitwise_op.clembed"
+     },
+@@ -412,6 +440,10 @@ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+ #include "./cl_kernels/canny.clembed"
+     },
+     {
++        "cast.cl",
++#include "./cl_kernels/cast.clembed"
++    },
++    {
+         "channel_combine.cl",
+ #include "./cl_kernels/channel_combine.clembed"
+     },
+@@ -532,6 +564,10 @@ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+ #include "./cl_kernels/floor.clembed"
+     },
+     {
++        "gather.cl",
++#include "./cl_kernels/gather.clembed"
++    },
++    {
+         "gaussian_pyramid.cl",
+ #include "./cl_kernels/gaussian_pyramid.clembed"
+     },
+@@ -636,6 +672,18 @@ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+ #include "./cl_kernels/pixelwise_mul_int.clembed"
+     },
+     {
++        "pixelwise_mul_quantized.cl",
++#include "./cl_kernels/pixelwise_mul_quantized.clembed"
++    },
++    {
++        "pixelwise_div_float.cl",
++#include "./cl_kernels/pixelwise_div_float.clembed"
++    },
++    {
++        "pixelwise_div_int.cl",
++#include "./cl_kernels/pixelwise_div_int.clembed"
++    },
++    {
+         "pooling_layer.cl",
+ #include "./cl_kernels/pooling_layer.clembed"
+     },
+@@ -648,10 +696,18 @@ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+ #include "./cl_kernels/quantization_layer.clembed"
+     },
+     {
++        "reduce_max.cl",
++#include "./cl_kernels/reduce_max.clembed"
++    },
++    {
+         "reduction_operation.cl",
+ #include "./cl_kernels/reduction_operation.clembed"
+     },
+     {
++        "reduction_mean.cl",
++#include "./cl_kernels/reduction_mean.clembed"
++    },
++    {
+         "remap.cl",
+ #include "./cl_kernels/remap.clembed"
+     },
+@@ -684,6 +740,10 @@ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+ #include "./cl_kernels/softmax_layer_quantized.clembed"
+     },
+     {
++        "strided_slice.cl",
++#include "./cl_kernels/strided_slice.clembed"
++    },
++    {
+         "tablelookup.cl",
+ #include "./cl_kernels/tablelookup.clembed"
+     },
+@@ -715,6 +775,18 @@ const std::map<std::string, std::string> CLKernelLibrary::_program_source_map =
+         "winograd.cl",
+ #include "./cl_kernels/winograd.clembed"
+     },
++    {
++        "topkv2.cl",
++#include "./cl_kernels/topkv2.clembed"
++    },
++    {
++        "topkv2_radixsort.cl",
++#include "./cl_kernels/topkv2_radixsort.clembed"
++    },
++    {
++        "topkv2_quicksort.cl",
++#include "./cl_kernels/topkv2_quicksort.clembed"
++    },
+ #endif /* EMBEDDED_KERNELS */
+ };
+ 
+diff --git a/src/core/CL/cl_kernels/activation_layer_qa8.cl b/src/core/CL/cl_kernels/activation_layer_qa8.cl
+index 66e54ed..5540932 100644
+--- a/src/core/CL/cl_kernels/activation_layer_qa8.cl
++++ b/src/core/CL/cl_kernels/activation_layer_qa8.cl
+@@ -21,10 +21,17 @@
+  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  * SOFTWARE.
+  */
+-#include "helpers.h"
++#include "helpers_asymm.h"
+ 
+ #define TYPE VEC_DATA_TYPE(DATA_TYPE, VEC_SIZE)
+ 
++// Logistic Activation
++inline TYPE logistic_op(TYPE x)
++{
++    // This function is a temporary function that is not actually executed.
++    // To keep the existing structure, it is added.
++    return x;
++}
+ // RELU Activation
+ inline TYPE relu_op(TYPE x)
+ {
+@@ -119,4 +126,100 @@ __kernel void activation_layer_qa8(
+     (data, 0, (__global DATA_TYPE *)output.ptr);
+ }
+ 
+-#endif /* defined(ACT) */
+\ No newline at end of file
++#endif /* defined(ACT) */
++
++/** This performs a logistic activation function on QASYMM8 inputs.
++ *
++ * @note In order to perform the logistic activation function "in-place", the pre-processor -DIN_PLACE must be passed at compile time
++ *
++ * @note Datatype should be given as a preprocessor argument using -DDATA_TYPE=type. e.g. -DDATA_TYPE=short
++ * @note Vector size should be given as a preprocessor argument using -DVEC_SIZE=size. e.g. -DVEC_SIZE=16
++ * @note Quantization scales of the input/output tensors are passed in with -DS1_VAL= and -DS2_VAL= respectively.
++ * @note Quantization offsets of the input/output tensors are passed in with -DO1_VAL= and -DO2_VAL= respectively.
++ * @note Quantized value of constant zero should be given as a preprocessor argument using -DCONST_0=value. e.g. -DCONST_0=128.
++ * @note Quantized can be optionally passed at compile time using -DINPUT_MULTIPLIER and -DINPUT_LEFT_SHIFT (if undefined, assume that the original data is used and not scaled separately.
++ * @note Number of integer bits should be given as a preprocessor argument using -DINPUT_INTEGER_BITS=value. e.g. -DINPUT_INTEGER_BITS=4.
++ * @note Number of input range radius should be given at compile time using -DINPUT_RANGE_RADIUS.
++ *
++ * @param[in]  input_ptr                            Pointer to the source image. Supported data types: QASYMM8
++ * @param[in]  input_stride_x                       Stride of the source image in X dimension (in bytes)
++ * @param[in]  input_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input_stride_y                       Stride of the source image in Y dimension (in bytes)
++ * @param[in]  input_step_y                         input_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  input_stride_z                       Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  input_step_z                         input_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  input_offset_first_element_in_bytes  The offset of the first element in the source image
++ * @param[out] output_ptr                           Pointer to the destination image. Supported data types: same as @p input_ptr
++ * @param[in]  output_stride_x                      Stride of the destination image in X dimension (in bytes)
++ * @param[in]  output_step_x                        output_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  output_stride_y                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  output_step_y                        output_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  output_stride_z                      Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  output_step_z                        output_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  output_offset_first_element_in_bytes The offset of the first element in the destination image
++ */
++__kernel void activation_layer_logistic_qa8(
++    TENSOR3D_DECLARATION(input)
++#ifndef IN_PLACE
++    ,
++    TENSOR3D_DECLARATION(output)
++#endif /* not IN_PLACE */
++)
++{
++    // Get pixels pointer
++    Tensor3D input = CONVERT_TO_TENSOR3D_STRUCT(input);
++#ifdef IN_PLACE
++    Tensor3D output = input;
++#else  /* IN_PLACE */
++    Tensor3D output = CONVERT_TO_TENSOR3D_STRUCT(output);
++#endif /* IN_PLACE */
++
++    // Load data
++    VEC_DATA_TYPE(int, 16)
++    data = CONVERT(VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)input.ptr), VEC_DATA_TYPE(int, 16));
++
++    VEC_DATA_TYPE(int, 16)
++    result = data;
++
++#if defined(INPUT_INTEGER_BITS) && defined(INPUT_RANGE_RADIUS)
++    const VEC_DATA_TYPE(int, 16) Q0_one      = INT_MAX;
++    const VEC_DATA_TYPE(int, 16) Q0_one_half = (1 << 30);
++
++    VEC_DATA_TYPE(int, 16)
++    input_val_centered = data;
++#ifdef O1_VAL
++    input_val_centered = data - O1_VAL;
++#endif /* O1_VAL */
++
++    VEC_DATA_TYPE(int, 16) result_left  = ASYMM_SELECT_USING_MASK(input_val_centered <= -INPUT_RANGE_RADIUS, 1, 0, 16);
++    VEC_DATA_TYPE(int, 16) result_right = ASYMM_SELECT_USING_MASK(input_val_centered >= INPUT_RANGE_RADIUS, 255, 0, 16);
++
++    VEC_DATA_TYPE(int, 16) input_mask         = ASYMM_SELECT_USING_MASK(input_val_centered > -INPUT_RANGE_RADIUS && input_val_centered < INPUT_RANGE_RADIUS, 1, 0, 16);
++    VEC_DATA_TYPE(int, 16) input_val_rescaled = input_val_centered * input_mask;
++#if defined(INPUT_MULTIPLIER) && defined(INPUT_LEFT_SHIFT)
++    if(INPUT_MULTIPLIER > 1)
++    {
++        input_val_rescaled   = ASYMM_MULT(input_val_rescaled * (1 << INPUT_LEFT_SHIFT), INPUT_MULTIPLIER, 16);
++    }
++#endif /* defined(INPUT_MULTIPLIER) && defined(INPUT_LEFT_SHIFT) */
++
++    VEC_DATA_TYPE(int, 16) mask_if_positive   = ASYMM_MASK_IF_NON_ZERO(input_val_rescaled > CONST_0, 16);
++    VEC_DATA_TYPE(int, 16) mask_if_zero       = ASYMM_MASK_IF_NON_ZERO(!input_val_rescaled, 16);
++    VEC_DATA_TYPE(int, 16) abs_input          = ASYMM_SELECT_USING_MASK(mask_if_positive, input_val_rescaled, -input_val_rescaled, 16);
++    VEC_DATA_TYPE(int, 16) result_exp         = ASYMM_EXP_ON_NEGATIVE_VALUES(-abs_input, INPUT_INTEGER_BITS, 16);
++    VEC_DATA_TYPE(int, 16) result_if_positive = ASYMM_ONE_OVER_ONE_PLUS_X_FOR_X_IN_0_1(result_exp, 16);
++    VEC_DATA_TYPE(int, 16) result_if_negative = Q0_one - result_if_positive;
++    VEC_DATA_TYPE(int, 16) result_logistic    = ASYMM_SELECT_USING_MASK(mask_if_zero, Q0_one_half, ASYMM_SELECT_USING_MASK(mask_if_positive, result_if_positive, result_if_negative, 16), 16);
++
++    result_logistic = ASYMM_ROUNDING_DIVIDE_BY_POW2(result_logistic, 23, 16);
++    result_logistic = ASYMM_SELECT_USING_MASK(result_logistic == 256, 255, result_logistic, 16);
++    result_logistic = result_logistic * input_mask;
++
++    result = result_left + result_right + result_logistic;
++#endif /* defined(INPUT_INTEGER_BITS) && defined(INPUT_RANGE_RADIUS) */
++
++    // Store result
++    TYPE tmp = CONVERT(result, TYPE);
++    VSTORE(VEC_SIZE)
++    (tmp, 0, (__global DATA_TYPE *)output.ptr);
++}
+diff --git a/src/core/CL/cl_kernels/arithmetic_op_quantized.cl b/src/core/CL/cl_kernels/arithmetic_op_quantized.cl
+new file mode 100644
+index 0000000..0c0a9ed
+--- /dev/null
++++ b/src/core/CL/cl_kernels/arithmetic_op_quantized.cl
+@@ -0,0 +1,138 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016, 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers_asymm.h"
++
++#if defined(FIXED_POINT_POSITION)
++#include "fixed_point.h"
++#endif /* FIXED_POINT_POSITION */
++
++#ifdef SATURATE
++#define ADD(x, y) add_sat((x), (y))
++#define SUB(x, y) sub_sat((x), (y))
++#else /* SATURATE */
++#define ADD(x, y) (x) + (y)
++#define SUB(x, y) (x) - (y)
++#endif /* SATURATE */
++
++/** Performs a pixelwise addition used to quantize down the int32 accumulator values of GEMMLowp to QASYMM8
++ *
++ * The following computations will be performed:
++ *
++ *  -# Add offset terms to inputs
++    -# Get scaled value of two inputs
++ *  -# Add inputs
++ *  -# Add offset terms to final result
++ *  -# Multiply each entry of result by result_mult_int
++ *  -# Shift the int32 accumulator by result_shift
++ *  -# Clamp the resulting int32 values to the [0..255] range and cast to QASYMM8.
++ *
++ * @attention The inputs and output data types need to be passed at compile time using -DDATA_TYPE_IN1, -DDATA_TYPE_IN2 and -DDATA_TYPE_OUT:
++ * e.g. -DDATA_TYPE_IN1=uchar -DDATA_TYPE_IN2=uchar -DDATA_TYPE_OUT=uchar
++ * @attention The number of bits to shift left of input tensors must be passed at compile time using -DLEFT_SHIFT
++ * @attention The offset, scalar scale factor and number of bits to shift right of input tensors must be passed at compile time using -DIN1_OFFSET, -RIN1_MULT_INT, -DIN1_SHIFT, -DIN2_OFFSET, -RIN2_MULT_INT and -DIN2_SHIFT
++ * @attention The offset, scalar scale factor and number of bits to shift right of output tensor must be passed at compile time using -DRESULT_OFFSET, -RESULT_MULT_INT and -DRESULT_SHIFT
++ *
++ * @attention The input and output data_types need to be passed at compile time using -DDATA_TYPE_IN1, -DDATA_TYPE_IN2 and -DDATA_TYPE_OUT:
++ * e.g. -DDATA_TYPE_IN1=uchar -DDATA_TYPE_IN2=uchar -DDATA_TYPE_OUT=uchar
++ * @attention The inputs and output scale information of qasymm8 need to be passed at compile time using -DSCALE_IN1, -DSCALE_IN2 and -DSCALE_OUT:
++ * e.g. -DSCALE_IN1=1.f -DSCALE_IN2=1.f -DSCALE_OUT=2.f
++ * @attention The inputs and output scale offset need to be passed at compile time using -DOFFSET_IN1, -DOFFSET_IN2 and -DOFFSET_OUT:
++ * e.g. -DOFFSET_IN1=0 -DOFFSET_IN2=0 -DOFFSET_OUT=0
++ * @attention Vector size should be given as a preprocessor argument using -DVEC_SIZE=size. e.g. -DVEC_SIZE=16
++ * @attention To perform saturating operation -DSATURATE has to be passed to the compiler otherwise wrapping policy will be used.
++ *
++ * @param[in]  in1_ptr                           Pointer to the source tensor. Supported data types: QASYMM8
++ * @param[in]  in1_stride_x                      Stride of the source tensor in X dimension (in bytes)
++ * @param[in]  in1_step_x                        in1_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in1_stride_y                      Stride of the source tensor in Y dimension (in bytes)
++ * @param[in]  in1_step_y                        in1_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in1_stride_z                      Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  in1_step_z                        in1_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  in1_offset_first_element_in_bytes The offset of the first element in the source tensor
++ * @param[in]  in2_ptr                           Pointer to the source tensor. Supported data types: QASYMM8
++ * @param[in]  in2_stride_x                      Stride of the source tensor in X dimension (in bytes)
++ * @param[in]  in2_step_x                        in2_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in2_stride_y                      Stride of the source tensor in Y dimension (in bytes)
++ * @param[in]  in2_step_y                        in2_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in2_stride_z                      Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  in2_step_z                        in2_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  in2_offset_first_element_in_bytes The offset of the first element in the source tensor
++ * @param[out] out_ptr                           Pointer to the destination tensor. Supported data types: QASYMM8
++ * @param[in]  out_stride_x                      Stride of the destination tensor in X dimension (in bytes)
++ * @param[in]  out_step_x                        out_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  out_stride_y                      Stride of the destination tensor in Y dimension (in bytes)
++ * @param[in]  out_step_y                        out_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  out_stride_z                      Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  out_step_z                        out_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  out_offset_first_element_in_bytes The offset of the first element in the destination tensor
++ */
++__kernel void arithmetic_add_qasymm8(
++    TENSOR3D_DECLARATION(in1),
++    TENSOR3D_DECLARATION(in2),
++    TENSOR3D_DECLARATION(out))
++{
++    // Get pixels pointer
++    Tensor3D in1 = CONVERT_TO_TENSOR3D_STRUCT(in1);
++    Tensor3D in2 = CONVERT_TO_TENSOR3D_STRUCT(in2);
++    Tensor3D out = CONVERT_TO_TENSOR3D_STRUCT(out);
++
++    // Load data
++    VEC_DATA_TYPE(int, 16)
++    in1_data = CONVERT(vload16(0, (__global DATA_TYPE_IN1 *)in1.ptr), VEC_DATA_TYPE(int, 16));
++    VEC_DATA_TYPE(int, 16)
++    in2_data = CONVERT(vload16(0, (__global DATA_TYPE_IN2 *)in2.ptr), VEC_DATA_TYPE(int, 16));
++
++    // Get scaled value of two inputs
++    VEC_DATA_TYPE(int, 16) in1_val = in1_data + (VEC_DATA_TYPE(int, 16))(IN1_OFFSET);
++    VEC_DATA_TYPE(int, 16) in2_val = in2_data + (VEC_DATA_TYPE(int, 16))(IN2_OFFSET);
++
++    VEC_DATA_TYPE(int, 16) left_shift = (VEC_DATA_TYPE(int, 16))1 << (VEC_DATA_TYPE(int, 16))(LEFT_SHIFT);
++    VEC_DATA_TYPE(int, 16) shifted_in1_val = in1_val * left_shift;
++    VEC_DATA_TYPE(int, 16) shifted_in2_val = in2_val * left_shift;
++
++    VEC_DATA_TYPE(int, 16) scaled_in1_val = ASYMM_MULT_BY_QUANT_MULTIPLIER_LESS_THAN_ONE(shifted_in1_val, IN1_MULT_INT, IN1_SHIFT, 16);
++    VEC_DATA_TYPE(int, 16) scaled_in2_val = ASYMM_MULT_BY_QUANT_MULTIPLIER_LESS_THAN_ONE(shifted_in2_val, IN2_MULT_INT, IN2_SHIFT, 16);
++
++    // Add inputs and multiply with a multiplier smaller than 1
++    VEC_DATA_TYPE(int, 16) sum_val = scaled_in1_val + scaled_in2_val;
++    VEC_DATA_TYPE(int, 16) out_val = ASYMM_MULT_BY_QUANT_MULTIPLIER_LESS_THAN_ONE(sum_val, RESULT_MULT_INT, RESULT_SHIFT, 16);
++    out_val += (VEC_DATA_TYPE(int, 16))(RESULT_OFFSET);
++
++    VEC_DATA_TYPE(uchar, 16) res = CONVERT(out_val, VEC_DATA_TYPE(uchar, 16));
++
++// TODO: Apply min-max BOUND to support fuse with relu.
++/*
++#if defined(MIN_BOUND)
++    res = max(res, (uchar16)MIN_BOUND);
++#endif // defined(MIN_BOUND)
++#if defined(MAX_BOUND)
++    res = min(res, (uchar16)MAX_BOUND);
++#endif // defined(MAX_BOUND)
++*/
++
++    // Store result
++    VSTORE(16)(CONVERT(res, VEC_DATA_TYPE(DATA_TYPE_OUT, 16)),
++                     0, (__global DATA_TYPE_OUT *)out.ptr);
++}
+diff --git a/src/core/CL/cl_kernels/cast.cl b/src/core/CL/cl_kernels/cast.cl
+new file mode 100644
+index 0000000..113804c
+--- /dev/null
++++ b/src/core/CL/cl_kernels/cast.cl
+@@ -0,0 +1,148 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers.h"
++
++#ifndef SCALE_IN
++#define SCALE_IN    1.0f
++#endif
++#ifndef OFFSET_IN
++#define OFFSET_IN   0
++#endif
++
++/** Perform a cast operation on an input tensor.
++ *
++ * @attention Data type can be passed using the -DDATA_TYPE_IN compile flag, e.g. -DDATA_TYPE_IN=float
++ * @attention Vector size should be given as a preprocessor argument using -DVEC_SIZE=size. e.g. -DVEC_SIZE=16
++ *
++ * @param[in]  input_ptr                            Pointer to the source image. Supported data types: F16/F32
++ * @param[in]  input_stride_x                       Stride of the source image in X dimension (in bytes)
++ * @param[in]  input_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input_stride_y                       Stride of the source image in Y dimension (in bytes)
++ * @param[in]  input_step_y                         input_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  input_stride_z                       Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  input_step_z                         input_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  input_offset_first_element_in_bytes  The offset of the first element in the source image
++ * @param[out] output_ptr                           Pointer to the destination image. Supported data types: same as @p input_ptr
++ * @param[in]  output_stride_x                      Stride of the destination image in X dimension (in bytes)
++ * @param[in]  output_step_x                        output_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  output_stride_y                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  output_step_y                        output_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  output_stride_z                      Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  output_step_z                        output_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  output_offset_first_element_in_bytes The offset of the first element in the destination image
++ */
++__kernel void cast(
++    TENSOR3D_DECLARATION(input),
++    TENSOR3D_DECLARATION(output))
++{
++    Tensor3D input  = CONVERT_TO_TENSOR3D_STRUCT(input);
++    Tensor3D output = CONVERT_TO_TENSOR3D_STRUCT(output);
++
++    VSTORE(VEC_SIZE)(CONVERT(VLOAD(VEC_SIZE)(0, (__global DATA_TYPE_IN *)input.ptr),
++                             VEC_DATA_TYPE(DATA_TYPE_OUT, VEC_SIZE)),
++                     0, (__global DATA_TYPE_OUT *)output.ptr);
++}
++
++
++/** Perform a cast operation on an QASYMM8 input tensor.
++ *
++ * @attention Vector size should be given as a preprocessor argument using -DVEC_SIZE=size. e.g. -DVEC_SIZE=16
++ *
++ * @param[in]  input_ptr                            Pointer to the source image. Supported data types: F16/F32
++ * @param[in]  input_stride_x                       Stride of the source image in X dimension (in bytes)
++ * @param[in]  input_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input_stride_y                       Stride of the source image in Y dimension (in bytes)
++ * @param[in]  input_step_y                         input_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  input_stride_z                       Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  input_step_z                         input_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  input_offset_first_element_in_bytes  The offset of the first element in the source image
++ * @param[out] output_ptr                           Pointer to the destination image. Supported data types: same as @p input_ptr
++ * @param[in]  output_stride_x                      Stride of the destination image in X dimension (in bytes)
++ * @param[in]  output_step_x                        output_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  output_stride_y                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  output_step_y                        output_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  output_stride_z                      Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  output_step_z                        output_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  output_offset_first_element_in_bytes The offset of the first element in the destination image
++ */
++__kernel void cast_qasymm_in(
++    TENSOR3D_DECLARATION(input),
++    TENSOR3D_DECLARATION(output))
++{
++    Tensor3D input  = CONVERT_TO_TENSOR3D_STRUCT(input);
++    Tensor3D output = CONVERT_TO_TENSOR3D_STRUCT(output);
++
++    VEC_DATA_TYPE(DATA_TYPE_IN, VEC_SIZE) in_data =
++        VLOAD(VEC_SIZE)(0, (__global DATA_TYPE_IN *)input.ptr);
++    VEC_DATA_TYPE(int, VEC_SIZE) offset = (VEC_DATA_TYPE(int, VEC_SIZE))(OFFSET_IN);
++    VEC_DATA_TYPE(float, VEC_SIZE) scale = (VEC_DATA_TYPE(float, VEC_SIZE))(SCALE_IN);
++
++    VEC_DATA_TYPE(int, VEC_SIZE) tmp = CONVERT(in_data, VEC_DATA_TYPE(int, VEC_SIZE)) - offset;
++    VEC_DATA_TYPE(float, VEC_SIZE) out_data = CONVERT(tmp, VEC_DATA_TYPE(float, VEC_SIZE)) * scale;
++
++    VSTORE(VEC_SIZE)(CONVERT(out_data, VEC_DATA_TYPE(DATA_TYPE_OUT, VEC_SIZE)),
++                     0, (__global DATA_TYPE_OUT *)output.ptr);
++}
++
++
++/** Perform a cast operation on an QASYMM8 output tensor.
++ *
++ * @attention Vector size should be given as a preprocessor argument using -DVEC_SIZE=size. e.g. -DVEC_SIZE=16
++ *
++ * @param[in]  input_ptr                            Pointer to the source image. Supported data types: F16/F32
++ * @param[in]  input_stride_x                       Stride of the source image in X dimension (in bytes)
++ * @param[in]  input_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input_stride_y                       Stride of the source image in Y dimension (in bytes)
++ * @param[in]  input_step_y                         input_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  input_stride_z                       Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  input_step_z                         input_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  input_offset_first_element_in_bytes  The offset of the first element in the source image
++ * @param[out] output_ptr                           Pointer to the destination image. Supported data types: U8
++ * @param[in]  output_stride_x                      Stride of the destination image in X dimension (in bytes)
++ * @param[in]  output_step_x                        output_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  output_stride_y                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  output_step_y                        output_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  output_stride_z                      Stride of the source tensor in Z dimension (in bytes)
++ * @param[in]  output_step_z                        output_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  output_offset_first_element_in_bytes The offset of the first element in the destination image
++ */
++__kernel void cast_qasymm_out(
++    TENSOR3D_DECLARATION(input),
++    TENSOR3D_DECLARATION(output))
++{
++    Tensor3D input  = CONVERT_TO_TENSOR3D_STRUCT(input);
++    Tensor3D output = CONVERT_TO_TENSOR3D_STRUCT(output);
++
++    VEC_DATA_TYPE(DATA_TYPE_IN, VEC_SIZE) in_data =
++        VLOAD(VEC_SIZE)(0, (__global DATA_TYPE_IN *)input.ptr);
++    VEC_DATA_TYPE(int, VEC_SIZE) offset = (VEC_DATA_TYPE(int, VEC_SIZE))(OFFSET_IN);
++    VEC_DATA_TYPE(float, VEC_SIZE) scale = (VEC_DATA_TYPE(float, VEC_SIZE))(SCALE_IN);
++
++    VEC_DATA_TYPE(float, VEC_SIZE) tmp = CONVERT(in_data, VEC_DATA_TYPE(float, VEC_SIZE)) / scale;
++    VEC_DATA_TYPE(float, VEC_SIZE) out_data = tmp + CONVERT(offset, VEC_DATA_TYPE(float, VEC_SIZE));
++
++    VSTORE(VEC_SIZE)(CONVERT(out_data, VEC_DATA_TYPE(DATA_TYPE_OUT, VEC_SIZE)),
++                     0, (__global DATA_TYPE_OUT *)output.ptr);
++}
+diff --git a/src/core/CL/cl_kernels/fixed_point.h b/src/core/CL/cl_kernels/fixed_point.h
+index 46fa645..e2f376b 100644
+--- a/src/core/CL/cl_kernels/fixed_point.h
++++ b/src/core/CL/cl_kernels/fixed_point.h
+@@ -1,4 +1,5 @@
+ /*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+  * Copyright (c) 2017-2018 ARM Limited.
+  *
+  * SPDX-License-Identifier: MIT
+@@ -298,6 +299,29 @@ MLALQ_SAT_IMPL(qs16x8, qs32x8)
+ #define MLAL_SAT_OP_EXPAND_STR(a, b, c, type, size, position) mlal_sat_##type##x##size((a), (b), (c), (position))
+ #define MLAL_SAT_OP_EXPAND(a, b, c, type, size, position) MLAL_SAT_OP_EXPAND_STR(a, b, c, type, size, position)
+ 
++/* Division of two fixed point numbers
++ *
++ * @param[in] type  the actual data type.
++ * @param[in] itype the intermediate data type.
++ *
++ * @return The result of the fixed point division.
++ */
++#define DIVQ_IMPL(type, itype)                                                         \
++    inline type div_##type(type VopA, type VopB, int fixed_point_position)             \
++    {                                                                                  \
++        itype round_val = (itype)(1 << (fixed_point_position - 1));                    \
++        itype res       = CONVERT((VopA), itype) / CONVERT((VopB), itype) + round_val; \
++        return CONVERT((res >> (itype)fixed_point_position), type);                    \
++    }
++
++DIVQ_IMPL(qs8x8, qs16x8)
++DIVQ_IMPL(qs16x8, qs32x8)
++DIVQ_IMPL(qs8x16, qs16x16)
++DIVQ_IMPL(qs16x16, qs32x16)
++
++#define DIV_OP_EXPAND_STR(a, b, type, size, position) div_##type##x##size((a), (b), (position))
++#define DIV_OP_EXPAND(a, b, type, size, position) DIV_OP_EXPAND_STR(a, b, type, size, position)
++
+ /** Saturate division of two fixed point vectors
+  *
+  * @param[in] stype the actual scalar data type.
+diff --git a/src/core/CL/cl_kernels/gather.cl b/src/core/CL/cl_kernels/gather.cl
+new file mode 100644
+index 0000000..25e20f5
+--- /dev/null
++++ b/src/core/CL/cl_kernels/gather.cl
+@@ -0,0 +1,106 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers.h"
++
++/** Perform gather
++ *
++ * @note Datatype should be given as a preprocessor argument using -DDATA_TYPE=type. e.g. -DDATA_TYPE=short
++ *
++ * @param[in]  input1_ptr                            Pointer to the first source tensor. Supported data types: U8/S32/F32
++ * @param[in]  input1_stride_x                       Stride of the first source tensor in X dimension (in bytes)
++ * @param[in]  input1_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input1_stride_y                       Stride of the first source tensor in Y dimension (in bytes)
++ * @param[in]  input1_step_y                         input_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  input1_stride_z                       Stride of the first source tensor in Z dimension (in bytes)
++ * @param[in]  input1_step_z                         input_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  input1_offset_first_element_in_bytes  The offset of the first element in the first source tensor
++ * @param[in]  input2_ptr                            Pointer to the first source tensor. Supported data types: U32
++ * @param[in]  input2_stride_x                       Stride of the first source tensor in X dimension (in bytes)
++ * @param[in]  input2_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input2_offset_first_element_in_bytes  The offset of the first element in the first source tensor
++ * @param[out] output_ptr                           Pointer to the destination tensor. Supported data types: same as @p input_ptr
++ * @param[in]  output_stride_x                      Stride of the destination tensor in X dimension (in bytes)
++ * @param[in]  output_step_x                        output_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  output_stride_y                      Stride of the destination tensor in Y dimension (in bytes)
++ * @param[in]  output_step_y                        output_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  output_stride_z                      Stride of the destination tensor in Z dimension (in bytes)
++ * @param[in]  output_step_z                        output_stride_z * number of elements along Z processed per workitem(in bytes)
++ * @param[in]  output_offset_first_element_in_bytes The offset of the first element in the destination tensor
++ */
++__kernel void gather(IMAGE_DECLARATION(input1),
++                    VECTOR_DECLARATION(input2),
++                    IMAGE_DECLARATION(output))
++{
++    Image in1  = CONVERT_TO_IMAGE_STRUCT_NO_STEP(input1);
++    Vector in2  = CONVERT_TO_VECTOR_STRUCT(input2);
++    Image out = CONVERT_TO_IMAGE_STRUCT_NO_STEP(output);
++
++    VEC_DATA_TYPE(DATA_TYPE_IN2, 2)
++    in2_data = CONVERT(vload2(0, (__global DATA_TYPE_IN2 *)in2.ptr), VEC_DATA_TYPE(DATA_TYPE_IN2, 2));
++
++    //TODO: performance tuning for memcopy
++    int index = in2_data.s0;
++    int stride=input1_stride_y/input1_stride_x;
++
++    for(int i=0; i<stride; i++){
++        *((__global DATA_TYPE_OUT *)offset(&out, i,get_global_id(0)))=*((__global DATA_TYPE_IN1 *)offset(&in1, i,index));
++    }
++}
++
++__kernel void gather_1d_out(IMAGE_DECLARATION(input1),
++                    VECTOR_DECLARATION(input2),
++                    VECTOR_DECLARATION(output))
++{
++    Image in1  = CONVERT_TO_IMAGE_STRUCT_NO_STEP(input1);
++    Vector in2  = CONVERT_TO_VECTOR_STRUCT(input2);
++    Vector out = CONVERT_TO_VECTOR_STRUCT_NO_STEP(output);
++
++    VEC_DATA_TYPE(DATA_TYPE_IN2, 2)
++    in2_data = CONVERT(vload2(0, (__global DATA_TYPE_IN2 *)in2.ptr), VEC_DATA_TYPE(DATA_TYPE_IN2, 2));
++
++    //TODO: performance tuning for memcopy
++    int index = in2_data.s0;
++    int stride=input1_stride_y/input1_stride_x;
++
++    for(int i=0; i<stride; i++){
++        *((__global DATA_TYPE_OUT *)vector_offset(&out, i+get_global_id(0)))=*((__global DATA_TYPE_IN1 *)offset(&in1, i, index));
++    }
++}
++
++__kernel void gather_1d(VECTOR_DECLARATION(input1),
++                    VECTOR_DECLARATION(input2),
++                    VECTOR_DECLARATION(output))
++{
++    Vector in1  = CONVERT_TO_VECTOR_STRUCT_NO_STEP(input1);
++    Vector in2  = CONVERT_TO_VECTOR_STRUCT(input2);
++    Vector out = CONVERT_TO_VECTOR_STRUCT_NO_STEP(output);
++
++    VEC_DATA_TYPE(DATA_TYPE_IN2, 2)
++    in2_data = CONVERT(vload2(0, (__global DATA_TYPE_IN2 *)in2.ptr), VEC_DATA_TYPE(DATA_TYPE_IN2, 2));
++
++    //TODO: performance tuning for memcopy
++    int index = in2_data.s0;
++    *((__global DATA_TYPE_OUT *)vector_offset(&out, get_global_id(0)))=*((__global DATA_TYPE_IN1 *)vector_offset(&in1, index));
++}
+diff --git a/src/core/CL/cl_kernels/pixelwise_div_float.cl b/src/core/CL/cl_kernels/pixelwise_div_float.cl
+new file mode 100644
+index 0000000..512c620
+--- /dev/null
++++ b/src/core/CL/cl_kernels/pixelwise_div_float.cl
+@@ -0,0 +1,96 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016, 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers.h"
++
++#ifdef SATURATE
++#define CONVERT_OP_FLOAT_STR(x, type, round) (convert_##type##_sat##round(x))
++#else /* SATURATE */
++#define CONVERT_OP_FLOAT_STR(x, type, round) (convert_##type##round(x))
++#endif /* SATURATE */
++#define CONVERT_OP_FLOAT(x, type, round) CONVERT_OP_FLOAT_STR(x, type, round)
++
++/** Performs a pixelwise division with float scale of either integer or float inputs.
++ *
++ * @attention The inputs and output data types need to be passed at compile time using -DDATA_TYPE_IN1, -DDATA_TYPE_IN2 and -DDATA_TYPE_OUT:
++ * e.g. -DDATA_TYPE_IN1=uchar -DDATA_TYPE_IN2=ushort -DDATA_TYPE_OUT=short
++ * @attention The data type of the intermediate result of the division should passed as well using -DDATA_TYPE_RES.
++ * e.g. If one of inputs is S16 -DDATA_TYPE_RES=int should be passed else -DDATA_TYPE_RES=short.
++ * @attention -DDATA_TYPE_FLOAT must be passed if floating point inputs are provided.
++ *
++ * @param[in]  in1_ptr                           Pointer to the source image. Supported data types: U8, S16, F16, F32
++ * @param[in]  in1_stride_x                      Stride of the source image in X dimension (in bytes)
++ * @param[in]  in1_step_x                        in1_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in1_stride_y                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in1_step_y                        in1_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in1_stride_z                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in1_step_z                        in1_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in1_offset_first_element_in_bytes The offset of the first element in the source image
++ * @param[in]  in2_ptr                           Pointer to the source image. Supported data types: U8, S16, F16, F32
++ * @param[in]  in2_stride_x                      Stride of the source image in X dimension (in bytes)
++ * @param[in]  in2_step_x                        in2_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in2_stride_y                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in2_step_y                        in2_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in2_stride_z                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in2_step_z                        in2_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in2_offset_first_element_in_bytes The offset of the first element in the source image
++ * @param[out] out_ptr                           Pointer to the destination image. Supported data types: U8, S16, F16, F32
++ * @param[in]  out_stride_x                      Stride of the destination image in X dimension (in bytes)
++ * @param[in]  out_step_x                        out_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  out_stride_y                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  out_step_y                        out_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  out_stride_z                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  out_step_z                        out_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  out_offset_first_element_in_bytes The offset of the first element in the destination image
++ * @param[in]  scale                             Float scaling factor. Supported data types: F32
++ */
++__kernel void pixelwise_div_float(
++    TENSOR3D_DECLARATION(in1),
++    TENSOR3D_DECLARATION(in2),
++    TENSOR3D_DECLARATION(out),
++    const float scale)
++{
++    // Get pixels pointer
++    Tensor3D in1 = CONVERT_TO_TENSOR3D_STRUCT(in1);
++    Tensor3D in2 = CONVERT_TO_TENSOR3D_STRUCT(in2);
++    Tensor3D out = CONVERT_TO_TENSOR3D_STRUCT(out);
++
++    // Load data
++    VEC_DATA_TYPE(DATA_TYPE_RES, 16)
++    in1_data = CONVERT(vload16(0, (__global DATA_TYPE_IN1 *)in1.ptr), VEC_DATA_TYPE(DATA_TYPE_RES, 16));
++    VEC_DATA_TYPE(DATA_TYPE_RES, 16)
++    in2_data = CONVERT(vload16(0, (__global DATA_TYPE_IN2 *)in2.ptr), VEC_DATA_TYPE(DATA_TYPE_RES, 16));
++
++    // Perform division
++#ifdef DATA_TYPE_FLOAT
++    VEC_DATA_TYPE(DATA_TYPE_OUT, 16)
++    res = CONVERT(in1_data / in2_data * (DATA_TYPE_RES)scale, VEC_DATA_TYPE(DATA_TYPE_OUT, 16));
++#else  /* DATA_TYPE_FLOAT */
++    VEC_DATA_TYPE(DATA_TYPE_OUT, 16)
++    res = CONVERT_OP_FLOAT(CONVERT_OP_FLOAT((convert_float16(in1_data / in2_data) * scale), VEC_DATA_TYPE(DATA_TYPE_RES, 16), ROUND), VEC_DATA_TYPE(DATA_TYPE_OUT, 16), ROUND);
++#endif /* DATA_TYPE_FLOAT */
++
++    // Store result
++    vstore16(res, 0, (__global DATA_TYPE_OUT *)out.ptr);
++}
+diff --git a/src/core/CL/cl_kernels/pixelwise_div_int.cl b/src/core/CL/cl_kernels/pixelwise_div_int.cl
+new file mode 100644
+index 0000000..82edf3b
+--- /dev/null
++++ b/src/core/CL/cl_kernels/pixelwise_div_int.cl
+@@ -0,0 +1,103 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016, 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers.h"
++
++#if defined(FIXED_POINT_POSITION)
++
++#include "fixed_point.h"
++
++#if defined(SATURATE)
++#define DIV_OP(x, y, scale, type, size) DIV_SAT_OP_EXPAND((x), (y), type, size, FIXED_POINT_POSITION)
++#else // SATURATE
++#define DIV_OP(x, y, scale, type, size) DIV_OP_EXPAND((x), (y), type, size, FIXED_POINT_POSITION)
++#endif // SATURATE
++
++#else // FIXED_POINT_POSITION
++
++#if defined(SATURATE)
++#define CONVERT_OP_INT_STR(x, type, size) (convert_##type##size##_sat(x))
++#else // SATURATE
++#define CONVERT_OP_INT_STR(x, type, size) (convert_##type##size(x))
++#endif // SATURATE
++#define CONVERT_OP_INT(x, type, size) CONVERT_OP_INT_STR(x, type, size)
++
++#define DIV_OP(x, y, scale, type, size) CONVERT_OP_INT((x) / (y) >> scale, type, size)
++
++#endif // FIXED_POINT_POSITION
++
++/** Performs a pixelwise division with integer scale of integer inputs.
++ *
++ * @attention The inputs and output data types need to be passed at compile time using -DDATA_TYPE_IN1, -DDATA_TYPE_IN2 and -DDATA_TYPE_OUT:
++ * e.g. -DDATA_TYPE_IN1=uchar -DDATA_TYPE_IN2=ushort -DDATA_TYPE_OUT=short
++ * @attention The data_type of the intermediate result of the division should passed as well using -DDATA_TYPE_RES.
++ * e.g. If one of inputs is S16 -DDATA_TYPE_RES=int should be passed else -DDATA_TYPE_RES=short.
++ * @note In case of fixed-point operation -DFIXED_POINT_POSITION=fixed_point_position must be provided: e.g. -DFIXED_POINT_POSITION=3
++ *
++ * @param[in]  in1_ptr                           Pointer to the source image. Supported data types: U8/QS8/QS16/S16
++ * @param[in]  in1_stride_x                      Stride of the source image in X dimension (in bytes)
++ * @param[in]  in1_step_x                        in1_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in1_stride_y                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in1_step_y                        in1_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in1_stride_z                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in1_step_z                        in1_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in1_offset_first_element_in_bytes The offset of the first element in the source image
++ * @param[in]  in2_ptr                           Pointer to the source image. Supported data types: same as @p in1_ptr
++ * @param[in]  in2_stride_x                      Stride of the source image in X dimension (in bytes)
++ * @param[in]  in2_step_x                        in2_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in2_stride_y                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in2_step_y                        in2_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in2_stride_z                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in2_step_z                        in2_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in2_offset_first_element_in_bytes The offset of the first element in the source image
++ * @param[out] out_ptr                           Pointer to the destination image. Supported data types: same as @p in1_ptr
++ * @param[in]  out_stride_x                      Stride of the destination image in X dimension (in bytes)
++ * @param[in]  out_step_x                        out_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  out_stride_y                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  out_step_y                        out_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  out_stride_z                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  out_step_z                        out_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  out_offset_first_element_in_bytes The offset of the first element in the destination image
++ * @param[in]  scale                             Integer scaling factor. Supported data types: S32 (ignored for QS8 and QS16 as the assumption is scale = 1).
++ */
++__kernel void pixelwise_div_int(
++    TENSOR3D_DECLARATION(in1),
++    TENSOR3D_DECLARATION(in2),
++    TENSOR3D_DECLARATION(out),
++    const uint scale)
++{
++    // Get pixels pointer
++    Tensor3D in1 = CONVERT_TO_TENSOR3D_STRUCT(in1);
++    Tensor3D in2 = CONVERT_TO_TENSOR3D_STRUCT(in2);
++    Tensor3D out = CONVERT_TO_TENSOR3D_STRUCT(out);
++
++    // Load data
++    VEC_DATA_TYPE(DATA_TYPE_RES, 16)
++    in1_data = CONVERT(vload16(0, (__global DATA_TYPE_IN1 *)in1.ptr), VEC_DATA_TYPE(DATA_TYPE_RES, 16));
++    VEC_DATA_TYPE(DATA_TYPE_RES, 16)
++    in2_data = CONVERT(vload16(0, (__global DATA_TYPE_IN2 *)in2.ptr), VEC_DATA_TYPE(DATA_TYPE_RES, 16));
++
++    // Perform division and store result
++    vstore16(DIV_OP(in1_data, in2_data, scale, DATA_TYPE_OUT, 16), 0, (__global DATA_TYPE_OUT *)out.ptr);
++}
+diff --git a/src/core/CL/cl_kernels/pixelwise_mul_quantized.cl b/src/core/CL/cl_kernels/pixelwise_mul_quantized.cl
+new file mode 100644
+index 0000000..ddc9d5a
+--- /dev/null
++++ b/src/core/CL/cl_kernels/pixelwise_mul_quantized.cl
+@@ -0,0 +1,119 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016, 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers_asymm.h"
++
++#ifdef SATURATE
++#define CONVERT_OP_FLOAT_STR(x, type, round) (convert_##type##_sat##round(x))
++#else /* SATURATE */
++#define CONVERT_OP_FLOAT_STR(x, type, round) (convert_##type##round(x))
++#endif /* SATURATE */
++#define CONVERT_OP_FLOAT(x, type, round) CONVERT_OP_FLOAT_STR(x, type, round)
++
++#if defined(RESULT_OFFSET) && defined(RESULT_MULT_INT) && defined(RESULT_SHIFT)
++/** Performs a pixelwise multiplication used to quantize down the int32 accumulator values of GEMMLowp to QASYMM8
++ *
++ * The following computations will be performed by the kernel:
++ *
++ *  -# Add offset terms to inputs
++ *  -# Multiply inputs
++ *  -# Add offset terms to final result
++ *  -# Multiply each entry of result by result_mult_int
++ *  -# Shift the int32 accumulator by result_shift
++ *  -# Clamp the resulting int32 values to the [0..255] range and cast to QASYMM8.
++ *
++ * @attention The inputs and output data types need to be passed at compile time using -DDATA_TYPE_IN1, -DDATA_TYPE_IN2 and -DDATA_TYPE_OUT:
++ * e.g. -DDATA_TYPE_IN1=uchar -DDATA_TYPE_IN2=uchar -DDATA_TYPE_OUT=uchar
++ * @attention The offset factor of inputs must be passed at compile time using -DIN1_OFFSET and -DIN2_OFFSET
++ * @attention The offset, scalar scale factor and number of bits to shift right of output tensor must be passed at compile time using -DRESULT_OFFSET, -RESULT_MULT_INT and -DRESULT_SHIFT
++ *
++ * @param[in]  in1_ptr                           Pointer to the source image. Supported data types: U8
++ * @param[in]  in1_stride_x                      Stride of the source image in X dimension (in bytes)
++ * @param[in]  in1_step_x                        in1_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in1_stride_y                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in1_step_y                        in1_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in1_stride_z                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in1_step_z                        in1_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in1_offset_first_element_in_bytes The offset of the first element in the source image
++ * @param[in]  in2_ptr                           Pointer to the source image. Supported data types: U8
++ * @param[in]  in2_stride_x                      Stride of the source image in X dimension (in bytes)
++ * @param[in]  in2_step_x                        in2_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  in2_stride_y                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in2_step_y                        in2_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in2_stride_z                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  in2_step_z                        in2_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  in2_offset_first_element_in_bytes The offset of the first element in the source image
++ * @param[out] out_ptr                           Pointer to the destination image. Supported data types: U8
++ * @param[in]  out_stride_x                      Stride of the destination image in X dimension (in bytes)
++ * @param[in]  out_step_x                        out_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  out_stride_y                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  out_step_y                        out_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  out_stride_z                      Stride of the destination image in Y dimension (in bytes)
++ * @param[in]  out_step_z                        out_stride_z * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  out_offset_first_element_in_bytes The offset of the first element in the destination image
++ * @param[in]  scale                             Float scaling factor. Supported data types: F32
++ */
++__kernel void pixelwise_mul_qasymm8(
++    TENSOR3D_DECLARATION(in1),
++    TENSOR3D_DECLARATION(in2),
++    TENSOR3D_DECLARATION(out),
++    const float scale)
++{
++    // Get pixels pointer
++    Tensor3D in1 = CONVERT_TO_TENSOR3D_STRUCT(in1);
++    Tensor3D in2 = CONVERT_TO_TENSOR3D_STRUCT(in2);
++    Tensor3D out = CONVERT_TO_TENSOR3D_STRUCT(out);
++
++    // Load data
++    VEC_DATA_TYPE(int, 16)
++    in1_data = CONVERT(vload16(0, (__global DATA_TYPE_IN1 *)in1.ptr), VEC_DATA_TYPE(int, 16));
++    VEC_DATA_TYPE(int, 16)
++    in2_data = CONVERT(vload16(0, (__global DATA_TYPE_IN2 *)in2.ptr), VEC_DATA_TYPE(int, 16));
++
++    // Perform multiplication of two inputs
++    VEC_DATA_TYPE(int, 16) in1_val = in1_data + (VEC_DATA_TYPE(int, 16))(IN1_OFFSET);
++    VEC_DATA_TYPE(int, 16) in2_val = in2_data + (VEC_DATA_TYPE(int, 16))(IN2_OFFSET);
++    VEC_DATA_TYPE(int, 16) out_val = in1_val * in2_val;
++
++    // Multiply with a multiplier smaller than 1
++    out_val = ASYMM_MULT_BY_QUANT_MULTIPLIER_LESS_THAN_ONE(out_val, RESULT_MULT_INT, RESULT_SHIFT, 16);
++    out_val += (VEC_DATA_TYPE(int, 16))(RESULT_OFFSET);
++
++    VEC_DATA_TYPE(uchar, 16) res = CONVERT(out_val, VEC_DATA_TYPE(uchar, 16));
++
++// TODO: Apply min-max BOUND to support fuse with relu.
++/*
++#if defined(MIN_BOUND)
++    res = max(res, (uchar16)MIN_BOUND);
++#endif // defined(MIN_BOUND)
++#if defined(MAX_BOUND)
++    res = min(res, (uchar16)MAX_BOUND);
++#endif // defined(MAX_BOUND)
++*/
++
++    // Store result
++    VSTORE(16)(CONVERT(res, VEC_DATA_TYPE(DATA_TYPE_OUT, 16)),
++                     0, (__global DATA_TYPE_OUT *)out.ptr);
++}
++#endif // defined(RESULT_OFFSET) && defined(RESULT_MULT_INT) && defined(RESULT_SHIFT)
+diff --git a/src/core/CL/cl_kernels/reduce_max.cl b/src/core/CL/cl_kernels/reduce_max.cl
+new file mode 100644
+index 0000000..dfa3b85
+--- /dev/null
++++ b/src/core/CL/cl_kernels/reduce_max.cl
+@@ -0,0 +1,60 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers.h"
++
++#if defined(WIDTH)
++/** Perform reduce max
++ *
++ * @note Datatype should be given as a preprocessor argument using -DDATA_TYPE=type. e.g. -DDATA_TYPE=short
++ *
++ * @param[in]  input_ptr                            Pointer to the first source tensor. Supported data types:  F16/F32
++ * @param[in]  input_stride_x                       Stride of the first source tensor in X dimension (in bytes)
++ * @param[in]  input_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input_offset_first_element_in_bytes  The offset of the first element in the first source tensor
++ * @param[out] output_ptr                           Pointer to the destination tensor. Supported data types: same as @p input_ptr
++ * @param[out] output_stride_x                      Stride of the destination tensor in X dimension (in bytes)
++ * @param[out] output_step_x                        output_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[out] output_offset_first_element_in_bytes The offset of the first element in the destination tensor
++ */
++__kernel void reduce_max(VECTOR_DECLARATION(input),
++                         VECTOR_DECLARATION(output))
++{
++    Vector input = CONVERT_TO_VECTOR_STRUCT(input);
++    Vector output = CONVERT_TO_VECTOR_STRUCT(output);
++
++    __global float *input_addr = (__global float *)(input.ptr);
++    __global float *output_addr = (__global float *)(output.ptr);
++
++    float max_value = *input_addr;
++    for(int x = 1; x < WIDTH; x++)
++    {
++        float value = *(input_addr + x);
++        max_value = max(value, max_value);
++    }
++
++    // Store max
++    *output_addr = max_value;
++}
++#endif // defined(WIDTH)
+diff --git a/src/core/CL/cl_kernels/reduction_mean.cl b/src/core/CL/cl_kernels/reduction_mean.cl
+new file mode 100644
+index 0000000..1a96eea
+--- /dev/null
++++ b/src/core/CL/cl_kernels/reduction_mean.cl
+@@ -0,0 +1,69 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016, 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers.h"
++
++inline DATA_TYPE sum_8(__global const DATA_TYPE *input)
++{
++    VEC_DATA_TYPE(DATA_TYPE, 8)
++    in = vload8(0, input);
++    in.s0123 += in.s4567;
++    in.s01 += in.s23;
++    return ((in.s0 + in.s1));
++}
++
++/** This function calculates the sum and sum of squares of a given input image.
++ *
++ * @note To enable calculation sum of squares -DSTDDEV should be passed as a preprocessor argument.
++ *
++ * @param[in]  src_ptr                           Pointer to the source image. Supported data types: U8
++ * @param[in]  src_stride_x                      Stride of the source image in X dimension (in bytes)
++ * @param[in]  src_step_x                        src_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  src_stride_y                      Stride of the source image in Y dimension (in bytes)
++ * @param[in]  src_step_y                        src_stride_y * number of elements along Y processed per workitem(in bytes)
++ * @param[in]  src_offset_first_element_in_bytes The offset of the first element in the source image
++ * @param[out] local_sum                         Local sum of all elements
++ * @param[in]  height                            Height of the input image
++ * @param[in]  divider                           Divider to calculate mean
++ */
++__kernel void reduction_mean(
++    IMAGE_DECLARATION(src),
++    IMAGE_DECLARATION(dst),
++    __local DATA_TYPE *local_sums, 
++    int height,
++    int divider)
++{
++    // Get pixels pointer
++    Image src = CONVERT_TO_IMAGE_STRUCT(src);
++    Image dst = CONVERT_TO_IMAGE_STRUCT(dst);
++
++    float8 tmp_sum = 0;
++    // Calculate partial sum
++
++    for(int i = 0; i < height; i++)
++    {
++        local_sums[0] += sum_8((__global DATA_TYPE *)offset(&src, 0, i));
++    }
++    ((__global DATA_TYPE *)offset(&dst, get_global_id(0), get_global_id(1)))[0] = local_sums[0]/divider;
++}
+diff --git a/src/core/CL/cl_kernels/strided_slice.cl b/src/core/CL/cl_kernels/strided_slice.cl
+new file mode 100644
+index 0000000..c5ff82f
+--- /dev/null
++++ b/src/core/CL/cl_kernels/strided_slice.cl
+@@ -0,0 +1,104 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "helpers.h"
++
++
++inline Tensor4D tensor4D_from_vector_no_step(const Vector *vector, int dim_x, int dim_y, int dim_z, int dim_w)
++{
++    int stride_x = vector->stride_x;
++    int stride_y = stride_x * dim_x;
++    int stride_z = stride_y * dim_y;
++    int stride_w = stride_z * dim_z;
++    Tensor4D tensor =
++    {
++        .ptr                           = vector->ptr,
++        .offset_first_element_in_bytes = vector->offset_first_element_in_bytes,
++        .stride_x                      = stride_x,
++        .stride_y                      = stride_y,
++        .stride_z                      = stride_z,
++        .stride_w                      = stride_w,
++    };
++    return tensor;
++}
++
++/** Extracts a strided slice up to 4-dimensions
++ *
++ * @note Datatype should be given as a preprocessor argument using -DELEMENT_DATA_TYPE=type. e.g. -DELEMENT_DATA_TYPE=short
++ * @note The size of an element should be given as a preprocessor argument using -DELEMENT_SIZE=size. e.g. -DELEMENT_SIZE=2
++ *
++ * @param[in]  input_ptr                            Pointer to the first source tensor. Supported data types: U8/S8/QS8/QASYMM8/U16/S16/QS16/U32/S32/F16/F32
++ * @param[in]  input_stride_x                       Stride of the first source tensor in X dimension (in bytes)
++ * @param[in]  input_step_x                         input_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  input_offset_first_element_in_bytes  The offset of the first element in the first source tensor
++ * @param[out] output_ptr                           Pointer to the destination tensor. Supported data types: same as @p input_ptr
++ * @param[in]  output_stride_x                      Stride of the destination tensor in X dimension (in bytes)
++ * @param[in]  output_step_x                        output_stride_x * number of elements along X processed per workitem(in bytes)
++ * @param[in]  output_offset_first_element_in_bytes The offset of the first element in the destination tensor
++ * @param[in]  dims_in                              The 4-dimensional dimension of the input. Supported data types: S32
++ * @param[in]  dims_out                             The 4-dimensional dimension of the output. Supported data types: S32
++ * @param[in]  starts                               The stride of X dimension of input tensor to be sliced. Supported data types: S32
++ * @param[in]  strides                              The stride of Y dimension of input tensor to be sliced. Supported data types: S32
++ */
++__kernel void strided_slice(VECTOR_DECLARATION(input),
++                            VECTOR_DECLARATION(output),
++                            const int4 dims_in,
++                            const int4 dims_out,
++                            const int4 starts,
++                            const int4 strides)
++{
++    // TODO: Should be change to CONVERT_TO_TENSOR4D_STRUCT in order to reduce inference of the offset
++    Vector vec_out = CONVERT_TO_VECTOR_STRUCT_NO_STEP(output);
++    Vector vec_in = CONVERT_TO_VECTOR_STRUCT_NO_STEP(input);
++
++    // Implemenation
++    // Infer a Tensor4D from output Vector and output's dimensions info
++    // Infer a Tensor4D from input Vector and input's dimensions info
++    // Infer indices of output as 4D from the offset of output vector
++    // Infer indices of input as 4D from indices of output
++    // out(offset of output vector) = in(offset of input)
++
++    Tensor4D tensor_out = tensor4D_from_vector_no_step(&vec_out, dims_out.x, dims_out.y, dims_out.z, dims_out.w);
++    Tensor4D tensor_in = tensor4D_from_vector_no_step(&vec_in, dims_in.x, dims_in.y, dims_in.z, dims_in.w);
++
++    // Must be output_step_x == output_stride_x == an element's size
++    const int offset_out = get_global_id(0) * output_stride_x;
++    int4 indices_out =
++    {
++            get_global_id(0) % dims_out.x,
++            (offset_out / tensor_out.stride_y) % dims_out.y,
++            (offset_out / tensor_out.stride_z) % dims_out.z,
++            (offset_out / tensor_out.stride_w) % dims_out.w,
++    };
++
++    int4 indices_in =
++    {
++            starts.x + (strides.x * indices_out.x),
++            starts.y + (strides.y * indices_out.y),
++            starts.z + (strides.z * indices_out.z),
++            starts.w + (strides.w * indices_out.w),
++    };
++
++    *((__global ELEMENT_DATA_TYPE *)vector_offset(&vec_out, get_global_id(0))) = *((__global ELEMENT_DATA_TYPE *)tensor4D_offset(&tensor_in, indices_in.x, indices_in.y, indices_in.z, indices_in.w));
++}
+diff --git a/src/core/CL/cl_kernels/topkv2.cl b/src/core/CL/cl_kernels/topkv2.cl
+new file mode 100644
+index 0000000..0b0cf82
+--- /dev/null
++++ b/src/core/CL/cl_kernels/topkv2.cl
+@@ -0,0 +1,111 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++
++#include "helpers.h"
++
++__kernel void topkv2_init(VECTOR_DECLARATION(input),
++    __global float* in_key_buf,
++    __global int* in_ind_buf,
++    const int n)
++{
++  int gid = get_global_id(0);
++  int lws = get_local_size(0);
++  int groups = get_num_groups(0);
++  int gws = lws * groups;
++  int iter = n / gws;
++
++  Vector input = CONVERT_TO_VECTOR_STRUCT_NO_STEP(input);
++
++  for(int i = 0; i < iter; ++i)
++  {
++    int idx = i * gws + gid;
++    in_key_buf[idx] = *(__global float*)(input.ptr + idx * input.stride_x);
++    in_ind_buf[idx] = idx;
++  }
++}
++
++__kernel void topkv2_find_first_negative(
++    __global float *out_key_buf,
++    __global int *first_negative_idx,
++    int n)
++{
++  int gid = get_global_id(0);
++
++  if( gid == n - 1 )
++  {
++    // if the last item is positive, the first negative index is n.
++    if( out_key_buf[gid] > 0.f )
++      *first_negative_idx = n;
++  } else if ( gid == 0 ) {
++    // if the first item is negative, set it 0.
++    if( out_key_buf[gid] < 0.f )
++      *first_negative_idx = 0;
++  } else {
++    // if its left is positive and it is negative, then it is the first negative item.
++    if( out_key_buf[gid-1] > 0.f && out_key_buf[gid] < 0.f )
++      *first_negative_idx = gid;
++  }
++}
++
++__kernel void topkv2_reorder_negatives(
++    __global float* in_key_buf,
++    __global float* out_key_buf,
++    __global float* in_ind_buf,
++    __global float* out_ind_buf,
++    __global int* first_negative_idx,
++    int n)
++{
++  int gid = get_global_id(0);
++
++  int num_negs = n - *first_negative_idx;
++  int in_idx;
++
++  if( gid < num_negs ) {
++    in_idx = n - 1 - gid;
++  } else {
++    in_idx = gid - num_negs;
++  }
++
++  out_key_buf[gid] = in_key_buf[in_idx];
++  out_ind_buf[gid] = in_ind_buf[in_idx];
++}
++
++__kernel void topkv2_store(
++    VECTOR_DECLARATION(values),
++    VECTOR_DECLARATION(indices),
++    __global float *out_key_buf,
++    __global int *out_ind_buf,
++    int n)
++{
++  int gid = get_global_id(0);
++
++  Vector values = CONVERT_TO_VECTOR_STRUCT_NO_STEP(values);
++  Vector indices = CONVERT_TO_VECTOR_STRUCT_NO_STEP(indices);
++
++  int idx = n - 1 - gid;
++
++  *(__global float*)(values.ptr + gid * values.stride_x) = out_key_buf[idx];
++  *(__global int*)(indices.ptr + gid * indices.stride_x) = out_ind_buf[idx];
++}
+diff --git a/src/core/CL/cl_kernels/topkv2_quicksort.cl b/src/core/CL/cl_kernels/topkv2_quicksort.cl
+new file mode 100644
+index 0000000..deadf84
+--- /dev/null
++++ b/src/core/CL/cl_kernels/topkv2_quicksort.cl
+@@ -0,0 +1,138 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++
++#include "helpers.h"
++
++__global inline float* get_vec_elem(Vector* vec, int idx)
++{
++  return (__global float*)(vec->ptr + idx * vec->stride_x);
++}
++
++__global inline int* get_vec_elem_int(Vector* vec, int idx)
++{
++  return (__global int*)(vec->ptr + idx * vec->stride_x);
++}
++
++// A utility function to swap two elements
++void swap(__global float *a, __global float *b)
++{
++    float t = *a;
++    *a = *b;
++    *b = t;
++}
++
++void swap_idx(__global int *a, __global int *b)
++{
++    int t = *a;
++    *a = *b;
++    *b = t;
++}
++
++/* This function is same in both iterative and recursive*/
++int partition (Vector* arr, __global int* indices, int l, int h)
++{
++    float x = *get_vec_elem(arr, h);
++    int i = (l - 1);
++
++    for (int j = l; j <= h- 1; j++)
++    {
++        if (*get_vec_elem(arr, j) >= x)
++        {
++            i++;
++            swap (get_vec_elem(arr,i), get_vec_elem(arr,j));
++            swap_idx(&indices[i], &indices[j]);
++        }
++    }
++    swap (get_vec_elem(arr, i + 1), get_vec_elem(arr, h));
++    swap_idx(&indices[i + 1], &indices[h]);
++    return (i + 1);
++}
++
++/* A[] --> Array to be sorted,
++   l  --> Starting index,
++   h  --> Ending index */
++void quickSortIterative (Vector* arr, __global int* indices, 
++    __global int *stack, int l, int h)
++{
++    // Create an auxiliary stack
++
++    // initialize top of stack
++    int top = -1;
++
++    // push initial values of l and h to stack
++    stack[ ++top ] = l;
++    stack[ ++top ] = h;
++
++    // Keep popping from stack while is not empty
++    while ( top >= 0 )
++    {
++        // Pop h and l
++        h = stack[ top-- ];
++        l = stack[ top-- ];
++
++        // Set pivot element at its correct position
++        // in sorted array
++        int p = partition( arr, indices, l, h );
++
++        // If there are elements on left side of pivot,
++        // then push left side to stack
++        if ( p-1 > l )
++        {
++            stack[ ++top ] = l;
++            stack[ ++top ] = p - 1;
++        }
++
++        // If there are elements on right side of pivot,
++        // then push right side to stack
++        if ( p+1 < h )
++        {
++            stack[ ++top ] = p + 1;
++            stack[ ++top ] = h;
++        }
++    }
++}
++
++__kernel void topkv2_quicksort(VECTOR_DECLARATION(input),
++    VECTOR_DECLARATION(topk_values), VECTOR_DECLARATION(topk_indices),
++    __global int* indices, __global int* temp_stack, int k, int n)
++{
++  Vector input = CONVERT_TO_VECTOR_STRUCT_NO_STEP(input);
++  Vector topk_values = CONVERT_TO_VECTOR_STRUCT_NO_STEP(topk_values);
++  Vector topk_indices = CONVERT_TO_VECTOR_STRUCT_NO_STEP(topk_indices);
++
++  for( int i = 0; i < n; ++i )
++  {
++    indices[i] = i;
++  }
++
++  quickSortIterative(&input, indices, temp_stack, 0, n-1);
++
++  // extract k items.
++  for(int i = 0; i < k; ++i)
++  {
++    *get_vec_elem(&topk_values, i)  = *get_vec_elem(&input, i);
++    *get_vec_elem_int(&topk_indices, i) = indices[i];
++  }
++}
+diff --git a/src/core/CL/cl_kernels/topkv2_radixsort.cl b/src/core/CL/cl_kernels/topkv2_radixsort.cl
+new file mode 100644
+index 0000000..cac0c07
+--- /dev/null
++++ b/src/core/CL/cl_kernels/topkv2_radixsort.cl
+@@ -0,0 +1,279 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++
++// reference:
++// https://code.google.com/archive/p/ocl-radix-sort/source/default/source
++// OpenCL kernel sources for the CLRadixSort class
++// the #include does not exist in OpenCL
++// Copyright Philippe Helluy, Université de Strasbourg, France, 2011, helluy@math.unistra.fr
++// licensed under the GNU Lesser General Public License see http://www.gnu.org/copyleft/lesser.html
++// if you find this software usefull you can cite the following work in your reports or articles:
++// Philippe HELLUY, A portable implementation of the radix sort algorithm in OpenCL, 2011.
++// http://hal.archives-ouvertes.fr/hal-00596730
++
++// Reference for floating point radix sort:
++// http://www.codercorner.com/RadixSortRevisited.htm
++
++// compute the histogram for each radix and each virtual processor for the pass
++__kernel void radixsort_histogram(__global float* in_key_buf,
++      __global int* d_Histograms,
++      const int pass,
++      __local int* loc_histo,
++      const int n)
++{
++  int it = get_local_id(0);  // i local number of the processor
++  int ig = get_global_id(0); // global number = i + g I
++
++  int gr = get_group_id(0); // g group number
++
++  int groups = get_num_groups(0);
++  int items  = get_local_size(0);
++
++  // set the local histograms to zero
++  for(int ir=0;ir<_RADIX;ir++){
++    loc_histo[ir * items + it] = 0;
++  }
++
++  barrier(CLK_LOCAL_MEM_FENCE);
++
++  // range of keys that are analyzed by the work item
++  int size= n/groups/items; // size of the sub-list
++  int start= ig * size; // beginning of the sub-list
++
++  unsigned int key;
++  int shortkey,k;
++
++  // compute the index
++  // the computation depends on the transposition
++  for(int j = 0; j < size ; j++) {
++#ifdef TRANSPOSE
++    k= groups * items * j + ig;
++#else
++    k=j+start;
++#endif
++
++    key = *((__global unsigned int*)(in_key_buf + k));
++
++    // extract the group of _BITS bits of the pass
++    // the result is in the range 0.._RADIX-1
++    shortkey=(( key >> (pass * _BITS)) & (_RADIX-1));
++
++    // increment the local histogram
++    loc_histo[shortkey *  items + it ]++;
++  }
++
++  barrier(CLK_LOCAL_MEM_FENCE);
++
++  // copy the local histogram to the global one
++  for(int ir=0;ir<_RADIX;ir++) {
++    d_Histograms[items * (ir * groups + gr) + it] = loc_histo[ir * items + it];
++  }
++
++  barrier(CLK_GLOBAL_MEM_FENCE);
++}
++
++// initial transpose of the list for improving
++// coalescent memory access
++__kernel void transpose(const __global int* invect,
++      __global int* outvect,
++      const int nbcol,
++      const int nbrow,
++      const __global int* inperm,
++      __global int* outperm,
++      __local int* blockmat,
++      __local int* blockperm,
++      const int tilesize){
++
++  int i0 = get_global_id(0)*tilesize;  // first row index
++  int j = get_global_id(1);  // column index
++
++  int jloc = get_local_id(1);  // local column index
++
++  // fill the cache
++  for(int iloc=0;iloc<tilesize;iloc++){
++    int k=(i0+iloc)*nbcol+j;  // position in the matrix
++    blockmat[iloc*tilesize+jloc]=invect[k];
++#ifdef PERMUT
++    blockperm[iloc*tilesize+jloc]=inperm[k];
++#endif
++  }
++
++  barrier(CLK_LOCAL_MEM_FENCE);
++
++  // first row index in the transpose
++  int j0=get_group_id(1)*tilesize;
++
++  // put the cache at the good place
++  for(int iloc=0;iloc<tilesize;iloc++){
++    int kt=(j0+iloc)*nbrow+i0+jloc;  // position in the transpose
++    outvect[kt]=blockmat[jloc*tilesize+iloc];
++#ifdef PERMUT
++      outperm[kt]=blockperm[jloc*tilesize+iloc];
++#endif
++  }
++
++}
++
++// each virtual processor reorders its data using the scanned histogram
++__kernel void radixsort_reorder(__global float* in_key,
++    __global float* out_key,
++    __global int* d_Histograms,
++    const int pass,
++    __global int* indices_in,
++    __global int* indices_out,
++    __local int* loc_histo,
++    const int n){
++
++  int it = get_local_id(0);
++  int ig = get_global_id(0);
++
++  int gr = get_group_id(0);
++  int groups=get_num_groups(0);
++  int items=get_local_size(0);
++
++  int start= ig *(n/groups/items);
++  int size= n/groups/items;
++
++  // take the histogram in the cache
++  for(int ir=0;ir<_RADIX;ir++){
++    loc_histo[ir * items + it]=
++      d_Histograms[items * (ir * groups + gr) + it];
++  }
++  barrier(CLK_LOCAL_MEM_FENCE);
++
++  int newpos,shortkey,k,newpost;
++  unsigned int key;
++
++  for(int j= 0; j< size;j++){
++#ifdef TRANSPOSE
++      k= groups * items * j + ig;
++#else
++      k=j+start;
++#endif
++    float org_value = in_key[k];
++    key = *(__global unsigned int*)(in_key + k);
++    shortkey=((key >> (pass * _BITS)) & (_RADIX-1));
++
++    newpos=loc_histo[shortkey * items + it];
++
++#ifdef TRANSPOSE
++    int ignew,jnew;
++    ignew= newpos/(n/groups/items);
++    jnew = newpos%(n/groups/items);
++    newpost = jnew * (groups*items) + ignew;
++#else
++    newpost=newpos;
++#endif
++
++    //d_outKeys[newpost]= key;  // killing line !!!
++    out_key[newpost] = org_value;
++
++#ifdef PERMUT
++    indices_out[newpost] = indices_in[k];
++#endif
++
++    newpos++;
++    loc_histo[shortkey * items + it]=newpos;
++  }
++}
++
++// perform a parallel prefix sum (a scan) on the local histograms
++// (see Blelloch 1990) each workitem worries about two memories
++// see also http://http.developer.nvidia.com/GPUGems3/gpugems3_ch39.html
++__kernel void radixsort_scanhistograms(__global int* histo, __local int* temp, __global int* globsum)
++{
++  int it = get_local_id(0);
++  int ig = get_global_id(0);
++  int decale = 1;
++  int n=get_local_size(0) * 2 ;
++  int gr=get_group_id(0);
++
++  // load input into local memory
++  // up sweep phase
++  temp[2*it] = histo[2*ig];
++  temp[2*it+1] = histo[2*ig+1];
++
++  // parallel prefix sum (algorithm of Blelloch 1990)
++  for (int d = n>>1; d > 0; d >>= 1){
++    barrier(CLK_LOCAL_MEM_FENCE);
++    if (it < d){
++      int ai = decale*(2*it+1)-1;
++      int bi = decale*(2*it+2)-1;
++      temp[bi] += temp[ai];
++    }
++    decale *= 2;
++  }
++
++  // store the last element in the global sum vector
++  // (maybe used in the next step for constructing the global scan)
++  // clear the last element
++  if (it == 0) {
++    globsum[gr]=temp[n-1];
++    temp[n - 1] = 0;
++  }
++
++  // down sweep phase
++  for (int d = 1; d < n; d *= 2){
++    decale >>= 1;
++    barrier(CLK_LOCAL_MEM_FENCE);
++
++    if (it < d){
++      int ai = decale*(2*it+1)-1;
++      int bi = decale*(2*it+2)-1;
++
++      int t = temp[ai];
++      temp[ai] = temp[bi];
++      temp[bi] += t;
++    }
++
++  }
++  barrier(CLK_LOCAL_MEM_FENCE);
++
++  // write results to device memory
++
++  histo[2*ig] = temp[2*it];
++  histo[2*ig+1] = temp[2*it+1];
++
++  barrier(CLK_GLOBAL_MEM_FENCE);
++
++}
++
++// use the global sum for updating the local histograms
++// each work item updates two values
++__kernel void radixsort_pastehistograms( __global int* histo,__global int* globsum)
++{
++  int ig = get_global_id(0);
++  int gr=get_group_id(0);
++
++  int s;
++
++  s=globsum[gr];
++
++  // write results to device memory
++  histo[2*ig] += s;
++  histo[2*ig+1] += s;
++
++  barrier(CLK_GLOBAL_MEM_FENCE);
++}
+diff --git a/src/core/CL/kernels/CLActivationLayerKernel.cpp b/src/core/CL/kernels/CLActivationLayerKernel.cpp
+index a78b3e1..4c3ecad 100644
+--- a/src/core/CL/kernels/CLActivationLayerKernel.cpp
++++ b/src/core/CL/kernels/CLActivationLayerKernel.cpp
+@@ -33,6 +33,7 @@
+ #include "arm_compute/core/Utils.h"
+ #include "arm_compute/core/Validate.h"
+ #include "arm_compute/core/Window.h"
++#include "arm_compute/core/utils/quantization/AsymmHelpers.h"
+ 
+ #include "arm_compute/core/CL/CLHelpers.h"
+ #include "arm_compute/core/Types.h"
+@@ -49,8 +50,9 @@ Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, c
+     ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8, DataType::QASYMM8, DataType::QS8, DataType::QS16, DataType::F16, DataType::F32);
+     ARM_COMPUTE_RETURN_ERROR_ON_MSG((input->data_type() == DataType::QASYMM8) && (act_info.activation() != ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU)
+                                     && (act_info.activation() != ActivationLayerInfo::ActivationFunction::BOUNDED_RELU)
+-                                    && (act_info.activation() != ActivationLayerInfo::ActivationFunction::RELU),
+-                                    "For QASYMM8 only relu, lower bounded relu and lower-upper bounded relu are supported");
++                                    && (act_info.activation() != ActivationLayerInfo::ActivationFunction::RELU)
++                                    && (act_info.activation() != ActivationLayerInfo::ActivationFunction::LOGISTIC),
++                                    "For QASYMM8 only relu, lower bounded relu, lower-upper bounded relu and logistic are supported");
+ 
+     // Checks performed when output is configured
+     if((output != nullptr) && (output->total_size() != 0))
+@@ -93,6 +95,43 @@ std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input, ITen
+     Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{};
+     return std::make_pair(err, win);
+ }
++
++inline bool is_activation_logistic(ActivationLayerInfo &act_info)
++{
++    if(act_info.activation() == ActivationLayerInfo::ActivationFunction::LOGISTIC)
++    {
++        return true;
++    }
++    return false;
++}
++
++/** Calculates logistic parameters from the quantized input scale and scaling factor for the exponent and places them as build options.
++ *
++ * Prepares these build options:
++ * -INPUT_MULTIPLIER, INPUT_LEFT_SHIFT - quantized representation of multiplier.
++ * -INPUT_RANGE_RADIUS - threshold difference between maximum value of input data and current processed value.
++ *                       it defines whether the value will be taken into account or not.
++ *
++ * @param[in] build_opts  Build options to extend
++ * @param[in] input_scale Input scaling factor
++ */
++void prepare_quantized_logistic_build_options(std::set<std::string> *build_opts, float input_scale)
++{
++    // Number of integer bits in temporary fixed-point representation of current-to-max difference
++    static const int input_integer_bits = 4;
++
++    const double input_real_multiplier = input_scale * (1ll << (31 - input_integer_bits));
++    int input_multiplier, input_left_shift;
++    quantization::calculate_quantized_multiplier_greater_than_one(input_real_multiplier, &input_multiplier, &input_left_shift);
++
++    const double max_input_rescaled = 1.0 * ((1 << input_integer_bits) - 1) * (1ll << (31 - input_integer_bits)) / (1ll << input_left_shift);
++    const int    input_range_radius = std::floor(max_input_rescaled);
++
++    build_opts->emplace(("-DINPUT_INTEGER_BITS=" + support::cpp11::to_string(input_integer_bits)));
++    build_opts->emplace(("-DINPUT_MULTIPLIER=" + support::cpp11::to_string(input_multiplier)));
++    build_opts->emplace(("-DINPUT_LEFT_SHIFT=" + support::cpp11::to_string(input_left_shift)));
++    build_opts->emplace(("-DINPUT_RANGE_RADIUS=" + support::cpp11::to_string(input_range_radius)));
++}
+ } // namespace
+ 
+ CLActivationLayerKernel::CLActivationLayerKernel()
+@@ -181,8 +220,16 @@ void CLActivationLayerKernel::configure(ICLTensor *input, ICLTensor *output, Act
+         build_opts.emplace(("-DFIXED_POINT_POSITION=" + support::cpp11::to_string(fixed_point_position)));
+     }
+ 
++    if(is_data_type_quantized_asymmetric(dt) && is_activation_logistic(act_info))
++    {
++        prepare_quantized_logistic_build_options(&build_opts, input->info()->quantization_info().scale);
++    }
++
+     // Create kernel
+-    std::string kernel_name = is_data_type_quantized_asymmetric(dt) ? std::string("activation_layer_qa8") : std::string("activation_layer");
++    std::string kernel_name = is_data_type_quantized_asymmetric(dt) && is_activation_logistic(act_info) ?
++                              std::string("activation_layer_logistic_qa8") :
++                              is_data_type_quantized_asymmetric(dt) ?
++                              std::string("activation_layer_qa8") : std::string("activation_layer");
+     _kernel                 = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel(kernel_name, build_opts));
+ 
+     // Make sure _kernel is initialized before calling the parent's configure
+diff --git a/src/core/CL/kernels/CLArithmeticAdditionKernel.cpp b/src/core/CL/kernels/CLArithmeticAdditionKernel.cpp
+index c4904ec..f5f4f1a 100644
+--- a/src/core/CL/kernels/CLArithmeticAdditionKernel.cpp
++++ b/src/core/CL/kernels/CLArithmeticAdditionKernel.cpp
+@@ -25,6 +25,7 @@
+ 
+ #include "arm_compute/core/CL/CLHelpers.h"
+ #include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/utils/quantization/AsymmHelpers.h"
+ 
+ using namespace arm_compute;
+ 
+@@ -36,8 +37,13 @@ Status validate_arguments(const ITensorInfo &input1, const ITensorInfo &input2,
+ {
+     ARM_COMPUTE_UNUSED(policy);
+ 
+-    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input1, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
+-    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input2, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input1, 1, DataType::U8, DataType::QS8, DataType::QASYMM8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input2, 1, DataType::U8, DataType::QS8, DataType::QASYMM8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    if (is_data_type_quantized_asymmetric(output.data_type()))
++    {
++        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(&output, &input1);
++        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(&output, &input2);
++    }
+ 
+     const TensorShape out_shape = TensorShape::broadcast_shape(input1.tensor_shape(), input2.tensor_shape());
+ 
+@@ -47,7 +53,7 @@ Status validate_arguments(const ITensorInfo &input1, const ITensorInfo &input2,
+     // Validate in case of configured output
+     if(output.total_size() > 0)
+     {
+-        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&output, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&output, 1, DataType::U8, DataType::QS8, DataType::QASYMM8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
+         ARM_COMPUTE_RETURN_ERROR_ON_MSG((output.data_type() == DataType::U8) && ((input1.data_type() != DataType::U8) || (input2.data_type() != DataType::U8)),
+                                         "Output can only be U8 if both inputs are U8");
+         ARM_COMPUTE_RETURN_ERROR_ON_MSG(detail::have_different_dimensions(out_shape, output.tensor_shape(), 0),
+@@ -132,8 +138,40 @@ void CLArithmeticAdditionKernel::configure(const ICLTensor *input1, const ICLTen
+         build_opts.emplace("-DFIXED_POINT_POSITION=" + support::cpp11::to_string(input1->info()->fixed_point_position()));
+     }
+ 
++    if (is_data_type_quantized_asymmetric(output->info()->data_type()))
++    {
++        const int left_shift = 20;
++        const double twice_max_input_scale = 2 * std::max(input1->info()->quantization_info().scale, input2->info()->quantization_info().scale);
++        const double real_input1_multiplier = input1->info()->quantization_info().scale / twice_max_input_scale;
++        const double real_input2_multiplier = input2->info()->quantization_info().scale / twice_max_input_scale;
++        const double real_output_multiplier = twice_max_input_scale / ((1 << left_shift) * output->info()->quantization_info().scale);
++
++        int input1_multiplier, input2_multiplier, output_multiplier;
++        int input1_shift, input2_shift, output_shift;
++        quantization::calculate_quantized_multiplier_less_than_one(real_input1_multiplier, &input1_multiplier, &input1_shift);
++        quantization::calculate_quantized_multiplier_less_than_one(real_input2_multiplier, &input2_multiplier, &input2_shift);
++        quantization::calculate_quantized_multiplier_less_than_one(real_output_multiplier, &output_multiplier, &output_shift);
++
++        build_opts.emplace("-DIN1_MULT_INT=" + support::cpp11::to_string(input1_multiplier));
++        build_opts.emplace("-DIN2_MULT_INT=" + support::cpp11::to_string(input2_multiplier));
++        build_opts.emplace("-DRESULT_MULT_INT=" + support::cpp11::to_string(output_multiplier));
++        build_opts.emplace("-DLEFT_SHIFT=" + support::cpp11::to_string(left_shift));
++        build_opts.emplace("-DIN1_SHIFT=" + support::cpp11::to_string(input1_shift));
++        build_opts.emplace("-DIN2_SHIFT=" + support::cpp11::to_string(input2_shift));
++        build_opts.emplace("-DRESULT_SHIFT=" + support::cpp11::to_string(output_shift));
++        build_opts.emplace("-DIN1_OFFSET=" + support::cpp11::to_string(-(input1->info()->quantization_info().offset)));
++        build_opts.emplace("-DIN2_OFFSET=" + support::cpp11::to_string(-(input2->info()->quantization_info().offset)));
++        build_opts.emplace("-DRESULT_OFFSET=" + support::cpp11::to_string(output->info()->quantization_info().offset));
++        // TODO: Apply min-max BOUND to support fuse with relu.
++    }
++
+     // Create kernel
+-    _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("arithmetic_add", build_opts));
++    std::string kernel_name = "arithmetic_add";
++    if (is_data_type_quantized_asymmetric(output->info()->data_type()))
++    {
++        kernel_name += "_qasymm8";
++    }
++    _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel(kernel_name, build_opts));
+ 
+     ICLKernel::configure(win_config.second);
+ }
+diff --git a/src/core/CL/kernels/CLArithmeticSubtractionKernel.cpp b/src/core/CL/kernels/CLArithmeticSubtractionKernel.cpp
+index 8308aa0..3053222 100644
+--- a/src/core/CL/kernels/CLArithmeticSubtractionKernel.cpp
++++ b/src/core/CL/kernels/CLArithmeticSubtractionKernel.cpp
+@@ -1,5 +1,6 @@
+ /*
+- * Copyright (c) 2016, 2017 ARM Limited.
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
+  *
+  * SPDX-License-Identifier: MIT
+  *
+@@ -24,37 +25,33 @@
+ #include "arm_compute/core/CL/kernels/CLArithmeticSubtractionKernel.h"
+ 
+ #include "arm_compute/core/CL/CLHelpers.h"
+-#include "arm_compute/core/CL/CLKernelLibrary.h"
+ #include "arm_compute/core/CL/ICLTensor.h"
+-#include "arm_compute/core/CL/OpenCL.h"
+-#include "arm_compute/core/Helpers.h"
+-#include "arm_compute/core/IAccessWindow.h"
+-#include "arm_compute/core/TensorInfo.h"
+-#include "arm_compute/core/Validate.h"
+-#include "arm_compute/core/Window.h"
+-
+-#include <set>
+-#include <string>
+ 
+ using namespace arm_compute;
+ 
+ namespace
+ {
++constexpr unsigned int num_elems_processed_per_iteration = 16;
++
+ Status validate_arguments(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy)
+ {
+     ARM_COMPUTE_UNUSED(policy);
++
+     ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input1, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
+     ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input2, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
+-    ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input1, input2);
++
++    const TensorShape &out_shape = TensorShape::broadcast_shape(input1->tensor_shape(), input2->tensor_shape());
++
++    ARM_COMPUTE_RETURN_ERROR_ON_MSG(out_shape.total_size() == 0, "Inputs are not broadcast compatible");
+     ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_FIXED_POINT(input1, input2);
+ 
+     // Validate in case of configured output
+-    if((output != nullptr) && (output->total_size() != 0))
++    if(output->total_size() > 0)
+     {
+         ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
+         ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->data_type() == DataType::U8 && (input1->data_type() != DataType::U8 || input2->data_type() != DataType::U8),
+                                         "Output can only be U8 if both inputs are U8");
+-        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input1, output);
++        ARM_COMPUTE_RETURN_ERROR_ON_MSG(detail::have_different_dimensions(out_shape, output->tensor_shape(), 0), "Wrong shape for output");
+         ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_FIXED_POINT(input1, output);
+     }
+ 
+@@ -63,17 +60,39 @@ Status validate_arguments(const ITensorInfo *input1, const ITensorInfo *input2,
+ 
+ std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output)
+ {
+-    constexpr unsigned int num_elems_processed_per_iteration = 16;
++    const std::pair<TensorShape, ValidRegion> broadcast_pair = ITensorInfo::broadcast_shape_and_valid_region(*input1, *input2);
++    const TensorShape &out_shape    = broadcast_pair.first;
++    const ValidRegion &valid_region = broadcast_pair.second;
++
++    // Auto initialize output if not initialized
++    {
++        set_shape_if_empty(*output, out_shape);
++
++        if(input1->data_type() == DataType::S16 || input2->data_type() == DataType::S16)
++        {
++            set_format_if_unknown(*output, Format::S16);
++        }
++        else if(input1->data_type() == DataType::F16 && input2->data_type() == DataType::F16)
++        {
++            set_format_if_unknown(*output, Format::F16);
++        }
++        else if(input1->data_type() == DataType::F32 || input2->data_type() == DataType::F32)
++        {
++            set_format_if_unknown(*output, Format::F32);
++        }
++    }
++
++    Window win        = calculate_max_window(valid_region, Steps(num_elems_processed_per_iteration));
++    Window win_input1 = win.broadcast_if_dimension_le_one(*input1);
++    Window win_input2 = win.broadcast_if_dimension_le_one(*input2);
+ 
+-    Window                 win = calculate_max_window(*input1, Steps(num_elems_processed_per_iteration));
+     AccessWindowHorizontal input1_access(input1, 0, num_elems_processed_per_iteration);
+     AccessWindowHorizontal input2_access(input2, 0, num_elems_processed_per_iteration);
+     AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration);
+ 
+-    bool window_changed = update_window_and_padding(win, input1_access, input2_access, output_access);
+-
+-    ValidRegion valid_region = intersect_valid_regions(input1->valid_region(),
+-                                                       input2->valid_region());
++    bool window_changed = update_window_and_padding(win_input1, input1_access)
++                          || update_window_and_padding(win_input2, input2_access)
++                          || update_window_and_padding(win, output_access);
+ 
+     output_access.set_valid_region(win, valid_region);
+ 
+@@ -90,28 +109,17 @@ CLArithmeticSubtractionKernel::CLArithmeticSubtractionKernel()
+ void CLArithmeticSubtractionKernel::configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, ConvertPolicy policy)
+ {
+     ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
+-
+-    // Auto initialize output if not initialized
+-    {
+-        set_shape_if_empty(*output->info(), input1->info()->tensor_shape());
+-
+-        if(input1->info()->data_type() == DataType::S16 || input2->info()->data_type() == DataType::S16)
+-        {
+-            set_format_if_unknown(*output->info(), Format::S16);
+-        }
+-        else if(input1->info()->data_type() == DataType::F32 || input2->info()->data_type() == DataType::F32)
+-        {
+-            set_format_if_unknown(*output->info(), Format::F32);
+-        }
+-    }
+-
+     ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input1->info(), input2->info(), output->info(), policy));
+ 
++    // Configure kernel window
++    auto win_config = validate_and_configure_window(input1->info(), input2->info(), output->info());
++    ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
++
+     _input1 = input1;
+     _input2 = input2;
+     _output = output;
+ 
+-    bool has_float_out = is_data_type_float(output->info()->data_type());
++    const bool has_float_out = is_data_type_float(output->info()->data_type());
+ 
+     // Set kernel build options
+     std::set<std::string> build_opts;
+@@ -127,14 +135,12 @@ void CLArithmeticSubtractionKernel::configure(const ICLTensor *input1, const ICL
+     // Create kernel
+     _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("arithmetic_sub", build_opts));
+ 
+-    // Configure kernel window
+-    auto win_config = validate_and_configure_window(input1->info(), input2->info(), output->info());
+-    ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
+     ICLKernel::configure(win_config.second);
+ }
+ 
+ Status CLArithmeticSubtractionKernel::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy)
+ {
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
+     ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input1, input2, output, policy));
+     ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input1->clone().get(), input2->clone().get(), output->clone().get()).first);
+ 
+@@ -146,16 +152,49 @@ void CLArithmeticSubtractionKernel::run(const Window &window, cl::CommandQueue &
+     ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
+     ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICLKernel::window(), window);
+ 
+-    Window collapsed = window.collapse_if_possible(ICLKernel::window(), Window::DimZ);
+-    Window slice     = collapsed.first_slice_window_3D();
++    const TensorShape &in_shape1 = _input1->info()->tensor_shape();
++    const TensorShape &in_shape2 = _input2->info()->tensor_shape();
++    const TensorShape &out_shape = _output->info()->tensor_shape();
++
++    bool can_collapse = true;
++    if(std::min(in_shape1.total_size(), in_shape2.total_size()) > 1)
++    {
++        can_collapse = (std::min(in_shape1.num_dimensions(), in_shape2.num_dimensions()) > Window::DimZ);
++        for(size_t d = Window::DimZ; can_collapse && (d < out_shape.num_dimensions()); d++)
++        {
++            can_collapse = (in_shape1[d] == in_shape2[d]);
++        }
++    }
++
++    bool   has_collapsed = false;
++    Window collapsed     = can_collapse ? window.collapse_if_possible(ICLKernel::window(), Window::DimZ, &has_collapsed) : window;
++
++    const TensorShape &in_shape1_collapsed = has_collapsed ? in_shape1.collapsed_from(Window::DimZ) : in_shape1;
++    const TensorShape &in_shape2_collapsed = has_collapsed ? in_shape2.collapsed_from(Window::DimZ) : in_shape2;
++
++    Window slice        = collapsed.first_slice_window_3D();
++    Window slice_input1 = slice.broadcast_if_dimension_le_one(in_shape1_collapsed);
++    Window slice_input2 = slice.broadcast_if_dimension_le_one(in_shape2_collapsed);
+ 
+     do
+     {
+         unsigned int idx = 0;
+-        add_3D_tensor_argument(idx, _input1, slice);
+-        add_3D_tensor_argument(idx, _input2, slice);
++
++        add_3D_tensor_argument(idx, _input1, slice_input1);
++        add_3D_tensor_argument(idx, _input2, slice_input2);
+         add_3D_tensor_argument(idx, _output, slice);
++
+         enqueue(queue, *this, slice);
++
++        collapsed.slide_window_slice_3D(slice_input1);
++        collapsed.slide_window_slice_3D(slice_input2);
+     }
+     while(collapsed.slide_window_slice_3D(slice));
+ }
++
++BorderSize CLArithmeticSubtractionKernel::border_size() const
++{
++    const unsigned int replicateSize = _output->info()->dimension(0) - std::min(_input1->info()->dimension(0), _input2->info()->dimension(0));
++    const unsigned int border        = std::min<unsigned int>(num_elems_processed_per_iteration - 1U, replicateSize);
++    return BorderSize(0, border, 0, 0);
++}
+diff --git a/src/core/CL/kernels/CLCastKernel.cpp b/src/core/CL/kernels/CLCastKernel.cpp
+new file mode 100644
+index 0000000..204ae74
+--- /dev/null
++++ b/src/core/CL/kernels/CLCastKernel.cpp
+@@ -0,0 +1,115 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/core/CL/kernels/CLCastKernel.h"
++
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/CLKernelLibrary.h"
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/Helpers.h"
++#include "arm_compute/core/IAccessWindow.h"
++#include "arm_compute/core/TensorInfo.h"
++#include "arm_compute/core/Utils.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/core/Window.h"
++
++using namespace arm_compute;
++
++CLCastKernel::CLCastKernel()
++    : _input(nullptr), _output(nullptr)
++{
++}
++
++void CLCastKernel::configure(const ICLTensor *input, ICLTensor *output)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
++
++    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8, DataType::QASYMM8,
++        DataType::S16, DataType::S32, DataType::F16, DataType::F32);
++    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8, DataType::QASYMM8,
++        DataType::S16, DataType::S32, DataType::F16, DataType::F32);
++    ARM_COMPUTE_ERROR_ON_MISMATCHING_SHAPES(input, output);
++
++    _input = input;
++    _output = output;
++
++    constexpr unsigned int num_elems_processed_per_iteration = 16;
++
++    // Set kernel build options
++    std::set<std::string> build_opts;
++    build_opts.emplace("-DDATA_TYPE_IN=" + get_cl_type_from_data_type(input->info()->data_type()));
++    build_opts.emplace("-DDATA_TYPE_OUT=" + get_cl_type_from_data_type(output->info()->data_type()));
++    build_opts.emplace(("-DVEC_SIZE=" + support::cpp11::to_string(num_elems_processed_per_iteration)));
++
++    // Create kernel
++    if (is_data_type_quantized_asymmetric(input->info()->data_type()))
++    {
++      const float scale_in = input->info()->quantization_info().scale;
++      const int offset_in = input->info()->quantization_info().offset;
++      build_opts.emplace("-DSCALE_IN=" + float_to_string_with_full_precision(scale_in));
++      build_opts.emplace("-DOFFSET_IN=" + support::cpp11::to_string(offset_in));
++
++      _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("cast_qasymm_in", build_opts));
++    }
++    else if (is_data_type_quantized_asymmetric(output->info()->data_type()))
++    {
++      const float scale_in = output->info()->quantization_info().scale;
++      const int offset_in = output->info()->quantization_info().offset;
++      build_opts.emplace("-DSCALE_IN=" + float_to_string_with_full_precision(scale_in));
++      build_opts.emplace("-DOFFSET_IN=" + support::cpp11::to_string(offset_in));
++
++      _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("cast_qasymm_out", build_opts));
++    }
++    else
++    {
++      _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("cast", build_opts));
++    }
++
++    // Configure kernel window
++    Window                 win = calculate_max_window(*input->info(), Steps(num_elems_processed_per_iteration));
++    AccessWindowHorizontal input_access(input->info(), 0, num_elems_processed_per_iteration);
++    AccessWindowHorizontal output_access(output->info(), 0, num_elems_processed_per_iteration);
++    update_window_and_padding(win, input_access, output_access);
++    output_access.set_valid_region(win, input->info()->valid_region());
++
++    ICLKernel::configure(win);
++}
++
++void CLCastKernel::run(const Window &window, cl::CommandQueue &queue)
++{
++    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICLKernel::window(), window);
++
++    Window collapsed = window.collapse_if_possible(ICLKernel::window(), Window::DimZ);
++    Window slice     = collapsed.first_slice_window_3D();
++
++    do
++    {
++        unsigned int idx = 0;
++        add_3D_tensor_argument(idx, _input, slice);
++        add_3D_tensor_argument(idx, _output, slice);
++        enqueue(queue, *this, slice);
++    }
++    while(collapsed.slide_window_slice_3D(slice));
++}
+diff --git a/src/core/CL/kernels/CLGatherKernel.cpp b/src/core/CL/kernels/CLGatherKernel.cpp
+new file mode 100644
+index 0000000..0a83008
+--- /dev/null
++++ b/src/core/CL/kernels/CLGatherKernel.cpp
+@@ -0,0 +1,147 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/core/CL/kernels/CLGatherKernel.h"
++
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/CLKernelLibrary.h"
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/OpenCL.h"
++#include "arm_compute/core/Error.h"
++#include "arm_compute/core/Helpers.h"
++#include "arm_compute/core/TensorInfo.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/core/Window.h"
++
++#include <cmath>
++#include <cstdlib>
++#include <set>
++#include <string>
++
++using namespace arm_compute;
++
++namespace
++{
++constexpr unsigned int num_elems_processed_per_iteration = 16;
++
++Status validate_arguments(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output)
++{
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input1, 1, DataType::U8, DataType::S32, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input2, 1, DataType::S32);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8, DataType::S32, DataType::F32);
++
++    return Status{};
++}
++
++} // namespace
++
++CLGatherKernel::CLGatherKernel()
++    : _input1(nullptr), _input2(nullptr), _output(nullptr)
++{
++}
++
++void CLGatherKernel::configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
++    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input2, 1, DataType::S32);
++    ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input1, output);
++
++    _input1 = input1;
++    _input2 = input2;
++    _output = output;
++
++    // Construct kernel name
++    std::string kernel_name = "gather";
++    if (input1->info()->num_dimensions()==1)
++    {
++        kernel_name = "gather_1d";
++    }
++    else if (input1->info()->num_dimensions()==2)
++    {
++        if(_output->info()->num_dimensions()==1)
++        {
++            kernel_name = "gather_1d_out";
++        }
++    }
++
++    // Set kernel build options
++    std::set<std::string> build_opts;
++    build_opts.emplace("-DDATA_TYPE_IN1=" + get_cl_type_from_data_type(input1->info()->data_type()));
++    build_opts.emplace("-DDATA_TYPE_IN2=" + get_cl_type_from_data_type(input2->info()->data_type()));
++    build_opts.emplace("-DDATA_TYPE_OUT=" + get_cl_type_from_data_type(output->info()->data_type()));
++
++    // Create kernel
++    _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel(kernel_name, build_opts));
++
++    // Configure kernel window
++    const unsigned int num_elems_processed_per_iteration = 1;
++    Window win = calculate_max_window(*input2->info(), Steps(num_elems_processed_per_iteration));
++    output->info()->set_valid_region(ValidRegion(Coordinates(), output->info()->tensor_shape()));
++
++    ICLKernel::configure(win);
++}
++
++Status CLGatherKernel::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
++    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input1, input2, output));
++
++    return Status{};
++}
++
++void CLGatherKernel::run(const Window &window, cl::CommandQueue &queue)
++{
++    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++    if (_input1->info()->num_dimensions()==1)
++    {
++        Window slice = window.first_slice_window_1D();
++
++        unsigned int idx = 0;
++        add_1D_tensor_argument(idx, _input1, slice);
++        add_1D_tensor_argument(idx, _input2, slice);
++        add_1D_tensor_argument(idx, _output, slice);
++        enqueue(queue, *this, slice);
++    }
++    else if (_input1->info()->num_dimensions()==2)
++    {
++        Window window_collapsed = window.collapse_if_possible(ICLKernel::window(), Window::DimY);
++        Window slice            = window.collapse_if_possible(ICLKernel::window(), Window::DimX);
++
++        //Set inputs
++        unsigned int idx = 0;
++        add_2D_tensor_argument(idx, _input1, window_collapsed);
++        add_1D_tensor_argument(idx, _input2, slice);
++        if(_output->info()->num_dimensions()==1)
++        {
++            add_1D_tensor_argument(idx, _output, slice);
++        }
++        else
++        {
++            add_2D_tensor_argument(idx, _output, window_collapsed);
++        }
++        enqueue(queue, *this, slice);
++    }
++}
+diff --git a/src/core/CL/kernels/CLPixelWiseDivisionKernel.cpp b/src/core/CL/kernels/CLPixelWiseDivisionKernel.cpp
+new file mode 100644
+index 0000000..26cb3e2
+--- /dev/null
++++ b/src/core/CL/kernels/CLPixelWiseDivisionKernel.cpp
+@@ -0,0 +1,284 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/core/CL/kernels/CLPixelWiseDivisionKernel.h"
++
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/CLKernelLibrary.h"
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/OpenCL.h"
++#include "arm_compute/core/Error.h"
++#include "arm_compute/core/Helpers.h"
++#include "arm_compute/core/TensorInfo.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/core/Window.h"
++
++#include <cmath>
++#include <cstdlib>
++#include <set>
++#include <string>
++
++using namespace arm_compute;
++
++namespace
++{
++constexpr unsigned int num_elems_processed_per_iteration = 16;
++
++Status validate_arguments(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, float scale,
++                          ConvertPolicy overflow_policy, RoundingPolicy rounding_policy)
++{
++    ARM_COMPUTE_UNUSED(overflow_policy);
++    ARM_COMPUTE_UNUSED(rounding_policy);
++
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input1, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input2, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_MSG(scale < 0, "Scale cannot be negative.");
++
++    const TensorShape &out_shape = TensorShape::broadcast_shape(input1->tensor_shape(), input2->tensor_shape());
++
++    ARM_COMPUTE_RETURN_ERROR_ON_MSG(out_shape.total_size() == 0, "Inputs are not broadcast compatible");
++    ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_FIXED_POINT(input1, input2);
++
++    if(is_data_type_fixed_point(input1->data_type()))
++    {
++        // All data types must be all QS8 or all QS16
++        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input1, input2);
++        ARM_COMPUTE_RETURN_ERROR_ON_MSG(scale != 1, "Unsupported scaling factor for QS8/QS16. Scale must be 1.");
++    }
++
++    // Validate in case of configured output
++    if(output->total_size() > 0)
++    {
++        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++        ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->data_type() == DataType::U8 && (input1->data_type() != DataType::U8 || input2->data_type() != DataType::U8),
++                                        "Output can only be U8 if both inputs are U8");
++        ARM_COMPUTE_RETURN_ERROR_ON_MSG(detail::have_different_dimensions(out_shape, output->tensor_shape(), 0), "Wrong shape for output");
++        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_FIXED_POINT(input1, output);
++        if(is_data_type_fixed_point(input1->data_type()))
++        {
++            ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input1, output);
++        }
++    }
++
++    return Status{};
++}
++
++std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output)
++{
++    const std::pair<TensorShape, ValidRegion> broadcast_pair = ITensorInfo::broadcast_shape_and_valid_region(*input1, *input2);
++    const TensorShape &out_shape    = broadcast_pair.first;
++    const ValidRegion &valid_region = broadcast_pair.second;
++
++    // Auto initialize output if not initialized
++    {
++        set_shape_if_empty(*output, out_shape);
++
++        if(input1->data_type() == DataType::S16 || input2->data_type() == DataType::S16)
++        {
++            set_format_if_unknown(*output, Format::S16);
++        }
++        else if(input1->data_type() == DataType::F32 || input2->data_type() == DataType::F32)
++        {
++            set_format_if_unknown(*output, Format::F32);
++        }
++    }
++
++    Window win        = calculate_max_window(valid_region, Steps(num_elems_processed_per_iteration));
++    Window win_input1 = win.broadcast_if_dimension_le_one(*input1);
++    Window win_input2 = win.broadcast_if_dimension_le_one(*input2);
++
++    AccessWindowHorizontal input1_access(input1, 0, num_elems_processed_per_iteration);
++    AccessWindowHorizontal input2_access(input2, 0, num_elems_processed_per_iteration);
++    AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration);
++
++    bool window_changed = update_window_and_padding(win_input1, input1_access)
++                          || update_window_and_padding(win_input2, input2_access)
++                          || update_window_and_padding(win, output_access);
++
++    output_access.set_valid_region(win, valid_region);
++
++    Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{};
++    return std::make_pair(err, win);
++}
++} // namespace
++
++CLPixelWiseDivisionKernel::CLPixelWiseDivisionKernel()
++    : _input1(nullptr), _input2(nullptr), _output(nullptr)
++{
++}
++
++void CLPixelWiseDivisionKernel::configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, float scale,
++                                                ConvertPolicy overflow_policy, RoundingPolicy rounding_policy)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
++    ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input1->info(), input2->info(), output->info(),
++                                                  scale, overflow_policy, rounding_policy));
++
++    // Configure kernel window
++    auto win_config = validate_and_configure_window(input1->info(), input2->info(), output->info());
++    ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
++
++    _input1 = input1;
++    _input2 = input2;
++    _output = output;
++
++    int scale_int = -1;
++    // Extract sign, exponent and mantissa
++    int   exponent            = 0;
++    float normalized_mantissa = std::frexp(scale, &exponent);
++    // Use int scaling if factor is equal to 1/2^n for 0 <= n <= 15
++    // frexp returns 0.5 as mantissa which means that the exponent will be in the range of -1 <= e <= 14
++    // Moreover, it will be negative as we deal with 1/2^n
++    if((normalized_mantissa == 0.5f) && (-14 <= exponent) && (exponent <= 1))
++    {
++        // Store the positive exponent. We know that we compute 1/2^n
++        // Additionally we need to subtract 1 to compensate that frexp used a mantissa of 0.5
++        scale_int = std::abs(exponent - 1);
++    }
++
++    std::string data_type;
++    std::string compute_type;
++    // Check if it has float inputs and output
++    if(is_data_type_float(input1->info()->data_type()) || is_data_type_float(input2->info()->data_type()))
++    {
++        scale_int    = -1;
++        compute_type = (input1->info()->data_type() == DataType::F32 || input2->info()->data_type() == DataType::F32) ? "float" : "half";
++        data_type    = "DATA_TYPE_FLOAT";
++    }
++    else
++    {
++        if(input1->info()->data_type() == DataType::S16 || input2->info()->data_type() == DataType::S16)
++        {
++            compute_type = "int";
++        }
++        else if(input1->info()->data_type() == DataType::QS8)
++        {
++            compute_type = "qs8";
++        }
++        else if(input1->info()->data_type() == DataType::QS16)
++        {
++            compute_type = "qs16";
++        }
++        else
++        {
++            compute_type = "ushort";
++        }
++        data_type = "DATA_TYPE_INT";
++    }
++
++    // Construct kernel name
++    std::string kernel_name = "pixelwise_div";
++    kernel_name += (scale_int >= 0) ? "_int" : "_float";
++
++    // Set kernel build options
++    std::set<std::string> build_opts;
++    build_opts.emplace((overflow_policy == ConvertPolicy::WRAP || is_data_type_float(output->info()->data_type())) ? "-DWRAP" : "-DSATURATE");
++    build_opts.emplace((rounding_policy == RoundingPolicy::TO_ZERO) ? "-DROUND=_rtz" : "-DROUND=_rte");
++    if(is_data_type_fixed_point(input1->info()->data_type()))
++    {
++        build_opts.emplace("-DFIXED_POINT_POSITION=" + support::cpp11::to_string(input1->info()->fixed_point_position()));
++    }
++    build_opts.emplace("-DDATA_TYPE_IN1=" + get_cl_type_from_data_type(input1->info()->data_type()));
++    build_opts.emplace("-DDATA_TYPE_IN2=" + get_cl_type_from_data_type(input2->info()->data_type()));
++    build_opts.emplace("-DDATA_TYPE_OUT=" + get_cl_type_from_data_type(output->info()->data_type()));
++    build_opts.emplace("-DDATA_TYPE_RES=" + compute_type);
++    build_opts.emplace("-D" + data_type);
++
++    // Create kernel
++    _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel(kernel_name, build_opts));
++
++    // Set scale argument
++    unsigned int idx = 3 * num_arguments_per_3D_tensor(); //Skip the inputs and output parameters
++
++    if(scale_int >= 0)
++    {
++        _kernel.setArg(idx++, scale_int);
++    }
++    else
++    {
++        _kernel.setArg(idx++, scale);
++    }
++
++    ICLKernel::configure(win_config.second);
++}
++
++Status CLPixelWiseDivisionKernel::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, float scale,
++                                                 ConvertPolicy overflow_policy, RoundingPolicy rounding_policy)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);
++    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input1, input2, output, scale, overflow_policy, rounding_policy));
++    ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input1->clone().get(), input2->clone().get(), output->clone().get()).first);
++
++    return Status{};
++}
++
++void CLPixelWiseDivisionKernel::run(const Window &window, cl::CommandQueue &queue)
++{
++    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICLKernel::window(), window);
++
++    const TensorShape &in_shape1 = _input1->info()->tensor_shape();
++    const TensorShape &in_shape2 = _input2->info()->tensor_shape();
++    const TensorShape &out_shape = _output->info()->tensor_shape();
++
++    bool can_collapse = true;
++    if(std::min(in_shape1.total_size(), in_shape2.total_size()) > 1)
++    {
++        can_collapse = (std::min(in_shape1.num_dimensions(), in_shape2.num_dimensions()) > Window::DimZ);
++        for(size_t d = Window::DimZ; can_collapse && (d < out_shape.num_dimensions()); ++d)
++        {
++            can_collapse = (in_shape1[d] == in_shape2[d]);
++        }
++    }
++
++    bool   has_collapsed = false;
++    Window collapsed     = can_collapse ? window.collapse_if_possible(ICLKernel::window(), Window::DimZ, &has_collapsed) : window;
++
++    const TensorShape &in_shape1_collapsed = has_collapsed ? in_shape1.collapsed_from(Window::DimZ) : in_shape1;
++    const TensorShape &in_shape2_collapsed = has_collapsed ? in_shape2.collapsed_from(Window::DimZ) : in_shape2;
++
++    Window slice        = collapsed.first_slice_window_3D();
++    Window slice_input1 = slice.broadcast_if_dimension_le_one(in_shape1_collapsed);
++    Window slice_input2 = slice.broadcast_if_dimension_le_one(in_shape2_collapsed);
++
++    do
++    {
++        unsigned int idx = 0;
++        add_3D_tensor_argument(idx, _input1, slice_input1);
++        add_3D_tensor_argument(idx, _input2, slice_input2);
++        add_3D_tensor_argument(idx, _output, slice);
++        enqueue(queue, *this, slice);
++
++        collapsed.slide_window_slice_3D(slice_input1);
++        collapsed.slide_window_slice_3D(slice_input2);
++    }
++    while(collapsed.slide_window_slice_3D(slice));
++}
++
++BorderSize CLPixelWiseDivisionKernel::border_size() const
++{
++    const unsigned int replicateSize = _output->info()->dimension(0) - std::min(_input1->info()->dimension(0), _input2->info()->dimension(0));
++    const unsigned int border        = std::min<unsigned int>(num_elems_processed_per_iteration - 1U, replicateSize);
++    return BorderSize(0, border, 0, 0);
++}
+diff --git a/src/core/CL/kernels/CLPixelWiseMultiplicationKernel.cpp b/src/core/CL/kernels/CLPixelWiseMultiplicationKernel.cpp
+index f30ba61..8aa77ae 100644
+--- a/src/core/CL/kernels/CLPixelWiseMultiplicationKernel.cpp
++++ b/src/core/CL/kernels/CLPixelWiseMultiplicationKernel.cpp
+@@ -32,6 +32,7 @@
+ #include "arm_compute/core/TensorInfo.h"
+ #include "arm_compute/core/Validate.h"
+ #include "arm_compute/core/Window.h"
++#include "arm_compute/core/utils/quantization/AsymmHelpers.h"
+ 
+ #include <cmath>
+ #include <cstdlib>
+@@ -50,8 +51,13 @@ Status validate_arguments(const ITensorInfo *input1, const ITensorInfo *input2,
+     ARM_COMPUTE_UNUSED(overflow_policy);
+     ARM_COMPUTE_UNUSED(rounding_policy);
+ 
+-    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input1, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
+-    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input2, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input1, 1, DataType::U8, DataType::QS8, DataType::QASYMM8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input2, 1, DataType::U8, DataType::QS8, DataType::QASYMM8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++    if (is_data_type_quantized_asymmetric(output->data_type()))
++    {
++        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(output, input1);
++        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(output, input2);
++    }
+     ARM_COMPUTE_RETURN_ERROR_ON_MSG(scale < 0, "Scale cannot be negative.");
+ 
+     const TensorShape &out_shape = TensorShape::broadcast_shape(input1->tensor_shape(), input2->tensor_shape());
+@@ -69,7 +75,7 @@ Status validate_arguments(const ITensorInfo *input1, const ITensorInfo *input2,
+     // Validate in case of configured output
+     if(output->total_size() > 0)
+     {
+-        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8, DataType::QS8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
++        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::U8, DataType::QS8, DataType::QASYMM8, DataType::QS16, DataType::S16, DataType::F16, DataType::F32);
+         ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->data_type() == DataType::U8 && (input1->data_type() != DataType::U8 || input2->data_type() != DataType::U8),
+                                         "Output can only be U8 if both inputs are U8");
+         ARM_COMPUTE_RETURN_ERROR_ON_MSG(detail::have_different_dimensions(out_shape, output->tensor_shape(), 0), "Wrong shape for output");
+@@ -188,7 +194,15 @@ void CLPixelWiseMultiplicationKernel::configure(const ICLTensor *input1, const I
+ 
+     // Construct kernel name
+     std::string kernel_name = "pixelwise_mul";
+-    kernel_name += (scale_int >= 0) ? "_int" : "_float";
++    if (is_data_type_quantized_asymmetric(output->info()->data_type()))
++    {
++        compute_type = "qasymm8";
++        kernel_name += "_qasymm8";
++    }
++    else
++    {
++        kernel_name += (scale_int >= 0) ? "_int" : "_float";
++    }
+ 
+     // Set kernel build options
+     std::set<std::string> build_opts;
+@@ -204,6 +218,21 @@ void CLPixelWiseMultiplicationKernel::configure(const ICLTensor *input1, const I
+     build_opts.emplace("-DDATA_TYPE_RES=" + compute_type);
+     build_opts.emplace("-D" + data_type);
+ 
++    if (is_data_type_quantized_asymmetric(output->info()->data_type()))
++    {
++        const QuantizationInfo output_quant_info = (output->info()->total_size() == 0) ? input1->info()->quantization_info() : output->info()->quantization_info();
++
++        float multiplier = input1->info()->quantization_info().scale * input2->info()->quantization_info().scale / output_quant_info.scale;
++        int   output_multiplier, output_shift;
++        quantization::calculate_quantized_multiplier_less_than_one(multiplier, &output_multiplier, &output_shift);
++
++        build_opts.emplace("-DRESULT_MULT_INT=" + support::cpp11::to_string(output_multiplier));
++        build_opts.emplace("-DRESULT_SHIFT=" + support::cpp11::to_string(output_shift));
++        build_opts.emplace("-DIN1_OFFSET=" + support::cpp11::to_string(-(input1->info()->quantization_info().offset)));
++        build_opts.emplace("-DIN2_OFFSET=" + support::cpp11::to_string(-(input2->info()->quantization_info().offset)));
++        build_opts.emplace("-DRESULT_OFFSET=" + support::cpp11::to_string(output->info()->quantization_info().offset));
++        // TODO: Apply min-max BOUND to support fuse with relu.
++    }
+     // Create kernel
+     _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel(kernel_name, build_opts));
+ 
+diff --git a/src/core/CL/kernels/CLReduceMaxKernel.cpp b/src/core/CL/kernels/CLReduceMaxKernel.cpp
+new file mode 100644
+index 0000000..cb1ee03
+--- /dev/null
++++ b/src/core/CL/kernels/CLReduceMaxKernel.cpp
+@@ -0,0 +1,135 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/core/CL/kernels/CLReduceMaxKernel.h"
++
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/CLKernelLibrary.h"
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/OpenCL.h"
++#include "arm_compute/core/Error.h"
++#include "arm_compute/core/Helpers.h"
++#include "arm_compute/core/TensorInfo.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/core/Window.h"
++
++#include <cmath>
++#include <cstdlib>
++#include <set>
++#include <string>
++
++using namespace arm_compute;
++
++namespace
++{
++constexpr unsigned int num_elems_processed_per_iteration = 16;
++
++Status validate_arguments(const ITensorInfo *input, int32_t axis, const ITensorInfo *output)
++{
++    // We can handle for simple case only
++    // Input rank: 2
++    // Output rank: 1
++    // Axis: one axis value, restrict to 1
++
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F16, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON_MSG(axis != 1, "Axis only allowed 1");
++
++    ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->tensor_shape().total_size() == 0, "Inputs are not broadcast compatible");
++
++    // Validate in case of configured output
++    if(output->total_size() > 0)
++    {
++        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::F16, DataType::F32);
++        ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->data_type() != input->data_type(),
++                                        "Output same type allowed for input and output");
++        ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->tensor_shape().num_dimensions() != 1, "Only support for output dimension 1");
++        ARM_COMPUTE_RETURN_ERROR_ON_MSG(input->tensor_shape().num_dimensions() != 2, "Only support for input dimension 2");
++    }
++
++    return Status{};
++}
++
++} // namespace
++
++CLReduceMaxKernel::CLReduceMaxKernel()
++    : _input(nullptr), _output(nullptr), _axis(0)
++{
++}
++
++void CLReduceMaxKernel::configure(const ICLTensor *input, int32_t axis, ICLTensor *output)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
++    ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), axis, output->info()));
++
++    _input = input;
++    _output = output;
++    _axis = axis;
++
++    // Configure kernel window
++    int cols = _input->info()->tensor_shape()[0];
++    int rows = _input->info()->tensor_shape()[1];
++    Window win;
++    win.set(0, Window::Dimension(0, cols, 1));
++    win.set(1, Window::Dimension(0, rows, 1));
++
++    // Construct kernel name
++    std::string kernel_name = "reduce_max";
++
++    // Set kernel build options
++    std::set<std::string> build_opts;
++    build_opts.emplace("-DWIDTH=" + support::cpp11::to_string(cols));
++
++    // Create kernel
++    _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel(kernel_name, build_opts));
++
++    ICLKernel::configure(win);
++}
++
++Status CLReduceMaxKernel::validate(const ITensorInfo *input, int32_t axis, const ITensorInfo *output)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
++    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, axis, output));
++
++    return Status{};
++}
++
++void CLReduceMaxKernel::run(const Window &window, cl::CommandQueue &queue)
++{
++    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICLKernel::window(), window);
++
++    Window window_input = window;
++    Window slice_input = window_input.first_slice_window_1D();
++
++    do
++    {
++        Window slice_output = slice_input.shift_dimensions(1);
++        unsigned int idx = 0;
++        add_1D_tensor_argument(idx, _input, slice_input);
++        add_1D_tensor_argument(idx, _output, slice_output);
++        enqueue(queue, *this, slice_input);
++
++    }
++    while(window_input.slide_window_slice_1D(slice_input));
++}
+diff --git a/src/core/CL/kernels/CLReductionMeanKernel.cpp b/src/core/CL/kernels/CLReductionMeanKernel.cpp
+new file mode 100644
+index 0000000..8e4dc38
+--- /dev/null
++++ b/src/core/CL/kernels/CLReductionMeanKernel.cpp
+@@ -0,0 +1,190 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/core/CL/kernels/CLReductionMeanKernel.h"
++
++#include "arm_compute/core/AccessWindowStatic.h"
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/CLKernelLibrary.h"
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/FixedPoint.h"
++#include "arm_compute/core/Helpers.h"
++#include "arm_compute/core/TensorInfo.h"
++#include "arm_compute/core/Utils.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/core/Window.h"
++
++#include "support/ToolchainSupport.h"
++
++using namespace arm_compute;
++
++namespace
++{
++Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, std::vector<uint32_t> axis)
++{
++    ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
++    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F32);
++    ARM_COMPUTE_RETURN_ERROR_ON(input->data_layout() != DataLayout::NCHW);
++    ARM_COMPUTE_RETURN_ERROR_ON_MSG(axis.size() >= TensorShape::num_max_dimensions, "Reduction axis greater than max number of dimensions");
++
++    std::vector<uint32_t>::const_iterator it;
++    bool axis_w = false;
++    bool axis_h = false;
++    for(it=axis.begin(); it!=axis.end(); ++it){
++         if((*it) == 0 )
++        {
++            axis_w = true;
++        }
++        else if((*it) == 1 )
++        {
++            axis_h = true;
++        }
++        else{
++            ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Unsupported axis!");
++        }
++    }
++    //TODO Other axises (currently, only axises for both width and height are supported.)
++    if( !axis_w || !axis_h)
++    {
++        ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Unsupported axis!");
++    }
++
++    if(output->total_size() != 0)
++    {
++        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
++        ARM_COMPUTE_RETURN_ERROR_ON(output->data_layout() != DataLayout::NCHW);
++    }
++
++    return Status{};
++}
++
++std::tuple<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output, std::vector<uint32_t> axis)
++{
++    // Output tensor auto initialization if not yet initialized
++    TensorShape output_shape{ input->tensor_shape() };
++    output_shape.set(0, 1);
++    output_shape.set(1, 1);
++    auto_init_if_empty(*output, output_shape, output->num_channels(), input->data_type(), input->fixed_point_position());
++
++    // Configure kernel window
++    constexpr unsigned int num_elems_processed_per_iteration_x = 8; //step
++    const unsigned int     num_elems_processed_per_iteration_y = input->dimension(1);
++
++    Window                win = calculate_max_window(*input, Steps(num_elems_processed_per_iteration_x, num_elems_processed_per_iteration_y));
++    AccessWindowRectangle input_access(input, 0, 0, num_elems_processed_per_iteration_x, num_elems_processed_per_iteration_y);
++    AccessWindowHorizontal output_access(output, 0, 1);
++    bool window_changed = update_window_and_padding(win, input_access,output_access);
++    output_access.set_valid_region(win, output->valid_region());
++
++    Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{};
++
++    return std::make_tuple(err, win);
++}
++} // namespace
++
++CLReductionMeanKernel::CLReductionMeanKernel()
++    : _input(nullptr), _output(nullptr), _reduction_axis(), _border_size()
++{
++}
++
++BorderSize CLReductionMeanKernel::border_size() const
++{
++    return _border_size;
++}
++
++void CLReductionMeanKernel::configure(const ICLTensor *input, ICLTensor *output, std::vector<uint32_t> axis)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
++
++    ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info(), axis));
++
++    _input          = input;
++    _output         = output;
++    _reduction_axis = axis;
++
++    constexpr unsigned int num_elems_processed_per_iteration_x = 8; //step
++
++    // Set border size
++    _border_size = BorderSize(ceil_to_multiple(input->info()->dimension(0), num_elems_processed_per_iteration_x) - input->info()->dimension(0));
++
++    // Set build options
++    std::set<std::string> build_opts;
++    build_opts.emplace(("-DDATA_TYPE=" + get_cl_type_from_data_type(input->info()->data_type())));
++    // build_opts.emplace(("-DVEC_SIZE=" + support::cpp11::to_string(num_elems_processed_per_iteration)));
++    if(is_data_type_fixed_point(input->info()->data_type()))
++    {
++        build_opts.emplace("-DFIXED_POINT_POSITION=" + support::cpp11::to_string(input->info()->fixed_point_position()));
++    }
++
++    // Create kernel
++    _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("reduction_mean", build_opts));
++
++    // Configure kernel window
++    auto win_config = validate_and_configure_window(_input->info(), _output->info(), axis);
++
++    ARM_COMPUTE_ERROR_THROW_ON(std::get<0>(win_config));
++
++    ICLKernel::configure(std::get<1>(win_config));
++}
++
++Status CLReductionMeanKernel::validate(const ITensorInfo *input, const ITensorInfo *output, std::vector<uint32_t> axis)
++{
++    ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, axis));
++    ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), output->clone().get(), axis)));
++
++    return Status{};
++}
++
++void CLReductionMeanKernel::run(const Window &window, cl::CommandQueue &queue)
++{
++    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++    // Set out window
++    Window out_window(window);
++    out_window.set(Window::DimX, Window::Dimension(0, 0, 0));
++
++    // Get first input and output slices
++    Window in_slice = window.first_slice_window_2D();
++    Window out_slice = out_window.first_slice_window_2D();
++
++    // Set local sums buffer
++    // TODO work_group
++    unsigned int local_sum_size = _lws_hint[0] * _input->info()->element_size();
++
++    unsigned int idx = 2 * num_arguments_per_2D_tensor();
++    _kernel.setArg(idx++, local_sum_size, nullptr);
++    _kernel.setArg<cl_int>(idx++, static_cast<cl_int>(_input->info()->dimension(1)));//height
++    _kernel.setArg<cl_int>(idx++, static_cast<cl_int>(_input->info()->dimension(0)*_input->info()->dimension(1)));//divider
++
++    do
++    {
++        unsigned int idx = 0;
++        add_2D_tensor_argument(idx, _input, in_slice);
++        in_slice.set_dimension_step(Window::DimY, _input->info()->dimension(1));
++        add_2D_tensor_argument(idx, _output, out_slice);
++        enqueue(queue, *this, in_slice);
++    }
++    while(window.slide_window_slice_2D(in_slice) && window.slide_window_slice_2D(out_slice));
++}
+diff --git a/src/core/CL/kernels/CLStridedSliceKernel.cpp b/src/core/CL/kernels/CLStridedSliceKernel.cpp
+new file mode 100644
+index 0000000..b57cf20
+--- /dev/null
++++ b/src/core/CL/kernels/CLStridedSliceKernel.cpp
+@@ -0,0 +1,316 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/core/CL/kernels/CLStridedSliceKernel.h"
++
++#include "arm_compute/core/AccessWindowStatic.h"
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/CLKernelLibrary.h"
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/OpenCL.h"
++#include "arm_compute/core/Helpers.h"
++#include "arm_compute/core/IAccessWindow.h"
++#include "arm_compute/core/TensorInfo.h"
++#include "arm_compute/core/Utils.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/core/Window.h"
++
++#include <string>
++
++
++using namespace std;
++using namespace arm_compute;
++
++static const int32_t maxDim = 4;
++
++CLStridedSliceKernel::CLStridedSliceKernel()
++    : _input(nullptr), _output(nullptr), _beginData(nullptr), _endData(nullptr), _stridesData(nullptr), _beginMask(0), _endMask(0), _shrinkAxisMask(0)
++{
++}
++
++Status CLStridedSliceKernel::validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *begin, const ITensorInfo *end, const ITensorInfo *strides, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask)
++{
++    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output, begin, end, strides);
++    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8, DataType::S8, DataType::QS8, DataType::QASYMM8,
++                                                  DataType::U16, DataType::S16, DataType::QS16,
++                                                  DataType::U32, DataType::S32, DataType::F16, DataType::F32);
++    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(begin, 1, DataType::S32);
++    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(end, 1, DataType::S32);
++    ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(strides, 1, DataType::S32);
++    ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
++
++    ARM_COMPUTE_ERROR_ON(begin->num_dimensions() != 1 || begin->dimension(0) > 4);
++    ARM_COMPUTE_ERROR_ON_MISMATCHING_DIMENSIONS(begin->tensor_shape(), end->tensor_shape(), strides->tensor_shape());
++
++    return Status{};
++}
++
++// Return the index for the first element along that axis. This index will be a
++// positive integer between [0, axisSize - 1] that can be used to index
++// directly into the data.
++inline int32_t StartForAxis(int32_t beginMask, int32_t begin, int32_t stride, const TensorShape &inputShape, int32_t axis)
++{
++    // Begin with the specified index
++    int32_t start = begin;
++
++    // beginMask override
++    if (beginMask & 1 << axis)
++    {
++        if (stride > 0)
++        {
++            // Forward iteration - use the first element. These values will get
++            // clamped below (Note: We could have set them to 0 and axisSize-1, but
++            // use lowest() and max() to maintain symmetry with StopForAxis())
++            start = std::numeric_limits<int32_t>::lowest();
++        }
++        else
++        {
++            // Backward iteration - use the last element.
++            start = std::numeric_limits<int32_t>::max();
++        }
++    }
++
++    // Handle negative indices
++    int32_t axisSize = inputShape[axis];
++    if (start < 0)
++    {
++        start += axisSize;
++    }
++
++    // Clamping
++    start = arm_compute::utility::clamp(start, 0, axisSize - 1);
++
++    return start;
++}
++
++// Return the "real" index for the end of iteration along that axis. This is an
++// "end" in the traditional C sense, in that it points to one past the last
++// element. ie. So if you were iterating through all elements of a 1D array of
++// size 4, this function would return 4 as the stop, because it is one past the
++// "real" indices of 0, 1, 2 & 3.
++inline int32_t StopForAxis(int32_t endMask, int32_t end, int32_t stride, const TensorShape &inputShape, int32_t axis)
++{
++    // Begin with the specified index
++    int32_t stop = end;
++
++    // endMask override
++    if (endMask & (1 << axis))
++    {
++        if (stride > 0)
++        {
++            // Forward iteration - use the last element. These values will get
++            // clamped below
++            stop = std::numeric_limits<int32_t>::max();
++        }
++        else
++        {
++            // Backward iteration - use the first element.
++            stop = std::numeric_limits<int32_t>::lowest();
++        }
++    }
++
++    // Handle negative indices
++    int32_t axisSize = inputShape[axis];
++    if (stop < 0) {
++        stop += axisSize;
++    }
++
++    // Clamping
++    // Because the end index points one past the last element, we need slightly
++    // different clamping ranges depending on the direction.
++    if (stride > 0)
++    {
++        // Forward iteration
++        stop = arm_compute::utility::clamp(stop, 0, axisSize);
++    }
++    else
++    {
++        // Backward iteration
++        stop = arm_compute::utility::clamp(stop, -1, axisSize - 1);
++    }
++
++    return stop;
++}
++
++inline int32_t offset4D(const TensorShape &shape, int32_t b, int32_t d, int32_t h, int32_t w)
++{
++    int32_t offset = b * shape[2] * shape[1] * shape[0];
++    offset += d * shape[1] * shape[0];
++    offset += h * shape[0];
++    offset += w;
++    return offset;
++}
++
++inline int32_t getOutDim(int32_t start, int32_t stop, int32_t stride)
++{
++    int32_t ret = 0;
++    if (stride > 0)
++    {
++        ret = ((stop - start - 1) / stride) + 1;
++    }
++    else
++    {
++        ret = ((stop - start + 1) / stride) + 1;
++    }
++    ARM_COMPUTE_ERROR_ON_MSG(ret < 0, "The dimension must be the natural number");
++    return ret;
++}
++
++void CLStridedSliceKernel::configure(const ICLTensor *input, ICLTensor *output, ICLTensor *beginData, ICLTensor *endData, ICLTensor *stridesData, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask)
++{
++    ARM_COMPUTE_ERROR_THROW_ON(validate(input->info(), output->info(), beginData->info(), endData->info(), stridesData->info(), beginMask, endMask, shrinkAxisMask));
++
++    _input = input;
++    _output = output;
++    _beginData = beginData;
++    _endData = endData;
++    _stridesData = stridesData;
++    _beginMask = beginMask;
++    _endMask = endMask;
++    _shrinkAxisMask = shrinkAxisMask;
++
++    constexpr unsigned int num_elems_processed_per_iteration = 1;
++
++    // Set kernel build options
++    std::set<std::string> build_opts;
++    build_opts.emplace("-DELEMENT_DATA_TYPE=" + get_cl_type_from_data_type(input->info()->data_type()));
++    build_opts.emplace("-DELEMENT_SIZE=" + support::cpp11::to_string(input->info()->element_size()));
++
++    // Create kernel
++    _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("strided_slice", build_opts));
++
++    // Create output's window without padding
++    TensorShape collapsed = output->info()->tensor_shape();
++    collapsed.collapse(4);
++    TensorInfo info = *output->info();
++    info.set_tensor_shape(collapsed);
++    Window win = calculate_max_window(info, Steps(num_elems_processed_per_iteration));
++
++    ICLKernel::configure(win);
++}
++
++void CLStridedSliceKernel::run(const Window &window, cl::CommandQueue &queue)
++{
++    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++    // Create input window
++    TensorShape collapsed = _input->info()->tensor_shape();
++    collapsed.collapse(4);
++    TensorInfo info = *_input->info();
++    info.set_tensor_shape(collapsed);
++    Window win_in = calculate_max_window(info, Steps(_input->info()->tensor_shape().total_size()));
++
++    _beginData->map(queue);
++    _endData->map(queue);
++    _stridesData->map(queue);
++
++    std::vector<int32_t> dimsIn;
++    std::vector<int32_t> dimsOut;
++    std::vector<int32_t> starts;
++    std::vector<int32_t> stops;
++    std::vector<int32_t> strides;
++
++    for (uint32_t n = 0; n < _beginData->info()->tensor_shape().total_size(); ++n)
++    {
++        const TensorShape shape = _input->info()->tensor_shape();
++        starts.emplace_back(StartForAxis(_beginMask, reinterpret_cast<int32_t *>(_beginData->buffer())[n],
++                                           reinterpret_cast<int32_t *>(_stridesData->buffer())[n],
++                                           shape, n));
++
++        stops.emplace_back(StopForAxis(_endMask, reinterpret_cast<int32_t *>(_endData->buffer())[n],
++                                           reinterpret_cast<int32_t *>(_stridesData->buffer())[n],
++                                           shape, n));
++
++        strides.emplace_back(reinterpret_cast<int32_t *>(_stridesData->buffer())[n]);
++        dimsIn.emplace_back(shape[n]);
++        dimsOut.emplace_back(getOutDim(starts[n], stops[n], strides[n]));
++    }
++
++    for (uint32_t n = _beginData->info()->tensor_shape().total_size(); n < 4; n++) {
++        starts.emplace_back(0);
++        stops.emplace_back(1);
++        strides.emplace_back(1);
++        dimsIn.emplace_back(1);
++        dimsOut.emplace_back(1);
++    }
++    // TODO: Apply shrinkAxisMask
++
++    _beginData->unmap(queue);
++    _stridesData->unmap(queue);
++    _endData->unmap(queue);
++
++    // Set parameters
++    unsigned int idx = 2 * num_arguments_per_1D_tensor(); // Skip the input and output parameters
++    const cl_int4 dimsInArg =
++    {
++        {
++            static_cast<cl_int>(dimsIn[0]),
++            static_cast<cl_int>(dimsIn[1]),
++            static_cast<cl_int>(dimsIn[2]),
++            static_cast<cl_int>(dimsIn[3]),
++        }
++    };
++    _kernel.setArg<cl_int4>(idx++, dimsInArg);
++
++    const cl_int4 dimsOutArg =
++    {
++        {
++            static_cast<cl_int>(dimsOut[0]),
++            static_cast<cl_int>(dimsOut[1]),
++            static_cast<cl_int>(dimsOut[2]),
++            static_cast<cl_int>(dimsOut[3]),
++        }
++    };
++    _kernel.setArg<cl_int4>(idx++, dimsOutArg);
++
++    const cl_int4 startsArg =
++    {
++        {
++            static_cast<cl_int>(starts[0]),
++            static_cast<cl_int>(starts[1]),
++            static_cast<cl_int>(starts[2]),
++            static_cast<cl_int>(starts[3]),
++        }
++    };
++    _kernel.setArg<cl_int4>(idx++, startsArg);
++
++    const cl_int4 stridesArg =
++    {
++        {
++            static_cast<cl_int>(strides[0]),
++            static_cast<cl_int>(strides[1]),
++            static_cast<cl_int>(strides[2]),
++            static_cast<cl_int>(strides[3]),
++        }
++    };
++    _kernel.setArg<cl_int4>(idx++, stridesArg);
++
++    // TODO: Apply slicing output's window
++    idx = 0;
++    add_1D_tensor_argument(idx, _input, win_in);
++    add_1D_tensor_argument(idx, _output, window);
++
++    enqueue(queue, *this, window);
++}
+diff --git a/src/core/CL/kernels/CLTopKV2Kernel.cpp b/src/core/CL/kernels/CLTopKV2Kernel.cpp
+new file mode 100644
+index 0000000..08cc6bc
+--- /dev/null
++++ b/src/core/CL/kernels/CLTopKV2Kernel.cpp
+@@ -0,0 +1,479 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/core/CL/kernels/CLTopKV2Kernel.h"
++
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/CLKernelLibrary.h"
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/Helpers.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/core/Window.h"
++
++#include <climits>
++#include <cassert>
++
++namespace arm_compute
++{
++////////////////////////////////////////////////////////////////////////////////
++CLTopKV2Single::CLTopKV2Single()
++  : _input(nullptr), _topk_values(nullptr), _topk_indices(nullptr)
++{}
++
++void CLTopKV2Single::configure(ICLTensor *input, ICLTensor *topk_values,
++    ICLTensor *topk_indices, cl::Buffer *indices,
++    cl::Buffer *temp_stack, int k, int n)
++{
++  ARM_COMPUTE_ERROR_ON(input == nullptr && indices== nullptr);
++  ARM_COMPUTE_ERROR_ON(topk_values == nullptr && topk_indices == nullptr);
++  ARM_COMPUTE_ERROR_ON(n == 0);
++
++  _input = input;
++  _topk_values = topk_values;
++  _topk_indices = topk_indices;
++
++  // Set kernel build options
++  std::set<std::string> build_opts;
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("topkv2_quicksort", build_opts));
++
++  unsigned int idx = 3*num_arguments_per_1D_tensor();
++  _kernel.setArg(idx++, *indices);
++  _kernel.setArg(idx++, *temp_stack);
++  _kernel.setArg<cl_int>(idx++, k);
++  _kernel.setArg<cl_int>(idx++, n);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, 1, 1));
++  ICLKernel::configure(win);
++}
++
++void CLTopKV2Single::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  unsigned int idx = 0;
++  add_1D_tensor_argument(idx, _input, window);
++  add_1D_tensor_argument(idx, _topk_values, window);
++  add_1D_tensor_argument(idx, _topk_indices, window);
++
++  enqueue(queue, *this, window);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLTopKV2Init::CLTopKV2Init()
++  : _input(nullptr)
++{}
++
++void CLTopKV2Init::configure(ICLTensor *input, cl::Buffer* in_key_buf,
++    cl::Buffer* in_ind_buf, int n)
++{
++  ARM_COMPUTE_ERROR_ON(input == nullptr && in_key_buf == nullptr);
++  ARM_COMPUTE_ERROR_ON(in_ind_buf == nullptr);
++  ARM_COMPUTE_ERROR_ON(n == 0);
++
++  _input = input;
++
++  // Set kernel build options
++  std::set<std::string> build_opts;
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("topkv2_init", build_opts));
++
++  unsigned int idx = num_arguments_per_1D_tensor();
++  _kernel.setArg(idx++, *in_key_buf);
++  _kernel.setArg(idx++, *in_ind_buf);
++  _kernel.setArg<cl_int>(idx++, n);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, n, 1));
++  ICLKernel::configure(win);
++}
++
++void CLTopKV2Init::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  unsigned int idx = 0;
++  add_1D_tensor_argument(idx, _input, window);
++
++  enqueue(queue, *this, window);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++// This kernel makes a histogram of radix for each work item.
++CLRadixSortHistogram::CLRadixSortHistogram()
++: _pass(0), _in_key_buf(nullptr)
++{}
++
++void CLRadixSortHistogram::configure(cl::Buffer* hist_buf, int bits, int n)
++{
++  ARM_COMPUTE_ERROR_ON(hist_buf == nullptr);
++
++  unsigned int radix = 1 << bits;
++  // Set kernel build options
++  std::set<std::string> build_opts;
++  build_opts.emplace("-D_BITS=" + support::cpp11::to_string(bits));
++  build_opts.emplace("-D_RADIX=" + support::cpp11::to_string(radix));
++  build_opts.emplace("-DPERMUT=1");
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("radixsort_histogram", build_opts));
++
++  int loc_histo_size = radix * _ITEMS * sizeof(cl_int);
++
++  unsigned int idx = 1;
++  _kernel.setArg(idx++, *hist_buf);
++
++  idx = 3;
++  _kernel.setArg(idx++, loc_histo_size, nullptr);
++  _kernel.setArg<cl_int>(idx++, n);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, _GROUPS*_ITEMS, 1));
++  ICLKernel::configure(win);
++}
++
++void CLRadixSortHistogram::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  _kernel.setArg(0, *_in_key_buf);
++  _kernel.setArg<cl_int>(2, _pass);
++
++  cl::NDRange lws   = cl::NDRange(_ITEMS, 1);
++
++  enqueue(queue, *this, window, lws);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLRadixSortScanHistogram::CLRadixSortScanHistogram()
++{}
++
++void CLRadixSortScanHistogram::configure(cl::Buffer* hist_buf, cl::Buffer* glob_sum_buf, int bits)
++{
++  ARM_COMPUTE_ERROR_ON(hist_buf  == nullptr && glob_sum_buf == nullptr);
++
++  unsigned int radix = 1 << bits;
++  // Set kernel build options
++  std::set<std::string> build_opts;
++  build_opts.emplace("-D_BITS=" + support::cpp11::to_string(bits));
++  build_opts.emplace("-D_RADIX=" + support::cpp11::to_string(radix));
++  build_opts.emplace("-DPERMUT=1");
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("radixsort_scanhistograms", build_opts));
++
++  int temp_size = std::max<uint32_t>(_HISTOSPLIT, _ITEMS * _GROUPS * radix / _HISTOSPLIT) * sizeof(cl_uint);
++
++  unsigned int idx = 0;
++  _kernel.setArg(idx++, *hist_buf);
++  _kernel.setArg(idx++, temp_size, nullptr);
++  _kernel.setArg(idx++, *glob_sum_buf);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, radix * _GROUPS * _ITEMS/2, 1));
++  ICLKernel::configure(win);
++}
++
++void CLRadixSortScanHistogram::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  const unsigned int gws_x = (window.x().end() - window.x().start()) / window.x().step();
++  cl::NDRange lws   = cl::NDRange(gws_x/_HISTOSPLIT, 1);
++
++  enqueue(queue, *this, window, lws);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLRadixSortGlobalScanHistogram::CLRadixSortGlobalScanHistogram()
++{}
++
++void CLRadixSortGlobalScanHistogram::configure(cl::Buffer* glob_sum_buf, cl::Buffer* temp_buf, int bits)
++{
++  ARM_COMPUTE_ERROR_ON(glob_sum_buf == nullptr && temp_buf == nullptr);
++
++  unsigned int radix = 1 << bits;
++  // Set kernel build options
++  std::set<std::string> build_opts;
++  build_opts.emplace("-D_BITS=" + support::cpp11::to_string(bits));
++  build_opts.emplace("-D_RADIX=" + support::cpp11::to_string(radix));
++  build_opts.emplace("-DPERMUT=1");
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("radixsort_scanhistograms", build_opts));
++
++  int temp_size = std::max<uint32_t>(_HISTOSPLIT, _ITEMS * _GROUPS * radix / _HISTOSPLIT) * sizeof(cl_uint);
++
++  unsigned int idx = 0;
++  _kernel.setArg(idx++, *glob_sum_buf);
++  _kernel.setArg(idx++, temp_size, nullptr);
++  _kernel.setArg(idx++, *temp_buf);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, _HISTOSPLIT/2, 1));
++  ICLKernel::configure(win);
++}
++
++void CLRadixSortGlobalScanHistogram::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  const unsigned int gws_x = (window.x().end() - window.x().start()) / window.x().step();
++  cl::NDRange lws   = cl::NDRange(gws_x, 1);
++
++  enqueue(queue, *this, window, lws);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLRadixSortPasteHistogram::CLRadixSortPasteHistogram()
++{}
++
++void CLRadixSortPasteHistogram::configure(cl::Buffer* hist_buf, cl::Buffer* glob_sum_buf, int bits)
++{
++  ARM_COMPUTE_ERROR_ON(hist_buf == nullptr && glob_sum_buf == nullptr);
++
++  unsigned int radix = 1 << bits;
++  // Set kernel build options
++  std::set<std::string> build_opts;
++  build_opts.emplace("-D_BITS=" + support::cpp11::to_string(bits));
++  build_opts.emplace("-D_RADIX=" + support::cpp11::to_string(radix));
++  build_opts.emplace("-DPERMUT=1");
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("radixsort_pastehistograms", build_opts));
++
++  unsigned int idx = 0;
++  _kernel.setArg(idx++, *hist_buf);
++  _kernel.setArg(idx++, *glob_sum_buf);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, radix * _GROUPS * _ITEMS / 2, 1));
++  ICLKernel::configure(win);
++}
++
++void CLRadixSortPasteHistogram::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  const unsigned int gws_x = (window.x().end() - window.x().start()) / window.x().step();
++  cl::NDRange lws   = cl::NDRange(gws_x/_HISTOSPLIT, 1);
++
++  enqueue(queue, *this, window, lws);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLRadixSortReorder::CLRadixSortReorder()
++: _pass(0), _in_key_buf(nullptr), _out_key_buf(nullptr),
++  _in_ind_buf(nullptr), _out_ind_buf(nullptr)
++{}
++
++void CLRadixSortReorder::configure(cl::Buffer *hist_buf, int bits, int n)
++{
++  ARM_COMPUTE_ERROR_ON(hist_buf == nullptr);
++  ARM_COMPUTE_ERROR_ON(n == 0);
++
++  unsigned int radix = 1 << bits;
++  // Set kernel build options
++  std::set<std::string> build_opts;
++  build_opts.emplace("-D_BITS=" + support::cpp11::to_string(bits));
++  build_opts.emplace("-D_RADIX=" + support::cpp11::to_string(radix));
++  build_opts.emplace("-DPERMUT=1");
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("radixsort_reorder", build_opts));
++
++  unsigned int idx = 2;
++  _kernel.setArg(idx++, *hist_buf);
++
++  idx = 6;
++  _kernel.setArg(idx++, sizeof(uint)* radix * _ITEMS, nullptr);
++  _kernel.setArg<cl_int>(idx++, n);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, _GROUPS * _ITEMS, 1));
++  ICLKernel::configure(win);
++}
++
++void CLRadixSortReorder::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  const unsigned int gws_x = (window.x().end() - window.x().start()) / window.x().step();
++  unsigned int lx = std::max(1U, (gws_x / _HISTOSPLIT));
++  cl::NDRange lws   = (lx < gws_x) ? cl::NDRange(lx, 1) : cl::NDRange(1, 1);
++
++  _kernel.setArg(0, *_in_key_buf);
++  _kernel.setArg(1, *_out_key_buf);
++  _kernel.setArg<cl_int>(3, _pass);
++  _kernel.setArg(4, *_in_ind_buf);
++  _kernel.setArg(5, *_out_ind_buf);
++
++  enqueue(queue, *this, window, lws);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLTopKV2FindFirstNegative::CLTopKV2FindFirstNegative()
++: _out_key_buf(nullptr)
++{}
++
++void CLTopKV2FindFirstNegative::configure(cl::Buffer *first_negative_idx_buf, int n)
++{
++  ARM_COMPUTE_ERROR_ON(first_negative_idx_buf == nullptr);
++  ARM_COMPUTE_ERROR_ON(n == 0);
++
++  // Set kernel build options
++  std::set<std::string> build_opts;
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("topkv2_find_first_negative", build_opts));
++
++  unsigned int idx = 1;
++  _kernel.setArg(idx++, *first_negative_idx_buf);
++  _kernel.setArg<cl_int>(idx++, n);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, n, 1));
++  ICLKernel::configure(win);
++}
++
++void CLTopKV2FindFirstNegative::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  unsigned int idx = 0;
++  _kernel.setArg(idx++, *_out_key_buf);
++
++  enqueue(queue, *this, window);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLTopKV2ReorderNegatives::CLTopKV2ReorderNegatives()
++: _in_key_buf(nullptr), _out_key_buf(nullptr),
++  _in_ind_buf(nullptr), _out_ind_buf(nullptr)
++{}
++
++void CLTopKV2ReorderNegatives::configure(cl::Buffer *first_negative_idx_buf, int n)
++{
++  ARM_COMPUTE_ERROR_ON(first_negative_idx_buf == nullptr);
++  ARM_COMPUTE_ERROR_ON(n == 0);
++
++  // Set kernel build options
++  std::set<std::string> build_opts;
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("topkv2_reorder_negatives", build_opts));
++
++  unsigned int idx = 4;
++  _kernel.setArg(idx++, *first_negative_idx_buf);
++  _kernel.setArg<cl_int>(idx++, n);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, n, 1));
++  ICLKernel::configure(win);
++}
++
++void CLTopKV2ReorderNegatives::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  unsigned int idx = 0;
++  _kernel.setArg(idx++, *_in_key_buf);
++  _kernel.setArg(idx++, *_out_key_buf);
++  _kernel.setArg(idx++, *_in_ind_buf);
++  _kernel.setArg(idx++, *_out_ind_buf);
++
++  enqueue(queue, *this, window);
++}
++
++////////////////////////////////////////////////////////////////////////////////
++CLTopKV2Store::CLTopKV2Store()
++: _values(nullptr), _indices(nullptr), _out_key_buf(nullptr), _out_ind_buf(nullptr)
++{}
++
++void CLTopKV2Store::configure(ICLTensor *values, ICLTensor *indices, int k, int n)
++{
++  ARM_COMPUTE_ERROR_ON(values == nullptr && indices == nullptr);
++  ARM_COMPUTE_ERROR_ON(k == 0);
++  ARM_COMPUTE_ERROR_ON(k > n);
++
++  _values = values;
++  _indices = indices;
++
++  // Set kernel build options
++  std::set<std::string> build_opts;
++
++  // Create kernel
++  _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("topkv2_store", build_opts));
++
++  unsigned int idx = 2 * num_arguments_per_1D_tensor() + 2;
++  _kernel.setArg<cl_int>(idx++, n);
++
++  // Configure kernel window
++  Window                 win;
++  win.set(0, Window::Dimension(0, k, 1));
++  ICLKernel::configure(win);
++}
++
++void CLTopKV2Store::setOutputBuffers(cl::Buffer *out_key_buf, cl::Buffer *out_ind_buf)
++{
++  _out_key_buf = out_key_buf;
++  _out_ind_buf = out_ind_buf;
++}
++
++void CLTopKV2Store::run(const Window &window, cl::CommandQueue &queue)
++{
++  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
++  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
++
++  unsigned int idx = 0;
++  add_1D_tensor_argument(idx, _values, window);
++  add_1D_tensor_argument(idx, _indices, window);
++  _kernel.setArg(idx++, *_out_key_buf);
++  _kernel.setArg(idx++, *_out_ind_buf);
++
++  enqueue(queue, *this, window);
++}
++
++} // namespace arm_compute
+diff --git a/src/core/Validate.cpp b/src/core/Validate.cpp
+index d4fabd4..d0374e7 100644
+--- a/src/core/Validate.cpp
++++ b/src/core/Validate.cpp
+@@ -169,7 +169,7 @@ arm_compute::Status arm_compute::error_on_invalid_subtensor(const char *function
+     // Subtensor should not index in x, y dimensions.
+     ARM_COMPUTE_RETURN_ERROR_ON_LOC(((coords.x() != 0) || (coords.y() != 0)), function, file, line);
+     // Subtensor shape should match parent tensor in x, y dimensions.
+-    ARM_COMPUTE_RETURN_ERROR_ON_LOC(((parent_shape.x() != shape.x()) || (parent_shape.y() != parent_shape.y())), function, file, line);
++    ARM_COMPUTE_RETURN_ERROR_ON_LOC(((parent_shape.x() != shape.x()) || (parent_shape.y() != shape.y())), function, file, line);
+ 
+     // Check dimensions
+     for(unsigned int i = 0; i < TensorShape::num_max_dimensions; ++i)
+diff --git a/src/runtime/CL/functions/CLArithmeticSubtraction.cpp b/src/runtime/CL/functions/CLArithmeticSubtraction.cpp
+index 5fca30c..3c13e3d 100644
+--- a/src/runtime/CL/functions/CLArithmeticSubtraction.cpp
++++ b/src/runtime/CL/functions/CLArithmeticSubtraction.cpp
+@@ -1,4 +1,5 @@
+ /*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+  * Copyright (c) 2016, 2017 ARM Limited.
+  *
+  * SPDX-License-Identifier: MIT
+@@ -23,6 +24,7 @@
+  */
+ #include "arm_compute/runtime/CL/functions/CLArithmeticSubtraction.h"
+ 
++#include "arm_compute/core/CL/ICLTensor.h"
+ #include "arm_compute/core/CL/kernels/CLArithmeticSubtractionKernel.h"
+ #include "support/ToolchainSupport.h"
+ 
+@@ -30,11 +32,21 @@
+ 
+ using namespace arm_compute;
+ 
+-void CLArithmeticSubtraction::configure(const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, ConvertPolicy policy)
++void CLArithmeticSubtraction::configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *output, ConvertPolicy policy)
+ {
+     auto k = arm_compute::support::cpp14::make_unique<CLArithmeticSubtractionKernel>();
+     k->configure(input1, input2, output, policy);
+     _kernel = std::move(k);
++
++    if(output->info()->dimension(0) > 1)
++    {
++        ICLTensor *broadcasted_info = (input1->info()->dimension(0) == 1) ? input1 : input2;
++
++        if(broadcasted_info->info()->dimension(0) == 1)
++        {
++            _border_handler.configure(broadcasted_info, _kernel->border_size(), BorderMode::REPLICATE);
++        }
++    }
+ }
+ 
+ Status CLArithmeticSubtraction::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy)
+diff --git a/src/runtime/CL/functions/CLCast.cpp b/src/runtime/CL/functions/CLCast.cpp
+new file mode 100644
+index 0000000..4669577
+--- /dev/null
++++ b/src/runtime/CL/functions/CLCast.cpp
+@@ -0,0 +1,37 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/runtime/CL/functions/CLCast.h"
++
++#include "arm_compute/core/CL/kernels/CLCastKernel.h"
++#include "support/ToolchainSupport.h"
++
++using namespace arm_compute;
++
++void CLCast::configure(ICLTensor *input, ICLTensor *output)
++{
++    auto k = arm_compute::support::cpp14::make_unique<CLCastKernel>();
++    k->configure(input, output);
++    _kernel = std::move(k);
++}
+diff --git a/src/runtime/CL/functions/CLGather.cpp b/src/runtime/CL/functions/CLGather.cpp
+new file mode 100644
+index 0000000..3f2f2c1
+--- /dev/null
++++ b/src/runtime/CL/functions/CLGather.cpp
+@@ -0,0 +1,45 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/runtime/CL/functions/CLGather.h"
++
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/kernels/CLGatherKernel.h"
++#include "support/ToolchainSupport.h"
++
++#include <utility>
++
++using namespace arm_compute;
++
++void CLGather::configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *output)
++{
++    auto k = arm_compute::support::cpp14::make_unique<CLGatherKernel>();
++    k->configure(input1, input2, output);
++    _kernel = std::move(k);
++}
++
++Status CLGather::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output)
++{
++    return CLGatherKernel::validate(input1, input2, output);
++}
+diff --git a/src/runtime/CL/functions/CLPixelWiseDivision.cpp b/src/runtime/CL/functions/CLPixelWiseDivision.cpp
+new file mode 100644
+index 0000000..343e944
+--- /dev/null
++++ b/src/runtime/CL/functions/CLPixelWiseDivision.cpp
+@@ -0,0 +1,57 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2016-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/runtime/CL/functions/CLPixelWiseDivision.h"
++
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/kernels/CLPixelWiseDivisionKernel.h"
++#include "support/ToolchainSupport.h"
++
++#include <utility>
++
++using namespace arm_compute;
++
++void CLPixelWiseDivision::configure(ICLTensor *input1, ICLTensor *input2, ICLTensor *output, float scale,
++                                          ConvertPolicy overflow_policy, RoundingPolicy rounding_policy)
++{
++    auto k = arm_compute::support::cpp14::make_unique<CLPixelWiseDivisionKernel>();
++    k->configure(input1, input2, output, scale, overflow_policy, rounding_policy);
++    _kernel = std::move(k);
++
++    if(output->info()->dimension(0) > 1)
++    {
++        ICLTensor *broadcasted_info = (input1->info()->dimension(0) == 1) ? input1 : input2;
++
++        if(broadcasted_info->info()->dimension(0) == 1)
++        {
++            _border_handler.configure(broadcasted_info, _kernel->border_size(), BorderMode::REPLICATE);
++        }
++    }
++}
++
++Status CLPixelWiseDivision::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, float scale,
++                                           ConvertPolicy overflow_policy, RoundingPolicy rounding_policy)
++{
++    return CLPixelWiseDivisionKernel::validate(input1, input2, output, scale, overflow_policy, rounding_policy);
++}
+diff --git a/src/runtime/CL/functions/CLReduceMax.cpp b/src/runtime/CL/functions/CLReduceMax.cpp
+new file mode 100644
+index 0000000..276ffd2
+--- /dev/null
++++ b/src/runtime/CL/functions/CLReduceMax.cpp
+@@ -0,0 +1,132 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/runtime/CL/functions/CLReduceMax.h"
++
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "support/ToolchainSupport.h"
++#include "arm_compute/core/CL/CLHelpers.h"
++#include "arm_compute/core/CL/kernels/CLReduceMaxKernel.h"
++
++#include <vector>
++#include <algorithm>
++
++#include <utility>
++
++#define REDUCE_MAX_RUN_ON_CPU 1
++
++namespace arm_compute
++{
++
++CLReduceMax::CLReduceMax()
++: _axis(0), _input(nullptr), _output(nullptr), _kernel(nullptr)
++{
++}
++
++void CLReduceMax::configure(ICLTensor *input, int axis, ICLTensor *output)
++{
++  _axis = axis;
++
++  _input = input;
++  _output = output;
++
++  auto k = arm_compute::support::cpp14::make_unique<CLReduceMaxKernel>();
++  k->configure(input, axis, output);
++  _kernel = std::move(k);
++
++  // We can handle for simple case only
++  // Output rank: 1
++  // Axis: one axis value, restrict to 1
++  ARM_COMPUTE_ERROR_ON(input->info()->tensor_shape().num_dimensions() != 2);
++  ARM_COMPUTE_ERROR_ON(output->info()->tensor_shape().num_dimensions() != 1);
++  ARM_COMPUTE_ERROR_ON(axis != 1);
++}
++
++Status CLReduceMax::validate(const ITensorInfo *input, int32_t axis, const ITensorInfo *output)
++{
++    return CLReduceMaxKernel::validate(input, axis, output);
++}
++
++void CLReduceMax::run()
++{
++#if REDUCE_MAX_RUN_ON_CPU
++    run_on_cpu();
++
++    arm_compute::CLScheduler::get().sync();
++#else
++    arm_compute::CLScheduler::get().enqueue(*_kernel);
++#endif
++}
++
++void CLReduceMax::run_on_cpu()
++{
++  cl::CommandQueue q = CLScheduler::get().queue();
++
++  _input->map(q);
++  _output->map(q);
++
++  // Compute by CPU for simple case
++  // Input rank: 2
++  // Output rank: 1
++  // Axis: one axis value, restrict to 1
++
++  float* input_data = (float*)_input->buffer();
++  float* output_data = (float*)_output->buffer();
++
++  std::vector<float> container_max;
++  int cols = _input->info()->tensor_shape()[0];
++  int rows = _input->info()->tensor_shape()[1];
++  container_max.resize(rows);
++
++  // Initialize as 1st element in row
++  float* input_pointer = input_data;
++  for (int i = 0; i < rows; i++)
++  {
++      container_max[i] = *input_pointer;
++      input_pointer += cols;
++  }
++
++  // Update max value in row
++  for (int i = 0; i < rows; i++)
++  {
++      float max_in_row = container_max[i];
++      for (int j = 1; j < cols; j++)
++      {
++          if (max_in_row < input_data[i * cols + j])
++          {
++              max_in_row = input_data[i * cols + j];
++          }
++      }
++      container_max[i] = max_in_row;
++  }
++
++  for (int i = 0; i < rows; i++)
++  {
++      output_data[i] = container_max[i];
++  }
++
++  _input->unmap(q);
++  _output->unmap(q);
++}
++} // namespace arm_compute
+diff --git a/src/runtime/CL/functions/CLReductionMean.cpp b/src/runtime/CL/functions/CLReductionMean.cpp
+new file mode 100644
+index 0000000..4f71e84
+--- /dev/null
++++ b/src/runtime/CL/functions/CLReductionMean.cpp
+@@ -0,0 +1,60 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017-2018 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/runtime/CL/functions/CLReductionMean.h"
++
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/kernels/CLReductionMeanKernel.h"
++#include "arm_compute/core/Error.h"
++#include "arm_compute/core/PixelValue.h"
++#include "arm_compute/core/TensorInfo.h"
++#include "arm_compute/core/Validate.h"
++#include "arm_compute/runtime/CL/CLScheduler.h"
++#include "arm_compute/runtime/Tensor.h"
++#include "support/ToolchainSupport.h"
++
++using namespace arm_compute;
++
++CLReductionMean::CLReductionMean()
++    : _reduction_mean_kernel(), _fill_border_kernel()
++{
++}
++
++Status CLReductionMean::validate(const ITensorInfo *input, const ITensorInfo *output, std::vector<uint32_t> axis)
++{
++    ARM_COMPUTE_RETURN_ON_ERROR(CLReductionMeanKernel::validate(input, output, axis));
++    return Status{};
++}
++
++void CLReductionMean::configure(ICLTensor *input, ICLTensor *output, std::vector<uint32_t> axis)
++{
++    _reduction_mean_kernel.configure(input, output, axis);
++    _fill_border_kernel.configure(input, _reduction_mean_kernel.border_size(), BorderMode::CONSTANT, PixelValue(0));
++}
++
++void CLReductionMean::run()
++{
++    CLScheduler::get().enqueue(_fill_border_kernel);
++    CLScheduler::get().enqueue(_reduction_mean_kernel);
++}
+diff --git a/src/runtime/CL/functions/CLStridedSlice.cpp b/src/runtime/CL/functions/CLStridedSlice.cpp
+new file mode 100644
+index 0000000..2695fc6
+--- /dev/null
++++ b/src/runtime/CL/functions/CLStridedSlice.cpp
+@@ -0,0 +1,288 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/runtime/CL/functions/CLStridedSlice.h"
++
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/kernels/CLStridedSliceKernel.h"
++#include "arm_compute/core/utils/misc/Utility.h"
++#include "arm_compute/runtime/CL/CLScheduler.h"
++#include "support/ToolchainSupport.h"
++#include <vector>
++
++using namespace arm_compute;
++
++static const int32_t maxDims = 4;
++
++// Return the index for the first element along that axis. This index will be a
++// positive integer between [0, axisSize - 1] that can be used to index
++// directly into the data.
++inline int32_t StartForAxis(int32_t beginMask,
++                            std::vector<int32_t> const &startIndices,
++                            std::vector<int32_t> const &strides,
++                            const TensorShape &inputShape, int32_t axis)
++{
++    // Begin with the specified index
++    int32_t start = startIndices[axis];
++
++    // beginMask override
++    if (beginMask & 1 << axis)
++    {
++        if (strides[axis] > 0)
++        {
++            // Forward iteration - use the first element. These values will get
++            // clamped below (Note: We could have set them to 0 and axisSize-1, but
++            // use lowest() and max() to maintain symmetry with StopForAxis())
++            start = std::numeric_limits<int32_t>::lowest();
++        }
++        else
++        {
++            // Backward iteration - use the last element.
++            start = std::numeric_limits<int32_t>::max();
++        }
++    }
++
++    // Handle negative indices
++    int32_t axisSize = inputShape[axis];
++    if (start < 0)
++    {
++        start += axisSize;
++    }
++
++    // Clamping
++    start = arm_compute::utility::clamp(start, 0, axisSize - 1);
++
++    return start;
++}
++
++// Return the "real" index for the end of iteration along that axis. This is an
++// "end" in the traditional C sense, in that it points to one past the last
++// element. ie. So if you were iterating through all elements of a 1D array of
++// size 4, this function would return 4 as the stop, because it is one past the
++// "real" indices of 0, 1, 2 & 3.
++inline int32_t StopForAxis(int32_t endMask, std::vector<int32_t> const &stopIndices,
++                           std::vector<int32_t> const &strides,
++                           const TensorShape &inputShape, int32_t axis)
++{
++    // Begin with the specified index
++    int32_t stop = stopIndices[axis];
++
++    // endMask override
++    if (endMask & (1 << axis))
++    {
++        if (strides[axis] > 0)
++        {
++            // Forward iteration - use the last element. These values will get
++            // clamped below
++            stop = std::numeric_limits<int32_t>::max();
++        }
++        else
++        {
++            // Backward iteration - use the first element.
++            stop = std::numeric_limits<int32_t>::lowest();
++        }
++    }
++
++    // Handle negative indices
++    int32_t axisSize = inputShape[axis];
++    if (stop < 0) {
++        stop += axisSize;
++    }
++
++    // Clamping
++    // Because the end index points one past the last element, we need slightly
++    // different clamping ranges depending on the direction.
++    if (strides[axis] > 0)
++    {
++        // Forward iteration
++        stop = arm_compute::utility::clamp(stop, 0, axisSize);
++    }
++    else
++    {
++        // Backward iteration
++        stop = arm_compute::utility::clamp(stop, -1, axisSize - 1);
++    }
++
++    return stop;
++}
++
++inline int32_t offset4D(const TensorShape &shape, int32_t b, int32_t d, int32_t h, int32_t w)
++{
++    int32_t offset = b * shape[2] * shape[1] * shape[0];
++    offset += d * shape[1] * shape[0];
++    offset += h * shape[0];
++    offset += w;
++    return offset;
++}
++
++void CLStridedSlice::configure(const ICLTensor *input, ICLTensor *output, ICLTensor *beginData, ICLTensor *endData, ICLTensor *stridesData, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask)
++{
++    auto k = arm_compute::support::cpp14::make_unique<CLStridedSliceKernel>();
++    k->configure(input, output, beginData, endData, stridesData, beginMask, endMask, shrinkAxisMask);
++    _kernel = std::move(k);
++}
++
++void CLStridedSliceCPU::configure(ICLTensor *input, ICLTensor *output, ICLTensor *beginData, ICLTensor *endData, ICLTensor *stridesData, int32_t beginMask, int32_t endMask, int32_t shrinkAxisMask)
++{
++    ARM_COMPUTE_ERROR_THROW_ON(CLStridedSliceKernel::validate(input->info(), output->info(), beginData->info(), endData->info(), stridesData->info(), beginMask, endMask, shrinkAxisMask));
++
++    _input          = input;
++    _output         = output;
++    _beginData      = beginData;
++    _endData        = endData;
++    _stridesData    = stridesData;
++    _beginMask      = beginMask;
++    _endMask        = endMask;
++    _shrinkAxisMask = shrinkAxisMask;
++}
++
++void CLStridedSliceCPU::run()
++{
++    run_on_cpu();
++
++    arm_compute::CLScheduler::get().sync();
++}
++
++inline int32_t getOutDim(int32_t start, int32_t stop, int32_t stride)
++{
++    if (stride > 0)
++    {
++        return ((stop - start - 1) / stride) + 1;
++    }
++    else
++    {
++        return ((stop - start + 1) / stride) + 1;
++    }
++}
++
++template <typename T>
++inline void StridedSlice(const T *inputData, const TensorShape &inputShape,
++                         int32_t beginMask, int32_t endMask,
++                         const std::vector<int32_t> &startIndices,
++                         const std::vector<int32_t> &stopIndices,
++                         const std::vector<int32_t> &strides, T *outputData)
++{
++    ARM_COMPUTE_ERROR_ON(startIndices.size() != maxDims);
++    ARM_COMPUTE_ERROR_ON(stopIndices.size() != maxDims);
++    ARM_COMPUTE_ERROR_ON(strides.size() != maxDims);
++
++    const int32_t start_b = StartForAxis(beginMask, startIndices, strides, inputShape, 3);
++    const int32_t stop_b = StopForAxis(endMask, stopIndices, strides, inputShape, 3);
++    const int32_t start_d = StartForAxis(beginMask, startIndices, strides, inputShape, 2);
++    const int32_t stop_d = StopForAxis(endMask, stopIndices, strides, inputShape, 2);
++    const int32_t start_h = StartForAxis(beginMask, startIndices, strides, inputShape, 1);
++    const int32_t stop_h = StopForAxis(endMask, stopIndices, strides, inputShape, 1);
++    const int32_t start_w = StartForAxis(beginMask, startIndices, strides, inputShape, 0);
++    const int32_t stop_w = StopForAxis(endMask, stopIndices, strides, inputShape, 0);
++
++    // The shape of outputData may collapse in one-dimension.
++    // Therefore, it is necessary to create a shape that matches the result of the outputData.
++    TensorShape outputShape(getOutDim(start_w, stop_w, strides[0]), getOutDim(start_h, stop_h, strides[1]),
++                            getOutDim(start_d, stop_d, strides[2]), getOutDim(start_b, stop_b, strides[3]));
++    for (int32_t in_b = start_b, b = 0; strides[3] > 0 ? in_b < stop_b : in_b > stop_b; in_b += strides[3], b++)
++    {
++        for (int32_t in_d = start_d, d = 0; strides[2] > 0 ? in_d < stop_d : in_d > stop_d; in_d += strides[2], d++)
++        {
++            for (int32_t in_h = start_h, h = 0; strides[1] > 0 ? in_h < stop_h : in_h > stop_h; in_h += strides[1], h++)
++            {
++                for (int32_t in_w = start_w, w = 0; strides[0] > 0 ? in_w < stop_w : in_w > stop_w; in_w += strides[0], w++)
++                {
++                    outputData[offset4D(outputShape, b, d, h, w)] = inputData[offset4D(inputShape, in_b, in_d, in_h, in_w)];
++                }
++            }
++        }
++    }
++}
++
++void CLStridedSliceCPU::run_on_cpu()
++{
++    // TODO: Support shrinkAxisMask
++    cl::CommandQueue q = CLScheduler::get().queue();
++
++    _input->map(q);
++    _output->map(q);
++    _beginData->map(q);
++    _endData->map(q);
++    _stridesData->map(q);
++
++    TensorShape inputShape = _input->info()->tensor_shape();
++    TensorShape outputShape = _output->info()->tensor_shape();
++
++    std::vector<int32_t> starts;
++    std::vector<int32_t> stops;
++    std::vector<int32_t> strides;
++
++    for (uint32_t idx = 0; idx <= _input->info()->num_dimensions() - 1; ++idx) {
++        starts.emplace_back(reinterpret_cast<int32_t *>(_beginData->buffer())[idx]);
++        stops.emplace_back(reinterpret_cast<int32_t *>(_endData->buffer())[idx]);
++        strides.emplace_back(reinterpret_cast<int32_t *>(_stridesData->buffer())[idx]);
++    }
++
++    for (uint32_t i = _input->info()->num_dimensions(); i < maxDims; i++) {
++        starts.emplace_back(0);
++        stops.emplace_back(1);
++        strides.emplace_back(1);
++    }
++
++    switch (_input->info()->data_type())
++    {
++        case DataType::U8:
++        case DataType::QASYMM8:
++            StridedSlice(reinterpret_cast<const uint8_t *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<uint8_t *>(_output->buffer()));
++            break;
++        case DataType::S8:
++        case DataType::QS8:
++            StridedSlice(reinterpret_cast<const int8_t *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<int8_t *>(_output->buffer()));
++            break;
++        case DataType::U16:
++            StridedSlice(reinterpret_cast<const uint16_t *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<uint16_t *>(_output->buffer()));
++            break;
++        case DataType::S16:
++        case DataType::QS16:
++            StridedSlice(reinterpret_cast<const int16_t *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<int16_t *>(_output->buffer()));
++            break;
++        case DataType::F16:
++            // Not sure this works.
++            StridedSlice(reinterpret_cast<const half *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<half *>(_output->buffer()));
++            break;
++        case DataType::U32:
++            StridedSlice(reinterpret_cast<const uint32_t *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<uint32_t *>(_output->buffer()));
++            break;
++        case DataType::S32:
++            StridedSlice(reinterpret_cast<const int32_t *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<int32_t *>(_output->buffer()));
++            break;
++        case DataType::F32:
++            StridedSlice(reinterpret_cast<const float *>(_input->buffer()), inputShape, _beginMask, _endMask, starts, stops, strides, reinterpret_cast<float *>(_output->buffer()));
++            break;
++        default:
++            ARM_COMPUTE_ERROR("DataType not supported");
++            break;
++    }
++
++    _input->unmap(q);
++    _output->unmap(q);
++    _beginData->unmap(q);
++    _endData->unmap(q);
++    _stridesData->unmap(q);
++}
+diff --git a/src/runtime/CL/functions/CLTopKV2.cpp b/src/runtime/CL/functions/CLTopKV2.cpp
+new file mode 100644
+index 0000000..ed9797e
+--- /dev/null
++++ b/src/runtime/CL/functions/CLTopKV2.cpp
+@@ -0,0 +1,310 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (c) 2017 ARM Limited.
++ *
++ * SPDX-License-Identifier: MIT
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in all
++ * copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ */
++#include "arm_compute/runtime/CL/functions/CLTopKV2.h"
++
++#include "arm_compute/core/CL/ICLTensor.h"
++#include "arm_compute/core/CL/CLHelpers.h"
++
++#include <vector>
++#include <algorithm>
++
++#include "../../topk_v2.h"
++
++namespace arm_compute
++{
++
++CLTopKV2::CLTopKV2()
++: _k(0), _total_bits(0), _bits(0), _radix(0), _hist_buf_size(0),
++  _glob_sum_buf_size(0), _n(0), _input(nullptr),
++  _values(nullptr), _indices(nullptr), _qs_idx_buf(), _qs_temp_buf(),
++  _hist_buf(), _glob_sum_buf(), _temp_buf(),
++  _first_negative_idx_buf(), _in_key_buf(), _out_key_buf(), _in_ind_buf(), _out_ind_buf(),
++  _p_in_key_buf(nullptr), _p_out_key_buf(nullptr), _p_in_ind_buf(nullptr), _p_out_ind_buf(nullptr),
++  _qs_kernel(),
++  _init_kernel(), _hist_kernel(), _scan_hist_kernel(), _glob_scan_hist_kernel(), _paste_hist_kernel(),
++  _reorder_kernel(), _find_first_negative_kernel(), _reorder_negatives_kernel(),_store_kernel()
++{
++}
++
++void CLTopKV2::configure(ICLTensor *input, int k, ICLTensor *values, ICLTensor *indices,
++    int total_bits, int bits)
++{
++    _total_bits = total_bits;
++    _bits = bits;
++    _n = input->info()->tensor_shape()[0];
++
++    // _total_bits should be divided by _bits.
++    ARM_COMPUTE_ERROR_ON((_total_bits % _bits) != 0);
++
++    _k = k;
++    _radix = 1 << bits;
++
++    _input = input;
++    _values = values;
++    _indices = indices;
++
++    std::string topk_env;
++
++    char* env = getenv("ACL_TOPKV2");
++    if( env )
++      topk_env = env;
++
++    if(topk_env == "GPU_SINGLE")
++    {
++      _qs_idx_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int) * _n);
++      _qs_temp_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int) * _n);
++
++      _qs_kernel.configure(input, values, indices, &_qs_idx_buf, &_qs_temp_buf, k, _n);
++    }
++    else if(topk_env == "GPU")
++    {
++      // n should be divided by (_GROUPS * _ITEMS)
++      ARM_COMPUTE_ERROR_ON((_n % (_GROUPS *_ITEMS)) != 0);
++
++      _hist_buf_size = _radix * _GROUPS * _ITEMS;
++      _glob_sum_buf_size = _HISTOSPLIT;
++
++      _hist_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int) * _hist_buf_size);
++      _glob_sum_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int) * _glob_sum_buf_size);
++      _temp_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int) * _glob_sum_buf_size);
++      _first_negative_idx_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int));
++      _in_key_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_float) * _n);
++      _out_key_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_float) * _n);
++      _in_ind_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int) * _n);
++      _out_ind_buf = cl::Buffer(CLScheduler::get().context(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE,
++          sizeof(cl_int) * _n);
++
++      _p_in_key_buf = &_in_key_buf;
++      _p_out_key_buf = &_out_key_buf;
++      _p_in_ind_buf = &_in_ind_buf;
++      _p_out_ind_buf = &_out_ind_buf;
++
++      _init_kernel.configure(input, _p_in_key_buf, _p_in_ind_buf, _n);
++      _hist_kernel.configure(&_hist_buf, bits, _n);
++      _scan_hist_kernel.configure(&_hist_buf, &_glob_sum_buf, bits);
++      _glob_scan_hist_kernel.configure(&_glob_sum_buf, &_temp_buf, bits);
++      _paste_hist_kernel.configure(&_hist_buf, &_glob_sum_buf, bits);
++      _reorder_kernel.configure(&_hist_buf, bits, _n);
++      _find_first_negative_kernel.configure(&_first_negative_idx_buf, _n);
++      _reorder_negatives_kernel.configure(&_first_negative_idx_buf, _n);
++      _store_kernel.configure(values, indices, k, _n);
++    }
++    else
++    {
++      // DO NOTHING for CPU.
++    }
++}
++
++void CLTopKV2::run()
++{
++  std::string topk_env;
++
++  char* env = getenv("ACL_TOPKV2");
++  if( env )
++    topk_env = env;
++
++  if(topk_env == "GPU_SINGLE")
++  {
++    run_on_gpu_single_quicksort();
++  }
++  else if(topk_env == "GPU")
++  {
++    run_on_gpu();
++  }
++  else
++  {
++    run_on_cpu();
++  }
++}
++
++void CLTopKV2::run_on_gpu_single_quicksort()
++{
++  // This is a single threaded quick sort implementation.
++  CLScheduler::get().enqueue(_qs_kernel, false);
++
++  arm_compute::CLScheduler::get().sync();
++}
++
++void CLTopKV2::run_on_gpu()
++{
++  cl::CommandQueue q = CLScheduler::get().queue();
++
++  //1. CLTopKV2Init set key buffer and index buffer.
++  //  - Key buffer is set as the same value of the layer's input
++  //  - Values in the index buffer are set as their indices.
++  CLScheduler::get().enqueue(_init_kernel, false);
++
++  int n_passes = _total_bits / _bits;
++
++  // 2. Repeat (total_bits/bits) times.
++  //   - total_bits is the number of bits of the data type (e.g., 32 for float)
++  //   - bits defines number of buckets (e.g. 16 buckets where bit is 4)
++  for(int pass = 0; pass < n_passes; ++pass) {
++    arm_compute::CLScheduler::get().sync();
++
++    // 2.1. Calculate histogram with _GROUPS * _ITEMS threads
++    _hist_kernel.setPass(pass, _p_in_key_buf);
++    CLScheduler::get().enqueue(_hist_kernel, false);
++
++    // 2.2. Calculate prefix sum locally with multiple threads
++    CLScheduler::get().enqueue(_scan_hist_kernel, false);
++    // 2.3. Calculate prefix sum within a work group
++    CLScheduler::get().enqueue(_glob_scan_hist_kernel, false);
++    // 2.4. Calculate global prefix sum
++    CLScheduler::get().enqueue(_paste_hist_kernel, false);
++
++    // 2.5. Reorder keys and indices based on the global prefix sum
++    _reorder_kernel.setPass(pass, _p_in_key_buf, _p_out_key_buf,
++        _p_in_ind_buf, _p_out_ind_buf);
++    CLScheduler::get().enqueue(_reorder_kernel, false);
++
++    cl::Buffer *tmp;
++    // swap key buffers
++    tmp = _p_in_key_buf;
++    _p_in_key_buf = _p_out_key_buf;
++    _p_out_key_buf = tmp;
++
++    // swap index buffers
++    tmp = _p_in_ind_buf;
++    _p_in_ind_buf = _p_out_ind_buf;
++    _p_out_ind_buf = tmp;
++  }
++
++  // 3. Get the first negative index
++  // Because we swap in_buf and out_buf at the end of the above for loop,
++  // the output buffers are in bufs.
++  _find_first_negative_kernel.setOutputBuffer(_p_in_key_buf);
++  CLScheduler::get().enqueue(_find_first_negative_kernel, false);
++
++  // 4. Correct odering of negatives
++  //   - Since radix sort does not consider negatives, negatives are considered as bigger values than positives.
++  // reordered data will be stored in _p_out_key_buf and _p_out_ind_buf
++  _reorder_negatives_kernel.setBuffers(_p_in_key_buf, _p_out_key_buf,
++      _p_in_ind_buf, _p_out_ind_buf);
++  CLScheduler::get().enqueue(_reorder_negatives_kernel, false);
++
++  // 5. Extract top k values from sorted keys and indices.
++  _store_kernel.setOutputBuffers(_p_out_key_buf, _p_out_ind_buf);
++  CLScheduler::get().enqueue(_store_kernel, false);
++
++  arm_compute::CLScheduler::get().sync();
++
++#if 0
++  // below code is left for debugging.
++  int first_neg;
++  q.enqueueReadBuffer(_first_negative_idx_buf, CL_TRUE, 0, sizeof(cl_int), &first_neg);
++  std::cout << "first neg = " << first_neg << std::endl;
++
++  float in_key[_n];
++  q.enqueueReadBuffer(*_p_in_key_buf, CL_TRUE, 0, sizeof(cl_float)*_n, in_key);
++  for(uint32_t i = 0 ; i < _n; ++i) {
++    std::cout << "in_key[" << i << "] = " << in_key[i] << std::endl;
++  }
++
++  float out_key[_n];
++  q.enqueueReadBuffer(*_p_out_key_buf, CL_TRUE, 0, sizeof(cl_float)*_n, out_key);
++  for(uint32_t i = 0 ; i < _n; ++i) {
++    std::cout << "out_key[" << i << "] = " << out_key[i] << std::endl;
++  }
++
++  int in_ind[_n];
++  q.enqueueReadBuffer(*_p_in_ind_buf, CL_TRUE, 0, sizeof(cl_int)*_n, in_ind);
++  for(uint32_t i = 0 ; i < _n; ++i) {
++    std::cout << "in_ind[" << i << "] = " << in_ind[i] << std::endl;
++  }
++
++  int out_ind[_n];
++  q.enqueueReadBuffer(*_p_out_ind_buf, CL_TRUE, 0, sizeof(cl_int)*_n, out_ind);
++  for(uint32_t i = 0 ; i < _n; ++i) {
++    std::cout << "out_ind[" << i << "] = " << out_ind[i] << std::endl;
++  }
++
++  int hist_buf[_hist_buf_size];
++  q.enqueueReadBuffer(_hist_buf, CL_TRUE, 0, sizeof(cl_int)*_hist_buf_size, hist_buf);
++  for(uint32_t i = 0 ; i < _hist_buf_size; ++i) {
++    std::cout << "hist_buf[" << i << "] = " << hist_buf[i] << std::endl;
++  }
++
++  int glob_sum_buf[_glob_sum_buf_size];
++  q.enqueueReadBuffer(_glob_sum_buf, CL_TRUE, 0, sizeof(cl_int)*_glob_sum_buf_size, glob_sum_buf);
++  for(uint32_t i = 0 ; i < _glob_sum_buf_size; ++i) {
++    std::cout << "glob_sum_buf[" << i << "] = " << glob_sum_buf[i] << std::endl;
++  }
++
++#endif
++}
++
++void CLTopKV2::run_on_cpu()
++{
++  cl::CommandQueue q = CLScheduler::get().queue();
++  //const Window& w = _topkv2_kernel.window();
++
++  _input->map(q);
++  _values->map(q);
++  _indices->map(q);
++
++  //int row_size = (w[0].end() - w[0].start()) / w[0].step();
++  int row_size = _input->info()->tensor_shape()[0];
++  int rank = _input->info()->num_dimensions();
++
++  if (rank > 2)
++    throw std::runtime_error("Not supported type.");
++
++  int row_num = (rank == 2 ? _input->info()->tensor_shape()[1] : 1);
++
++  if (_input->info()->data_type() == DataType::F32)
++  {
++    nnfw::rt::optimized_ops::TopK<float>(row_size, row_num, (float*)_input->buffer(), _k,
++        (int32*)_indices->buffer(), (float*)_values->buffer());
++  }
++  else if (_input->info()->data_type() == DataType::S32)
++  {
++    nnfw::rt::optimized_ops::TopK<int32_t>(row_size, row_num, (int32_t*)_input->buffer(), _k,
++        (int32*)_indices->buffer(), (int32_t*)_values->buffer());
++  }
++  else if (_input->info()->data_type() == DataType::QASYMM8)
++  {
++    nnfw::rt::optimized_ops::TopK<uint8_t>(row_size, row_num, (uint8_t*)_input->buffer(), _k,
++        (int32*)_indices->buffer(), (uint8_t*)_values->buffer());
++  }
++  else
++  {
++    throw std::runtime_error("Not supported type.");
++  }
++
++  _input->unmap(q);
++  _values->unmap(q);
++  _indices->unmap(q);
++}
++} // namespace arm_compute
+diff --git a/src/runtime/topk_v2.h b/src/runtime/topk_v2.h
+new file mode 100644
+index 0000000..2419ee9
+--- /dev/null
++++ b/src/runtime/topk_v2.h
+@@ -0,0 +1,141 @@
++/*
++ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
++ * Copyright (C) 2017 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#ifndef __NNFW_RT_OPTIMIZED_OPS_TOPK_V2_H__
++#define __NNFW_RT_OPTIMIZED_OPS_TOPK_V2_H__
++
++typedef int32_t int32;
++
++namespace nnfw
++{
++namespace rt
++{
++namespace optimized_ops
++{
++// The follwing codes are impemented and modified while referring to TFLite topk_v2.cc file.
++// TopK_v2 of NN Runtime supports TENSOR_FLOAT32, TENSOR_QUANT8_ASYMM, TENSOR_INT32 other than
++// TFLite.
++//(TFLite additionaly supports kTfLiteInt64.)
++
++// The class that collects top indexes of k values. Based on template
++// tensorflow::gtl::TopN<> but, for optimization,
++// it re-uses the same container.
++template <typename T> class TopContainer
++{
++public:
++  TopContainer() = delete;
++  TopContainer(int32 k, int32 row_size) : k_(k), container_(), values_(nullptr)
++  { container_.reserve(std::min(k, row_size) + 1); }
++
++  /** Prevent instances of this class from being copied (As this class contains pointers) */
++  TopContainer(const TopContainer&) = delete;
++    /** Prevent instances of this class from being copied (As this class contains pointers) */
++  TopContainer& operator=(const TopContainer&) = delete;
++
++  void start_collecting(const T *values)
++  {
++    values_ = values;
++    container_.clear();
++  }
++
++  void push(int32 a)
++  {
++    auto comparator = [this](int32 a, int32 b) { return compare_fun(a, b); };
++    if (container_.size() <= (size_t)k_)
++    {
++      container_.push_back(a);
++      if (container_.size() == (size_t)(k_ + 1))
++      {
++        std::make_heap(container_.begin(), container_.end(), comparator);
++        std::pop_heap(container_.begin(), container_.end(), comparator);
++      }
++    }
++    else if (comparator(a, container_.front()))
++    {
++      container_.back() = a;
++      std::push_heap(container_.begin(), container_.end(), comparator);
++      std::pop_heap(container_.begin(), container_.end(), comparator);
++    }
++  }
++
++  const std::vector<int32> &sorted_result()
++  {
++    auto comparator = [this](int32 a, int32 b) { return compare_fun(a, b); };
++    if (container_.size() <= (size_t)(k_))
++    {
++      std::sort(container_.begin(), container_.end(), comparator);
++    }
++    else
++    {
++      std::sort_heap(container_.begin(), container_.end() - 1, comparator);
++      container_.resize(k_);
++    }
++    return container_;
++  }
++
++private:
++  int32 k_;
++  std::vector<int32> container_;
++  const T *values_ = nullptr;
++
++  bool compare_fun(int32 a, int32 b) const
++  {
++    if (values_[b] < values_[a])
++    {
++      return true;
++    }
++    else if (values_[b] > values_[a])
++    {
++      return false;
++    }
++    else
++    {
++      return a < b;
++    }
++  }
++};
++
++template <typename T>
++void TopK(int32 row_size, int32 num_rows, const T *data, int32 k, int32 *output_indexes,
++          T *output_values)
++{
++  TopContainer<T> topc(k, row_size);
++  for (int row = 0; row < num_rows; ++row)
++  {
++    const T *values_row = data + row * row_size;
++    topc.start_collecting(values_row);
++    for (int32 c = 0; c < row_size; ++c)
++    {
++      topc.push(c);
++    }
++
++    // Prepare output buffers.
++    int32 *indexes_row = output_indexes + row * k;
++    T *output_row = output_values + row * k;
++    // We always assume that the output is sorted.
++    const auto &top_k = topc.sorted_result();
++    std::copy(top_k.begin(), top_k.end(), indexes_row);
++    std::transform(top_k.begin(), top_k.end(), output_row,
++                   [values_row](const int32 loc) { return values_row[loc]; });
++  }
++}
++
++} // namespace optimized_ops
++} // namespace rt
++} // namespace nnfw
++
++#endif // __NNFW_RT_OPTIMIZED_OPS_TOPK_V2_H__
+-- 
+1.9.1
+