Class to define execution instance to collect input/output information for inference and prepare executor run (TODO) More...

#include <Execution.h>

Public Member Functions
	Execution (const std::shared_ptr< IExecutors > &executors)
	Construct a new Execution object.

	Execution (const std::shared_ptr< IExecutors > &executors, const ir::SubgraphIndex &entry_index)
	Construct a new Execution object for signature.

const ir::Graph &	primary_subgraph () const
	Returns primary graph object.

void	changeInputShape (const ir::IOIndex &index, const ir::Shape &new_shape)
	Change input shape.

void	setInput (const ir::IOIndex &index, const void *buffer, size_t length)
	Set input data's information.

void	setOutput (const ir::IOIndex &index, void *buffer, size_t length)
	Set output data's information.

const ir::OperandInfo &	inputInfo (const ir::IOIndex &index)
	Get the Input Info object.

const ir::OperandInfo &	outputInfo (const ir::IOIndex &index)
	Get the Output Info object.

const void *	outputBuffer (const ir::IOIndex &index) const
	Get internally allocated output buffer.

uint32_t	inputSize ()
	Get input size.

uint32_t	outputSize ()
	Get output size.

void	execute ()
	Execution.

void	startExecute (void)
	Start asynchronous execution.

void	waitFinish (void)
	Return when execution is finished.

bool	isFinished (void) const
	Check execution is finished.

void	train (uint32_t training_step)
	Train.

float	getLoss (const ir::IOIndex &ind)
	Get loss.

void	iterateTrainableTensors (const std::function< void(const ir::OperandIndex &, const backend::train::ITrainableTensor *)> &fn) const
	Iterate trainable tensors.

const ExecutionContext &	context () const
	Get context of execution.

void	restoreContext (const ExecutionContext &ctx)
	Set context of execution at once.

ExecutionOptions &	executionOptions ()

Detailed Description

Class to define execution instance to collect input/output information for inference and prepare executor run (TODO)

Definition at line 40 of file Execution.h.

Constructor & Destructor Documentation

◆ Execution() [1/2]

onert::exec::Execution::Execution ( const std::shared_ptr< IExecutors > & executors )

Construct a new Execution object.

Parameters

[in] executor Model executor

Definition at line 30 of file Execution.cc.

                                                               : _executors{executors}
{
  assert(executors != nullptr);
  assert(executors->entryExecutor() != nullptr);
 
  // Initialize I/O description
  for (uint32_t i = 0; i < _executors->inputSize(); ++i)
    _ctx.desc.inputs.emplace_back(_executors->inputInfo(ir::IOIndex(i)));
 
  for (uint32_t i = 0; i < _executors->outputSize(); ++i)
    _ctx.desc.outputs.emplace_back(_executors->outputInfo(ir::IOIndex(i)));
  _ctx.shape_updated = false;
 
  _is_internal_output_tensor.resize(_executors->outputSize());
  for (uint32_t i = 0; i < _executors->outputSize(); ++i)
  {
    const auto output_tensor =
      dynamic_cast<const backend::builtin::IOTensor *>(_executors->outputTensor(ir::IOIndex{i}));
    if (!output_tensor)
      throw std::runtime_error("Output tensor must be IOTensor");
 
    _is_internal_output_tensor.at(i) = output_tensor->hasBackendTensor();
  }
 
  // Initialize options
  ExecutionOptions::fromGlobalConfig(_ctx.options);
}

References onert::exec::ExecutionContext::desc, onert::exec::ExecutionOptions::fromGlobalConfig(), onert::exec::IODescription::inputs, onert::exec::ExecutionContext::options, onert::exec::IODescription::outputs, and onert::exec::ExecutionContext::shape_updated.

◆ Execution() [2/2]

onert::exec::Execution::Execution	(	const std::shared_ptr< IExecutors > &	executors,
		const ir::SubgraphIndex &	entry_index
	)

Construct a new Execution object for signature.

Parameters

[in]	executors	Model executors
[in]	entry_index	Entry subgraph index

Definition at line 58 of file Execution.cc.

  : Execution(std::make_shared<SignatureExecutors>(executors, entry_index))
{
  // DO NOTHING
}

Member Function Documentation

◆ changeInputShape()

void onert::exec::Execution::changeInputShape	(	const ir::IOIndex &	index,
		const ir::Shape &	new_shape
	)

Change input shape.

Parameters

[in]	index	Input index
[in]	new_shape	shape to change

Definition at line 65 of file Execution.cc.

{
  // This will be used later to set input tensor dynamic
  // Note that 'compiled' model will not be updated with new_shape
  // but new_shape will change model input shape while 'running' the model
  auto &input_desc = _ctx.desc.inputs.at(index.value());
  if (new_shape != input_desc.info.shape())
  {
    input_desc.info.shape(new_shape);
    _ctx.shape_updated = true;
 
    VERBOSE(Execution) << "Model input shape will be changed at the start of execute()"
                       << "(index: " << index << ")" << std::endl;
  }
}

References onert::exec::ExecutionContext::desc, onert::exec::IODescription::inputs, onert::exec::ExecutionContext::shape_updated, and VERBOSE.

◆ context()

const ExecutionContext & onert::exec::Execution::context ( ) const

inline

Get context of execution.

Returns: Execution context

Definition at line 183 of file Execution.h.

183{ return _ctx; }

◆ execute()

void onert::exec::Execution::execute ( )

Execution.

Note: It should be called after setting input and output buffer

Definition at line 100 of file Execution.cc.

{
  VERBOSE(Execution) << "Start execution" << std::endl;
 
  // Input length validation check
  for (const auto &input : _ctx.desc.inputs)
  {
    if (input.info.total_size() > input.size)
      throw std::runtime_error{"Too small input buffer length"};
  }
 
  // Output length validation check
  if (!_ctx.shape_updated)
  {
    assert(_ctx.desc.outputs.size() == _is_internal_output_tensor.size());
    for (uint32_t i = 0; i < _ctx.desc.outputs.size(); ++i)
    {
      const bool is_managed_internally = _is_internal_output_tensor.at(i);
      const auto &output = _ctx.desc.outputs.at(i);
      if (!is_managed_internally && output.info.total_size() > output.size)
        throw std::runtime_error{"Too small output buffer length"};
      if (is_managed_internally && output.buffer != nullptr)
        VERBOSE(Execution) << "Warning: Output buffer was set from API even though the output "
                              "tensor was allocated internally"
                           << std::endl;
    }
  }
 
  _executors->execute(_ctx);
  finished = true;
 
  VERBOSE(Execution) << "Execution finished" << std::endl;
}

References onert::exec::ExecutionContext::desc, onert::exec::IODescription::inputs, onert::exec::IODescription::outputs, onert::exec::ExecutionContext::shape_updated, and VERBOSE.

Referenced by startExecute().

◆ executionOptions()

ExecutionOptions & onert::exec::Execution::executionOptions ( )

inline

Definition at line 191 of file Execution.h.

191{ return _ctx.options; }

References onert::exec::ExecutionContext::options.

◆ getLoss()

float onert::exec::Execution::getLoss ( const ir::IOIndex & ind )

Get loss.

Note: It should be called after training

Parameters

[in] ind Output index

Returns: float Loss value

Definition at line 163 of file Execution.cc.

{
  auto execs = dynamic_cast<exec::train::TrainableExecutors *>(_executors.get());
  if (!execs)
  {
    throw std::runtime_error{"Supported only TrainableExecutors"};
  }
 
  return execs->getLoss(ind);
}

References onert::exec::train::TrainableExecutors::getLoss().

◆ inputInfo()

const ir::OperandInfo & onert::exec::Execution::inputInfo ( const ir::IOIndex & index )

inline

Get the Input Info object.

Parameters

[in] index Input index

Returns: Input info

Definition at line 92 of file Execution.h.

  {
    return _ctx.desc.inputs.at(index.value()).info;
  }

References onert::exec::ExecutionContext::desc, and onert::exec::IODescription::inputs.

◆ inputSize()

uint32_t onert::exec::Execution::inputSize ( )

inline

Get input size.

Returns: Input size

Definition at line 121 of file Execution.h.

121{ return _ctx.desc.inputs.size(); }

References onert::exec::ExecutionContext::desc, and onert::exec::IODescription::inputs.

◆ isFinished()

bool onert::exec::Execution::isFinished ( void ) const

Check execution is finished.

Returns: true if execution is finished, otherwise false

Definition at line 149 of file Execution.cc.

149{ return finished; }

◆ iterateTrainableTensors()

void onert::exec::Execution::iterateTrainableTensors ( const std::function< void(const ir::OperandIndex &, const backend::train::ITrainableTensor *)> & fn ) const

Iterate trainable tensors.

Note: It should be called after training

Parameters

[in] fn function to be called with OperandIndex and a pointer to ITrainableTensor

Definition at line 174 of file Execution.cc.

{
  auto execs = dynamic_cast<exec::train::TrainableExecutors *>(_executors.get());
  if (!execs)
  {
    throw std::runtime_error{"Supported only TrainableExecutors"};
  }
  execs->iterateTrainableTensors(fn);
}

References onert::exec::train::TrainableExecutors::iterateTrainableTensors().

◆ outputBuffer()

const void * onert::exec::Execution::outputBuffer ( const ir::IOIndex & index ) const

inline

Get internally allocated output buffer.

Parameters

[in] index Output index

Returns: Buffer pointer

Definition at line 112 of file Execution.h.

  {
    return entryExecutor()->outputBuffer(index.value());
  }

References onert::exec::IExecutor::outputBuffer().

◆ outputInfo()

const ir::OperandInfo & onert::exec::Execution::outputInfo ( const ir::IOIndex & index )

inline

Get the Output Info object.

Parameters

[in] index Output index

Returns: Output info

Definition at line 102 of file Execution.h.

  {
    return _ctx.desc.outputs.at(index.value()).info;
  }

References onert::exec::ExecutionContext::desc, and onert::exec::IODescription::outputs.

◆ outputSize()

uint32_t onert::exec::Execution::outputSize ( )

inline

Get output size.

Returns: Output size

Definition at line 127 of file Execution.h.

127{ return _ctx.desc.outputs.size(); }

References onert::exec::ExecutionContext::desc, and onert::exec::IODescription::outputs.

◆ primary_subgraph()

const ir::Graph & onert::exec::Execution::primary_subgraph ( ) const

inline

Returns primary graph object.

Returns: Graph object

Definition at line 62 of file Execution.h.

62{ return entryExecutor()->graph(); }

onert::exec::IExecutor::graph

virtual const ir::Graph & graph() const =0

Returns graph object.

References onert::exec::IExecutor::graph().

◆ restoreContext()

void onert::exec::Execution::restoreContext ( const ExecutionContext & ctx )

inline

Set context of execution at once.

Parameters

[in] ctx Execution context

Definition at line 189 of file Execution.h.

189{ _ctx = ctx; }

◆ setInput()

void onert::exec::Execution::setInput	(	const ir::IOIndex &	index,
		const void *	buffer,
		size_t	length
	)

Set input data's information.

Parameters

[in]	index	Input index
[in]	buffer	Input data's buffer pointer
[in]	length	Input data's length

Definition at line 82 of file Execution.cc.

{
  // Length validation in execute(): datatype can be changed by API call
  auto &input_desc = _ctx.desc.inputs.at(index.value());
  input_desc.buffer = buffer;
  input_desc.size = length;
}

References onert::exec::ExecutionContext::desc, and onert::exec::IODescription::inputs.

◆ setOutput()

void onert::exec::Execution::setOutput	(	const ir::IOIndex &	index,
		void *	buffer,
		size_t	length
	)

Set output data's information.

Parameters

[in]	index	Output index
[in]	buffer	Output data's buffer pointer
[in]	length	Output data's length

Definition at line 90 of file Execution.cc.

{
  // Length validation in execute()
  // - datatype can be changed by API call
  // - shape can be changed by dynamic shape inference
  auto &output_desc = _ctx.desc.outputs.at(index.value());
  output_desc.buffer = buffer;
  output_desc.size = length;
}

References onert::exec::ExecutionContext::desc, and onert::exec::IODescription::outputs.

◆ startExecute()

void onert::exec::Execution::startExecute ( void )

Start asynchronous execution.

Note: It returns after execution thread is started It should be called after setting input and output buffer

Definition at line 134 of file Execution.cc.

{
  VERBOSE(Execution) << "Create asynchronous execution thread" << std::endl;
 
  _exec_thread = std::make_unique<std::thread>(&Execution::execute, this);
}

References execute(), and VERBOSE.

◆ train()

void onert::exec::Execution::train ( uint32_t training_step )

Train.

Note: It should be called after setting input and output buffer

Parameters

training_step The number of iterations of the training process. In other words, the number of gradient update.

Definition at line 151 of file Execution.cc.

{
  auto execs = dynamic_cast<exec::train::TrainableExecutors *>(_executors.get());
  if (!execs)
  {
    throw std::runtime_error{"Supported only TrainableExecutors"};
  }
 
  execs->train(_ctx, training_step);
  finished = true;
}

References onert::exec::train::TrainableExecutors::train().

◆ waitFinish()

void onert::exec::Execution::waitFinish ( void )

Return when execution is finished.

Note: It waits until execution is finished

Definition at line 141 of file Execution.cc.

{
  VERBOSE(Execution) << "Wait to finish execution" << std::endl;
 
  _exec_thread->join();
  finished = true;
}

References VERBOSE.

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

runtime/onert/core/include/exec/Execution.h
runtime/onert/core/src/exec/Execution.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Execution() [1/2]

◆ Execution() [2/2]

Member Function Documentation

◆ changeInputShape()

◆ context()

◆ execute()

◆ executionOptions()

◆ getLoss()

◆ inputInfo()

◆ inputSize()

◆ isFinished()

◆ iterateTrainableTensors()

◆ outputBuffer()

◆ outputInfo()

◆ outputSize()

◆ primary_subgraph()

◆ restoreContext()

◆ setInput()

◆ setOutput()

◆ startExecute()

◆ train()

◆ waitFinish()