onert::backend::basic::StaticTensorManager Class Reference

#include <StaticTensorManager.h>

Public Member Functions
	StaticTensorManager (const std::shared_ptr< TensorRegistry > &reg, DynamicTensorManager *dynamic_tensor_manager, const ir::OperandIndexMap< ir::OperandIndex > &shared_memory_operand_indexes)
	StaticTensorManager (const std::shared_ptr< TensorRegistry > &reg, const std::string planner_id, DynamicTensorManager *dynamic_tensor_manager, const ir::OperandIndexMap< ir::OperandIndex > &shared_memory_operand_indexes)
virtual	~StaticTensorManager ()=default
void	allocateNonconsts (void)
void	deallocateNonconsts (void)
void	buildTensor (const ir::OperandIndex &ind, const ir::OperandInfo &tensor_info, bool as_const)
void	claimPlan (const ir::OperandIndex &ind, uint32_t size)
void	releasePlan (const ir::OperandIndex &ind)
void	iterate (const std::function< void(const ir::OperandIndex &)> &fn)

Detailed Description

Definition at line 36 of file StaticTensorManager.h.

Constructor & Destructor Documentation

StaticTensorManager() [1/2]

onert::backend::basic::StaticTensorManager::StaticTensorManager	(	const std::shared_ptr< TensorRegistry > &	reg,
		DynamicTensorManager *	dynamic_tensor_manager,
		const ir::OperandIndexMap< ir::OperandIndex > &	shared_memory_operand_indexes
	)

Definition at line 32 of file StaticTensorManager.cc.

  : _nonconst_mgr{new MemoryManager()}, _tensors{reg},
    _dynamic_tensor_manager{dynamic_tensor_manager},
    _shared_memory_operand_indexes{shared_memory_operand_indexes}
{
  // DO NOTHING
}

StaticTensorManager() [2/2]

onert::backend::basic::StaticTensorManager::StaticTensorManager	(	const std::shared_ptr< TensorRegistry > &	reg,
		const std::string	planner_id,
		DynamicTensorManager *	dynamic_tensor_manager,
		const ir::OperandIndexMap< ir::OperandIndex > &	shared_memory_operand_indexes
	)

Definition at line 42 of file StaticTensorManager.cc.

  : _nonconst_mgr{new MemoryManager(planner_id)}, _tensors{reg},
    _dynamic_tensor_manager{dynamic_tensor_manager},
    _shared_memory_operand_indexes{shared_memory_operand_indexes}
{
  // DO NOTHING
}

~StaticTensorManager()

virtual onert::backend::basic::StaticTensorManager::~StaticTensorManager ( )

virtualdefault

Member Function Documentation

allocateNonconsts()

void onert::backend::basic::StaticTensorManager::allocateNonconsts

(

void

)

Definition at line 53 of file StaticTensorManager.cc.

{
  _nonconst_mgr->allocate();
 
  for (auto &&[ind, tensor] : _tensors->native_tensors())
  {
    const auto adjusted_ind = adjustWithMemorySourceOperand(ind);
    if (!_as_constants[adjusted_ind] && !tensor->is_dynamic())
    {
      auto *buffer = _nonconst_mgr->getBuffer(adjusted_ind);
      tensor->setBuffer(buffer);
 
      VERBOSE(CPU_StaticTensorManager)
        << "TENSOR " << ind << " : " << static_cast<void *>(buffer) << std::endl;
    }
  }
}

References VERBOSE.

buildTensor()

void onert::backend::basic::StaticTensorManager::buildTensor	(	const ir::OperandIndex &	ind,
		const ir::OperandInfo &	tensor_info,
		bool	as_const
	)

Definition at line 73 of file StaticTensorManager.cc.

{
  assert(!_tensors->getNativeTensor(ind));
  if (as_const)
  {
    auto tensor = std::make_unique<ExternalTensor>(tensor_info);
    _tensors->setNativeTensor(ind, std::move(tensor));
  }
  else
  {
    auto tensor =
      std::make_unique<Tensor>(tensor_info, _dynamic_tensor_manager->dynamic_mem_mgr().get());
    _tensors->setNativeTensor(ind, std::move(tensor));
  }
  _as_constants[ind] = as_const;
}

References onert::backend::basic::DynamicTensorManager::dynamic_mem_mgr().

claimPlan()

void onert::backend::basic::StaticTensorManager::claimPlan	(	const ir::OperandIndex &	ind,
		uint32_t	size
	)

Definition at line 91 of file StaticTensorManager.cc.

{
  assert(_tensors->getNativeTensor(ind));
 
  // This method is called only when a tensor has proper shape
  assert(!_tensors->getNativeTensor(ind)->is_dynamic());
 
  const auto claim_ind = adjustWithMemorySourceOperand(ind);
  if (_as_constants[claim_ind])
  {
    return;
  }
  if (isSharedMemoryOperand(claim_ind))
  {
    ++_source_operand_inds_ref_counter[claim_ind];
    if (_source_operand_inds_ref_counter[claim_ind] > 1)
    {
      return; // claimPlan should be called only for the first usage
    }
  }
  _nonconst_mgr->claimPlan(claim_ind, size);
}

References size.

deallocateNonconsts()

void onert::backend::basic::StaticTensorManager::deallocateNonconsts

(

void

)

Definition at line 71 of file StaticTensorManager.cc.

{ _nonconst_mgr->deallocate(); }

iterate()

void onert::backend::basic::StaticTensorManager::iterate

(

const std::function< void(const ir::OperandIndex &)> &

fn

)

Definition at line 140 of file StaticTensorManager.cc.

{
  for (const auto &it : _tensors->native_tensors())
    fn(it.first);
}

releasePlan()

void onert::backend::basic::StaticTensorManager::releasePlan

(

const ir::OperandIndex &

ind

)

Definition at line 114 of file StaticTensorManager.cc.

{
  assert(_tensors->getNativeTensor(ind));
 
  // This method is called only when a tensor has proper shape
  assert(!_tensors->getNativeTensor(ind)->is_dynamic());
 
  const auto release_ind = adjustWithMemorySourceOperand(ind);
  if (_as_constants[release_ind])
  {
    return;
  }
  if (isSharedMemoryOperand(release_ind))
  {
    if (_source_operand_inds_ref_counter[release_ind] > 0) // sanity check
    {
      --_source_operand_inds_ref_counter[release_ind];
    }
    if (_source_operand_inds_ref_counter[release_ind] > 0)
    {
      return; // releasePlan should be called only for the first usage
    }
  }
  _nonconst_mgr->releasePlan(release_ind);
}

---

The documentation for this class was generated from the following files:

• runtime/onert/core/include/backend/basic/StaticTensorManager.h
• runtime/onert/core/src/backend/basic/StaticTensorManager.cc