onert::exec::ExecTime Class Reference

#include <ExecTime.h>

Public Member Functions
	ExecTime (const std::vector< const backend::Backend * > &backends)
int64_t	getOperationExecTime (const backend::Backend *backend, const std::string &operation, bool quant, uint32_t op_size) const
	Get exec time of an operation with input size or linearly interpolated value based on size if there is no record for given size.
void	updateOperationExecTime (const backend::Backend *backend, const std::string &operation, bool quant, uint32_t op_size, int64_t time)
	Update exec time of the operation on a backend with given input size or add new entity if there is no one.
int64_t	getPermuteTime (const backend::Backend *from_backend, const backend::Backend *to_backend, bool quant, uint32_t op_size) const
	Get the permute time from one backend to another.
void	updatePermuteTime (const backend::Backend *from_backend, const backend::Backend *to_backend, bool quant, uint32_t op_size, int64_t time)
	Update permute time from one backend to another.
void	storeOperationsExecTime () const
	Update metrics file with new data.

Static Public Member Functions
static int64_t	getMax ()
	Get the max value of int32_t in int64_t.

Static Public Attributes
static const int64_t	NOT_FOUND = -1

Detailed Description

Definition at line 33 of file ExecTime.h.

Constructor & Destructor Documentation

ExecTime()

onert::exec::ExecTime::ExecTime ( const std::vector< const backend::Backend * > &  backends )

inlineexplicit

Definition at line 36 of file ExecTime.h.

    : _json(backends, _measurements)
  {
  }

Member Function Documentation

getMax()

static int64_t onert::exec::ExecTime::getMax ( )

inlinestatic

Get the max value of int32_t in int64_t.

Returns

max value

Definition at line 93 of file ExecTime.h.

{ return _MAX; }

Referenced by updateOperationExecTime().

getOperationExecTime()

int64_t onert::exec::ExecTime::getOperationExecTime	(	const backend::Backend *	backend,
		const std::string &	operation,
		bool	quant,
		uint32_t	op_size
	)		const

Get exec time of an operation with input size or linearly interpolated value based on size if there is no record for given size.

Parameters

[in]	backend	id of a backend
[in]	operation	name of an operation
[in]	quant	if input type quantized
[in]	op_size	sum of operation's flattened sizes of inputs and outputs

Returns

execution time for given input sizes -1 if there are no records for given parameters (backend, op, quantization).

Definition at line 27 of file ExecTime.cc.

{
  auto found_backend = _measurements.find(backend);
  if (found_backend == _measurements.end())
    return NOT_FOUND; // no execution time for this backend
 
  auto found_operation_with_type = found_backend->second.find(operation);
  if (found_operation_with_type == found_backend->second.end())
    // no execution time for this operation
    return NOT_FOUND;
 
  auto found_operation = found_operation_with_type->second.find(quant);
  if (found_operation == found_operation_with_type->second.end())
    // no execution time for this operation
    return NOT_FOUND;
 
  auto found_size = found_operation->second.find(op_size);
  if (found_size != found_operation->second.end())
    return found_size->second; // found execution time
 
  // Try to interpolate
  if (found_operation->second.size() < 2)
    // not possible to do linear interpolation
    return found_operation->second.begin()->second;
 
  // if we reach here, then this means, that there is no record, that is equal to op_size
  auto upper_bound = found_operation->second.upper_bound(op_size); // > op_size
  auto lower_bound = upper_bound;
 
  if (upper_bound == found_operation->second.end()) // all values <= op_size
  {
    upper_bound--;
    lower_bound = upper_bound;
    lower_bound--;
  }
  else if (upper_bound == found_operation->second.begin()) // all values > op_size
  {
    upper_bound++;
  }
  else // op_size between
  {
    lower_bound--;
  }
 
  // Linear interpolation
  const auto x0 = static_cast<int64_t>(lower_bound->first); // size
  const auto x1 = static_cast<int64_t>(upper_bound->first); // size
  const int64_t y0 = lower_bound->second;                   // time
  const int64_t y1 = upper_bound->second;                   // time
  const auto x = static_cast<int64_t>(op_size);
 
  int64_t interpolated_value = y0 + (x - x0) * (y1 - y0) / (x1 - x0);
 
  // In some cases ops with smaller inputs is executed slower than the one
  // with larger inputs, more likely because of a backend's load difference
  if (interpolated_value < 0 && x > x1)
  {
    return y0;
  }
  // It must be non-positive ONLY if it's lesser than both of them
  assert(interpolated_value > 0 || x < x0);
 
  // execution time must be non-negative
  return std::max<int64_t>(interpolated_value, 1);
}

References NOT_FOUND.

Referenced by getPermuteTime().

getPermuteTime()

int64_t onert::exec::ExecTime::getPermuteTime	(	const backend::Backend *	from_backend,
		const backend::Backend *	to_backend,
		bool	quant,
		uint32_t	op_size
	)		const

Get the permute time from one backend to another.

Parameters

[in]	from_backend
[in]	to_backend
[in]	quant	if input type quantized
[in]	op_size	sum of operation's flattened sizes of inputs and outputs

Returns

permutation time for operation size

Definition at line 127 of file ExecTime.cc.

{
  return getOperationExecTime(from_backend, to_backend->config()->id(), quant, op_size);
}

References onert::backend::Backend::config(), and getOperationExecTime().

storeOperationsExecTime()

void onert::exec::ExecTime::storeOperationsExecTime ( ) const

inline

Update metrics file with new data.

Definition at line 97 of file ExecTime.h.

{ _json.storeOperationsExecTime(); }

References onert::exec::JSON::storeOperationsExecTime().

updateOperationExecTime()

void onert::exec::ExecTime::updateOperationExecTime	(	const backend::Backend *	backend,
		const std::string &	operation,
		bool	quant,
		uint32_t	op_size,
		int64_t	time
	)

Update exec time of the operation on a backend with given input size or add new entity if there is no one.

Parameters

[in]	backend	id of a backend
[in]	operation	name of an operation
[in]	quant	if input type quantized
[in]	op_size	sum of operation's flattened sizes of inputs and outputs
[in]	time	real measured value

Definition at line 95 of file ExecTime.cc.

{
  // If the op is not implemented for some input, it should not be scheduled
  const auto &recs = _measurements[backend][operation][quant];
  if (time == getMax() ||
      std::any_of(recs.begin(), recs.end(),
                  [](std::pair<const uint32_t, const int64_t> p) { return p.second == getMax(); }))
  {
    _measurements[backend][operation][quant].clear();
    _measurements[backend][operation][quant].emplace(op_size, getMax());
  }
  else
  {
    auto it = _measurements[backend][operation][quant].emplace(op_size, time);
    if (!it.second)
    {
      // affect of the last measurement is bigger than the previous ones:
      //   this prefers new metrics than older once, so will adapt backend changes
      it.first->second = (it.first->second + time) / 2;
    }
  }
}

References getMax().

Referenced by updatePermuteTime().

updatePermuteTime()

void onert::exec::ExecTime::updatePermuteTime	(	const backend::Backend *	from_backend,
		const backend::Backend *	to_backend,
		bool	quant,
		uint32_t	op_size,
		int64_t	time
	)

Update permute time from one backend to another.

Parameters

[in]	from_backend
[in]	to_backend
[in]	quant	if input type quantized
[in]	time	measured permutation time
[in]	op_size	sum of operation's flattened sizes of inputs and outputs

Definition at line 120 of file ExecTime.cc.

{
  updateOperationExecTime(from_backend, to_backend->config()->id(), quant, op_size, time);
}

References onert::backend::Backend::config(), and updateOperationExecTime().

Field Documentation

NOT_FOUND

const int64_t onert::exec::ExecTime::NOT_FOUND = -1

static

Definition at line 98 of file ExecTime.h.

Referenced by getOperationExecTime().

---

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

• runtime/onert/core/src/exec/ExecTime.h
• runtime/onert/core/src/exec/ExecTime.cc