onert::exec::FunctionSequence Class Reference

#include <FunctionSequence.h>

Collaboration diagram for onert::exec::FunctionSequence:

Data Structures
struct	DynamicTensorCtx

Public Member Functions
template<typename... Args>
	FunctionSequence (Args &&...args)
virtual	~FunctionSequence ()=default
void	run () override
void	prepare () override
void	append (std::unique_ptr< IFunction > &&function)
	Appends an IFunction object to the function sequence.
void	iterate (const std::function< void(IFunction &)> &fn)
template<typename T , typename... Args>
void	wrap (Args &&...args)
void	dynamic_tensor_ctx (std::shared_ptr< DynamicTensorCtx > &dynamic_tensor_ctx)
	Prepare to run FunctionSequence which "might" handle dynamic tensor.
std::shared_ptr< DynamicTensorCtx > &	dynamic_tensor_ctx ()
void	enableDynamicShapeInferer (bool enable)
	Call this function by passing true if this FunctionSequence handles dynamic tensors and should run DynamicShapeInferer. This function can be called multiple times and if false is passed during multiple calls, DynamicShapeInfere will not be run.
void	initRunning ()
	Call this function to initialize vars before running.
Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default

Protected Attributes
std::vector< std::unique_ptr< IFunction > >	_functions
bool	_enable_dynamic_shape_inferer = false
std::shared_ptr< DynamicTensorCtx >	_dynamic_tensor_ctx = nullptr

Detailed Description

Definition at line 33 of file FunctionSequence.h.

Constructor & Destructor Documentation

FunctionSequence()

template<typename... Args>

onert::exec::FunctionSequence::FunctionSequence ( Args &&...  args )

inline

Definition at line 36 of file FunctionSequence.h.

  {
    (_functions.emplace_back(std::move(args)), ...);
  }

References _functions.

~FunctionSequence()

virtual onert::exec::FunctionSequence::~FunctionSequence ( )

virtualdefault

Member Function Documentation

append()

void onert::exec::FunctionSequence::append

(

std::unique_ptr< IFunction > &&

function

)

Appends an IFunction object to the function sequence.

Parameters

function

IFunction object to be appended

Definition at line 68 of file FunctionSequence.cc.

{
  _functions.push_back(std::move(function));
}

References _functions.

dynamic_tensor_ctx() [1/2]

std::shared_ptr< DynamicTensorCtx > & onert::exec::FunctionSequence::dynamic_tensor_ctx ( )

inline

Definition at line 81 of file FunctionSequence.h.

{ return _dynamic_tensor_ctx; }

References _dynamic_tensor_ctx.

Referenced by dynamic_tensor_ctx(), and run().

dynamic_tensor_ctx() [2/2]

void onert::exec::FunctionSequence::dynamic_tensor_ctx ( std::shared_ptr< DynamicTensorCtx > &  dynamic_tensor_ctx )

inline

Prepare to run FunctionSequence which "might" handle dynamic tensor.

Note

Calling this does not mean that run() will handle dynamic tensor. enableDynamicShapeInferer(true) will make run() will handle dynamic tensor.

Definition at line 76 of file FunctionSequence.h.

  {
    _dynamic_tensor_ctx = dynamic_tensor_ctx;
  }

References _dynamic_tensor_ctx, and dynamic_tensor_ctx().

enableDynamicShapeInferer()

void onert::exec::FunctionSequence::enableDynamicShapeInferer ( bool  enable )

inline

Call this function by passing true if this FunctionSequence handles dynamic tensors and should run DynamicShapeInferer. This function can be called multiple times and if false is passed during multiple calls, DynamicShapeInfere will not be run.

Note

This must be called before run(). If not called, run() assumes that all tensors are dynamic and DynamicShapeInferer will be run.

Definition at line 90 of file FunctionSequence.h.

  {
    _enable_dynamic_shape_inferer = _enable_dynamic_shape_inferer || enable;
  }

References _enable_dynamic_shape_inferer.

Referenced by run().

initRunning()

void onert::exec::FunctionSequence::initRunning ( )

inline

Call this function to initialize vars before running.

Note

When we run a model with static tensor input and then run with dynamic tensor input, _enable_dynamic_shape_inferer is set to false at first run. Once _enable_dynamic_shape_inferer is set to true it cannot be changed to false only with calling enableDynamicShapeInferer(). So initializing it to false is necessary.

Definition at line 104 of file FunctionSequence.h.

{ _enable_dynamic_shape_inferer = false; }

References _enable_dynamic_shape_inferer.

iterate()

void onert::exec::FunctionSequence::iterate

(

const std::function< void(IFunction &)> &

fn

)

Definition at line 73 of file FunctionSequence.cc.

{
  for (const auto &func : _functions)
  {
    fn(*func);
  }
}

References _functions.

prepare()

void onert::exec::FunctionSequence::prepare ( )

overridevirtual

Reimplemented from onert::exec::IFunction.

Definition at line 60 of file FunctionSequence.cc.

{
  for (const auto &function : _functions)
  {
    function->prepare();
  }
}

References _functions.

run()

void onert::exec::FunctionSequence::run ( )

overridevirtual

Implements onert::exec::IFunction.

Definition at line 25 of file FunctionSequence.cc.

{
  if (_enable_dynamic_shape_inferer && _dynamic_tensor_ctx)
  {
    // acl_cl and acl_neon backend don't support dynamic shape.
    // _dynamic_tensor_ctx is always nullptr for acl_cl and acl_neon
    // Thus, those two bakends cannot reach here.
 
    // Do dynamic shape inference
    _dynamic_tensor_ctx->op->accept(*_dynamic_tensor_ctx->dynamic_shape_inferer);
 
    for (const auto &function : _functions)
    {
      // NOTE the function could be also FunctionSequence so we do this
      // TODO Remove this or do this recursively
      auto *sub_func_seq = dynamic_cast<FunctionSequence *>(function.get());
      if (sub_func_seq != nullptr)
      {
        sub_func_seq->enableDynamicShapeInferer(true);
        sub_func_seq->dynamic_tensor_ctx(dynamic_tensor_ctx());
      }
 
      // run kernel
      function->run();
    }
  }
  else
  {
    for (const auto &function : _functions)
    {
      function->run();
    }
  }
}

References _dynamic_tensor_ctx, _enable_dynamic_shape_inferer, _functions, dynamic_tensor_ctx(), and enableDynamicShapeInferer().

Referenced by onert::exec::Job::run().

wrap()

template<typename T , typename... Args>

void onert::exec::FunctionSequence::wrap ( Args &&...  args )

inline

Definition at line 56 of file FunctionSequence.h.

  {
    for (auto &&function : _functions)
    {
      function = std::make_unique<T>(std::move(function), args...);
    }
  }

References _functions.

Field Documentation

_dynamic_tensor_ctx

std::shared_ptr<DynamicTensorCtx> onert::exec::FunctionSequence::_dynamic_tensor_ctx = nullptr

protected

Definition at line 112 of file FunctionSequence.h.

Referenced by dynamic_tensor_ctx(), dynamic_tensor_ctx(), and run().

_enable_dynamic_shape_inferer

bool onert::exec::FunctionSequence::_enable_dynamic_shape_inferer = false

protected

Definition at line 110 of file FunctionSequence.h.

Referenced by enableDynamicShapeInferer(), initRunning(), and run().

_functions

std::vector<std::unique_ptr<IFunction> > onert::exec::FunctionSequence::_functions

protected

Definition at line 107 of file FunctionSequence.h.

Referenced by append(), FunctionSequence(), iterate(), prepare(), run(), and wrap().

---

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

• runtime/onert/core/include/exec/FunctionSequence.h
• runtime/onert/core/src/exec/FunctionSequence.cc