onert::backend::train::TensorBuilder Class Reference

#include <TensorBuilder.h>

Public Member Functions
	TensorBuilder (const std::shared_ptr< TensorRegistry > &tensor_reg, const exec::train::optimizer::Optimizer *optimizer)
void	registerTensorInfo (const ir::OperandIndex &ind, const ir::OperandInfo &info)
	Register tensor information to allocate on train backend.
void	registerBackwardTensorInfo (const ir::OperandIndex &ind, const ir::OperandInfo &info)
	Register informations of tensor used only in backward to allocate on train backend.
void	registerDisposableBackwardTensorInfo (const DisposableTensorIndex &index, const ir::OperandInfo &info)
void	registerLayerScopeTensor (const LayerScopeTensorIndex &index, std::shared_ptr< LayerScopeTensor > &info)
void	notifyFirstUse (const ir::OperandIndex &)
void	notifyLastUse (const ir::OperandIndex &)
void	notifyBackwardFirstUse (const ir::OperandIndex &)
void	notifyBackwardLastUse (const ir::OperandIndex &)
void	notifyDisposableBackPropFirstUse (const DisposableTensorIndex &)
void	notifyDisposableBackPropLastUse (const DisposableTensorIndex &)
void	notifyLayerScopeFirstUse (const LayerScopeTensorIndex &)
void	notifyLayerScopeLastUse (const LayerScopeTensorIndex &)
bool	isRegistered (const ir::OperandIndex &) const
bool	isRegisteredBackward (const ir::OperandIndex &) const
bool	isRegisteredDisposableBackwardTensor (const DisposableTensorIndex &index) const
bool	isRegisteredLayerScopeTensor (const ir::OperationIndex &) const
const util::Set< LayerScopeTensorIndex > &	getRegisteredLayerScopeTensorIndices (const ir::OperationIndex &) const
LayerScopeTensorLifeTime	getLayerScopeTensorLifeTime (const LayerScopeTensorIndex &) const
void	allocate (void)
void	allocateBackward (void)
void	allocateLayerScope (void)

Detailed Description

Definition at line 33 of file TensorBuilder.h.

Constructor & Destructor Documentation

TensorBuilder()

onert::backend::train::TensorBuilder::TensorBuilder	(	const std::shared_ptr< TensorRegistry > &	tensor_reg,
		const exec::train::optimizer::Optimizer *	optimizer
	)

Definition at line 24 of file TensorBuilder.cc.

  : _tensor_reg{tensor_reg}, _tensor_mgr{new TensorManager(tensor_reg, optimizer->getVarCount())},
    _optimizer{optimizer}
{
  /* empty */
}

Member Function Documentation

allocate()

void onert::backend::train::TensorBuilder::allocate

(

void

)

Definition at line 223 of file TensorBuilder.cc.

{
  _tensor_mgr->allocateNonConstTensors();
  _tensor_mgr->allocateTrainableTensors();
}

allocateBackward()

void onert::backend::train::TensorBuilder::allocateBackward

(

void

)

Definition at line 229 of file TensorBuilder.cc.

{
  _tensor_mgr->allocateBackPropTensors();
  _tensor_mgr->allocateGradientTensors();
  _tensor_mgr->allocateDisposableBackPropTensors();
}

allocateLayerScope()

void onert::backend::train::TensorBuilder::allocateLayerScope

(

void

)

Definition at line 236 of file TensorBuilder.cc.

{ _tensor_mgr->allocateLayerScopeTensors(); }

getLayerScopeTensorLifeTime()

LayerScopeTensorLifeTime onert::backend::train::TensorBuilder::getLayerScopeTensorLifeTime

(

const LayerScopeTensorIndex &

index

)

const

Definition at line 216 of file TensorBuilder.cc.

{
  const auto &ls_tensors = _tensor_reg->layerscope_tensors();
  const auto &tensor = ls_tensors.at(index);
  return tensor->lifetime();
}

Referenced by onert::backend::train::TensorPlanner::planLayerScopeTensors().

getRegisteredLayerScopeTensorIndices()

const util::Set< LayerScopeTensorIndex > & onert::backend::train::TensorBuilder::getRegisteredLayerScopeTensorIndices

(

const ir::OperationIndex &

index

)

const

Definition at line 207 of file TensorBuilder.cc.

{
  const auto pair = _operation_to_layerscope.find(index);
  assert(pair != _operation_to_layerscope.end());
 
  return pair->second;
}

Referenced by onert::backend::train::TensorPlanner::planLayerScopeTensors().

isRegistered()

bool onert::backend::train::TensorBuilder::isRegistered

(

const ir::OperandIndex &

index

)

const

Definition at line 185 of file TensorBuilder.cc.

{
  return _tensor_info_map.find(index) != _tensor_info_map.end();
}

Referenced by onert::backend::train::TensorPlanner::planNonConstTensors(), and onert::backend::train::TensorPlanner::planTrainableTensors().

isRegisteredBackward()

bool onert::backend::train::TensorBuilder::isRegisteredBackward

(

const ir::OperandIndex &

index

)

const

Definition at line 190 of file TensorBuilder.cc.

{
  return _backward_tensor_info_map.find(index) != _backward_tensor_info_map.end();
}

Referenced by onert::backend::train::TensorPlanner::planBackPropTensors(), and onert::backend::train::TensorPlanner::planGradientTensors().

isRegisteredDisposableBackwardTensor()

bool onert::backend::train::TensorBuilder::isRegisteredDisposableBackwardTensor

(

const DisposableTensorIndex &

index

)

const

Definition at line 195 of file TensorBuilder.cc.

{
  return _disposable_backprops.contains(index);
}

Referenced by onert::backend::train::TensorPlanner::planDisposableBackPropTensors().

isRegisteredLayerScopeTensor()

bool onert::backend::train::TensorBuilder::isRegisteredLayerScopeTensor

(

const ir::OperationIndex &

index

)

const

Definition at line 200 of file TensorBuilder.cc.

{
  const auto pair = _operation_to_layerscope.find(index);
  return (pair != _operation_to_layerscope.end());
}

Referenced by onert::backend::train::TensorPlanner::planLayerScopeTensors().

notifyBackwardFirstUse()

void onert::backend::train::TensorBuilder::notifyBackwardFirstUse

(

const ir::OperandIndex &

index

)

Definition at line 140 of file TensorBuilder.cc.

{
  // TODO Support momory plan
  if (_as_constants[index])
  {
    _tensor_mgr->claimGradientPlan(index);
  }
  else
  {
    _tensor_mgr->claimBackPropPlan(index);
  }
}

Referenced by onert::backend::train::TensorPlanner::planBackPropTensors(), and onert::backend::train::TensorPlanner::planGradientTensors().

notifyBackwardLastUse()

void onert::backend::train::TensorBuilder::notifyBackwardLastUse

(

const ir::OperandIndex &

index

)

Definition at line 153 of file TensorBuilder.cc.

{
  if (_as_constants[index])
  {
    _tensor_mgr->releaseGradientPlan(index);
  }
  else
  {
    _tensor_mgr->releaseBackPropPlan(index);
  }
}

Referenced by onert::backend::train::TensorPlanner::planBackPropTensors(), and onert::backend::train::TensorPlanner::planGradientTensors().

notifyDisposableBackPropFirstUse()

void onert::backend::train::TensorBuilder::notifyDisposableBackPropFirstUse

(

const DisposableTensorIndex &

index

)

Definition at line 165 of file TensorBuilder.cc.

{
  _tensor_mgr->claimDisposableBackPropPlan(index);
}

Referenced by onert::backend::train::TensorPlanner::planDisposableBackPropTensors().

notifyDisposableBackPropLastUse()

void onert::backend::train::TensorBuilder::notifyDisposableBackPropLastUse

(

const DisposableTensorIndex &

index

)

Definition at line 170 of file TensorBuilder.cc.

{
  _tensor_mgr->releaseDisposableBackPropPlan(index);
}

Referenced by onert::backend::train::TensorPlanner::planDisposableBackPropTensors().

notifyFirstUse()

void onert::backend::train::TensorBuilder::notifyFirstUse

(

const ir::OperandIndex &

index

)

Definition at line 115 of file TensorBuilder.cc.

{
  // TODO Support momory plan
  if (_as_constants[index])
  {
    _tensor_mgr->claimTrainablePlan(index);
  }
  else
  {
    _tensor_mgr->claimNonConstPlan(index);
  }
}

Referenced by onert::backend::train::TensorPlanner::planNonConstTensors(), and onert::backend::train::TensorPlanner::planTrainableTensors().

notifyLastUse()

void onert::backend::train::TensorBuilder::notifyLastUse

(

const ir::OperandIndex &

index

)

Definition at line 128 of file TensorBuilder.cc.

{
  if (_as_constants[index])
  {
    _tensor_mgr->releaseTrainablePlan(index);
  }
  else
  {
    _tensor_mgr->releaseNonConstPlan(index);
  }
}

Referenced by onert::backend::train::TensorPlanner::planNonConstTensors(), and onert::backend::train::TensorPlanner::planTrainableTensors().

notifyLayerScopeFirstUse()

void onert::backend::train::TensorBuilder::notifyLayerScopeFirstUse

(

const LayerScopeTensorIndex &

index

)

Definition at line 175 of file TensorBuilder.cc.

{
  _tensor_mgr->claimLayerScopePlan(index);
}

Referenced by onert::backend::train::TensorPlanner::planLayerScopeTensors().

notifyLayerScopeLastUse()

void onert::backend::train::TensorBuilder::notifyLayerScopeLastUse

(

const LayerScopeTensorIndex &

index

)

Definition at line 180 of file TensorBuilder.cc.

{
  _tensor_mgr->releaseLayerScopePlan(index);
}

Referenced by onert::backend::train::TensorPlanner::planLayerScopeTensors().

registerBackwardTensorInfo()

void onert::backend::train::TensorBuilder::registerBackwardTensorInfo	(	const ir::OperandIndex &	ind,
		const ir::OperandInfo &	info
	)

Register informations of tensor used only in backward to allocate on train backend.

Parameters

[in]	ind	Operand index
[in]	info	Operand information

Definition at line 53 of file TensorBuilder.cc.

{
  _backward_tensor_info_map.emplace(index, info);
 
  assert(!info.isDynamic());
 
  // NOTE For now, whether or not to build operands to trainable tensor depends on whether
  //      the corresponding operand is constant.
  assert(_as_constants[index] == info.isConstant());
  if (_as_constants[index])
  {
    auto tensor = std::make_unique<GradientTensor>(info);
    _tensor_reg->setGradientTensor(index, std::move(tensor));
 
    // Initialize tensors for gradient variables
    for (uint32_t i = 0; i < _optimizer->getVarCount(); ++i)
    {
      auto tensor = std::make_unique<Tensor>(info);
      _tensor_reg->getTrainableTensor(index)->appendOptVar(std::move(tensor));
    }
  }
  else
  {
    auto tensor = std::make_unique<BackPropTensor>(info);
    _tensor_reg->setBackPropTensor(index, std::move(tensor));
  }
}

References onert::exec::train::optimizer::Optimizer::getVarCount(), and info.

registerDisposableBackwardTensorInfo()

void onert::backend::train::TensorBuilder::registerDisposableBackwardTensorInfo	(	const DisposableTensorIndex &	index,
		const ir::OperandInfo &	info
	)

Definition at line 82 of file TensorBuilder.cc.

{
  assert(!info.isDynamic());
  assert(!_as_constants[index.operand_index()]);
 
  auto disposable_tensor = std::make_unique<BackPropTensor>(info);
  _tensor_reg->setDisposableBackPropTensor(index, std::move(disposable_tensor));
 
  _disposable_backprops.add(index);
}

References info.

registerLayerScopeTensor()

void onert::backend::train::TensorBuilder::registerLayerScopeTensor	(	const LayerScopeTensorIndex &	index,
		std::shared_ptr< LayerScopeTensor > &	info
	)

Definition at line 94 of file TensorBuilder.cc.

{
  const auto op_idx = index.op_index();
 
  const auto pair = _operation_to_layerscope.find(op_idx);
  if (pair == _operation_to_layerscope.end())
  {
    util::Set<LayerScopeTensorIndex> tensor_indices;
    tensor_indices.add(index);
    _operation_to_layerscope[op_idx] = tensor_indices;
  }
  else
  {
    assert(!pair->second.contains(index));
    pair->second.add(index);
  }
 
  _tensor_reg->setLayerScopeTensor(index, tensor);
}

References onert::util::Set< Element >::add().

registerTensorInfo()

void onert::backend::train::TensorBuilder::registerTensorInfo	(	const ir::OperandIndex &	ind,
		const ir::OperandInfo &	info
	)

Register tensor information to allocate on train backend.

Parameters

[in]	ind	Operand index
[in]	info	Operand information

Definition at line 32 of file TensorBuilder.cc.

{
  _tensor_info_map.emplace(index, info);
  _as_constants[index] = info.isConstant();
 
  assert(!info.isDynamic());
 
  // NOTE For now, whether or not to build operands to trainable tensor depends on whether
  //      the corresponding operand is constant.
  if (_as_constants[index])
  {
    auto tensor = std::make_unique<TrainableTensor>(info);
    _tensor_reg->setTrainableTensor(index, std::move(tensor));
  }
  else
  {
    auto tensor = std::make_unique<Tensor>(info);
    _tensor_reg->setNonConstTensor(index, std::move(tensor));
  }
}

References info.

---

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

• runtime/onert/backend/train/TensorBuilder.h
• runtime/onert/backend/train/TensorBuilder.cc