Make Softmax kernels on OpenCL stateless

* ClSoftmaxKernel and ClSoftmax are created.
* ClSoftmaxKernel is now state-less and ClSoftmax handles
  the internal tensors required for computation.
* add_const_tensor() is added to TensorPack not only
  to have symmetric interface but also to benefit from
  implicit conversion.

Implements: COMPMID-3998

Change-Id: I4f823121777be24260fd12b2cd71a6ff718c4eed
Signed-off-by: Sang-Hoon Park <sang-hoon.park@arm.com>
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/5087
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>

3 files changed, 452 insertions, 115 deletions

diff --git a/src/runtime/CL/functions/CLSoftmaxLayer.cpp b/src/runtime/CL/functions/CLSoftmaxLayer.cpp
index 93e63dd779..938a10a7c0 100644
--- a/src/runtime/CL/functions/CLSoftmaxLayer.cpp
+++ b/src/runtime/CL/functions/CLSoftmaxLayer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Arm Limited.
+ * Copyright (c) 2017-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -22,34 +22,35 @@
  * SOFTWARE.
  */
 #include "arm_compute/runtime/CL/functions/CLSoftmaxLayer.h"
-
 #include "arm_compute/core/CL/CLHelpers.h"
+#include "arm_compute/core/CL/CLKernelLibrary.h"
 #include "arm_compute/core/Helpers.h"
+#include "arm_compute/core/KernelDescriptors.h"
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/Utils.h"
-#include "arm_compute/core/utils/misc/ShapeCalculator.h"
-#include "arm_compute/runtime/CL/CLScheduler.h"
-#include "src/core/CL/ICLKernel.h"
-#include "src/core/CL/kernels/CLFillBorderKernel.h"
-#include "src/core/CL/kernels/CLSoftmaxLayerKernel.h"
-#include "src/core/helpers/SoftmaxHelpers.h"
+#include "src/core/gpu/cl/kernels/ClSoftmaxKernel.h"
+#include "src/runtime/gpu/cl/operators/ClPermute.h"
+#include "src/runtime/gpu/cl/operators/ClSoftmax.h"
 
 namespace arm_compute
 {
+using OperatorType = opencl::ClSoftmax;
+
+template <bool IS_LOG>
+struct CLSoftmaxLayerGeneric<IS_LOG>::Impl
+{
+    const ICLTensor              *src{ nullptr };
+    ICLTensor                    *dst{ nullptr };
+    std::unique_ptr<OperatorType> op{ nullptr };
+    MemoryGroup                   memory_group{};
+    std::vector<std::pair<TensorType, std::unique_ptr<CLTensor>>> workspace_tensors{};
+};
+
 template <bool IS_LOG>
 CLSoftmaxLayerGeneric<IS_LOG>::CLSoftmaxLayerGeneric(std::shared_ptr<IMemoryManager> memory_manager)
-    : _memory_group(std::move(memory_manager)),
-      _permute_input(),
-      _permute_output(),
-      _max_shift_exp_sum_kernel(std::make_unique<CLLogits1DMaxShiftExpSumKernel>()),
-      _norm_kernel(std::make_unique<CLLogits1DNormKernel>()),
-      _max(),
-      _sum(),
-      _tmp(),
-      _input_permuted(),
-      _output_permuted(),
-      _needs_permute()
+    : _impl(std::make_unique<Impl>())
 {
+    _impl->memory_group = MemoryGroup(std::move(memory_manager));
 }
 
 template <bool IS_LOG>
@@ -64,118 +65,59 @@ void CLSoftmaxLayerGeneric<IS_LOG>::configure(const ICLTensor *input, ICLTensor
 template <bool IS_LOG>
 void CLSoftmaxLayerGeneric<IS_LOG>::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, float beta, int32_t axis)
 {
-    // Perform validation step
-    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
-    ARM_COMPUTE_ERROR_THROW_ON(CLSoftmaxLayerGeneric<IS_LOG>::validate(input->info(), output->info(), beta, axis));
-
-    const size_t actual_axis = static_cast<size_t>(wrap_around(axis, static_cast<int32_t>(input->info()->num_dimensions())));
+    _impl->src = input;
+    _impl->dst = output;
+    _impl->op  = std::make_unique<OperatorType>();
 
-    _needs_permute              = actual_axis != 0;
-    ICLTensor       *tmp_output = output;
-    const ICLTensor *tmp_input  = _needs_permute ? &_input_permuted : input;
-    if(_needs_permute)
-    {
-        _memory_group.manage(&_input_permuted);
-        _memory_group.manage(&_output_permuted);
-        _permute_input.configure(compile_context, input, &_input_permuted, softmax_helpers::get_permutation_vector_from_softmax_axis(actual_axis));
-        tmp_output = &_output_permuted;
-    }
-
-    // Create intermediate tensors
-    DataType   tmp_data_type = is_data_type_quantized_asymmetric(tmp_input->info()->data_type()) ? DataType::S32 : tmp_input->info()->data_type();
-    TensorInfo tensor_info_tmp(tmp_input->info()->clone()->set_data_type(tmp_data_type));
-    _tmp.allocator()->init(tensor_info_tmp);
-    TensorShape max_sum_shape = tmp_input->info()->tensor_shape();
-    max_sum_shape.set(0, 1);
-    _max.allocator()->init(tmp_input->info()->clone()->set_tensor_shape(max_sum_shape));
-    _sum.allocator()->init(tmp_input->info()->clone()->set_tensor_shape(max_sum_shape).set_data_type(tmp_data_type));
-
-    // Set GPU target to kernels
-    _max_shift_exp_sum_kernel->set_target(CLScheduler::get().target());
-
-    // Manage intermediate buffers
-    _memory_group.manage(&_tmp);
-    _memory_group.manage(&_max);
-    _memory_group.manage(&_sum);
-
-    SoftmaxKernelInfo softmax_info;
-    softmax_info.beta            = beta;
-    softmax_info.is_log          = IS_LOG;
-    softmax_info.input_data_type = tmp_input->info()->data_type();
-
-    // Configure kernels
-    _max_shift_exp_sum_kernel->configure(compile_context, tmp_input, &_max, &_tmp, &_sum, softmax_info);
-    _norm_kernel->configure(compile_context, &_tmp, &_sum, tmp_output, softmax_info);
-
-    // Allocate intermediate buffers
-    _tmp.allocator()->allocate();
-    _max.allocator()->allocate();
-    _sum.allocator()->allocate();
-    if(_needs_permute)
-    {
-        _permute_output.configure(compile_context, &_output_permuted, output, softmax_helpers::get_permutation_vector_from_softmax_axis(actual_axis));
-        _input_permuted.allocator()->allocate();
-        _output_permuted.allocator()->allocate();
-    }
+    SoftmaxKernelInfo softmax_info{ beta, IS_LOG, input->info()->data_type(), axis };
+    _impl->op->configure(compile_context, *input->info(), *output->info(), softmax_info);
 }
 
 template <bool IS_LOG>
 Status CLSoftmaxLayerGeneric<IS_LOG>::validate(const ITensorInfo *input, const ITensorInfo *output, float beta, int32_t axis)
 {
-    ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
-    ARM_COMPUTE_RETURN_ERROR_ON_MSG(input->num_dimensions() > 4, "Only up to 4 dimensions are supported");
-    ARM_COMPUTE_UNUSED(beta);
-    ARM_COMPUTE_RETURN_ERROR_ON(axis < static_cast<int32_t>(-input->num_dimensions()) || static_cast<int32_t>(input->num_dimensions()) <= axis);
-
-    const size_t actual_axis   = static_cast<size_t>(wrap_around(axis, static_cast<int32_t>(input->num_dimensions())));
-    const bool   needs_permute = actual_axis != 0;
-    if(needs_permute)
+    SoftmaxKernelInfo softmax_info{ beta, IS_LOG, input->data_type(), axis };
+    return OperatorType::validate(*input, *output, softmax_info);
+}
+
+template <bool IS_LOG>
+void           CLSoftmaxLayerGeneric<IS_LOG>::allocate_workspace()
+{
+    const auto memory_requirements = _impl->op->workspace();
+    std::for_each(memory_requirements.begin(), memory_requirements.end(), [this](const experimental::MemoryInfo & memory_info)
     {
-        const PermutationVector permutation_vector = softmax_helpers::get_permutation_vector_from_softmax_axis(actual_axis);
-        const TensorShape       permuted_shape     = misc::shape_calculator::compute_permutation_output_shape(*input, permutation_vector);
-        TensorInfo              input_permuted(input->clone()->set_tensor_shape(permuted_shape));
-        ARM_COMPUTE_RETURN_ON_ERROR(CLPermute::validate(input, &input_permuted, permutation_vector));
-        TensorInfo output_permuted(output->clone()->set_tensor_shape(permuted_shape));
-        ARM_COMPUTE_RETURN_ON_ERROR(CLPermute::validate(&output_permuted, output, permutation_vector));
-    }
-
-    // Create intermediate tensor info
-    DataType   tmp_data_type = is_data_type_quantized_asymmetric(input->data_type()) ? DataType::S32 : input->data_type();
-    TensorInfo tensor_info_tmp(input->clone()->set_data_type(tmp_data_type).set_is_resizable(true));
-
-    TensorShape max_sum_shape = input->tensor_shape();
-    max_sum_shape.set(0, 1);
-    TensorInfo tensor_info_max(input->clone()->set_tensor_shape(max_sum_shape).set_is_resizable(true));
-    TensorInfo tensor_info_sum(input->clone()->set_tensor_shape(max_sum_shape).set_data_type(tmp_data_type).set_quantization_info(QuantizationInfo()).set_is_resizable(true));
-
-    SoftmaxKernelInfo softmax_info;
-    softmax_info.beta            = beta;
-    softmax_info.is_log          = IS_LOG;
-    softmax_info.input_data_type = input->data_type();
-
-    ARM_COMPUTE_RETURN_ON_ERROR(CLLogits1DMaxShiftExpSumKernel::validate(input, &tensor_info_max, &tensor_info_tmp, &tensor_info_sum));
-    ARM_COMPUTE_RETURN_ON_ERROR(CLLogits1DNormKernel::validate(&tensor_info_tmp, &tensor_info_sum, output, softmax_info));
-
-    return Status{};
+        auto tensor_info = TensorInfo{ TensorShape(memory_info.size), 1, DataType::U8 };
+        _impl->workspace_tensors.emplace_back(memory_info.type, std::make_unique<CLTensor>());
+        auto tensor = _impl->workspace_tensors.back().second.get();
+        ARM_COMPUTE_ERROR_ON_NULLPTR(tensor);
+        _impl->memory_group.manage(tensor);
+        tensor->allocator()->init(tensor_info);
+        tensor->allocator()->allocate();
+    });
 }
 
 template <bool IS_LOG>
 void           CLSoftmaxLayerGeneric<IS_LOG>::run()
 {
-    MemoryGroupResourceScope scope_mg(_memory_group);
+    allocate_workspace();
 
-    if(_needs_permute)
-    {
-        _permute_input.run();
-    }
+    // Acquire all the temporaries
+    MemoryGroupResourceScope scope_mg(_impl->memory_group);
+
+    ARM_COMPUTE_ERROR_ON_NULLPTR(_impl->src, _impl->dst);
 
-    CLScheduler::get().enqueue(*_max_shift_exp_sum_kernel, false);
-    CLScheduler::get().enqueue(*_norm_kernel, !_needs_permute);
+    ITensorPack pack;
+    pack.add_tensor(TensorType::ACL_SRC, _impl->src);
+    pack.add_tensor(TensorType::ACL_DST, _impl->dst);
 
-    if(_needs_permute)
+    std::for_each(_impl->workspace_tensors.begin(), _impl->workspace_tensors.end(), [&pack](std::pair<TensorType, std::unique_ptr<CLTensor>> &wt)
     {
-        _permute_output.run();
-    }
+        auto tensor = wt.second.get();
+        ARM_COMPUTE_ERROR_ON_NULLPTR(tensor);
+        pack.add_tensor(wt.first, tensor);
+    });
+
+    _impl->op->run(pack);
 }
 
 template class CLSoftmaxLayerGeneric<false>;
diff --git a/src/runtime/gpu/cl/operators/ClSoftmax.cpp b/src/runtime/gpu/cl/operators/ClSoftmax.cpp
new file mode 100644
index 0000000000..c3ec7cc0da
--- /dev/null
+++ b/src/runtime/gpu/cl/operators/ClSoftmax.cpp
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2021 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 "src/runtime/gpu/cl/operators/ClSoftmax.h"
+#include "arm_compute/core/utils/misc/ShapeCalculator.h"
+#include "src/core/gpu/cl/kernels/ClSoftmaxKernel.h"
+#include "src/core/helpers/SoftmaxHelpers.h"
+#include "src/runtime/gpu/cl/operators/ClPermute.h"
+#include "support/Cast.h"
+
+namespace arm_compute
+{
+namespace opencl
+{
+namespace
+{
+void run_permute(ClPermute *op, const ITensor *src, ITensor *dst)
+{
+    ARM_COMPUTE_ERROR_ON_NULLPTR(src, dst, op);
+    ITensorPack pack;
+    pack.add_const_tensor(TensorType::ACL_SRC, src);
+    pack.add_tensor(TensorType::ACL_DST, dst);
+    op->run(pack);
+}
+} // namespace
+
+ClSoftmax::ClSoftmax()
+    : _permute_input(std::make_unique<ClPermute>()),
+      _permute_output(std::make_unique<ClPermute>()),
+      _max_shift_exp_sum_kernel(std::make_unique<kernels::ClLogits1DMaxShiftExpSumKernel>()),
+      _norm_kernel(std::make_unique<kernels::ClLogits1DNormKernel>()),
+      _max_info(_internal_info[static_cast<uint32_t>(InternalTensorIdx::MAX)]),
+      _sum_info(_internal_info[static_cast<uint32_t>(InternalTensorIdx::SUM)]),
+      _tmp_info(_internal_info[static_cast<uint32_t>(InternalTensorIdx::TMP)]),
+      _permuted_src_info(_internal_info[static_cast<uint32_t>(InternalTensorIdx::PERMUTED_SRC)]),
+      _permuted_dst_info(_internal_info[static_cast<uint32_t>(InternalTensorIdx::PERMUTED_DST)])
+{
+}
+
+TensorType ClSoftmax::convert_internal_idx_to_tensor_type(InternalTensorIdx idx) const
+{
+    switch(idx)
+    {
+        case InternalTensorIdx::MAX:
+            return TensorType::ACL_INT_0;
+        case InternalTensorIdx::SUM:
+            return TensorType::ACL_INT_1;
+        case InternalTensorIdx::TMP:
+            return TensorType::ACL_INT_2;
+        case InternalTensorIdx::PERMUTED_SRC:
+            return TensorType::ACL_INT_3;
+        case InternalTensorIdx::PERMUTED_DST:
+            return TensorType::ACL_INT_4;
+        default:
+            ARM_COMPUTE_ERROR("invalid internal tensor index is given.");
+            break;
+    };
+    return TensorType::ACL_UNKNOWN;
+}
+
+void ClSoftmax::create_internal_tensor(TensorInfo &info, InternalTensorIdx idx)
+{
+    const auto tensor_idx = static_cast<uint32_t>(idx);
+    if(!_internal_tensor[tensor_idx])
+    {
+        _internal_tensor[tensor_idx] = std::make_unique<CLTensor>();
+    }
+    _internal_tensor[tensor_idx]->allocator()->init(info);
+}
+
+void ClSoftmax::create_internal_tensor()
+{
+    for(uint32_t i = 0; i < static_cast<uint32_t>(InternalTensorIdx::COUNT); i++)
+    {
+        const auto tensor_idx = static_cast<InternalTensorIdx>(i);
+
+        if(!_needs_permute && (tensor_idx == InternalTensorIdx::PERMUTED_DST || tensor_idx == InternalTensorIdx::PERMUTED_SRC))
+        {
+            continue;
+        }
+        create_internal_tensor(_internal_info[i], static_cast<InternalTensorIdx>(i));
+    }
+}
+
+void ClSoftmax::configure(const CLCompileContext &compile_context, const ITensorInfo &src, ITensorInfo &dst, const SoftmaxKernelInfo &info)
+{
+    ARM_COMPUTE_ERROR_THROW_ON(validate(src, dst, info));
+
+    const size_t actual_axis = static_cast<size_t>(wrap_around(info.axis, static_cast<int32_t>(src.num_dimensions())));
+
+    _needs_permute = actual_axis != 0;
+
+    const ITensorInfo &tmp_input_info  = _needs_permute ? _permuted_src_info : src;
+    ITensorInfo       &tmp_output_info = _needs_permute ? _permuted_dst_info : dst;
+
+    if(_needs_permute)
+    {
+        const auto perm_info = softmax_helpers::get_permutation_vector_from_softmax_axis(actual_axis);
+        _permute_input->configure(compile_context, &src, &_permuted_src_info, perm_info);
+    }
+
+    DataType tmp_data_type = is_data_type_quantized_asymmetric(tmp_input_info.data_type()) ? DataType::S32 : tmp_input_info.data_type();
+    _tmp_info              = tmp_input_info.clone()->set_data_type(tmp_data_type);
+
+    TensorShape max_sum_shape = tmp_input_info.tensor_shape();
+    _max_info                 = tmp_input_info.clone()->set_tensor_shape(max_sum_shape);
+    _sum_info                 = tmp_input_info.clone()->set_tensor_shape(max_sum_shape).set_data_type(tmp_data_type);
+
+    // Set GPU target to kernels
+    _max_shift_exp_sum_kernel->set_target(CLScheduler::get().target());
+
+    _max_shift_exp_sum_kernel->configure(compile_context, tmp_input_info, _max_info, _tmp_info, _sum_info, info);
+    _norm_kernel->configure(compile_context, _tmp_info, _sum_info, tmp_output_info, info);
+
+    if(_needs_permute)
+    {
+        const auto perm_info = softmax_helpers::get_permutation_vector_from_softmax_axis(actual_axis);
+        _permute_output->configure(compile_context, &_permuted_dst_info, &dst, perm_info);
+    }
+}
+
+Status ClSoftmax::validate(const ITensorInfo &src, const ITensorInfo &dst, const SoftmaxKernelInfo &info)
+{
+    ARM_COMPUTE_RETURN_ERROR_ON_MSG(src.num_dimensions() > 4, "Only up to 4 dimensions are supported");
+    ARM_COMPUTE_UNUSED(info.beta);
+    ARM_COMPUTE_RETURN_ERROR_ON(info.axis < static_cast<int32_t>(-src.num_dimensions()) || static_cast<int32_t>(src.num_dimensions()) <= info.axis);
+
+    const size_t actual_axis   = static_cast<size_t>(wrap_around(info.axis, static_cast<int32_t>(src.num_dimensions())));
+    const bool   needs_permute = actual_axis != 0;
+    if(needs_permute)
+    {
+        const PermutationVector permutation_vector = softmax_helpers::get_permutation_vector_from_softmax_axis(actual_axis);
+        const TensorShape       permuted_shape     = misc::shape_calculator::compute_permutation_output_shape(src, permutation_vector);
+        TensorInfo              input_permuted(src.clone()->set_tensor_shape(permuted_shape));
+        ARM_COMPUTE_RETURN_ON_ERROR(ClPermute::validate(&src, &input_permuted, permutation_vector));
+        TensorInfo output_permuted(dst.clone()->set_tensor_shape(permuted_shape));
+        ARM_COMPUTE_RETURN_ON_ERROR(ClPermute::validate(&output_permuted, &dst, permutation_vector));
+    }
+
+    // Create intermediate tensor info
+    DataType   tmp_data_type = is_data_type_quantized_asymmetric(src.data_type()) ? DataType::S32 : src.data_type();
+    TensorInfo tensor_info_tmp(src.clone()->set_data_type(tmp_data_type).set_is_resizable(true));
+
+    TensorShape max_sum_shape = src.tensor_shape();
+    max_sum_shape.set(0, 1);
+    TensorInfo tensor_info_max(src.clone()->set_tensor_shape(max_sum_shape).set_is_resizable(true));
+    TensorInfo tensor_info_sum(src.clone()->set_tensor_shape(max_sum_shape).set_data_type(tmp_data_type).set_quantization_info(QuantizationInfo()).set_is_resizable(true));
+
+    ARM_COMPUTE_RETURN_ON_ERROR(kernels::ClLogits1DMaxShiftExpSumKernel::validate(src, tensor_info_max, tensor_info_tmp, tensor_info_sum));
+    ARM_COMPUTE_RETURN_ON_ERROR(kernels::ClLogits1DNormKernel::validate(tensor_info_tmp, tensor_info_sum, dst, info));
+
+    return Status{};
+}
+
+void ClSoftmax::import_workspace_memory(ITensorPack &tensors)
+{
+    auto import_workspace_memory = [this, &tensors](InternalTensorIdx idx)
+    {
+        const auto workspace_idx   = convert_internal_idx_to_tensor_type(idx);
+        auto       imported_tensor = tensors.get_tensor(workspace_idx);
+        if(imported_tensor)
+        {
+            auto imported_memory = utils::cast::polymorphic_downcast<ICLTensor *>(imported_tensor)->cl_buffer();
+            _internal_tensor[static_cast<uint32_t>(idx)].get()->allocator()->import_memory(imported_memory);
+        }
+    };
+
+    import_workspace_memory(InternalTensorIdx::PERMUTED_SRC);
+    import_workspace_memory(InternalTensorIdx::PERMUTED_DST);
+    import_workspace_memory(InternalTensorIdx::MAX);
+    import_workspace_memory(InternalTensorIdx::SUM);
+    import_workspace_memory(InternalTensorIdx::TMP);
+}
+
+void ClSoftmax::run_source_permute(const ITensor *src)
+{
+    if(_needs_permute)
+    {
+        auto permuted_src = _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::PERMUTED_SRC)].get();
+        run_permute(_permute_input.get(), src, permuted_src);
+    }
+}
+
+void ClSoftmax::run_destination_permute(ITensor *dst)
+{
+    if(_needs_permute)
+    {
+        auto permuted_dst = _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::PERMUTED_DST)].get();
+        run_permute(_permute_output.get(), permuted_dst, dst);
+    }
+}
+
+void ClSoftmax::run_max_sum(const ITensor *src)
+{
+    auto max = _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::MAX)].get();
+    auto sum = _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::SUM)].get();
+    auto tmp = _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::TMP)].get();
+
+    ARM_COMPUTE_ERROR_ON_NULLPTR(src, tmp, max, sum);
+
+    ITensorPack sum_pack;
+    sum_pack.add_const_tensor(TensorType::ACL_SRC, src);
+    sum_pack.add_tensor(TensorType::ACL_DST, tmp);
+    sum_pack.add_tensor(TensorType::ACL_INT_0, max);
+    sum_pack.add_tensor(TensorType::ACL_INT_1, sum);
+
+    CLScheduler::get().enqueue_op(*_max_shift_exp_sum_kernel.get(), sum_pack, false);
+}
+
+void ClSoftmax::run_norm(ITensor *dst)
+{
+    auto sum = _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::SUM)].get();
+    auto tmp = _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::TMP)].get();
+
+    ARM_COMPUTE_ERROR_ON_NULLPTR(tmp, sum, dst);
+
+    ITensorPack norm_pack;
+    norm_pack.add_const_tensor(TensorType::ACL_SRC, tmp);
+    norm_pack.add_tensor(TensorType::ACL_DST, dst);
+    norm_pack.add_tensor(TensorType::ACL_INT_0, sum);
+
+    CLScheduler::get().enqueue_op(*_norm_kernel.get(), norm_pack, false);
+}
+
+void ClSoftmax::run(ITensorPack &tensors)
+{
+    create_internal_tensor();
+
+    auto src = tensors.get_const_tensor(TensorType::ACL_SRC);
+    auto dst = tensors.get_tensor(TensorType::ACL_DST);
+
+    import_workspace_memory(tensors);
+    run_source_permute(src);
+    run_max_sum(!_needs_permute ? src : _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::PERMUTED_SRC)].get());
+    run_norm(!_needs_permute ? dst : _internal_tensor[static_cast<uint32_t>(InternalTensorIdx::PERMUTED_DST)].get());
+    run_destination_permute(dst);
+}
+
+experimental::MemoryRequirements ClSoftmax::workspace() const
+{
+    experimental::MemoryRequirements req{};
+
+    req.emplace_back(convert_internal_idx_to_tensor_type(InternalTensorIdx::SUM), _sum_info.total_size(), 0);
+    req.emplace_back(convert_internal_idx_to_tensor_type(InternalTensorIdx::TMP), _tmp_info.total_size(), 0);
+    req.emplace_back(convert_internal_idx_to_tensor_type(InternalTensorIdx::MAX), _max_info.total_size(), 0);
+
+    if(_needs_permute)
+    {
+        req.emplace_back(convert_internal_idx_to_tensor_type(InternalTensorIdx::PERMUTED_SRC), _permuted_src_info.total_size(), 0);
+        req.emplace_back(convert_internal_idx_to_tensor_type(InternalTensorIdx::PERMUTED_DST), _permuted_dst_info.total_size(), 0);
+    }
+
+    return req;
+}
+} // namespace opencl
+} // namespace arm_compute
\ No newline at end of file
diff --git a/src/runtime/gpu/cl/operators/ClSoftmax.h b/src/runtime/gpu/cl/operators/ClSoftmax.h
new file mode 100644
index 0000000000..e38b7c595a
--- /dev/null
+++ b/src/runtime/gpu/cl/operators/ClSoftmax.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2021 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_CL_SOFTMAX_H
+#define ARM_COMPUTE_CL_SOFTMAX_H
+
+#include "arm_compute/runtime/CL/CLTensor.h"
+#include "src/core/gpu/cl/ClCompileContext.h"
+#include "src/runtime/gpu/cl/IClOperator.h"
+
+namespace arm_compute
+{
+struct SoftmaxKernelInfo;
+
+namespace opencl
+{
+class ClPermute;
+namespace kernels
+{
+class ClLogits1DMaxShiftExpSumKernel;
+class ClLogits1DNormKernel;
+} // namespace kernels
+class ClSoftmax : public IClOperator
+{
+public:
+    /** Constructor */
+    ClSoftmax();
+    /** Configure the operator
+     *
+     * @param[in]  compile_context The compile context to be used.
+     * @param[in]  src             Source tensor info. Data types supported: QASYMM8/QASYMM8_SIGNED/F16/F32 for Softmax and F16/F32 for Log Softmax
+     * @param[out] dst             Destination tensor info. Data types supported: same as @p src
+     * @param[in]  info            Contains information consumed by kernels for softmax described in @ref SoftmaxKernelInfo.
+     *
+     */
+    void configure(const CLCompileContext &compile_context, const ITensorInfo &src, ITensorInfo &dst, const SoftmaxKernelInfo &info);
+    /** Static function to check if the given info will lead to a valid configuration
+     *
+     * @param[in]  src  Source tensor info. Data types supported: QASYMM8/QASYMM8_SIGNED/F16/F32 for Softmax and F16/F32 for Log Softmax
+     * @param[out] dst  Destination tensor info. Data types supported: same as @p src
+     * @param[in]  info Contains information consumed by kernels for softmax described in @ref SoftmaxKernelInfo.
+     *
+     */
+    static Status validate(const ITensorInfo &src, const ITensorInfo &dst, const SoftmaxKernelInfo &info);
+    // Inherited methods overridden:
+    void run(ITensorPack &tensors) override;
+    experimental::MemoryRequirements workspace() const override;
+
+private:
+    enum class InternalTensorIdx
+    {
+        MAX = 0,
+        SUM,
+        TMP,
+        PERMUTED_SRC,
+        PERMUTED_DST,
+        COUNT
+    };
+
+    /** Create a single internal tensor
+     *
+     * @param[in] info The information used to create a tensor
+     * @param[in] idx  The index within the internal array the created tensor will be held
+     */
+    void create_internal_tensor(TensorInfo &info, InternalTensorIdx idx);
+    /** Create all required internal tensors */
+    void create_internal_tensor();
+    /** Function to convert from internal tensor index to @ref TensorType used externally */
+    TensorType convert_internal_idx_to_tensor_type(InternalTensorIdx idx) const;
+    /** Function to import workspace memory allocated by the caller into internal tensor instances */
+    void import_workspace_memory(ITensorPack &tensors);
+    /** Function to permute the given source tensor when permutation is required */
+    void run_source_permute(const ITensor *src);
+    /** Function to permute the intemediate tensor to the final destination tensor when permutation is required */
+    void run_destination_permute(ITensor *dst);
+    /** Function to run @ref arm_compute::opencl::kernels::ClLogits1DMaxShiftExpSumKernel */
+    void run_max_sum(const ITensor *src);
+    /** Function to run @ref kernels::ClLogits1DNormKernel */
+    void run_norm(ITensor *dst);
+
+    std::unique_ptr<ClPermute>                               _permute_input;
+    std::unique_ptr<ClPermute>                               _permute_output;
+    std::unique_ptr<kernels::ClLogits1DMaxShiftExpSumKernel> _max_shift_exp_sum_kernel;
+    std::unique_ptr<kernels::ClLogits1DNormKernel>           _norm_kernel;
+    bool                                                     _needs_permute{ false };
+
+    std::array<TensorInfo, static_cast<uint32_t>(InternalTensorIdx::COUNT)>                _internal_info{};
+    std::array<std::unique_ptr<CLTensor>, static_cast<uint32_t>(InternalTensorIdx::COUNT)> _internal_tensor{};
+
+    TensorInfo &_max_info;
+    TensorInfo &_sum_info;
+    TensorInfo &_tmp_info;
+    TensorInfo &_permuted_src_info;
+    TensorInfo &_permuted_dst_info;
+};
+
+} // opencl
+} // arm_compute
+#endif /* ARM_COMPUTE_CL_SOFTMAX_H */
\ No newline at end of file