[neurun] Implement StageGenerator for TensorConvert nodes (#2151)

This commit implements StageGenerator for TensorConvert nodes.

Signed-off-by: sjsujinkim sjsujin.kim@samsung.com

diff --git a/runtimes/neurun/src/backend/acl_cl/StageGenerator.cc b/runtimes/neurun/src/backend/acl_cl/StageGenerator.cc
index 52a63aa..047eae3 100644 (file)
--- a/runtimes/neurun/src/backend/acl_cl/StageGenerator.cc
+++ b/runtimes/neurun/src/backend/acl_cl/StageGenerator.cc
@@ -8,6 +8,8 @@
 #include <arm_compute/runtime/CL/functions/CLSoftmaxLayer.h>
 
 #include "kernel/acl_cl/ConcatLayer.h"
+#include "kernel/acl_cl/TensorConvertFromCommonLayer.h"
+#include "kernel/acl_cl/TensorConvertToCommonLayer.h"
 
 #include "internal/Padding.h"
 #include "internal/Model.h"
@@ -522,12 +524,68 @@ Stage StageGenerator::generate(const ::internal::tflite::op::TensorConvert::CpuT
 Stage StageGenerator::generate(
     const ::internal::tflite::op::TensorConvert::AclFromCommon::Node &node)
 {
-  throw std::runtime_error("NYI - StageGenerator::generate(TensorConvert::AclFromCommon)");
+  const ::internal::tflite::operand::Index ifm_index{node.param().ifm_index};
+
+  struct Param
+  {
+    int ifm_index;
+  };
+
+  Param param;
+
+  param.ifm_index = ifm_index.asInt();
+
+  auto tensors = _tensor_builder;
+
+  _common_tensor_builder->mark(ifm_index);
+
+  auto common_tensor_builder = _common_tensor_builder;
+
+  return [tensors, common_tensor_builder, param](IExecutionBuilder &builder) {
+    auto input_alloc = tensors->at(::internal::tflite::operand::Index{param.ifm_index}).get();
+    auto common_tensor =
+        common_tensor_builder->at(::internal::tflite::operand::Index{param.ifm_index});
+
+    std::unique_ptr<::neurun::kernel::acl_cl::TensorConvertFromCommonLayer> fn{
+        new ::neurun::kernel::acl_cl::TensorConvertFromCommonLayer};
+
+    fn->configure(common_tensor.get(), input_alloc);
+
+    builder.append(std::move(fn));
+  };
 }
 
 Stage StageGenerator::generate(const ::internal::tflite::op::TensorConvert::AclToCommon::Node &node)
 {
-  throw std::runtime_error("NYI - StageGenerator::generate(TensorConvert::AclToCommon)");
+  const ::internal::tflite::operand::Index ofm_index{node.param().ofm_index};
+
+  struct Param
+  {
+    int ofm_index;
+  };
+
+  Param param;
+
+  param.ofm_index = ofm_index.asInt();
+
+  auto tensors = _tensor_builder;
+
+  _common_tensor_builder->mark(ofm_index);
+
+  auto common_tensor_builder = _common_tensor_builder;
+
+  return [tensors, common_tensor_builder, param](IExecutionBuilder &builder) {
+    auto output_alloc = tensors->at(::internal::tflite::operand::Index{param.ofm_index}).get();
+    auto common_tensor =
+        common_tensor_builder->at(::internal::tflite::operand::Index{param.ofm_index});
+
+    std::unique_ptr<::neurun::kernel::acl_cl::TensorConvertToCommonLayer> fn{
+        new ::neurun::kernel::acl_cl::TensorConvertToCommonLayer};
+
+    fn->configure(output_alloc, common_tensor.get());
+
+    builder.append(std::move(fn));
+  };
 }
 
 } // namespace acl_cl

diff --git a/runtimes/neurun/src/backend/cpu/StageGenerator.cc b/runtimes/neurun/src/backend/cpu/StageGenerator.cc
index 2cb5e69..a3b882d 100644 (file)
--- a/runtimes/neurun/src/backend/cpu/StageGenerator.cc
+++ b/runtimes/neurun/src/backend/cpu/StageGenerator.cc
@@ -10,6 +10,8 @@
 #include "kernel/cpufallback/FullyConnectedLayer.h"
 #include "kernel/cpufallback/ReshapeLayer.h"
 #include "kernel/cpufallback/SoftMaxLayer.h"
+#include "kernel/cpufallback/TensorConvertFromCommonLayer.h"
+#include "kernel/cpufallback/TensorConvertToCommonLayer.h"
 
 #include "logging.h"
 
@@ -509,12 +511,68 @@ Stage StageGenerator::generate(const ::internal::tflite::op::Softmax::Node &node
 Stage StageGenerator::generate(
     const ::internal::tflite::op::TensorConvert::CpuFromCommon::Node &node)
 {
-  throw std::runtime_error("NYI - StageGenerator::generate(TensorConvert::CpuFromCommon)");
+  const ::internal::tflite::operand::Index ifm_index{node.param().ifm_index};
+
+  struct Param
+  {
+    int ifm_index;
+  };
+
+  Param param;
+
+  param.ifm_index = ifm_index.asInt();
+
+  auto tensors = _tensor_builder;
+
+  _common_tensor_builder->mark(ifm_index);
+
+  auto common_tensor_builder = _common_tensor_builder;
+
+  return [tensors, common_tensor_builder, param](IExecutionBuilder &builder) {
+    auto input_alloc = tensors->at(::internal::tflite::operand::Index{param.ifm_index}).get();
+    auto common_tensor =
+        common_tensor_builder->at(::internal::tflite::operand::Index{param.ifm_index});
+
+    std::unique_ptr<::neurun::kernel::cpu::TensorConvertFromCommonLayer> fn{
+        new ::neurun::kernel::cpu::TensorConvertFromCommonLayer};
+
+    fn->configure(common_tensor.get(), input_alloc->buffer());
+
+    builder.append(std::move(fn));
+  };
 }
 
 Stage StageGenerator::generate(const ::internal::tflite::op::TensorConvert::CpuToCommon::Node &node)
 {
-  throw std::runtime_error("NYI - StageGenerator::generate(TensorConvert::CpuToCommon)");
+  const ::internal::tflite::operand::Index ofm_index{node.param().ofm_index};
+
+  struct Param
+  {
+    int ofm_index;
+  };
+
+  Param param;
+
+  param.ofm_index = ofm_index.asInt();
+
+  auto tensors = _tensor_builder;
+
+  _common_tensor_builder->mark(ofm_index);
+
+  auto common_tensor_builder = _common_tensor_builder;
+
+  return [tensors, common_tensor_builder, param](IExecutionBuilder &builder) {
+    auto output_alloc = tensors->at(::internal::tflite::operand::Index{param.ofm_index}).get();
+    auto common_tensor =
+        common_tensor_builder->at(::internal::tflite::operand::Index{param.ofm_index});
+
+    std::unique_ptr<::neurun::kernel::cpu::TensorConvertToCommonLayer> fn{
+        new ::neurun::kernel::cpu::TensorConvertToCommonLayer};
+
+    fn->configure(output_alloc->buffer(), common_tensor.get());
+
+    builder.append(std::move(fn));
+  };
 }
 
 Stage StageGenerator::generate(

diff --git a/runtimes/neurun/src/compilation.cc b/runtimes/neurun/src/compilation.cc
index 009337d..5c52c86 100644 (file)
--- a/runtimes/neurun/src/compilation.cc
+++ b/runtimes/neurun/src/compilation.cc
@@ -389,22 +389,26 @@ void Planner::visit(const ::internal::tflite::op::Softmax::Node &node)
 
 void Planner::visit(const ::internal::tflite::op::TensorConvert::CpuFromCommon::Node &node)
 {
-  VERBOSE(CpuFromCommon) << "Configure CpuFromCommon operation" << std::endl;
+  auto stage_gen = _backend_resolver.getStageGenerator(typeid(node));
+  _builder.addStage(stage_gen->generate(node));
 }
 
 void Planner::visit(const ::internal::tflite::op::TensorConvert::CpuToCommon::Node &node)
 {
-  VERBOSE(CpuToCommon) << "Configure CpuToCommon operation" << std::endl;
+  auto stage_gen = _backend_resolver.getStageGenerator(typeid(node));
+  _builder.addStage(stage_gen->generate(node));
 }
 
 void Planner::visit(const ::internal::tflite::op::TensorConvert::AclFromCommon::Node &node)
 {
-  VERBOSE(AclFromCommon) << "Configure AclFromCommon operation" << std::endl;
+  auto stage_gen = _backend_resolver.getStageGenerator(typeid(node));
+  _builder.addStage(stage_gen->generate(node));
 }
 
 void Planner::visit(const ::internal::tflite::op::TensorConvert::AclToCommon::Node &node)
 {
-  VERBOSE(AclToCommon) << "Configure AclToCommon operation" << std::endl;
+  auto stage_gen = _backend_resolver.getStageGenerator(typeid(node));
+  _builder.addStage(stage_gen->generate(node));
 }
 
 class TensorMarker : public ::internal::tflite::op::NodeVisitor

diff --git a/runtimes/neurun/src/internal/common/TensorBuilder.cc b/runtimes/neurun/src/internal/common/TensorBuilder.cc
index 61bc618..31ac71c 100644 (file)
--- a/runtimes/neurun/src/internal/common/TensorBuilder.cc
+++ b/runtimes/neurun/src/internal/common/TensorBuilder.cc
@@ -16,7 +16,13 @@ void TensorBuilder::mark(const ::internal::tflite::operand::Index &ind)
 {
   assert(_tensors.size() == 0);
 
-  _inds.insert(ind.asInt());
+  int index = ind.asInt();
+
+  auto it = _inds.find(index);
+  if (it == _inds.end())
+  {
+    _inds.insert(index);
+  }
 }
 
 void TensorBuilder::markFromCommon(const ::internal::tflite::op::Node &op, int32_t ind)