Port OpenCL Scale to new API

Partially resolves: COMPMID-4190

Change-Id: I680dd80fcbe4e7568511792c60a725b2646fa6ff
Signed-off-by: Manuel Bottini <manuel.bottini@arm.com>
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/5197
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: TeresaARM <teresa.charlinreyes@arm.com>
Reviewed-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>

4 files changed, 171 insertions, 28 deletions

diff --git a/src/runtime/CL/functions/CLScale.cpp b/src/runtime/CL/functions/CLScale.cpp
index 9862d0a1b3..cbd93c1086 100644
--- a/src/runtime/CL/functions/CLScale.cpp
+++ b/src/runtime/CL/functions/CLScale.cpp
@@ -23,17 +23,26 @@
  */
 #include "arm_compute/runtime/CL/functions/CLScale.h"
 
+#include "arm_compute/core/CL/CLKernelLibrary.h"
 #include "arm_compute/core/CL/ICLTensor.h"
-#include "arm_compute/core/Error.h"
-#include "arm_compute/core/Validate.h"
-#include "arm_compute/runtime/CL/CLScheduler.h"
+#include "arm_compute/core/KernelDescriptors.h"
+#include "src/core/CL/ICLKernel.h"
+#include "src/runtime/gpu/cl/operators/ClScale.h"
 
 namespace arm_compute
 {
+struct CLScale::Impl
+{
+    const ICLTensor                 *src{ nullptr };
+    ICLTensor                       *dst{ nullptr };
+    std::unique_ptr<opencl::ClScale> op{ nullptr };
+};
+
 CLScale::CLScale()
-    : _border_handler(std::make_unique<CLFillBorderKernel>()), _kernel()
+    : _impl(std::make_unique<Impl>())
 {
 }
+CLScale::~CLScale() = default;
 
 void CLScale::configure(ICLTensor *input, ICLTensor *output, const ScaleKernelInfo &info)
 {
@@ -42,33 +51,23 @@ void CLScale::configure(ICLTensor *input, ICLTensor *output, const ScaleKernelIn
 
 void CLScale::configure(const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *output, const ScaleKernelInfo &info)
 {
-    auto k = std::make_unique<CLScaleKernel>();
-    k->set_target(CLScheduler::get().target());
-    k->configure(compile_context, input, output, info);
-    _kernel = std::move(k);
+    _impl->src = input;
+    _impl->dst = output;
 
-    // Tune kernels
-    CLScheduler::get().tune_kernel_static(*_kernel);
-
-    const DataLayout data_layout = info.data_layout == DataLayout::UNKNOWN ? input->info()->data_layout() : info.data_layout;
-    if(data_layout == DataLayout::NCHW && !_kernel->border_size().empty())
-    {
-        _border_handler->configure(compile_context, input, _kernel->border_size(), info.border_mode, info.constant_border_value);
-    }
+    _impl->op = std::make_unique<opencl::ClScale>();
+    _impl->op->configure(compile_context, input->info(), output->info(), info);
 }
 
 Status CLScale::validate(const ITensorInfo *input, const ITensorInfo *output, const ScaleKernelInfo &info)
 {
-    return CLScaleKernel::validate(input, output, info);
+    return opencl::ClScale::validate(input, output, info);
 }
 
 void CLScale::run()
 {
-    if(!_kernel->border_size().empty())
-    {
-        CLScheduler::get().enqueue(*_border_handler, false);
-    }
-    CLScheduler::get().enqueue(*_kernel);
+    ITensorPack pack;
+    pack.add_tensor(TensorType::ACL_SRC, _impl->src);
+    pack.add_tensor(TensorType::ACL_DST, _impl->dst);
+    _impl->op->run(pack);
 }
-
 } // namespace arm_compute
diff --git a/src/runtime/CL/tuners/BifrostTuner.cpp b/src/runtime/CL/tuners/BifrostTuner.cpp
index 7a06de6d1c..fe95829cca 100644
--- a/src/runtime/CL/tuners/BifrostTuner.cpp
+++ b/src/runtime/CL/tuners/BifrostTuner.cpp
@@ -28,6 +28,7 @@
 #include "support/Cast.h"
 
 #include "src/core/gpu/cl/kernels/ClPoolingKernel.h"
+#include "src/core/gpu/cl/kernels/ClScaleKernel.h"
 
 namespace arm_compute
 {
@@ -234,18 +235,18 @@ void tune_pooling_kernel(opencl::kernels::ClPoolingKernel &k)
     k.set_lws_hint(lws_hint);
 }
 
-void tune_scale_kernel(CLScaleKernel &k)
+void tune_scale_kernel(opencl::kernels::ClScaleKernel &k)
 {
     cl::NDRange               lws_hint      = k.lws_hint();
     const GPUTarget           gpu_target    = k.get_target();
-    const DataType            dt            = k.input()->info()->data_type();
+    const DataType            dt            = k.get_data_type();
     const InterpolationPolicy interpolation = k.get_interpolation_policy();
 
     // Configure the local work size for Bifrost, interpolation (bilinear) and datatype F32.
     // The value are obtained via exhaustive autotuning.
     if(gpu_target_is_in(gpu_target, GPUTarget::G71, GPUTarget::G72) && (dt == DataType::F32) && (interpolation == InterpolationPolicy::BILINEAR))
     {
-        auto dim_0 = k.output()->info()->dimension(0);
+        const auto dim_0 = k.get_output_x_dim();
         if(dim_0 == 480)
         {
             lws_hint = cl::NDRange(2, 1);
@@ -285,9 +286,9 @@ void BifrostTuner::tune_kernel_static(ICLKernel &kernel)
     {
         tune_pooling_kernel(*utils::cast::polymorphic_downcast<opencl::kernels::ClPoolingKernel *>(&kernel));
     }
-    else if(dynamic_cast<CLScaleKernel *>(&kernel) != nullptr)
+    else if(dynamic_cast<opencl::kernels::ClScaleKernel *>(&kernel) != nullptr)
     {
-        tune_scale_kernel(*utils::cast::polymorphic_downcast<CLScaleKernel *>(&kernel));
+        tune_scale_kernel(*utils::cast::polymorphic_downcast<opencl::kernels::ClScaleKernel *>(&kernel));
     }
 }
 
diff --git a/src/runtime/gpu/cl/operators/ClScale.cpp b/src/runtime/gpu/cl/operators/ClScale.cpp
new file mode 100644
index 0000000000..4730c8a16e
--- /dev/null
+++ b/src/runtime/gpu/cl/operators/ClScale.cpp
@@ -0,0 +1,69 @@
+/*
+ * 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/ClScale.h"
+
+#include "arm_compute/core/Error.h"
+#include "arm_compute/runtime/CL/CLScheduler.h"
+#include "src/core/CL/kernels/CLFillBorderKernel.h"
+#include "src/core/gpu/cl/ClCompileContext.h"
+#include "src/core/gpu/cl/kernels/ClScaleKernel.h"
+
+namespace arm_compute
+{
+namespace opencl
+{
+void ClScale::configure(const CLCompileContext &compile_context, ITensorInfo *src, ITensorInfo *dst, const ScaleKernelInfo &info)
+{
+    ARM_COMPUTE_ERROR_ON_NULLPTR(src);
+    // Configure Scale kernel
+    auto k = std::make_unique<kernels::ClScaleKernel>();
+    k->set_target(CLScheduler::get().target());
+    k->configure(compile_context, src, dst, info);
+    _kernel = std::move(k);
+    if(!_kernel->border_size().empty())
+    {
+        auto b = std::make_unique<CLFillBorderKernel>();
+        b->configure(compile_context, src, _kernel->border_size(), info.border_mode, info.constant_border_value);
+        _border_handler = std::move(b);
+    }
+    // Tune kernel
+    CLScheduler::get().tune_kernel_static(*_kernel);
+}
+
+Status ClScale::validate(const ITensorInfo *src, const ITensorInfo *dst, const ScaleKernelInfo &info)
+{
+    return kernels::ClScaleKernel::validate(src, dst, info);
+}
+
+void ClScale::run(ITensorPack &tensors)
+{
+    ARM_COMPUTE_ERROR_ON_MSG(tensors.empty(), "No inputs provided");
+    if(!_kernel->border_size().empty())
+    {
+        CLScheduler::get().enqueue_op(*_border_handler.get(), tensors, false);
+    }
+    CLScheduler::get().enqueue_op(*_kernel.get(), tensors);
+}
+} // namespace opencl
+} // namespace arm_compute
\ No newline at end of file
diff --git a/src/runtime/gpu/cl/operators/ClScale.h b/src/runtime/gpu/cl/operators/ClScale.h
new file mode 100644
index 0000000000..6eccb59be8
--- /dev/null
+++ b/src/runtime/gpu/cl/operators/ClScale.h
@@ -0,0 +1,74 @@
+/*
+ * 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_SCALE_H
+#define ARM_COMPUTE_CL_SCALE_H
+
+#include "arm_compute/core/KernelDescriptors.h"
+#include "src/core/gpu/cl/ClCompileContext.h"
+#include "src/runtime/gpu/cl/IClOperator.h"
+
+namespace arm_compute
+{
+namespace opencl
+{
+/** Basic function to simulate a scale layer. This function calls the following OpenCL kernels:
+ *
+ * -# @ref CLFillBorderKernel (executed if padding size is different from zero)
+ * -# @ref kernels::ClScaleKernel
+ */
+class ClScale : public IClOperator
+{
+public:
+    /** Constructor */
+    ClScale() = default;
+    /** Initialize the function's source, destination, interpolation type and border_mode.
+     *
+     * @param[in]     compile_context The compile context to be used.
+     * @param[in,out] src             Source tensor info. Data types supported: U8/QASYMM8/QASYMM8_SIGNED/S16/F16/F32. (Written to only for @p border_mode != UNDEFINED)
+     * @param[out]    dst             Destination tensor info. Data types supported: Same as @p src
+     *                                All but the lowest two dimensions must be the same size as in the input tensor, i.e. scaling is only performed within the XY-plane.
+     * @param[in]     info            @ref ScaleKernelInfo descriptor to be used to configure
+     */
+    void configure(const CLCompileContext &compile_context, ITensorInfo *src, ITensorInfo *dst, const ScaleKernelInfo &info);
+
+    /** Static function to check if given info will lead to a valid configuration of @ref ClScale
+     *
+     * @param[in] src  Source tensor info. Data types supported: U8/QASYMM8/QASYMM8_SIGNED/S16/F16/F32.
+     * @param[in] dst  Output tensor info. Data type supported: Same as @p src
+     *                 All but the lowest two dimensions must be the same size as in the input tensor, i.e. scaling is only performed within the XY-plane.
+     * @param[in] info @ref ScaleKernelInfo descriptor to be used to validate
+     *
+     * @return a status
+     */
+    static Status validate(const ITensorInfo *src, const ITensorInfo *dst, const ScaleKernelInfo &info);
+
+    // Inherited method overridden
+    void run(ITensorPack &tensors) override;
+
+protected:
+    std::unique_ptr<ICLKernel> _border_handler{ nullptr };
+};
+} // namespace opencl
+} // namespace arm_compute
+#endif /*ARM_COMPUTE_CLSCALE_H */