Port ElementwiseBinary to CKW part 2

* Add fp16 support
* Implement broadcasting to elementwise binary
* Implement kernel name and kernel config id
* Always use explicit cast in ckw unary, binary and ternary elementwise
  functions. This is to address the accidental use of double literals,
  with other benefits.
* Refactor TypeConverter for smaller includes

Resolves COMPMID-6260

Change-Id: I26b726746f8c0dd7b5942ad379d56f4d7642d15f
Signed-off-by: SiCong Li <sicong.li@arm.com>
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/9999
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Jakub Sujak <jakub.sujak@arm.com>
Reviewed-by: Viet-Hoa Do <viet-hoa.do@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Benchmark: Arm Jenkins <bsgcomp@arm.com>

3 files changed, 155 insertions, 49 deletions

diff --git a/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/WriterHelper.h b/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/WriterHelper.h
index 46c0f4ed8c..f4a056c5a0 100644
--- a/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/WriterHelper.h
+++ b/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/WriterHelper.h
@@ -24,10 +24,12 @@
 #ifndef ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_WRITERHELPER
 #define ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_WRITERHELPER
 
+#include "arm_compute/core/utils/misc/Utility.h"
+#include "ckw/TensorTileSampler.h"
 #include "src/dynamic_fusion/sketch/gpu/ckw_driver/GpuCkwComponentArgument.h"
 #include "src/dynamic_fusion/sketch/gpu/ckw_driver/GpuCkwScopedKernelWriter.h"
-#include "ckw/TensorTileSampler.h"
 
+#include <algorithm>
 #include <functional>
 
 using namespace ckw;
@@ -39,29 +41,6 @@ namespace dynamic_fusion
 {
 using SamplerCreator = std::function<TensorTileSampler(GpuCkwScopedKernelWriter &, int32_t /* m0 */, int32_t /* n0 */)>;
 
-/** Load lhs and rhs tiles of dimension [m0, n0] only when not loaded and prepare the sampler
- */
-inline void load_lhs_rhs_tiles_and_prepare_sampler(GpuCkwScopedKernelWriter &writer, GpuCkwComponentArgument *lhs, GpuCkwComponentArgument *rhs, int32_t m0, int32_t n0, SamplerCreator create_sampler)
-{
-    if(!lhs->has_tile() && !rhs->has_tile())
-    {
-        const auto sampler = create_sampler(writer, m0, n0);
-
-        writer->op_load_once(lhs, sampler);
-        writer->op_load_once(rhs, sampler);
-    }
-    else if(lhs->has_tile())
-    {
-        const auto &sampler = lhs->tile_sampler();
-        writer->op_load_once(rhs, sampler);
-    }
-    else
-    {
-        const auto &sampler = rhs->tile_sampler();
-        writer->op_load_once(lhs, sampler);
-    }
-}
-
 /** Load src and dst tiles of dimension [m0, n0] only when not loaded and prepare the sampler
  */
 inline void load_src_dst_tiles_and_prepare_sampler(GpuCkwScopedKernelWriter &writer, GpuCkwComponentArgument *src, GpuCkwComponentArgument *dst, int32_t m0, int32_t n0, SamplerCreator create_sampler)
@@ -88,6 +67,94 @@ inline void load_src_dst_tiles_and_prepare_sampler(GpuCkwScopedKernelWriter &wri
     }
 }
 
+/** Get boundary aware coordinate along one axis. Load and store of size step_v at the coordinate will not be out of bound
+ *
+ * @param[in,out] writer          Writer
+ * @param[out]    coord           Resultant coordinate
+ * @param[in]     gid             Global work item id
+ * @param[in]     step_v          Step size / vector size
+ * @param[in]     leftover_step_v Leftover step size at the boundary
+ * @param[in]     prefix          Prefix to all the tiles declared within this function
+ * @param[in]     const_0         Constant tile of value 0
+ */
+inline void get_coord(GpuCkwScopedKernelWriter writer, TileOperand &coord, TileOperand &gid, int32_t step_v, int32_t leftover_step_v, const std::string &prefix, TileOperand &const_0)
+{
+    auto &step          = writer->declare_tile(prefix + "step", step_v);
+    auto &leftover_step = writer->declare_tile(prefix + "leftover_step", leftover_step_v);
+
+    // step - leftover_step
+    auto &step_minus_leftover = writer->declare_tile(prefix + "step_minus_leftover", ckw::DataType::Int32);
+    writer->op_binary_expression(step_minus_leftover, step, ckw::BinaryOp::Sub, leftover_step);
+
+    // (step - leftover_step) % step
+    auto &coord_correction = writer->declare_tile(prefix + "coord_correction", ckw::DataType::Int32);
+    writer->op_binary_expression(coord_correction, step_minus_leftover, ckw::BinaryOp::Mod, step);
+
+    // (gid * step)
+    auto &raw_coord = writer->declare_tile(prefix + "raw_coord", ckw::DataType::Int32);
+    writer->op_binary_expression(raw_coord, gid, ckw::BinaryOp::Mul, step);
+
+    // (gid * step) - (step - leftover_step) % step
+    auto &corrected_coord = writer->declare_tile(prefix + "corrected_coord", ckw::DataType::Int32);
+    writer->op_binary_expression(corrected_coord, raw_coord, ckw::BinaryOp::Sub, coord_correction);
+
+    // max((gid * step) - (step - leftover_step) % step, 0)
+    writer->op_binary_elementwise_function(coord, ckw::BinaryFunction::Max, corrected_coord, const_0);
+}
+
+/** Declare coordinate tiles "{prefix}_dim0_coord" and "{prefix}_dim1_coord", and create a boundary-aware sampler from tile of size [n0, m0], against the overall dimensions [dim0, dim1]
+ * The load and store of tile [n0, m0] will never be out of bound of [dim0, dim1]
+ */
+
+/** Declare coordinate tiles "{prefix}_dim0_coord" and "{prefix}_dim1_coord", and create a boundary-aware sampler from tile of size [n0, m0], against the overall dimensions [dim0, dim1]
+ * The load and store of tile [n0, m0] will never be out of bound of [dim0, dim1]
+ *
+ * @param[in,out] writer  Writer
+ * @param[in]     gid_0   Global work item id 0
+ * @param[in]     gid_1   Global work item id 1
+ * @param[in]     dim0_v  Dimension 0
+ * @param[in]     dim1_v  Dimension 1
+ * @param[in]     n0_v    Tile size dimension 0
+ * @param[in]     m0_v    Tile size dimension 1
+ * @param[in]     prefix  Prefix to all the tiles declared within this function
+ * @param[in]     const_0 Constant tile of value 0
+ *
+ * @return TensorTileSampler
+ */
+inline TensorTileSampler create_boundary_aware_2d_sampler(GpuCkwScopedKernelWriter writer, TileOperand &gid_0, TileOperand &gid_1, int32_t dim0_v, int32_t dim1_v, int32_t n0_v, int32_t m0_v,
+                                                          const std::string prefix, TileOperand &const_0)
+{
+    // Clamp tile size [n0, m0] against dimension [dim0, dim1]
+    // This is needed to:
+    // * Guard against tile sizes are bigger than the tensor dimensions
+    // * Handle broadcasting tiles (e.g. src tensor is of size 1 in one of the dimensions)
+    n0_v                       = utility::clamp(n0_v, 1, dim0_v);
+    m0_v                       = utility::clamp(m0_v, 1, dim1_v);
+    const int32_t partial_n0_v = dim0_v % n0_v;
+    const int32_t partial_m0_v = dim1_v % m0_v;
+
+    // Declare #prefix_dim0_coord and #prefix_dim1_coord
+    auto &dim0_coord = writer->declare_tile(prefix + "dim0_coord", ckw::DataType::Int32);
+    get_coord(writer, dim0_coord, gid_0, n0_v, partial_n0_v, prefix + "dim0_", const_0);
+    auto &dim1_coord = writer->declare_tile(prefix + "dim1_coord", ckw::DataType::Int32);
+    get_coord(writer, dim1_coord, gid_1, m0_v, partial_m0_v, prefix + "dim1_", const_0);
+
+    // Set sampler
+    // Only set fields related to boundary aware loading/storing. Other info (e.g. format) is not responsibility of this function
+    TensorTileSampler sampler;
+
+    sampler.x(dim0_coord);
+    sampler.y(dim1_coord);
+
+    sampler.width(n0_v);
+    sampler.height(m0_v);
+
+    sampler.address_mode_x(TensorSamplerAddressModeX::None);
+    sampler.address_mode_y(TensorSamplerAddressModeY::None);
+    sampler.address_mode_z(TensorSamplerAddressModeZ::None);
+
+    return sampler;
+}
 } // namespace dynamic_fusion
 } // namespace experimental
 } // namespace arm_compute
diff --git a/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/TypeConverter.h b/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/type_converter/Common.h
index 8a38d67d80..34b1283add 100644
--- a/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/TypeConverter.h
+++ b/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/type_converter/Common.h
@@ -21,8 +21,8 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#ifndef ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPECONVERTER
-#define ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPECONVERTER
+#ifndef ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPE_CONVERTER_COMMON
+#define ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPE_CONVERTER_COMMON
 
 #include "arm_compute/core/ITensorInfo.h"
 #include "arm_compute/core/TensorShape.h"
@@ -106,46 +106,32 @@ inline TensorComponentType from_ckw(const ckw::TensorComponentType &component)
     {
         case ckw::TensorComponentType::OffsetFirstElement:
             return TensorComponentType::OffsetFirstElement;
-            break;
         case ckw::TensorComponentType::Stride0:
             return TensorComponentType::Stride0;
-            break;
         case ckw::TensorComponentType::Stride1:
             return TensorComponentType::Stride1;
-            break;
         case ckw::TensorComponentType::Stride2:
             return TensorComponentType::Stride2;
-            break;
         case ckw::TensorComponentType::Stride3:
             return TensorComponentType::Stride3;
-            break;
         case ckw::TensorComponentType::Stride4:
             return TensorComponentType::Stride4;
-            break;
         case ckw::TensorComponentType::Dim0:
             return TensorComponentType::Dim0;
-            break;
         case ckw::TensorComponentType::Dim1:
             return TensorComponentType::Dim1;
-            break;
         case ckw::TensorComponentType::Dim2:
             return TensorComponentType::Dim2;
-            break;
         case ckw::TensorComponentType::Dim3:
             return TensorComponentType::Dim3;
-            break;
         case ckw::TensorComponentType::Dim4:
             return TensorComponentType::Dim4;
-            break;
         case ckw::TensorComponentType::Dim1xDim2:
             return TensorComponentType::Dim1xDim2;
-            break;
         case ckw::TensorComponentType::Dim2xDim3:
             return TensorComponentType::Dim2xDim3;
-            break;
         case ckw::TensorComponentType::Dim1xDim2xDim3:
             return TensorComponentType::Dim1xDim2xDim3;
-            break;
         case ckw::TensorComponentType::Unknown:
             return TensorComponentType::Unknown;
         default:
@@ -160,16 +146,12 @@ inline ckw::TensorStorageType to_ckw(const TensorStorageType &storage)
     {
         case TensorStorageType::ClBufferUint8Ptr:
             return ckw::TensorStorageType::BufferUint8Ptr;
-            break;
         case TensorStorageType::ClImage2dReadOnly:
             return ckw::TensorStorageType::Texture2dReadOnly;
-            break;
         case TensorStorageType::ClImage2dWriteOnly:
             return ckw::TensorStorageType::Texture2dWriteOnly;
-            break;
         case TensorStorageType::Unknown:
             return ckw::TensorStorageType::Unknown;
-            break;
         default:
             ARM_COMPUTE_ERROR("Unknown tensor storage type");
             return ckw::TensorStorageType::Unknown;
@@ -181,16 +163,12 @@ inline TensorStorageType from_ckw(const ckw::TensorStorageType &storage)
     {
         case ckw::TensorStorageType::BufferUint8Ptr:
             return TensorStorageType::ClBufferUint8Ptr;
-            break;
         case ckw::TensorStorageType::Texture2dReadOnly:
             return TensorStorageType::ClImage2dReadOnly;
-            break;
         case ckw::TensorStorageType::Texture2dWriteOnly:
             return TensorStorageType::ClImage2dWriteOnly;
-            break;
         case ckw::TensorStorageType::Unknown:
             return TensorStorageType::Unknown;
-            break;
         default:
             ARM_COMPUTE_ERROR("Unknown CKW tensor storage type");
             return TensorStorageType::Unknown;
@@ -199,4 +177,4 @@ inline TensorStorageType from_ckw(const ckw::TensorStorageType &storage)
 } // namespace dynamic_fusion
 } // namespace experimental
 } // namespace arm_compute
-#endif /* ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPECONVERTER */
+#endif /* ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPE_CONVERTER_COMMON */
diff --git a/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/type_converter/ElementwiseBinary.h b/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/type_converter/ElementwiseBinary.h
new file mode 100644
index 0000000000..9cb022fc10
--- /dev/null
+++ b/src/dynamic_fusion/sketch/gpu/ckw_driver/components/utils/type_converter/ElementwiseBinary.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023 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 ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPE_CONVERTER_ELEMENTWISEBINARY
+#define ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPE_CONVERTER_ELEMENTWISEBINARY
+
+#include "ckw/types/Operators.h"
+#include "src/dynamic_fusion/sketch/gpu/operators/internal/GpuElementwiseBinaryCommon.h"
+
+namespace arm_compute
+{
+namespace experimental
+{
+namespace dynamic_fusion
+{
+inline ckw::BinaryOp to_ckw(const ElementwiseBinaryCommonAttributes &attributes)
+{
+    switch(attributes.operation())
+    {
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Add:
+            return ckw::BinaryOp::Add;
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Sub:
+            return ckw::BinaryOp::Sub;
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Div:
+            return ckw::BinaryOp::Div;
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Mul:
+            return ckw::BinaryOp::Mul;
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Min:
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Max:
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Power:
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::Prelu:
+        case ElementwiseBinaryCommonAttributes::ElementwiseOp::SquaredDiff:
+        default:
+            ARM_COMPUTE_ERROR("Cannot convert ElementwiseBinaryCommonAttributes to corresponding ckw::BinaryOp");
+    }
+}
+} // namespace dynamic_fusion
+} // namespace experimental
+} // namespace arm_compute
+
+#endif /* ACL_SRC_DYNAMIC_FUSION_SKETCH_GPU_CKW_DRIVER_COMPONENTS_UTILS_TYPE_CONVERTER_ELEMENTWISEBINARY */