[onert/acl_cl] Refactor operation handling to use separate operation files (#16268)

This commit refactors ACL-CL backend to move operation implementations from KernelGenerator.cc and Validator.h to separate operation files in ops/ directory.
This improves code organization and consistency with other backend patterns.

ONE-DCO-1.0-Signed-off-by: Hyeongseok Oh <hseok82.oh@samsung.com>

Author: hseok-oh

runtime/onert/backend/acl_cl/CMakeLists.txt

@@ -10,8 +10,7 @@ file(GLOB SOURCES "*.cc")
 file(GLOB OPERAND_SOURCES "operand/*.cc")
 list(APPEND SOURCES ${OPERAND_SOURCES})
 macro(OP NAME)
-  # ACL_CL backend doesn't have separate operation files,
-  # but we include the macro for consistency with other backend pattern
+  list(APPEND SOURCES ops/${NAME}.cc)
 endmacro(OP)
 include(Operation.lst)
 

runtime/onert/backend/acl_cl/KernelGenerator.cc

@@ -30,8 +30,7 @@ class Validator : public backend::ValidatorBase
   Validator(const ir::Graph &graph) : backend::ValidatorBase(graph) {}
 
 private:
-#define OP(InternalName) \
-  void visit(const ir::operation::InternalName &) override { _supported = true; }
+#define OP(InternalName) void visit(const ir::operation::InternalName &) override;
 #include "Operation.lst"
 #undef OP
 };

runtime/onert/backend/acl_cl/Validator.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * 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.
+ */
+
+#include "../KernelGenerator.h"
+#include "../Validator.h"
+
+#include <AclKernelGen.h>
+
+namespace onert::backend::acl_cl
+{
+
+void Validator::visit(const ir::operation::ArgMinMax &) { _supported = true; }
+
+void KernelGenerator::visit(const ir::operation::ArgMinMax &node)
+{
+  const auto ofm_index{node.getOutputs().at(0)};
+  const auto ifm_index{node.getInputs().at(ir::operation::ArgMinMax::Input::INPUT)};
+  const auto axis_index{node.getInputs().at(ir::operation::ArgMinMax::Input::AXIS)};
+
+  auto ifm_shape = _ctx.at(ifm_index).shape();
+  auto ofm_shape = _ctx.at(ofm_index).shape();
+
+  assert((ifm_shape.rank() - 1) == ofm_shape.rank());
+
+  auto ofm_tensor = _tensor_reg->getAclTensor(ofm_index);
+  auto ifm_tensor = _tensor_reg->getAclTensor(ifm_index);
+  const auto ifm_rank = _ctx.at(ifm_index).shape().rank();
+
+  int axis_value = _ctx.at(axis_index).asScalar<int32_t>();
+  if (axis_value < 0)
+  {
+    axis_value += ifm_rank;
+  }
+
+  auto acl_axis = acl_common::ToARMComputeAxis(ifm_rank, axis_value).value();
+  auto reduce_type = node.param().is_arg_max ? ::arm_compute::ReductionOperation::ARG_IDX_MAX
+                                             : ::arm_compute::ReductionOperation::ARG_IDX_MIN;
+  auto fn = acl_common::generateLayer<arm_compute::CLArgMinMaxLayer>(
+    ifm_tensor->handle(), acl_axis, ofm_tensor->handle(), reduce_type);
+
+  _return_fn = acl_common::asAclFunction(std::move(fn));
+}
+
+} // namespace onert::backend::acl_cl

runtime/onert/backend/acl_cl/ops/ArgMinMax.cc

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * 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.
+ */
+
+#include "../KernelGenerator.h"
+#include "../Validator.h"
+
+#include <AclKernelGen.h>
+
+namespace onert::backend::acl_cl
+{
+
+void Validator::visit(const ir::operation::BatchToSpaceND &) { _supported = true; }
+
+void KernelGenerator::visit(const ir::operation::BatchToSpaceND &node)
+{
+  const auto ofm_index{node.getOutputs().at(0)};
+  const auto ifm_index{node.getInputs().at(ir::operation::BatchToSpaceND::Input::INPUT)};
+  const auto block_size_index{
+    node.getInputs().at(ir::operation::BatchToSpaceND::Input::BLOCK_SIZE)};
+
+  const auto NNApiInputs = 2;
+  if (node.getInputs().size() != NNApiInputs)
+  {
+    const auto crops_index{node.getInputs().at(ir::operation::BatchToSpaceND::Input::CROPS_DATA)};
+    if (!_ctx.at(crops_index).isConstant())
+    {
+      throw std::runtime_error("Non-constant crops NYI for acl_cl backend BatchToSpaceND");
+    }
+
+    auto crops = _ctx.at(crops_index).asVector<int32_t>();
+    for (auto &&crop : crops)
+    {
+      if (crop != 0)
+      {
+        throw std::runtime_error("Non-zero crops NYI for acl_cl backend BatchToSpaceND");
+      }
+    }
+  }
+
+  auto ofm_tensor = _tensor_reg->getAclTensor(ofm_index);
+  auto ifm_tensor = _tensor_reg->getAclTensor(ifm_index);
+
+  if (!_ctx.at(block_size_index).data())
+    throw std::runtime_error("ACL CL does not support dynamic block size for BatchToSpaceND");
+
+  auto block = _ctx.at(block_size_index).asVector<int32_t>();
+  int32_t height = block[0];
+  int32_t width = block[1];
+
+  auto fn = acl_common::generateLayer<arm_compute::CLBatchToSpaceLayer>(
+    ifm_tensor->handle(), width, height, ofm_tensor->handle());
+
+  _return_fn = acl_common::asAclFunction(std::move(fn));
+}
+
+} // namespace onert::backend::acl_cl

runtime/onert/backend/acl_cl/ops/BatchToSpaceND.cc

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * 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.
+ */
+
+#include "../KernelGenerator.h"
+#include "../Validator.h"
+
+#include <AclKernelGen.h>
+
+namespace onert::backend::acl_cl
+{
+
+void Validator::visit(const ir::operation::BinaryArithmetic &) { _supported = true; }
+
+void KernelGenerator::visit(const ir::operation::BinaryArithmetic &node)
+{
+  const auto ofm_index{node.getOutputs().at(0)};
+  const auto lhs_index{node.getInputs().at(ir::operation::BinaryArithmetic::Input::LHS)};
+  const auto rhs_index{node.getInputs().at(ir::operation::BinaryArithmetic::Input::RHS)};
+
+  const auto activation = node.param().activation;
+
+  auto ofm_tensor = _tensor_reg->getAclTensor(ofm_index);
+  auto lhs_tensor = _tensor_reg->getAclTensor(lhs_index);
+  auto rhs_tensor = _tensor_reg->getAclTensor(rhs_index);
+
+  const auto act_info = acl_common::asActivationLayerInfo(activation);
+
+  std::unique_ptr<arm_compute::IFunction> fn;
+  switch (node.param().arithmetic_type)
+  {
+    case ir::operation::BinaryArithmetic::ArithmeticType::ADD:
+    {
+      arm_compute::CLArithmeticAddition::validate(lhs_tensor->info(), rhs_tensor->info(),
+                                                  ofm_tensor->info(),
+                                                  arm_compute::ConvertPolicy::SATURATE, act_info)
+        .throw_if_error();
+      fn = acl_common::generateLayer<arm_compute::CLArithmeticAddition>(
+        lhs_tensor->handle(), rhs_tensor->handle(), ofm_tensor->handle(),
+        arm_compute::ConvertPolicy::SATURATE, act_info);
+      break;
+    }
+    case ir::operation::BinaryArithmetic::ArithmeticType::SUB:
+    {
+      arm_compute::CLArithmeticSubtraction::validate(lhs_tensor->info(), rhs_tensor->info(),
+                                                     ofm_tensor->info(),
+                                                     arm_compute::ConvertPolicy::SATURATE, act_info)
+        .throw_if_error();
+      fn = acl_common::generateLayer<arm_compute::CLArithmeticSubtraction>(
+        lhs_tensor->handle(), rhs_tensor->handle(), ofm_tensor->handle(),
+        arm_compute::ConvertPolicy::SATURATE, act_info);
+      break;
+    }
+    case ir::operation::BinaryArithmetic::ArithmeticType::MUL:
+    {
+      arm_compute::CLPixelWiseMultiplication::validate(
+        lhs_tensor->info(), rhs_tensor->info(), ofm_tensor->info(), 1.0,
+        arm_compute::ConvertPolicy::SATURATE, arm_compute::RoundingPolicy::TO_NEAREST_EVEN,
+        act_info)
+        .throw_if_error();
+      fn = acl_common::generateLayer<arm_compute::CLPixelWiseMultiplication>(
+        lhs_tensor->handle(), rhs_tensor->handle(), ofm_tensor->handle(), 1.0, // scale
+        arm_compute::ConvertPolicy::SATURATE, arm_compute::RoundingPolicy::TO_NEAREST_EVEN,
+        act_info);
+      break;
+    }
+    case ir::operation::BinaryArithmetic::ArithmeticType::DIV:
+    {
+      arm_compute::CLArithmeticDivision::validate(lhs_tensor->info(), rhs_tensor->info(),
+                                                  ofm_tensor->info(), act_info)
+        .throw_if_error();
+      fn = acl_common::generateLayer<arm_compute::CLArithmeticDivision>(
+        lhs_tensor->handle(), rhs_tensor->handle(), ofm_tensor->handle(), act_info);
+      break;
+    }
+    default:
+      assert(false && "The BinaryArithmetic operation supports only binary arithmetic operations");
+      break;
+  }
+
+  _return_fn = acl_common::asAclFunction(std::move(fn));
+}
+
+} // namespace onert::backend::acl_cl

runtime/onert/backend/acl_cl/ops/BinaryArithmetic.cc

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * 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.
+ */
+
+#include "../KernelGenerator.h"
+#include "../Validator.h"
+
+#include <AclKernelGen.h>
+
+namespace onert::backend::acl_cl
+{
+
+void Validator::visit(const ir::operation::Comparison &) { _supported = true; }
+
+void KernelGenerator::visit(const ir::operation::Comparison &node)
+{
+  const auto output_index{node.getOutputs().at(0)};
+  const auto input0_index{node.getInputs().at(ir::operation::Comparison::Input::INPUT0)};
+  const auto input1_index{node.getInputs().at(ir::operation::Comparison::Input::INPUT1)};
+
+  const auto comparison_type = node.param().comparison_type;
+
+  auto output_tensor = _tensor_reg->getAclTensor(output_index);
+  auto input0_tensor = _tensor_reg->getAclTensor(input0_index);
+  auto input1_tensor = _tensor_reg->getAclTensor(input1_index);
+
+  auto fn = acl_common::generateLayer<arm_compute::CLComparison>(
+    input0_tensor->handle(), input1_tensor->handle(), output_tensor->handle(),
+    (arm_compute::ComparisonOperation)comparison_type);
+
+  _return_fn = acl_common::asAclFunction(std::move(fn));
+}
+
+} // namespace onert::backend::acl_cl

runtime/onert/backend/acl_cl/ops/Comparison.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * 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.
+ */
+
+#include "../KernelGenerator.h"
+#include "../Validator.h"
+
+#include <AclKernelGen.h>
+#include "exec/NopFunction.h"
+
+namespace onert::backend::acl_cl
+{
+
+void Validator::visit(const ir::operation::Concat &) { _supported = true; }
+
+void KernelGenerator::visit(const ir::operation::Concat &node)
+{
+  const auto ofm_index{node.getOutputs().at(0)};
+
+  std::vector<ir::OperandIndex> input_indexes;
+
+  for (const auto &input : node.getInputs())
+    input_indexes.emplace_back(input);
+
+  const auto axis = node.param().axis;
+
+  // Concat elimination check
+  bool eliminated = _tensor_builder->areSubTensorsOf(ofm_index, node.getInputs());
+  if (eliminated)
+  {
+    // If concat eliminated, return a NOP IFunction
+    VERBOSE(acl_cl_KernelGenerator_Concat) << "Concat eliminated" << std::endl;
+    _return_fn = std::make_unique<exec::NopFunction>();
+    return;
+  }
+
+  auto output_tensor = _tensor_reg->getAclTensor(ofm_index);
+  std::vector<const ::arm_compute::ICLTensor *> input_tensors;
+  for (const auto &ifm_ind : input_indexes)
+    input_tensors.emplace_back(_tensor_reg->getAclTensor(ifm_ind)->handle());
+
+  std::unique_ptr<::arm_compute::IFunction> fn;
+  if (input_indexes.size() < 2)
+  {
+    ::arm_compute::ICLTensor *input_tesor =
+      _tensor_reg->getAclTensor(input_indexes.at(0))->handle();
+
+    fn = acl_common::generateLayer<arm_compute::CLCopy>(input_tesor, output_tensor->handle());
+  }
+  else
+  {
+    const auto rank = _ctx.at(ofm_index).shape().rank();
+    const auto fixed_axis = acl_common::ToARMComputeAxis(rank, axis).value();
+    fn = acl_common::generateLayer<::arm_compute::CLConcatenateLayer>(
+      input_tensors, output_tensor->handle(), fixed_axis);
+  }
+
+  _return_fn = acl_common::asAclFunction(std::move(fn));
+}
+
+} // namespace onert::backend::acl_cl