[neurun] Remove no longer used template parameter (#9384)

Remove template parameter `T_Object` of TensorBuilder, TensorManager, MemoryManager classes.

Signed-off-by: Sergei Barannikov <s.barannikov@samsung.com>

diff --git a/runtime/neurun/backend/acl_cl/TensorBuilder.h b/runtime/neurun/backend/acl_cl/TensorBuilder.h
index 8ce69a6..3b1a9f2 100644 (file)
--- a/runtime/neurun/backend/acl_cl/TensorBuilder.h
+++ b/runtime/neurun/backend/acl_cl/TensorBuilder.h
@@ -31,9 +31,7 @@ namespace acl_cl
 {
 
 using TensorBuilder =
-    ::neurun::backend::acl_common::TemplTensorBuilder<::neurun::backend::acl_cl::operand::ICLTensor,
-                                                      operand::CLTensor, operand::CLSubTensor,
-                                                      operand::Object>;
+    acl_common::TemplTensorBuilder<operand::ICLTensor, operand::CLTensor, operand::CLSubTensor>;
 
 } // namespace acl_cl
 } // namespace backend

diff --git a/runtime/neurun/backend/acl_cl/TensorManager.h b/runtime/neurun/backend/acl_cl/TensorManager.h
index 10145bb..e4ec338 100644 (file)
--- a/runtime/neurun/backend/acl_cl/TensorManager.h
+++ b/runtime/neurun/backend/acl_cl/TensorManager.h
@@ -42,23 +42,20 @@ namespace acl_cl
 {
 
 using MemoryManager =
-    ::neurun::backend::acl_common::AclMemoryManager<operand::ICLTensor, operand::CLTensor,
-                                                    operand::CLSubTensor, operand::Object>;
+    acl_common::AclMemoryManager<operand::ICLTensor, operand::CLTensor, operand::CLSubTensor>;
 
-using LinearMemoryManager = ::neurun::backend::acl_common::AclLinearMemoryManager<
-    operand::ICLTensor, operand::CLTensor, operand::CLSubTensor, operand::Object,
+using LinearMemoryManager = acl_common::AclLinearMemoryManager<
+    operand::ICLTensor, operand::CLTensor, operand::CLSubTensor,
     ::arm_compute::MemoryManagerOnDemand, ::arm_compute::PoolManager,
     ::arm_compute::BlobLifetimeManager, ::arm_compute::CLBufferAllocator,
     ::arm_compute::CLMemoryGroup>;
 
-using InternalBufferManager = ::neurun::backend::acl_common::AclInternalBufferManager<
+using InternalBufferManager = acl_common::AclInternalBufferManager<
     ::arm_compute::MemoryManagerOnDemand, ::arm_compute::PoolManager,
     ::arm_compute::BlobLifetimeManager, ::arm_compute::CLBufferAllocator>;
 
 using TensorManager =
-    ::neurun::backend::acl_common::AclTensorManager<::neurun::backend::acl_cl::operand::ICLTensor,
-                                                    operand::CLTensor, operand::CLSubTensor,
-                                                    operand::Object>;
+    acl_common::AclTensorManager<operand::ICLTensor, operand::CLTensor, operand::CLSubTensor>;
 
 TensorManager *createTensorManager()
 {

diff --git a/runtime/neurun/backend/acl_common/AclLinearMemoryManager.h b/runtime/neurun/backend/acl_common/AclLinearMemoryManager.h
index 793c7b2..3ef9358 100644 (file)
--- a/runtime/neurun/backend/acl_common/AclLinearMemoryManager.h
+++ b/runtime/neurun/backend/acl_common/AclLinearMemoryManager.h
@@ -46,10 +46,10 @@ namespace backend
 namespace acl_common
 {
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object,
-          typename T_MemoryManager, typename T_PoolManager, typename T_LifetimeManager,
-          typename T_Allocator, typename T_MemoryGroup>
-class AclLinearMemoryManager : public AclMemoryManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_MemoryManager,
+          typename T_PoolManager, typename T_LifetimeManager, typename T_Allocator,
+          typename T_MemoryGroup>
+class AclLinearMemoryManager : public AclMemoryManager<T_ITensor, T_Tensor, T_SubTensor>
 {
 public:
   AclLinearMemoryManager()

diff --git a/runtime/neurun/backend/acl_common/AclMemoryManager.h b/runtime/neurun/backend/acl_common/AclMemoryManager.h
index 39662fc..910a990 100644 (file)
--- a/runtime/neurun/backend/acl_common/AclMemoryManager.h
+++ b/runtime/neurun/backend/acl_common/AclMemoryManager.h
@@ -33,7 +33,7 @@ namespace backend
 namespace acl_common
 {
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 class AclMemoryManager : public backend::IMemoryManager
 {
 public:

diff --git a/runtime/neurun/backend/acl_common/AclTensorManager.h b/runtime/neurun/backend/acl_common/AclTensorManager.h
index 3849f18..ca77046 100644 (file)
--- a/runtime/neurun/backend/acl_common/AclTensorManager.h
+++ b/runtime/neurun/backend/acl_common/AclTensorManager.h
@@ -31,11 +31,11 @@ namespace backend
 namespace acl_common
 {
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 class AclTensorManager : public backend::ITensorManager
 {
 public:
-  using T_AclMemoryManager = AclMemoryManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>;
+  using T_AclMemoryManager = AclMemoryManager<T_ITensor, T_Tensor, T_SubTensor>;
 
   AclTensorManager(T_AclMemoryManager *const_mgr, T_AclMemoryManager *nonconst_mgr,
                    IInternalBufferManager *inter_mgr);
@@ -95,8 +95,8 @@ namespace backend
 namespace acl_common
 {
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::AclTensorManager(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::AclTensorManager(
     T_AclMemoryManager *const_mgr, T_AclMemoryManager *nonconst_mgr,
     IInternalBufferManager *inter_mgr)
     : _const_mgr{const_mgr}, _nonconst_mgr{nonconst_mgr}, _inter_mgr{inter_mgr}
@@ -104,46 +104,44 @@ AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::AclTensorManager(
   // DO NOTHING
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::allocateConsts(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::allocateConsts(void)
 {
   _const_mgr->allocate();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::allocateNonconsts(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::allocateNonconsts(void)
 {
   _nonconst_mgr->allocate();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::deallocateConsts(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::deallocateConsts(void)
 {
   _const_mgr->deallocate();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::deallocateNonconsts(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::deallocateNonconsts(void)
 {
   _nonconst_mgr->deallocate();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::allocateInternalBufferManager(
-    void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::allocateInternalBufferManager(void)
 {
   _inter_mgr->allocate();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::deallocateInternalBufferManager(
-    void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::deallocateInternalBufferManager(void)
 {
   _inter_mgr->deallocate();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildTensor(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::buildTensor(
     const model::OperandIndex &ind, const ::arm_compute::TensorInfo &info, size_t rank,
     bool as_const, size_t num_uses)
 {
@@ -160,8 +158,8 @@ void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildTensor(
   }
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildSubtensor(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::buildSubtensor(
     const model::OperandIndex &parent, const model::OperandIndex &child,
     const ::arm_compute::TensorShape &shape, const ::arm_compute::Coordinates &coordinates,
     size_t rank, bool extent_parent)
@@ -173,9 +171,8 @@ void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildSubtenso
   _ind_to_mgr.insert({child, *_nonconst_mgr});
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-std::shared_ptr<T_ITensor>
-AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::findTensorAsParent(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+std::shared_ptr<T_ITensor> AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::findTensorAsParent(
     const model::OperandIndex &ind)
 {
 
@@ -197,25 +194,25 @@ AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::findTensorAsParent
   }
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::startLifetime(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::startLifetime(
     const model::OperandIndex &ind)
 {
   assert(_ind_to_mgr.find(ind) != _ind_to_mgr.end());
   _ind_to_mgr.at(ind).startLifetime(ind);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::finishLifetime(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::finishLifetime(
     const model::OperandIndex &ind)
 {
   assert(_ind_to_mgr.find(ind) != _ind_to_mgr.end());
   _ind_to_mgr.at(ind).finishLifetime(ind);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-std::shared_ptr<T_ITensor> AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::at(
-    const ::neurun::model::OperandIndex &ind)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+std::shared_ptr<T_ITensor>
+AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::at(const ::neurun::model::OperandIndex &ind)
 {
   assert(_ind_to_mgr.find(ind) != _ind_to_mgr.end());
 
@@ -230,36 +227,36 @@ std::shared_ptr<T_ITensor> AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_
   }
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 model::OperandIndexMap<std::shared_ptr<T_Tensor>> &
-AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::constTensors(void)
+AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::constTensors(void)
 {
   return _const_mgr->tensors();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 model::OperandIndexMap<std::shared_ptr<T_Tensor>> &
-AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::nonconstTensors(void)
+AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::nonconstTensors(void)
 {
   return _nonconst_mgr->tensors();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 model::OperandIndexMap<std::shared_ptr<T_SubTensor>> &
-AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::nonconstSubtensors(void)
+AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::nonconstSubtensors(void)
 {
   return _nonconst_mgr->subtensors();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 std::shared_ptr<::arm_compute::IMemoryManager>
-AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::internal_buffer_manager(void)
+AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::internal_buffer_manager(void)
 {
   return _inter_mgr->internal_buffer_manager();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::iterate(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::iterate(
     const std::function<void(const model::OperandIndex &)> &fn)
 {
   for (auto it : _nonconst_mgr->tensors())
@@ -272,8 +269,8 @@ void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::iterate(
     fn(it.first);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>::tryDeallocConstants(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>::tryDeallocConstants(void)
 {
   auto &tensors = _const_mgr->tensors();
 

diff --git a/runtime/neurun/backend/acl_common/TemplTensorBuilder.h b/runtime/neurun/backend/acl_common/TemplTensorBuilder.h
index c770b52..2b9102a 100644 (file)
--- a/runtime/neurun/backend/acl_common/TemplTensorBuilder.h
+++ b/runtime/neurun/backend/acl_common/TemplTensorBuilder.h
@@ -40,11 +40,11 @@ enum class UsesType
   LAST
 };
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 class TemplTensorBuilder : public ITensorBuilder
 {
 public:
-  using T_AclTensorManager = AclTensorManager<T_ITensor, T_Tensor, T_SubTensor, T_Object>;
+  using T_AclTensorManager = AclTensorManager<T_ITensor, T_Tensor, T_SubTensor>;
 
   TemplTensorBuilder(T_AclTensorManager *tensor_mgr);
 
@@ -151,8 +151,8 @@ namespace backend
 namespace acl_common
 {
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::TemplTensorBuilder(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::TemplTensorBuilder(
     T_AclTensorManager *tensor_mgr)
     : _tensor_mgr{tensor_mgr}, _executor_str(util::getConfigString(util::config::EXECUTOR)),
       _first_uses_num(0)
@@ -160,8 +160,8 @@ TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::TemplTensorBuild
   assert(_tensor_mgr);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::registerTensorInfo(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::registerTensorInfo(
     const model::OperandIndex &ind, const model::OperandInfo &info, model::Layout backend_layout,
     bool as_const)
 {
@@ -178,8 +178,8 @@ void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::registerTen
   _first_uses_visit[ind] = false;
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::registerSubTensorInfo(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::registerSubTensorInfo(
     const model::OperandIndex &ind, const compiler::SubTensorInfo &info)
 {
   assert(_tensor_mgr->constTensors().size() == 0);
@@ -202,87 +202,85 @@ void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::registerSub
   _parent_uses[parent_ind]++;
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::notifyFirstUse(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::notifyFirstUse(
     const model::OperandIndex &ind)
 {
   _first_uses_num++;
   _uses_queue.emplace(UsesType::FIRST, ind);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::notifyLastUse(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::notifyLastUse(
     const model::OperandIndex &ind)
 {
   _uses_queue.emplace(UsesType::LAST, ind);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-bool TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::isRegistered(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+bool TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::isRegistered(
     const model::OperandIndex &ind) const
 {
   return _tensor_info_map.find(ind) != _tensor_info_map.end() ||
          _subtensor_info_map.find(ind) != _subtensor_info_map.end();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::prepare(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::prepare(void)
 {
   buildTensors();
   buildSubtensors();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::allocateConsts(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::allocateConsts(void)
 {
   assert(_constants.size() == _tensor_mgr->constTensors().size());
   _tensor_mgr->allocateConsts();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::allocateNonconsts(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::allocateNonconsts(void)
 {
   assert(_tensor_info_map.size() == _tensor_mgr->nonconstTensors().size() + _constants.size());
   _tensor_mgr->allocateNonconsts();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::postFunctionPrepare(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::postFunctionPrepare(void)
 {
   _tensor_mgr->tryDeallocConstants();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::finalize(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::finalize(void)
 {
   validate();
   _tensor_mgr->allocateInternalBufferManager();
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 std::shared_ptr<::neurun::backend::operand::ITensor>
-TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::tensorAt(
-    const model::OperandIndex &ind)
+TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::tensorAt(const model::OperandIndex &ind)
 {
   return _tensor_mgr->at(ind);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::iterate(
-    const IterateFunction &fn)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::iterate(const IterateFunction &fn)
 {
   _tensor_mgr->iterate(fn);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-std::shared_ptr<T_ITensor> TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::at(
-    const ::neurun::model::OperandIndex &ind)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+std::shared_ptr<T_ITensor>
+TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::at(const ::neurun::model::OperandIndex &ind)
 {
   return _tensor_mgr->at(ind);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-bool TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::isSubTensorOf(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+bool TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::isSubTensorOf(
     const model::OperandIndex &parent, const model::OperandIndex &child)
 {
   if (_subtensor_info_map.find(child) == _subtensor_info_map.end())
@@ -304,22 +302,22 @@ bool TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::isSubTensor
   return true;
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::dimCorrection(
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::dimCorrection(
     const model::OperandIndex &index, bool apply_dim_correction)
 {
   _apply_dim_correction_map[index] = apply_dim_correction;
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
 std::unique_ptr<ITensorManager>
-TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::releaseTensorManager(void)
+TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::releaseTensorManager(void)
 {
   return std::move(_tensor_mgr);
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildTensors(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::buildTensors(void)
 {
   assert(_tensor_mgr->constTensors().size() == 0);
   assert(_tensor_mgr->nonconstTensors().size() == 0);
@@ -338,8 +336,8 @@ void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildTensor
   }
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildSubtensors(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::buildSubtensors(void)
 {
   // TODO Handle SubTensor(subsumption)
   //      Currently this TemplTensorBuilder does not have subsumption info yet
@@ -406,9 +404,8 @@ void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::buildSubten
   }
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::preVisit(
-    const model::Operation &node)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::preVisit(const model::Operation &node)
 {
   // For now others executor doesn't need this step
   if (_executor_str != "Linear")
@@ -481,9 +478,8 @@ void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::preVisit(
   }
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::postVisit(
-    const model::Operation &node)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::postVisit(const model::Operation &node)
 {
   // For now others executor doesn't need this step
   if (_executor_str != "Linear")
@@ -558,8 +554,8 @@ void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::postVisit(
   }
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::validate(void)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::validate(void)
 {
   // For now others executor doesn't need this step
   if (_executor_str != "Linear")
@@ -598,9 +594,9 @@ void TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::validate(vo
       [](std::pair<const model::OperandIndex, uint32_t> it) { return it.second == 0; }));
 }
 
-template <typename T_ITensor, typename T_Tensor, typename T_SubTensor, typename T_Object>
-model::OperandIndex TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor, T_Object>::findRootParent(
-    model::OperandIndex ind)
+template <typename T_ITensor, typename T_Tensor, typename T_SubTensor>
+model::OperandIndex
+TemplTensorBuilder<T_ITensor, T_Tensor, T_SubTensor>::findRootParent(model::OperandIndex ind)
 {
   if (_subtensor_info_map.find(ind) == _subtensor_info_map.end())
     return ind;

diff --git a/runtime/neurun/backend/acl_neon/TensorBuilder.h b/runtime/neurun/backend/acl_neon/TensorBuilder.h
index 3da30df..26b4248 100644 (file)
--- a/runtime/neurun/backend/acl_neon/TensorBuilder.h
+++ b/runtime/neurun/backend/acl_neon/TensorBuilder.h
@@ -31,9 +31,8 @@ namespace backend
 namespace acl_neon
 {
 
-using TensorBuilder = ::neurun::backend::acl_common::TemplTensorBuilder<
-    ::neurun::backend::acl_neon::operand::INETensor, operand::NETensor, operand::NESubTensor,
-    ::neurun::backend::operand::Object>;
+using TensorBuilder =
+    acl_common::TemplTensorBuilder<operand::INETensor, operand::NETensor, operand::NESubTensor>;
 
 } // namespace acl_neon
 } // namespace backend

diff --git a/runtime/neurun/backend/acl_neon/TensorManager.h b/runtime/neurun/backend/acl_neon/TensorManager.h
index 3d5c40b..f8e30f8 100644 (file)
--- a/runtime/neurun/backend/acl_neon/TensorManager.h
+++ b/runtime/neurun/backend/acl_neon/TensorManager.h
@@ -42,23 +42,19 @@ namespace acl_neon
 {
 
 using MemoryManager =
-    ::neurun::backend::acl_common::AclMemoryManager<operand::INETensor, operand::NETensor,
-                                                    operand::NESubTensor,
-                                                    ::neurun::backend::operand::Object>;
+    acl_common::AclMemoryManager<operand::INETensor, operand::NETensor, operand::NESubTensor>;
 
-using LinearMemoryManager = ::neurun::backend::acl_common::AclLinearMemoryManager<
-    operand::INETensor, operand::NETensor, operand::NESubTensor, ::neurun::backend::operand::Object,
+using LinearMemoryManager = acl_common::AclLinearMemoryManager<
+    operand::INETensor, operand::NETensor, operand::NESubTensor,
     ::arm_compute::MemoryManagerOnDemand, ::arm_compute::PoolManager,
     ::arm_compute::OffsetLifetimeManager, ::arm_compute::Allocator, ::arm_compute::MemoryGroup>;
 
-using InternalBufferManager = ::neurun::backend::acl_common::AclInternalBufferManager<
+using InternalBufferManager = acl_common::AclInternalBufferManager<
     ::arm_compute::MemoryManagerOnDemand, ::arm_compute::PoolManager,
     ::arm_compute::OffsetLifetimeManager, ::arm_compute::Allocator>;
 
-using TensorManager =
-    ::neurun::backend::acl_common::AclTensorManager<::neurun::backend::acl_neon::operand::INETensor,
-                                                    operand::NETensor, operand::NESubTensor,
-                                                    ::neurun::backend::operand::Object>;
+using TensorManager = acl_common::AclTensorManager<acl_neon::operand::INETensor, operand::NETensor,
+                                                   operand::NESubTensor>;
 
 TensorManager *createTensorManager()
 {