onert_micro::execute Namespace Reference

Namespaces
namespace	pal
namespace	testing

Data Structures
class	KernelBuiltinExecuteRegistry
class	KernelCustomExecuteRegistry
struct	OMExecuteArgs
struct	OMKernelExecute
class	OMRuntimeKernel

Typedefs
using	KernelExecuteFunc = OMStatus(const OMExecuteArgs &)

Functions
OMStatus	execute_arg_common (const OMExecuteArgs &execute_args, const std::function< OMStatus(const core::OMRuntimeShape &input1_shape, const float *input1_data, const int *input2_data, const core::OMRuntimeShape &output_shape, int *output_data)> &f_float)
template<typename T >
void	readDataKernel (OMRuntimeKernel *runtime_kernel, const T *&cast_input_data1, const T *&cast_input_data2, bool *&cast_output_data, core::OMRuntimeShape &input1_shape_ref, core::OMRuntimeShape &input2_shape_ref, core::OMRuntimeShape &output_shape_ref)
template<typename T >
void	evalComparisonGeneric (OMRuntimeKernel *runtime_kernel, bool F(T, T))
template<typename T , typename AccType >
void	evalQuantizedComparisonGeneric (OMRuntimeKernel *runtime_kernel, bool F(AccType, AccType))
OMStatus	createConvParams (core::ConvQuant &params, const circle::Tensor *input, const circle::Tensor *filter, const circle::Tensor *output, circle::ActivationFunctionType act_type)
OMStatus	execute_math_common (const OMExecuteArgs &execute_args, const std::function< OMStatus(const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)> &f_float)
OMStatus	execute_pooling_common (const OMExecuteArgs &execute_args, const std::function< OMStatus(const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)> &f_float, const std::function< OMStatus(const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const int8_t *input_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)> &f_int8)
OMStatus	readKernelDataTISO (const OMExecuteArgs &execute_args, uint8_t *&input_data1, uint8_t *&input_data2, uint8_t *&output_data, core::OMRuntimeShape &input1_shape_ref, core::OMRuntimeShape &input2_shape_ref, core::OMRuntimeShape &output_shape_ref, circle::TensorType &tensor_type)
OMStatus	execute_relu_common (const OMExecuteArgs &execute_args, bool is_relu_6)
OMStatus	execute_reshape_common (const OMExecuteArgs &execute_args)
OMStatus	execute_spaces_batches_nd_common (const OMExecuteArgs &execute_args, const std::function< OMStatus(const core::OMRuntimeShape &unextended_input1_shape, const float *input1_data, const core::OMRuntimeShape &unextended_input2_shape, const int32_t *block_shape_data, const core::OMRuntimeShape &unextended_input3_shape, const int32_t *crops_data, const core::OMRuntimeShape &unextended_output_shape, float *output_data)> &f)
void	readQuantParams (const circle::Tensor *tensor, long &zero_point, float &scale)
template<typename T >
OMStatus	calculateActivationRange (circle::ActivationFunctionType activation, T *activation_min, T *activation_max)
double	getQuantizedConvolutionMultipler (float input_scale, float filter_scale, float output_scale)
void	quantizeMultiplier (double double_multiplier, int32_t *quantized_multiplier, int *shift)
void	quantizeMultiplierSmallerThanOneExp (double double_multiplier, int32_t *quantized_multiplier, int *left_shift)
std::vector< double >	getQuantizedConvolutionMultiplers (float input_scale, const flatbuffers::Vector< float > *filter_scale, float output_scale)
OMStatus	calculateActivationRangeQuantized (circle::ActivationFunctionType activation, int32_t output_zero_point, float output_scale, circle::TensorType data_type, int32_t *activation_min, int32_t *activation_max)
int	computeOutSize (circle::Padding padding, int image_size, int filter_size, int stride, int dilation_rate=1)
int	computePadding (int32_t stride, int32_t dilation_rate, int32_t in_size, int32_t filter_size, int32_t out_size)
void	computePaddingHeightWidth (int32_t stride_height, int32_t stride_width, int32_t dilation_rate_height, int32_t dilation_rate_width, int32_t in_height, int32_t in_width, int32_t filter_height, int32_t filter_width, circle::Padding padding, int32_t *padding_h, int32_t *padding_w)
void	calculateQuantParams (core::ArithmeticQuantParams &params, const circle::Tensor *input1, const circle::Tensor *input2, const circle::Tensor *output, circle::ActivationFunctionType act)
OMStatus	SISOHeader (const OMExecuteArgs &execute_args, const circle::Tensor **input, const circle::Tensor **output, uint8_t **input_data, uint8_t **output_data)
OMStatus	TISOHeader (const OMExecuteArgs &execute_args, const circle::Tensor **input1, const circle::Tensor **input2, const circle::Tensor **output, OMRuntimeKernel *runtime_kernel)
int	calculateInputRadius (int input_integer_bits, int input_left_shift, int total_signed_bits)

Variables
constexpr KernelBuiltinExecuteRegistry	kernel_builtin_execute
constexpr KernelCustomExecuteRegistry	kernel_custom_execute

Typedef Documentation

KernelExecuteFunc

using onert_micro::execute::KernelExecuteFunc = typedef OMStatus(const OMExecuteArgs &)

Definition at line 31 of file OMKernelExecutionBuilder.h.

Function Documentation

calculateActivationRange()

template<typename T >

OMStatus onert_micro::execute::calculateActivationRange	(	circle::ActivationFunctionType	activation,
		T *	activation_min,
		T *	activation_max
	)

Definition at line 36 of file OMUtils.h.

{
  switch (activation)
  {
    case circle::ActivationFunctionType::ActivationFunctionType_NONE:
      *activation_min = std::numeric_limits<T>::lowest();
      *activation_max = std::numeric_limits<T>::max();
      break;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU:
      *activation_min = 0;
      *activation_max = std::numeric_limits<T>::max();
      break;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU_N1_TO_1:
      *activation_min = -1;
      *activation_max = 1;
      break;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU6:
      *activation_min = 0;
      *activation_max = 6;
      break;
    default:
      assert(false && "Unsupported activation.");
      return UnsupportedActivation;
  }
 
  return Ok;
}

References onert_micro::Ok, and onert_micro::UnsupportedActivation.

calculateActivationRangeQuantized()

OMStatus onert_micro::execute::calculateActivationRangeQuantized	(	circle::ActivationFunctionType	activation,
		int32_t	output_zero_point,
		float	output_scale,
		circle::TensorType	data_type,
		int32_t *	activation_min,
		int32_t *	activation_max
	)

Definition at line 112 of file OMUtils.cpp.

{
  int32_t qmin;
  int32_t qmax;
  switch (data_type)
  {
    case circle::TensorType_UINT8:
      qmin = 0;
      qmax = std::numeric_limits<uint8_t>::max();
      break;
    case circle::TensorType_INT8:
      qmin = std::numeric_limits<int8_t>::min();
      qmax = std::numeric_limits<int8_t>::max();
      break;
    case circle::TensorType_INT16:
      // For now, assume that signed int16 type implies signed symmetric quantization.
      assert(output_zero_point == 0);
      qmin = std::numeric_limits<int16_t>::min();
      qmax = std::numeric_limits<int16_t>::max();
      break;
    default:
      assert(false && "Unsupported type.");
      return UnsupportedType;
  }
 
  return calculateActivationRangeQuantizedImpl(activation, qmin, qmax, output_zero_point,
                                               output_scale, activation_min, activation_max);
}

References onert_micro::UnsupportedType.

Referenced by calculateQuantParams(), and createConvParams().

calculateInputRadius()

int onert_micro::execute::calculateInputRadius ( int  input_integer_bits, int  input_left_shift, int  total_signed_bits  )

inline

Definition at line 170 of file OMUtils.h.

{
  const double max_input_rescaled = 1.0 * ((1 << input_integer_bits) - 1) *
                                    (1LL << (total_signed_bits - input_integer_bits)) /
                                    (1LL << input_left_shift);
  // Tighten bound using floor.  Suppose that we could use the exact value.
  // After scaling the difference, the result would be at the maximum.  Thus we
  // must ensure that our value has lower magnitude.
  return static_cast<int>(std::floor(max_input_rescaled));
}

calculateQuantParams()

void onert_micro::execute::calculateQuantParams	(	core::ArithmeticQuantParams &	params,
		const circle::Tensor *	input1,
		const circle::Tensor *	input2,
		const circle::Tensor *	output,
		circle::ActivationFunctionType	act
	)

Definition at line 194 of file OMUtils.cpp.

{
  long input1_zp;
  long input2_zp;
  long output_zp;
 
  float input1_scale;
  float input2_scale;
  float output_scale;
 
  // Read input1 quant params
  readQuantParams(input1, input1_zp, input1_scale);
  // Read input2 quant params
  readQuantParams(input2, input2_zp, input2_scale);
  // Read output quant params
  readQuantParams(output, output_zp, output_scale);
 
  params.input1_offset = -static_cast<int32_t>(input1_zp);
  params.input2_offset = -static_cast<int32_t>(input2_zp);
  params.output_offset = static_cast<int32_t>(output_zp);
  params.left_shift = (output->type() == circle::TensorType_INT16) ? 15 : 20;
  const double twice_max_input_scale =
    2 * static_cast<double>(std::max(input1_scale, input2_scale));
  const double real_input1_multiplier = static_cast<double>(input1_scale) / twice_max_input_scale;
  const double real_input2_multiplier = static_cast<double>(input2_scale) / twice_max_input_scale;
  const double real_output_multiplier =
    twice_max_input_scale / ((1 << params.left_shift) * static_cast<double>(output_scale));
 
  quantizeMultiplierSmallerThanOneExp(real_input1_multiplier, &params.input1_multiplier,
                                      &params.input1_shift);
 
  quantizeMultiplierSmallerThanOneExp(real_input2_multiplier, &params.input2_multiplier,
                                      &params.input2_shift);
 
  quantizeMultiplierSmallerThanOneExp(real_output_multiplier, &params.output_multiplier,
                                      &params.output_shift);
 
  calculateActivationRangeQuantized(act, output_zp, output_scale, output->type(),
                                    &params.quantized_activation_min,
                                    &params.quantized_activation_max);
}

References calculateActivationRangeQuantized(), onert_micro::core::ArithmeticQuantParams::input1_multiplier, onert_micro::core::ArithmeticQuantParams::input1_offset, onert_micro::core::ArithmeticQuantParams::input1_shift, onert_micro::core::ArithmeticQuantParams::input2_multiplier, onert_micro::core::ArithmeticQuantParams::input2_offset, onert_micro::core::ArithmeticQuantParams::input2_shift, onert_micro::core::ArithmeticQuantParams::left_shift, onert_micro::core::ArithmeticQuantParams::output_multiplier, onert_micro::core::ArithmeticQuantParams::output_offset, onert_micro::core::ArithmeticQuantParams::output_shift, onert_micro::core::ArithmeticQuantParams::quantized_activation_max, onert_micro::core::ArithmeticQuantParams::quantized_activation_min, quantizeMultiplierSmallerThanOneExp(), and readQuantParams().

computeOutSize()

int onert_micro::execute::computeOutSize ( circle::Padding  padding, int  image_size, int  filter_size, int  stride, int  dilation_rate = 1  )

inline

Definition at line 114 of file OMUtils.h.

{
  int effective_filter_size = (filter_size - 1) * dilation_rate + 1;
 
  if (stride == 0)
    return 0;
 
  switch (padding)
  {
    case circle::Padding_SAME:
      return (image_size + stride - 1) / stride;
    case circle::Padding_VALID:
      return (image_size + stride - effective_filter_size) / stride;
    default:
      return 0;
  }
}

Referenced by computePaddingHeightWidth().

computePadding()

int onert_micro::execute::computePadding ( int32_t  stride, int32_t  dilation_rate, int32_t  in_size, int32_t  filter_size, int32_t  out_size  )

inline

Definition at line 133 of file OMUtils.h.

{
  int32_t effective_filter_size = (filter_size - 1) * dilation_rate + 1;
  int32_t padding = ((out_size - 1) * stride + effective_filter_size - in_size) / 2;
  return padding > 0 ? padding : 0;
}

Referenced by computePaddingHeightWidth().

computePaddingHeightWidth()

void onert_micro::execute::computePaddingHeightWidth ( int32_t  stride_height, int32_t  stride_width, int32_t  dilation_rate_height, int32_t  dilation_rate_width, int32_t  in_height, int32_t  in_width, int32_t  filter_height, int32_t  filter_width, circle::Padding  padding, int32_t *  padding_h, int32_t *  padding_w  )

inline

Definition at line 141 of file OMUtils.h.

{
 
  int out_width =
    computeOutSize(padding, in_width, filter_width, stride_width, dilation_rate_width);
  int out_height =
    computeOutSize(padding, in_height, filter_height, stride_height, dilation_rate_height);
 
  *padding_h =
    computePadding(stride_height, dilation_rate_height, in_height, filter_height, out_height);
 
  *padding_w = computePadding(stride_width, dilation_rate_width, in_width, filter_width, out_width);
}

References computeOutSize(), and computePadding().

createConvParams()

OMStatus onert_micro::execute::createConvParams	(	core::ConvQuant &	params,
		const circle::Tensor *	input,
		const circle::Tensor *	filter,
		const circle::Tensor *	output,
		circle::ActivationFunctionType	act_type
	)

Definition at line 23 of file ConvolutionCommon.cpp.

{
  assert(input->quantization() != nullptr);  // Fix caller
  assert(filter->quantization() != nullptr); // Fix caller
  assert(output->quantization() != nullptr); // Fix caller
 
  const auto *input_scales = input->quantization()->scale();
  const auto *filter_scales = filter->quantization()->scale();
  const auto *output_scales = output->quantization()->scale();
 
  assert(input_scales != nullptr);  // Fix caller
  assert(filter_scales != nullptr); // Fix caller
  assert(output_scales != nullptr); // Fix caller
 
  assert(input_scales->size() != 0);  // Fix caller
  assert(filter_scales->size() != 0); // Fix caller
  assert(output_scales->size() != 0); // Fix caller
 
  const auto input_zero_points = input->quantization()->zero_point();
  const auto filter_zero_points = filter->quantization()->zero_point();
  const auto output_zero_points = output->quantization()->zero_point();
 
  assert(input_zero_points != nullptr);  // Fix caller
  assert(filter_zero_points != nullptr); // Fix caller
  assert(output_zero_points != nullptr); // Fix caller
 
  assert(input_zero_points->size() != 0);  // Fix caller
  assert(filter_zero_points->size() != 0); // Fix caller
  assert(output_zero_points->size() != 0); // Fix caller
 
  const auto input_zp = input_zero_points->operator[](0);
  const auto filter_zp = filter_zero_points->operator[](0);
  const auto output_zp = output_zero_points->operator[](0);
 
  const auto output_scale = output_scales->operator[](0);
 
  int32_t activation_min{};
  int32_t activation_max{};
  OMStatus status = execute::calculateActivationRangeQuantized(
    act_type, static_cast<int32_t>(output_zp), output_scale, output->type(), &activation_min,
    &activation_max);
  assert(status == Ok);
  if (status != Ok)
    return status;
 
  // The kernel expects input and filter zero points to be negated.
  params.input_offset = -static_cast<int32_t>(input_zp);    // Note the '-'.
  params.weights_offset = -static_cast<int32_t>(filter_zp); // Note the '-'.
  params.output_offset = static_cast<int32_t>(output_zp);
  params.quantized_activation_min = activation_min;
  params.quantized_activation_max = activation_max;
 
  assert(filter_scales->size() > 1); // Support only channel-wise quantization
  // Channel-wise quantization
  const auto input_scale = input_scales->operator[](0);
  const std::vector<double> effective_output_scale =
    execute::getQuantizedConvolutionMultiplers(input_scale, filter_scales, output_scale);
 
  size_t n = effective_output_scale.size();
  params.per_channel_output_shift.resize(n);
  params.per_channel_output_multiplier.resize(n);
  for (size_t i = 0; i < n; ++i)
  {
    execute::quantizeMultiplier(effective_output_scale[i], &params.per_channel_output_multiplier[i],
                                &params.per_channel_output_shift[i]);
  }
 
  return Ok;
}

References calculateActivationRangeQuantized(), getQuantizedConvolutionMultiplers(), onert_micro::core::ConvQuant::input_offset, onert_micro::Ok, onert_micro::core::ConvQuant::output_offset, onert_micro::core::ConvQuant::per_channel_output_multiplier, onert_micro::core::ConvQuant::per_channel_output_shift, onert_micro::core::ConvQuant::quantized_activation_max, onert_micro::core::ConvQuant::quantized_activation_min, quantizeMultiplier(), and onert_micro::core::ConvQuant::weights_offset.

evalComparisonGeneric()

template<typename T >

void onert_micro::execute::evalComparisonGeneric	(	OMRuntimeKernel *	runtime_kernel,
		bool	FT, T
	)

Definition at line 82 of file ComparisonCommon.h.

{
 
  const T *cast_input_data1 = nullptr;
  const T *cast_input_data2 = nullptr;
  bool *cast_output_data = nullptr;
 
  core::OMRuntimeShape input1_shape;
  core::OMRuntimeShape input2_shape;
  core::OMRuntimeShape output_shape;
 
  readDataKernel(runtime_kernel, cast_input_data1, cast_input_data2, cast_output_data, input1_shape,
                 input2_shape, output_shape);
 
  onert_micro::core::ComparisonParams op_params;
  op_params.is_broadcast = input1_shape.flatSize() != input2_shape.flatSize();
 
  if (op_params.is_broadcast)
  {
    onert_micro::execute::pal::BroadcastComparison4DSlowNoScaling<T>(
      op_params, input1_shape, cast_input_data1, input2_shape, cast_input_data2, output_shape,
      cast_output_data, F);
  }
  else
  {
    const int64_t flat_size = input1_shape.flatSize();
    onert_micro::execute::pal::ComparisonNoScaling<T>(flat_size, cast_input_data1, cast_input_data2,
                                                      cast_output_data, F);
  }
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::core::ComparisonParams::is_broadcast, output_shape, and readDataKernel().

evalQuantizedComparisonGeneric()

template<typename T , typename AccType >

void onert_micro::execute::evalQuantizedComparisonGeneric	(	OMRuntimeKernel *	runtime_kernel,
		bool	FAccType, AccType
	)

Definition at line 114 of file ComparisonCommon.h.

{
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  input1 = runtime_kernel->inputs[input1TensorIdx];
  input2 = runtime_kernel->inputs[input2TensorIdx];
  output = runtime_kernel->outputs[outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(output != nullptr);
 
  const T *cast_input_data1 = nullptr;
  const T *cast_input_data2 = nullptr;
  bool *cast_output_data = nullptr;
 
  core::OMRuntimeShape input1_shape;
  core::OMRuntimeShape input2_shape;
  core::OMRuntimeShape output_shape;
 
  readDataKernel(runtime_kernel, cast_input_data1, cast_input_data2, cast_output_data, input1_shape,
                 input2_shape, output_shape);
 
  assert(input1->quantization() != nullptr);
  assert(input1->quantization()->scale() != nullptr);
  assert(input1->quantization()->scale()->size() == 1);
  assert(input1->quantization()->zero_point() != nullptr);
  assert(input1->quantization()->zero_point()->size() == 1);
 
  auto input1_scale = *input1->quantization()->scale()->begin();
  auto input2_scale = *input2->quantization()->scale()->begin();
 
  auto input1_zero_point = *input1->quantization()->zero_point()->begin();
  auto input2_zero_point = *input2->quantization()->zero_point()->begin();
 
  int32_t x_multiplier;
  int x_shift;
 
  int32_t y_multiplier;
  int y_shift;
 
  onert_micro::execute::quantizeMultiplierSmallerThanOneExp(input1_scale, &x_multiplier, &x_shift);
  onert_micro::execute::quantizeMultiplierSmallerThanOneExp(input2_scale, &y_multiplier, &y_shift);
 
  onert_micro::core::ComparisonParams op_params;
  op_params.left_shift = 8;
  op_params.input1_offset = -input1_zero_point; // Note the '-'
  op_params.input1_shift = x_shift;
  op_params.input1_multiplier = x_multiplier;
  op_params.input2_offset = -input2_zero_point; // Note the '-'
  op_params.input2_shift = y_shift;
  op_params.input2_multiplier = y_multiplier;
  op_params.is_broadcast = input1_shape.flatSize() != input2_shape.flatSize();
  ;
 
  if (op_params.is_broadcast)
  {
    onert_micro::execute::pal::BroadcastComparison4DSlowWithScaling<T>(
      op_params, input1_shape, cast_input_data1, input2_shape, cast_input_data2, output_shape,
      cast_output_data, F);
  }
  else
  {
    const int64_t flat_size = input1_shape.flatSize();
    onert_micro::execute::pal::ComparisonWithScaling<T>(op_params, flat_size, cast_input_data1,
                                                        cast_input_data2, cast_output_data, F);
  }
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::core::ComparisonParams::input1_multiplier, onert_micro::core::ComparisonParams::input1_offset, onert_micro::core::ComparisonParams::input1_shift, onert_micro::core::ComparisonParams::input2_multiplier, onert_micro::core::ComparisonParams::input2_offset, onert_micro::core::ComparisonParams::input2_shift, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::core::ComparisonParams::is_broadcast, onert_micro::core::ComparisonParams::left_shift, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, quantizeMultiplierSmallerThanOneExp(), and readDataKernel().

execute_arg_common()

OMStatus onert_micro::execute::execute_arg_common	(	const OMExecuteArgs &	execute_args,
		const std::function< OMStatus(const core::OMRuntimeShape &input1_shape, const float *input1_data, const int *input2_data, const core::OMRuntimeShape &output_shape, int *output_data)> &	f_float
	)

Definition at line 32 of file ArgCommon.cpp.

{
  core::OMRuntimeContext &runtime_context = execute_args.runtime_context;
  core::OMRuntimeStorage &runtime_storage = execute_args.runtime_storage;
  uint16_t op_index = execute_args.kernel_index;
  const circle::Tensor *output;
  const circle::Tensor *input1;
  const circle::Tensor *input2;
 
  uint8_t *output_data;
  uint8_t *input_data;
  uint8_t *axis_data;
 
  // Read kernel
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  output = runtime_kernel.outputs[outputTensorIdx];
  assert(output != nullptr);
 
  input1 = runtime_kernel.inputs[input1TensorIdx];
  assert(input1 != nullptr);
 
  input2 = runtime_kernel.inputs[input2TensorIdx];
  assert(input2 != nullptr);
 
  runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
  output_data = runtime_kernel.outputs_data[outputTensorIdx];
  assert(output_data != nullptr);
 
  input_data = runtime_kernel.inputs_data[input1TensorIdx];
  assert(input_data != nullptr);
 
  axis_data = runtime_kernel.inputs_data[input2TensorIdx];
  assert(axis_data != nullptr);
 
  OMStatus status;
  const core::OMRuntimeShape input1_shape(input1);
  const core::OMRuntimeShape output_shape(output);
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = f_float(input1_shape, reinterpret_cast<const float *>(input_data),
                       reinterpret_cast<const int *>(axis_data), output_shape,
                       reinterpret_cast<int *>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
  return status;
}

References onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::execute::OMExecuteArgs::kernel_index, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_data, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::execute::OMExecuteArgs::runtime_context, onert_micro::execute::OMExecuteArgs::runtime_storage, and onert_micro::UnsupportedType.

execute_math_common()

OMStatus onert_micro::execute::execute_math_common	(	const OMExecuteArgs &	execute_args,
		const std::function< OMStatus(const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)> &	f_float
	)

execute_pooling_common()

OMStatus onert_micro::execute::execute_pooling_common	(	const OMExecuteArgs &	execute_args,
		const std::function< OMStatus(const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)> &	f_float,
		const std::function< OMStatus(const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const int8_t *input_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)> &	f_int8
	)

execute_relu_common()

OMStatus onert_micro::execute::execute_relu_common	(	const OMExecuteArgs &	execute_args,
		bool	is_relu_6
	)

Definition at line 32 of file ReluCommon.cpp.

{
  core::OMRuntimeContext &runtime_context = execute_args.runtime_context;
  core::OMRuntimeStorage &runtime_storage = execute_args.runtime_storage;
  uint16_t op_index = execute_args.kernel_index;
 
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  OMStatus status = Ok;
 
  OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  input = runtime_kernel.inputs[inputTensorIdx];
  output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  if (status != Ok)
    return status;
 
  input_data = runtime_kernel.inputs_data[inputTensorIdx];
  output_data = runtime_kernel.outputs_data[outputTensorIdx];
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  float alpha = 0.f;
  auto options = runtime_kernel.first_operator->builtin_options_as_LeakyReluOptions();
  if (options != nullptr)
    alpha = options->alpha();
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      core::OMRuntimeShape input_shape(input);
      core::OMRuntimeShape output_shape(output);
 
      const auto *input_data_float = core::utils::castInputData<float>(input_data);
      auto *output_data_float = core::utils::castOutputData<float>(output_data);
 
      assert(output_data_float);
      const int flat_size = input_shape.flatSize();
 
      status = pal::ReLUCommon(flat_size, input_data_float, output_data_float, alpha, is_relu_6);
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      core::OMRuntimeShape input_shape(input);
      core::OMRuntimeShape output_shape(output);
 
      const auto *input_data_int8 = core::utils::castInputData<int8_t>(input_data);
      auto *output_data_int8 = core::utils::castOutputData<int8_t>(output_data);
 
      assert(output_data_int8);
      const int flat_size = input_shape.flatSize();
 
      status = pal::ReLUCommon(flat_size, input_data_int8, output_data_int8, alpha, is_relu_6);
    }
    break;
#endif // DIS_QUANT
 
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
      break;
    }
  }
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_data, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::execute::pal::ReLUCommon(), onert_micro::execute::OMExecuteArgs::runtime_context, onert_micro::execute::OMExecuteArgs::runtime_storage, and onert_micro::UnsupportedType.

execute_reshape_common()

OMStatus onert_micro::execute::execute_reshape_common

(

const OMExecuteArgs &

execute_args

)

Definition at line 31 of file ReshapeCommon.cpp.

{
  core::OMRuntimeContext &runtime_context = execute_args.runtime_context;
  core::OMRuntimeStorage &runtime_storage = execute_args.runtime_storage;
  uint16_t op_index = execute_args.kernel_index;
 
  OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  OMStatus status = Ok;
 
  status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  if (status != Ok)
    return status;
 
  uint8_t *input_data = runtime_kernel.inputs_data[inputTensorIdx];
  uint8_t *output_data = runtime_kernel.outputs_data[outputTensorIdx];
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  // Check is it inplace kernel
  if (input_data == output_data)
    return Ok;
 
  const core::OMRuntimeShape shape(input);
 
  const size_t element_size =
    static_cast<uint32_t>(getOMDataTypeSize(core::onertMicroDatatype(input->type())));
  const int32_t num_elements = shape.flatSize();
  std::memcpy(output_data, input_data, num_elements * element_size);
 
  return status;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::Ok, onert_micro::core::onertMicroDatatype(), onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_data, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::execute::OMExecuteArgs::runtime_context, and onert_micro::execute::OMExecuteArgs::runtime_storage.

execute_spaces_batches_nd_common()

OMStatus onert_micro::execute::execute_spaces_batches_nd_common	(	const OMExecuteArgs &	execute_args,
		const std::function< OMStatus(const core::OMRuntimeShape &unextended_input1_shape, const float *input1_data, const core::OMRuntimeShape &unextended_input2_shape, const int32_t *block_shape_data, const core::OMRuntimeShape &unextended_input3_shape, const int32_t *crops_data, const core::OMRuntimeShape &unextended_output_shape, float *output_data)> &	f
	)

getQuantizedConvolutionMultipler()

double onert_micro::execute::getQuantizedConvolutionMultipler ( float  input_scale, float  filter_scale, float  output_scale  )

inline

Definition at line 65 of file OMUtils.h.

{
  const double input_product_scale = static_cast<double>(input_scale * filter_scale);
 
  assert(input_product_scale >= 0);
 
  assert(output_scale != 0.f);
 
  return input_product_scale / static_cast<double>(output_scale);
}

Referenced by getQuantizedConvolutionMultiplers().

getQuantizedConvolutionMultiplers()

std::vector< double > onert_micro::execute::getQuantizedConvolutionMultiplers ( float  input_scale, const flatbuffers::Vector< float > *  filter_scale, float  output_scale  )

inline

Definition at line 95 of file OMUtils.h.

{
  std::vector<double> effective_output_scales;
  size_t n = filter_scale->size();
  effective_output_scales.reserve(n);
  for (size_t i = 0; i < n; ++i)
  {
    effective_output_scales.push_back(
      getQuantizedConvolutionMultipler(input_scale, filter_scale->operator[](i), output_scale));
  }
  return effective_output_scales;
}

References getQuantizedConvolutionMultipler(), and flatbuffers::Vector< T >::size().

Referenced by createConvParams().

quantizeMultiplier()

void onert_micro::execute::quantizeMultiplier	(	double	double_multiplier,
		int32_t *	quantized_multiplier,
		int *	shift
	)

Definition at line 23 of file OMUtils.cpp.

{
  if (double_multiplier == 0.0)
  {
    *quantized_multiplier = 0;
    *shift = 0;
    return;
  }
 
  const double q = std::frexp(double_multiplier, shift);
  auto q_fixed = static_cast<int64_t>(std::round(q * (int64_t(1) << 31)));
 
  if (q_fixed == (int64_t(1) << 31))
  {
    q_fixed /= 2;
    ++*shift;
  }
  assert(q_fixed <= std::numeric_limits<int32_t>::max());
  // A shift amount smaller than -31 would cause all bits to be shifted out
  // and thus all results would be zero. We implement that instead with
  // q_fixed==0, so as to avoid hitting issues with right-shift
  // operations with shift amounts greater than 31. Note that this happens
  // roughly when abs(double_multiplier) < 2^-31 and the present handling means
  // that we're effectively flushing tiny double_multiplier's to zero.
  // We could conceivably handle values in the range (roughly) [32, 63]
  // as 'denormals' i.e. (shift==0, q_fixed < 2^30). In that point of view
  // the present handling is just doing 'flush denormals to zero'. We could
  // reconsider and actually generate nonzero denormals if a need arises.
  if (*shift < -31)
  {
    *shift = 0;
    q_fixed = 0;
  }
  *quantized_multiplier = static_cast<int32_t>(q_fixed);
}

Referenced by createConvParams(), and quantizeMultiplierSmallerThanOneExp().

quantizeMultiplierSmallerThanOneExp()

void onert_micro::execute::quantizeMultiplierSmallerThanOneExp	(	double	double_multiplier,
		int32_t *	quantized_multiplier,
		int *	left_shift
	)

Definition at line 60 of file OMUtils.cpp.

{
  assert(double_multiplier < 1.0);
  assert(double_multiplier > 0.0);
  int shift;
  onert_micro::execute::quantizeMultiplier(double_multiplier, quantized_multiplier, &shift);
  assert(shift <= 0);
  *left_shift = shift;
}

References quantizeMultiplier().

Referenced by calculateQuantParams(), and evalQuantizedComparisonGeneric().

readDataKernel()

template<typename T >

void onert_micro::execute::readDataKernel	(	OMRuntimeKernel *	runtime_kernel,
		const T *&	cast_input_data1,
		const T *&	cast_input_data2,
		bool *&	cast_output_data,
		core::OMRuntimeShape &	input1_shape_ref,
		core::OMRuntimeShape &	input2_shape_ref,
		core::OMRuntimeShape &	output_shape_ref
	)

Definition at line 44 of file ComparisonCommon.h.

{
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data1 = nullptr;
  uint8_t *input_data2 = nullptr;
  uint8_t *output_data = nullptr;
 
  input1 = runtime_kernel->inputs[input1TensorIdx];
  input2 = runtime_kernel->inputs[input2TensorIdx];
  output = runtime_kernel->outputs[outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(output != nullptr);
 
  input_data1 = runtime_kernel->inputs_data[input1TensorIdx];
  input_data2 = runtime_kernel->inputs_data[input2TensorIdx];
  output_data = runtime_kernel->outputs_data[outputTensorIdx];
 
  assert(input_data1 != nullptr);
  assert(input_data2 != nullptr);
  assert(output_data != nullptr);
 
  cast_input_data1 = core::utils::castInputData<T>(input_data1);
  cast_input_data2 = core::utils::castInputData<T>(input_data2);
  cast_output_data = core::utils::castOutputData<bool>(output_data);
 
  input1_shape_ref = std::move(core::OMRuntimeShape(input1));
  input2_shape_ref = std::move(core::OMRuntimeShape(input2));
  output_shape_ref = std::move(core::OMRuntimeShape(output));
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::execute::OMRuntimeKernel::outputs, and onert_micro::execute::OMRuntimeKernel::outputs_data.

Referenced by evalComparisonGeneric(), and evalQuantizedComparisonGeneric().

readKernelDataTISO()

OMStatus onert_micro::execute::readKernelDataTISO	(	const OMExecuteArgs &	execute_args,
		uint8_t *&	input_data1,
		uint8_t *&	input_data2,
		uint8_t *&	output_data,
		core::OMRuntimeShape &	input1_shape_ref,
		core::OMRuntimeShape &	input2_shape_ref,
		core::OMRuntimeShape &	output_shape_ref,
		circle::TensorType &	tensor_type
	)

Definition at line 32 of file ReadKernelDataCommon.cpp.

{
 
  core::OMRuntimeContext &runtime_context = execute_args.runtime_context;
  core::OMRuntimeStorage &runtime_storage = execute_args.runtime_storage;
  uint16_t op_index = execute_args.kernel_index;
 
  OMStatus status = Ok;
 
  OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  input1 = runtime_kernel.inputs[TensorIndexTISO::input1TensorIdx];
  input2 = runtime_kernel.inputs[TensorIndexTISO::input2TensorIdx];
  output = runtime_kernel.outputs[TensorIndexTISO::outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(output != nullptr);
 
  input_data1 = runtime_kernel.inputs_data[TensorIndexTISO::input1TensorIdx];
  input_data2 = runtime_kernel.inputs_data[TensorIndexTISO::input2TensorIdx];
  output_data = runtime_kernel.outputs_data[TensorIndexTISO::outputTensorIdx];
 
  input1_shape_ref = std::move(core::OMRuntimeShape(input1));
  input2_shape_ref = std::move(core::OMRuntimeShape(input2));
  output_shape_ref = std::move(core::OMRuntimeShape(output));
 
  tensor_type = input1->type();
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), TensorIndexTISO::input1TensorIdx, TensorIndexTISO::input2TensorIdx, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_data, TensorIndexTISO::outputTensorIdx, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::execute::OMExecuteArgs::runtime_context, and onert_micro::execute::OMExecuteArgs::runtime_storage.

readQuantParams()

void onert_micro::execute::readQuantParams	(	const circle::Tensor *	tensor,
		long &	zero_point,
		float &	scale
	)

Definition at line 143 of file OMUtils.cpp.

{
  // additional check
  assert(tensor->quantization() != nullptr); // Fix caller
  assert(tensor->quantization()->scale() != nullptr and
         tensor->quantization()->scale()->size() == 1); // Fix caller
  assert(tensor->quantization()->zero_point() != nullptr and
         tensor->quantization()->zero_point()->size() == 1); // Fix caller
 
  // read zero point
  zero_point = tensor->quantization()->zero_point()->operator[](0);
  // read scale
  scale = tensor->quantization()->scale()->operator[](0);
}

Referenced by calculateQuantParams().

SISOHeader()

OMStatus onert_micro::execute::SISOHeader	(	const OMExecuteArgs &	execute_args,
		const circle::Tensor **	input,
		const circle::Tensor **	output,
		uint8_t **	input_data,
		uint8_t **	output_data
	)

Definition at line 159 of file OMUtils.cpp.

{
  OMStatus status;
 
  core::OMRuntimeContext &runtime_context = execute_args.runtime_context;
  core::OMRuntimeStorage &runtime_storage = execute_args.runtime_storage;
  uint16_t op_index = execute_args.kernel_index;
 
  {
    OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    *input = runtime_kernel.inputs[0];
    *output = runtime_kernel.outputs[0];
 
    assert(*input != nullptr);
    assert(*output != nullptr);
 
    status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
    if (status != Ok)
      return status;
 
    *input_data = runtime_kernel.inputs_data[0];
    *output_data = runtime_kernel.outputs_data[0];
  }
 
  assert(*input_data != nullptr);
  assert(*output_data != nullptr);
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_data, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::execute::OMExecuteArgs::runtime_context, and onert_micro::execute::OMExecuteArgs::runtime_storage.

TISOHeader()

OMStatus onert_micro::execute::TISOHeader	(	const OMExecuteArgs &	execute_args,
		const circle::Tensor **	input1,
		const circle::Tensor **	input2,
		const circle::Tensor **	output,
		OMRuntimeKernel *	runtime_kernel
	)

Definition at line 240 of file OMUtils.cpp.

{
  OMStatus status;
 
  core::OMRuntimeContext &runtime_context = execute_args.runtime_context;
  core::OMRuntimeStorage &runtime_storage = execute_args.runtime_storage;
  uint16_t op_index = execute_args.kernel_index;
 
  status = runtime_kernel->readKernel(op_index, runtime_context);
 
  *input1 = runtime_kernel->inputs[0];
  *input2 = runtime_kernel->inputs[1];
  *output = runtime_kernel->outputs[0];
 
  assert(*input1 != nullptr);
  assert(*input2 != nullptr);
  assert(*output != nullptr);
 
  status = runtime_kernel->getDataFromStorage(op_index, runtime_storage, runtime_context);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::execute::OMExecuteArgs::runtime_context, and onert_micro::execute::OMExecuteArgs::runtime_storage.

Variable Documentation

kernel_builtin_execute

constexpr KernelBuiltinExecuteRegistry onert_micro::execute::kernel_builtin_execute

constexpr

Definition at line 126 of file OMKernelExecutionBuilder.h.

Referenced by onert_micro::execute::OMKernelExecute::runForward().

kernel_custom_execute

constexpr KernelCustomExecuteRegistry onert_micro::execute::kernel_custom_execute

constexpr

Definition at line 127 of file OMKernelExecutionBuilder.h.

Referenced by onert_micro::execute::OMKernelExecute::runForward().