[neurun] Use Object instead of ICLTensor in acl_cl::concat (#5637)

This change is done to replace explicitely calling acl::map/unmap
with Object::access, so that we can controll it in one place.
This change is needed for PR 5636

Signed-off-by: Dilshodzhon Poshshoev <d.poshshoev@samsung.com>

diff --git a/runtimes/neurun/backend/acl_cl/KernelGenerator.cc b/runtimes/neurun/backend/acl_cl/KernelGenerator.cc
index 45ab283..83bd02e 100644 (file)
--- a/runtimes/neurun/backend/acl_cl/KernelGenerator.cc
+++ b/runtimes/neurun/backend/acl_cl/KernelGenerator.cc
@@ -373,11 +373,13 @@ void KernelGenerator::visit(const model::operation::ConcatNode &node)
     return;
   }
 
-  auto output_alloc = _tensor_builder->at(ofm_index).get();
+  auto output_alloc = static_cast<::neurun::backend::acl_cl::operand::Object *>(
+      _tensor_builder->wrapTensor(ofm_index).get());
 
-  std::vector<::neurun::backend::acl_cl::operand::ICLTensor *> input_allocs;
+  std::vector<::neurun::backend::acl_cl::operand::Object *> input_allocs;
   for (auto &ifm_ind : input_indexes)
-    input_allocs.emplace_back(_tensor_builder->at(ifm_ind).get());
+    input_allocs.emplace_back(static_cast<::neurun::backend::acl_cl::operand::Object *>(
+        _tensor_builder->wrapTensor(ifm_ind).get()));
 
   auto fn = nnfw::cpp14::make_unique<::neurun::backend::acl_cl::kernel::ConcatLayer>();
 

diff --git a/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.cc b/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.cc
index dd23260..fee3272 100644 (file)
--- a/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.cc
+++ b/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.cc
@@ -68,12 +68,12 @@ template <typename T> bool ConcatLayer::concatenate()
 
     for (auto input : _input_allocs)
     {
-      assert(_output_alloc->layout() == input->layout());
-      assert(matchSizeExceptAxis(_output_alloc, input, _axis));
-      axis_sum += input->dimension(_axis);
+      assert(_output_alloc->ptr()->layout() == input->ptr()->layout());
+      assert(matchSizeExceptAxis(_output_alloc->ptr(), input->ptr(), _axis));
+      axis_sum += input->ptr()->dimension(_axis);
     }
 
-    assert(_output_alloc->dimension(_axis) == axis_sum);
+    assert(_output_alloc->ptr()->dimension(_axis) == axis_sum);
   }
 
   VERBOSE(Concat_RUN) << "START Concat" << std::endl;
@@ -84,43 +84,47 @@ template <typename T> bool ConcatLayer::concatenate()
 
     auto &queue = ::arm_compute::CLScheduler::get().queue();
 
-    _output_alloc->map(queue);
-
-    for (auto input : _input_allocs)
-    {
-      input->map(queue);
-
-      for (int32_t i = 0; i < input->info()->dimension(0); i++)
+    auto outout_fn = [&](::neurun::backend::operand::ITensor &out_tensor) {
+      for (auto input : _input_allocs)
       {
-        for (int32_t j = 0; j < input->info()->dimension(1); j++)
-        {
-          for (int32_t k = 0; k < input->info()->dimension(2); k++)
+        auto &out_cl_tensor =
+            static_cast<::neurun::backend::acl_cl::operand::ICLTensor &>(out_tensor);
+        auto input_fn = [&](::neurun::backend::operand::ITensor &in_tensor) {
+          auto &in_cl_tensor =
+              static_cast<::neurun::backend::acl_cl::operand::ICLTensor &>(in_tensor);
+          for (int32_t i = 0; i < in_cl_tensor.info()->dimension(0); i++)
           {
-            for (int32_t l = 0; l < input->info()->dimension(3); l++)
+            for (int32_t j = 0; j < in_cl_tensor.info()->dimension(1); j++)
             {
-              int32_t io = (_axis == 0) ? axis_offset : 0;
-              int32_t jo = (_axis == 1) ? axis_offset : 0;
-              int32_t ko = (_axis == 2) ? axis_offset : 0;
-              int32_t lo = (_axis == 3) ? axis_offset : 0;
-              T value = *reinterpret_cast<T *>(input->handle()->ptr_to_element({i, j, k, l}));
-              *reinterpret_cast<T *>(_output_alloc->handle()->ptr_to_element(
-                  {i + io, j + jo, k + ko, l + lo})) = value;
+              for (int32_t k = 0; k < in_cl_tensor.info()->dimension(2); k++)
+              {
+                for (int32_t l = 0; l < in_cl_tensor.info()->dimension(3); l++)
+                {
+                  int32_t io = (_axis == 0) ? axis_offset : 0;
+                  int32_t jo = (_axis == 1) ? axis_offset : 0;
+                  int32_t ko = (_axis == 2) ? axis_offset : 0;
+                  int32_t lo = (_axis == 3) ? axis_offset : 0;
+                  T value =
+                      *reinterpret_cast<T *>(in_cl_tensor.handle()->ptr_to_element({i, j, k, l}));
+                  *reinterpret_cast<T *>(out_cl_tensor.handle()->ptr_to_element(
+                      {i + io, j + jo, k + ko, l + lo})) = value;
+                }
+              }
             }
           }
-        }
+          if (_axis == 0)
+            axis_offset += in_cl_tensor.info()->dimension(0);
+          if (_axis == 1)
+            axis_offset += in_cl_tensor.info()->dimension(1);
+          if (_axis == 2)
+            axis_offset += in_cl_tensor.info()->dimension(2);
+          if (_axis == 3)
+            axis_offset += in_cl_tensor.info()->dimension(3);
+        };
+        input->access(input_fn);
       }
-      if (_axis == 0)
-        axis_offset += input->info()->dimension(0);
-      if (_axis == 1)
-        axis_offset += input->info()->dimension(1);
-      if (_axis == 2)
-        axis_offset += input->info()->dimension(2);
-      if (_axis == 3)
-        axis_offset += input->info()->dimension(3);
-
-      input->unmap(queue);
-    }
-    _output_alloc->unmap(queue);
+    };
+    _output_alloc->access(outout_fn);
   }
 
   VERBOSE(Concat_RUN) << "End   Concat" << std::endl;
@@ -129,8 +133,8 @@ template <typename T> bool ConcatLayer::concatenate()
 }
 
 void ConcatLayer::configure(
-    const std::vector<::neurun::backend::acl_cl::operand::ICLTensor *> &input_allocs, int32_t axis,
-    ::neurun::backend::acl_cl::operand::ICLTensor *output_alloc)
+    const std::vector<::neurun::backend::acl_cl::operand::Object *> &input_allocs, int32_t axis,
+    ::neurun::backend::acl_cl::operand::Object *output_alloc)
 {
   _input_allocs = input_allocs;
   _output_alloc = output_alloc;
@@ -144,9 +148,10 @@ void ConcatLayer::configure(
   // NHWC -> CWHN
   // NCHW -> WHCN
   _axis =
-      ::neurun::backend::acl_common::ToARMComputeAxis(output_alloc->num_dimensions(), axis).value();
+      ::neurun::backend::acl_common::ToARMComputeAxis(_output_alloc->ptr()->num_dimensions(), axis)
+          .value();
 
-  _input_type = input_allocs[0]->data_type();
+  _input_type = input_allocs[0]->ptr()->data_type();
 }
 
 void ConcatLayer::run()

diff --git a/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.h b/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.h
index e122158..ed273e2 100644 (file)
--- a/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.h
+++ b/runtimes/neurun/backend/acl_cl/kernel/ConcatLayer.h
@@ -20,7 +20,7 @@
 #include <arm_compute/runtime/IFunction.h>
 #include <arm_compute/core/Types.h>
 
-#include "operand/ICLTensor.h"
+#include "operand/Object.h"
 
 namespace neurun
 {
@@ -42,9 +42,9 @@ public:
   ConcatLayer();
 
 public:
-  void configure(const std::vector<::neurun::backend::acl_cl::operand::ICLTensor *> &input_allocs,
+  void configure(const std::vector<::neurun::backend::acl_cl::operand::Object *> &input_allocs,
                  int32_t axis /* NNAPI tensor axis from NHWC order */,
-                 ::neurun::backend::acl_cl::operand::ICLTensor *output_alloc);
+                 ::neurun::backend::acl_cl::operand::Object *output_alloc);
 
   void run();
 
@@ -52,8 +52,8 @@ private:
   template <typename T> bool concatenate();
 
 private:
-  std::vector<::neurun::backend::acl_cl::operand::ICLTensor *> _input_allocs;
-  ::neurun::backend::acl_cl::operand::ICLTensor *_output_alloc;
+  std::vector<::neurun::backend::acl_cl::operand::Object *> _input_allocs;
+  ::neurun::backend::acl_cl::operand::Object *_output_alloc;
   int32_t _axis;
   arm_compute::DataType _input_type;
 };

diff --git a/runtimes/neurun/backend/acl_common/AclMemoryManager.h b/runtimes/neurun/backend/acl_common/AclMemoryManager.h
index 8fb3c43..44473dc 100644 (file)
--- a/runtimes/neurun/backend/acl_common/AclMemoryManager.h
+++ b/runtimes/neurun/backend/acl_common/AclMemoryManager.h
@@ -75,7 +75,7 @@ public:
     _tensors[ind] = tensor;
   }
 
-  std::shared_ptr<backend::operand::IObject> wrapTensor(const model::OperandIndex &ind)
+  std::shared_ptr<T_Object> wrapTensor(const model::OperandIndex &ind)
   {
     if (_objects.find(ind) != _objects.end())
     {