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)

OMStatus	execute_kernel_CircleAbs (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleAdd (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleAddN (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleArgMax (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleArgMin (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleAveragePool2D (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleBatchToSpaceND (const onert_micro::execute::OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleCast (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleCeil (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleConcatenation (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleConv2D (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleCos (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleDepthwiseConv2D (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleDequantize (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleDiv (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleElu (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleEqual (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleExp (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleExpandDims (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleFill (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleFloor (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleFloorDiv (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleFloorMod (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleFullyConnected (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleGather (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleGatherND (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleGreater (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleGreaterEqual (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleGRU (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleL2Normalize (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleL2Pool2D (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleLeakyRelu (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleLess (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleLessEqual (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleLog (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleLogistic (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleLogSoftmax (const OMExecuteArgs &execute_args)

OMStatus	execute_math_common (const OMExecuteArgs &execute_args, const std::function< OMStatus(const core::OMRuntimeShape &, const float , const core::OMRuntimeShape &, float )> &f_float)

OMStatus	execute_kernel_CircleMaximum (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleMaxPool2D (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleMean (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleMinimum (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleMul (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleNeg (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleNotEqual (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CirclePack (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CirclePad (const OMExecuteArgs &execute_args)

OMStatus	execute_pooling_common (const OMExecuteArgs &execute_args, const std::function< OMStatus(const core::Pool2DParams &, const core::OMRuntimeShape &, const float , const core::OMRuntimeShape &, float )> &f_float, const std::function< OMStatus(const core::Pool2DParams &, const core::OMRuntimeShape &, const int8_t , const core::OMRuntimeShape &, int8_t )> &f_int8)

OMStatus	execute_kernel_CircleQuantize (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleReduceProd (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleRelu (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleRelu6 (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleReshape (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleRound (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleRsqrt (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSelectV2 (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleShape (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSin (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSlice (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSoftmax (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)> &func)

OMStatus	execute_kernel_CircleSpaceToBatchND (const onert_micro::execute::OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSpaceToDepth (const onert_micro::execute::OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSplit (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSplitV (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSqrt (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSquare (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSquaredDifference (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleStridedSlice (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSub (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSum (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleSVDF (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleTanh (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleTranspose (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleTransposeConv (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleUnpack (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleWhile (const OMExecuteArgs &execute_args)

OMStatus	execute_kernel_CircleZerosLike (const OMExecuteArgs &execute_args)

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.

Referenced by execute_kernel_CircleAdd(), execute_kernel_CircleConv2D(), execute_kernel_CircleDepthwiseConv2D(), execute_kernel_CircleDiv(), execute_kernel_CircleFullyConnected(), execute_kernel_CircleMul(), execute_kernel_CircleSquaredDifference(), execute_kernel_CircleSub(), execute_kernel_CircleTransposeConv(), and execute_pooling_common().

◆ 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(), createConvParams(), and execute_pooling_common().

◆ 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));
}

Referenced by execute_kernel_CircleSoftmax().

◆ 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);
}

Referenced by execute_kernel_CircleAdd(), and execute_kernel_CircleSub().

◆ 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().

Referenced by execute_kernel_CircleConv2D(), execute_kernel_CircleDepthwiseConv2D(), execute_kernel_CircleTransposeConv(), and execute_pooling_common().

◆ 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 28 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.

Referenced by execute_kernel_CircleConv2D(), and execute_kernel_CircleDepthwiseConv2D().

◆ 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);
  }
}

◆ 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 37 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;
}

Referenced by execute_kernel_CircleArgMax(), and execute_kernel_CircleArgMin().

◆ execute_kernel_CircleAbs()

OMStatus onert_micro::execute::execute_kernel_CircleAbs ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Abs.cpp.

{
  auto abs_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                             const core::OMRuntimeShape &output_shape, float *output_data) {
    assert(input_shape == output_shape);
    return pal::Abs(input_shape, input_data, output_data);
  };
 
  return execute_math_common(execute_args, abs_float_lambda);
}

References onert_micro::execute::pal::Abs(), execute_math_common(), and output_shape.

◆ execute_kernel_CircleAdd()

OMStatus onert_micro::execute::execute_kernel_CircleAdd ( const OMExecuteArgs & execute_args )

Definition at line 45 of file Add.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 *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  uint8_t *input1_data;
  uint8_t *input2_data;
  uint8_t *output_data;
 
  uint16_t input1_index = 0;
  uint16_t input2_index = 0;
 
  const circle::AddOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input1 = runtime_kernel.inputs[input1TensorIdx];
    input2 = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input1 != nullptr);
    assert(input2 != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input1_data = runtime_kernel.inputs_data[input1TensorIdx];
    input2_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input1_data != nullptr);
    assert(input2_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_AddOptions();
 
    input1_index = runtime_kernel.inputs_index[input1TensorIdx];
    input2_index = runtime_kernel.inputs_index[input2TensorIdx];
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input1_shape(input1);
  core::OMRuntimeShape input2_shape(input2);
  core::OMRuntimeShape output_shape(output);
 
#ifndef DIS_DYN_SHAPES
  // Check dynamic shapes
  {
    auto input_1_dynamic_shape = runtime_storage.getDynamicRuntimeShape(input1_index);
    if (input_1_dynamic_shape.flatSize() != 0)
      input1_shape = input_1_dynamic_shape;
 
    auto input_2_dynamic_shape = runtime_storage.getDynamicRuntimeShape(input2_index);
    if (input_2_dynamic_shape.flatSize() != 0)
      input2_shape = input_2_dynamic_shape;
  }
#endif // DIS_DYN_SHAPES
 
  // Check broadcast property
  core::BinaryArithmeticBroadcastParams params{};
  const bool need_broadcast = pal::processBroadcastShapes(input1_shape, input2_shape, &params);
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      execute::calculateActivationRange(options->fused_activation_function(),
                                        &params.float_activation_min, &params.float_activation_max);
      if (need_broadcast)
      {
        status = pal::BroadcastAdd4DSlow(
          params, input1_shape, core::utils::castInputData<float>(input1_data), input2_shape,
          core::utils::castInputData<float>(input2_data), output_shape,
          core::utils::castOutputData<float>(output_data));
      }
      else
      {
        status =
          pal::Add(params, output_shape.flatSize(), core::utils::castInputData<float>(input1_data),
                   core::utils::castInputData<float>(input2_data),
                   core::utils::castOutputData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    case circle::TensorType_INT64:
    {
      execute::calculateActivationRange(options->fused_activation_function(),
                                        &params.int64_activation_min, &params.int64_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastAdd4DSlow(
          params, input1_shape, core::utils::castInputData<int64_t>(input1_data), input2_shape,
          core::utils::castInputData<int64_t>(input2_data), output_shape,
          core::utils::castOutputData<int64_t>(output_data));
      }
      else
      {
        status = pal::Add(params, input1_shape.flatSize(),
                          core::utils::castInputData<int64_t>(input1_data),
                          core::utils::castInputData<int64_t>(input2_data),
                          core::utils::castOutputData<int64_t>(output_data));
      }
    }
    break;
    case circle::TensorType_INT32:
    {
      execute::calculateActivationRange(options->fused_activation_function(),
                                        &params.int32_activation_min, &params.int32_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastAdd4DSlow(
          params, input1_shape, core::utils::castInputData<int32_t>(input1_data), input2_shape,
          core::utils::castInputData<int32_t>(input2_data), output_shape,
          core::utils::castOutputData<int32_t>(output_data));
      }
      else
      {
        status = pal::Add(params, input1_shape.flatSize(),
                          core::utils::castInputData<int32_t>(input1_data),
                          core::utils::castInputData<int32_t>(input2_data),
                          core::utils::castOutputData<int32_t>(output_data));
      }
    }
    break;
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      core::ArithmeticQuantParams add_params{};
 
      calculateQuantParams(add_params, input1, input2, output,
                           options->fused_activation_function());
 
      if (need_broadcast)
      {
        status = pal::BroadcastAdd4DSlow(
          add_params, input1_shape, core::utils::castInputData<int8_t>(input1_data), input2_shape,
          core::utils::castInputData<int8_t>(input2_data), output_shape,
          core::utils::castOutputData<int8_t>(output_data));
      }
      else
      {
        status = pal::Add(add_params, input1_shape.flatSize(),
                          core::utils::castInputData<int8_t>(input1_data),
                          core::utils::castInputData<int8_t>(input2_data),
                          core::utils::castOutputData<int8_t>(output_data));
      }
    }
    break;
#endif // DIF_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleAddN()

OMStatus onert_micro::execute::execute_kernel_CircleAddN ( const OMExecuteArgs & execute_args )

Definition at line 37 of file AddN.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;
 
  uint8_t *output_data;
 
  // Read kernel
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  output = runtime_kernel.outputs[outputTensorIdx];
  assert(output != nullptr);
 
  runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  output_data = runtime_kernel.outputs_data[outputTensorIdx];
  assert(output_data != nullptr);
 
  OMStatus status;
 
  core::OMRuntimeShape output_shape(output);
  switch (output->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = onert_micro::execute::pal::AddN<float>(
        output_shape.flatSize(), runtime_kernel.inputs_num,
        reinterpret_cast<const float *const *>(runtime_kernel.inputs_data),
        reinterpret_cast<float *>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
  return status;
}

◆ execute_kernel_CircleArgMax()

OMStatus onert_micro::execute::execute_kernel_CircleArgMax ( const OMExecuteArgs & execute_args )

Definition at line 28 of file ArgMax.cpp.

{
  auto arg_max_float_lambda = [](const core::OMRuntimeShape &input1_shape, const float *input1_data,
                                 const int *input2_data, const core::OMRuntimeShape &output_shape,
                                 int *output_data) {
    return onert_micro::execute::pal::ArgMax(input1_shape, input1_data, input2_data, output_shape,
                                             output_data);
  };
 
  return execute_arg_common(execute_args, arg_max_float_lambda);
}

References onert_micro::execute::pal::ArgMax(), execute_arg_common(), and output_shape.

◆ execute_kernel_CircleArgMin()

OMStatus onert_micro::execute::execute_kernel_CircleArgMin ( const OMExecuteArgs & execute_args )

Definition at line 28 of file ArgMin.cpp.

{
  auto arg_max_float_lambda = [](const core::OMRuntimeShape &input1_shape, const float *input1_data,
                                 const int *input2_data, const core::OMRuntimeShape &output_shape,
                                 int *output_data) {
    return onert_micro::execute::pal::ArgMin(input1_shape, input1_data, input2_data, output_shape,
                                             output_data);
  };
 
  return execute_arg_common(execute_args, arg_max_float_lambda);
}

References onert_micro::execute::pal::ArgMin(), execute_arg_common(), and output_shape.

◆ execute_kernel_CircleAveragePool2D()

OMStatus onert_micro::execute::execute_kernel_CircleAveragePool2D ( const OMExecuteArgs & execute_args )

Definition at line 29 of file AveragePool2D.cpp.

{
  auto avg_pool_float_lambda = [](const core::Pool2DParams &params,
                                  const core::OMRuntimeShape &input_shape, const float *input_data,
                                  const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::AveragePool(params, input_shape, input_data, output_shape, output_data);
  };
 
#ifndef DIS_QUANT
  auto avg_pool_int8_lambda = [](const core::Pool2DParams &params,
                                 const core::OMRuntimeShape &input_shape, const int8_t *input_data,
                                 const core::OMRuntimeShape &output_shape, int8_t *output_data) {
    return pal::AveragePool(params, input_shape, input_data, output_shape, output_data);
  };
#else
  auto avg_pool_int8_lambda = [](const core::Pool2DParams &params,
                                 const core::OMRuntimeShape &input_shape, const int8_t *input_data,
                                 const core::OMRuntimeShape &output_shape,
                                 int8_t *output_data) { return UnsupportedType; };
#endif // DIS_QUANT
 
  return execute_pooling_common(execute_args, avg_pool_float_lambda, avg_pool_int8_lambda);
}

References onert_micro::execute::pal::AveragePool(), execute_pooling_common(), output_shape, and onert_micro::UnsupportedType.

◆ execute_kernel_CircleBatchToSpaceND()

OMStatus onert_micro::execute::execute_kernel_CircleBatchToSpaceND ( const onert_micro::execute::OMExecuteArgs & execute_args )

Definition at line 29 of file BatchToSpaceND.cpp.

{
  auto batch_to_space_float_lambda =
    [](const core::OMRuntimeShape &input1_shape, const float *input1_data,
       const core::OMRuntimeShape &input2_shape, const int32_t *block_shape_data,
       const core::OMRuntimeShape &input3_shape, const int32_t *crops_data,
       const core::OMRuntimeShape &output_shape, float *output_data) {
      return pal::BatchToSpaceND<float>(input1_shape, input1_data, input2_shape, block_shape_data,
                                        input3_shape, crops_data, output_shape, output_data);
    };
 
  return execute_spaces_batches_nd_common(execute_args, batch_to_space_float_lambda);
}

References execute_spaces_batches_nd_common(), and output_shape.

◆ execute_kernel_CircleCast()

OMStatus onert_micro::execute::execute_kernel_CircleCast ( const OMExecuteArgs & execute_args )

Definition at line 46 of file Cast.cpp.

{
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  SISOHeader(execute_args, &input, &output, &input_data, &output_data);
 
  OMStatus status;
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      switch (output->type())
      {
        case circle::TensorType_INT32:
        {
          status = pal::Cast(
            core::OMRuntimeShape(input), core::utils::castInputData<float>(input_data),
            core::OMRuntimeShape(output), core::utils::castOutputData<int32_t>(output_data));
          break;
        }
        case circle::TensorType_INT8:
        {
          status = pal::Cast(
            core::OMRuntimeShape(input), core::utils::castInputData<float>(input_data),
            core::OMRuntimeShape(output), core::utils::castOutputData<int8_t>(output_data));
          break;
        }
        case circle::TensorType_INT16:
        {
          status = pal::Cast(
            core::OMRuntimeShape(input), core::utils::castInputData<float>(input_data),
            core::OMRuntimeShape(output), core::utils::castOutputData<int16_t>(output_data));
          break;
        }
        default:
        {
          status = UnsupportedType;
          assert(false && "Unsupported type.");
          break;
        }
      }
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
      break;
    }
  }
 
  return status;
}

References onert_micro::execute::pal::Cast(), SISOHeader(), and onert_micro::UnsupportedType.

◆ execute_kernel_CircleCeil()

OMStatus onert_micro::execute::execute_kernel_CircleCeil ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Ceil.cpp.

{
  auto ceil_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                              const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Ceil(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, ceil_float_lambda);
}

References onert_micro::execute::pal::Ceil(), execute_math_common(), and output_shape.

◆ execute_kernel_CircleConcatenation()

OMStatus onert_micro::execute::execute_kernel_CircleConcatenation ( const OMExecuteArgs & execute_args )

Definition at line 81 of file Concatenation.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;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const auto *t0 = runtime_kernel.inputs[0];
  OMStatus status = Ok;
 
  status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
  if (status != Ok)
    return status;
 
  switch (t0->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      status = evalGeneric<float>(runtime_kernel);
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
      status = evalGeneric<int8_t>(runtime_kernel);
      break;
#endif // DIS_QUANT
    case circle::TensorType_INT32:
      status = evalGeneric<int32_t>(runtime_kernel);
      break;
    case circle::TensorType_INT64:
      status = evalGeneric<int64_t>(runtime_kernel);
      break;
    default:
      assert(false && "Unsupported type.");
      status = UnsupportedType;
  }
 
  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::readKernel(), onert_micro::execute::OMExecuteArgs::runtime_context, onert_micro::execute::OMExecuteArgs::runtime_storage, and onert_micro::UnsupportedType.

◆ execute_kernel_CircleConv2D()

OMStatus onert_micro::execute::execute_kernel_CircleConv2D ( const OMExecuteArgs & execute_args )

Definition at line 50 of file Conv2D.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;
  const circle::Tensor *weight;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *weight_data;
  uint8_t *bias_data;
  uint8_t *output_data;
 
  const circle::Conv2DOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[inputTensorIdx];
    weight = runtime_kernel.inputs[weightTensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(weight != nullptr);
    // Bias can be 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];
    weight_data = runtime_kernel.inputs_data[weightTensorIdx];
    bias_data = runtime_kernel.inputs_data[biasTensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(weight_data != nullptr);
    // Bias can be nullptr
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_Conv2DOptions();
  }
 
  OMStatus status;
 
  int32_t padding_h = 0;
  int32_t padding_w = 0;
 
  OMRuntimeShape weight_shape(weight);
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  const int input_width = input_shape.dims(2);
  const int input_height = input_shape.dims(1);
  const int weight_width = weight_shape.dims(2);
  const int weight_height = weight_shape.dims(1);
  execute::computePaddingHeightWidth(options->stride_h(), options->stride_w(),
                                     options->dilation_h_factor(), options->dilation_w_factor(),
                                     input_height, input_width, weight_height, weight_width,
                                     options->padding(), &padding_h, &padding_w);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      FloatConv2D params{};
      status = calculateActivationRange(options->fused_activation_function(),
                                        &params.activation_min, &params.activation_max);
      params.stride_w = options->stride_w();
      params.stride_h = options->stride_h();
      params.dilation_width_factor = options->dilation_w_factor();
      params.dilation_height_factor = options->dilation_h_factor();
      params.pad_h = padding_h;
      params.pad_w = padding_w;
 
      if (status != Ok)
        return status;
 
      status = pal::ConvFloat(&params, input_shape, core::utils::castInputData<float>(input_data),
                              weight_shape, core::utils::castInputData<float>(weight_data),
                              core::utils::castInputData<float>(bias_data), output_shape,
                              core::utils::castOutputData<float>(output_data));
      assert(status == Ok);
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      ConvQuant params{};
      params.pad_h = padding_h;
      params.pad_w = padding_w;
 
      const auto padding = options->padding();
      const auto stride_height = options->stride_h();
      const auto stride_width = options->stride_w();
      const auto dilation_height_factor = options->dilation_h_factor();
      const auto dilation_width_factor = options->dilation_h_factor();
 
      params.stride_height = stride_height;
      params.stride_width = stride_width;
      params.dilation_height_factor = dilation_height_factor;
      params.dilation_width_factor = dilation_width_factor;
 
      status =
        createConvParams(params, input, weight, output, options->fused_activation_function());
      assert(status == Ok);
      if (status != Ok)
        return status;
 
      status =
        pal::ConvPerChannel(params, input_shape, core::utils::castInputData<int8_t>(input_data),
                            weight_shape, core::utils::castInputData<int8_t>(weight_data),
                            core::utils::castInputData<int32_t>(bias_data), output_shape,
                            core::utils::castOutputData<int8_t>(output_data));
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleCos()

OMStatus onert_micro::execute::execute_kernel_CircleCos ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Cos.cpp.

{
  auto cos_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                             const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Cos(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, cos_float_lambda);
}

References onert_micro::execute::pal::Cos(), execute_math_common(), and output_shape.

◆ execute_kernel_CircleDepthwiseConv2D()

OMStatus onert_micro::execute::execute_kernel_CircleDepthwiseConv2D ( const OMExecuteArgs & execute_args )

Definition at line 50 of file DepthwiseConv2D.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;
  const circle::Tensor *weight;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *weight_data;
  uint8_t *bias_data;
  uint8_t *output_data;
 
  const circle::DepthwiseConv2DOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[inputTensorIdx];
    weight = runtime_kernel.inputs[weightTensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(weight != nullptr);
    // Bias can be 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];
    weight_data = runtime_kernel.inputs_data[weightTensorIdx];
    bias_data = runtime_kernel.inputs_data[biasTensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(weight_data != nullptr);
    // Bias can be nullptr
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_DepthwiseConv2DOptions();
  }
 
  OMStatus status;
 
  int32_t padding_h = 0;
  int32_t padding_w = 0;
 
  OMRuntimeShape weight_shape(weight);
  OMRuntimeShape input_shape(input);
 
  const int input_width = input_shape.dims(2);
  const int input_height = input_shape.dims(1);
  const int weight_width = weight_shape.dims(2);
  const int weight_height = weight_shape.dims(1);
  execute::computePaddingHeightWidth(options->stride_h(), options->stride_w(),
                                     options->dilation_h_factor(), options->dilation_w_factor(),
                                     input_height, input_width, weight_height, weight_width,
                                     options->padding(), &padding_h, &padding_w);
 
  const auto output_shape = OMRuntimeShape(output);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
 
      FloatConv2D params{};
      status = calculateActivationRange(options->fused_activation_function(),
                                        &params.activation_min, &params.activation_max);
      params.stride_w = options->stride_w();
      params.stride_h = options->stride_h();
      params.dilation_width_factor = options->dilation_w_factor();
      params.dilation_height_factor = options->dilation_h_factor();
      params.depth_multiplier = options->depth_multiplier();
      params.pad_h = padding_h;
      params.pad_w = padding_w;
 
      if (status != Ok)
        return status;
 
      status = execute::pal::DepthwiseConv2D<float>(
        &params, input_shape, core::utils::castInputData<float>(input_data), weight_shape,
        core::utils::castInputData<float>(weight_data),
        core::utils::castInputData<float>(bias_data), output_shape,
        core::utils::castOutputData<float>(output_data));
      assert(status == Ok);
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      ConvQuant params{};
      params.pad_h = padding_h;
      params.pad_w = padding_w;
      params.depth_multiplier = options->depth_multiplier();
 
      const auto padding = options->padding();
      const auto stride_height = options->stride_h();
      const auto stride_width = options->stride_w();
      const auto dilation_height_factor = options->dilation_h_factor();
      const auto dilation_width_factor = options->dilation_h_factor();
 
      params.stride_height = stride_height;
      params.stride_width = stride_width;
      params.dilation_height_factor = dilation_height_factor;
      params.dilation_width_factor = dilation_width_factor;
 
      status =
        createConvParams(params, input, weight, output, options->fused_activation_function());
      assert(status == Ok);
      if (status != Ok)
        return status;
 
      status = pal::DepthwiseConvPerChannel(
        params, input_shape, core::utils::castInputData<int8_t>(input_data), weight_shape,
        core::utils::castInputData<int8_t>(weight_data),
        core::utils::castInputData<int32_t>(bias_data), output_shape,
        core::utils::castOutputData<int8_t>(output_data));
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleDequantize()

OMStatus onert_micro::execute::execute_kernel_CircleDequantize ( const OMExecuteArgs & execute_args )

Definition at line 43 of file Dequantize.cpp.

{
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  SISOHeader(execute_args, &input, &output, &input_data, &output_data);
 
  assert(output->type() == circle::TensorType_FLOAT32);
 
  OMStatus status = Ok;
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_INT8:
    {
      assert(input->quantization() != nullptr);
      assert(input->quantization()->scale() != nullptr and
             input->quantization()->scale()->size() == 1);
      assert(input->quantization()->zero_point() != nullptr and
             input->quantization()->zero_point()->size() == 1);
      core::QuantizationParams params{};
      params.zero_point = input->quantization()->zero_point()->operator[](0);
      params.scale = input->quantization()->scale()->operator[](0);
 
      status = pal::Dequantize(params, core::OMRuntimeShape(input).flatSize(),
                               core::utils::castInputData<int8_t>(input_data),
                               core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

References onert_micro::execute::pal::Dequantize(), onert_micro::Ok, SISOHeader(), onert_micro::UnsupportedType, and onert_micro::core::QuantizationParams::zero_point.

◆ execute_kernel_CircleDiv()

OMStatus onert_micro::execute::execute_kernel_CircleDiv ( const OMExecuteArgs & execute_args )

Definition at line 45 of file Div.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 *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  uint8_t *input1_data;
  uint8_t *input2_data;
  uint8_t *output_data;
 
  const circle::DivOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input1 = runtime_kernel.inputs[input1TensorIdx];
    input2 = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input1 != nullptr);
    assert(input2 != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input1_data = runtime_kernel.inputs_data[input1TensorIdx];
    input2_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input1_data != nullptr);
    assert(input2_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_DivOptions();
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input1_shape(input1);
  core::OMRuntimeShape input2_shape(input2);
  core::OMRuntimeShape output_shape(output);
 
  core::BinaryArithmeticBroadcastParams params{};
  const bool need_broadcast = pal::processBroadcastShapes(input1_shape, input2_shape, &params);
 
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.float_activation_min,
                                                 &params.float_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastDiv4DSlow(
          params, input1_shape, core::utils::castInputData<float>(input1_data), input2_shape,
          core::utils::castInputData<float>(input2_data), output_shape,
          core::utils::castOutputData<float>(output_data));
      }
      else
      {
        status =
          pal::Div(params, input1_shape.flatSize(), core::utils::castInputData<float>(input1_data),
                   core::utils::castInputData<float>(input2_data),
                   core::utils::castOutputData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    case circle::TensorType_INT64:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.int64_activation_min,
                                                 &params.int64_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastDiv4DSlow(
          params, input1_shape, core::utils::castInputData<int64_t>(input1_data), input2_shape,
          core::utils::castInputData<int64_t>(input2_data), output_shape,
          core::utils::castOutputData<int64_t>(output_data));
      }
      else
      {
        status = pal::Div(params, input1_shape.flatSize(),
                          core::utils::castInputData<int64_t>(input1_data),
                          core::utils::castInputData<int64_t>(input2_data),
                          core::utils::castOutputData<int64_t>(output_data));
      }
    }
    break;
    case circle::TensorType_INT32:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.int32_activation_min,
                                                 &params.int32_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastDiv4DSlow(
          params, input1_shape, core::utils::castInputData<int32_t>(input1_data), input2_shape,
          core::utils::castInputData<int32_t>(input2_data), output_shape,
          core::utils::castOutputData<int32_t>(output_data));
      }
      else
      {
        status = pal::Div(params, input1_shape.flatSize(),
                          core::utils::castInputData<int32_t>(input1_data),
                          core::utils::castInputData<int32_t>(input2_data),
                          core::utils::castOutputData<int32_t>(output_data));
      }
    }
    break;
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleElu()

OMStatus onert_micro::execute::execute_kernel_CircleElu ( const OMExecuteArgs & execute_args )

Definition at line 42 of file Elu.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);
 
  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::Elu(flat_size, input_data_float, output_data_float);
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
      break;
    }
  }
 
  return status;
}

◆ execute_kernel_CircleEqual()

OMStatus onert_micro::execute::execute_kernel_CircleEqual ( const OMExecuteArgs & execute_args )

Definition at line 44 of file Equal.cpp.

{
  OMStatus status = Ok;
 
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  OMRuntimeKernel runtime_kernel;
 
  TISOHeader(execute_args, &input1, &input2, &output, &runtime_kernel);
 
  switch (input1->type())
  {
    case circle::TensorType_INT64:
      onert_micro::execute::evalComparisonGeneric<int64_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::EqualFn);
      break;
    case circle::TensorType_INT32:
      onert_micro::execute::evalComparisonGeneric<int32_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::EqualFn);
      break;
 
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::evalComparisonGeneric<float>(&runtime_kernel,
                                                         onert_micro::execute::pal::EqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::EqualFn(), onert_micro::Ok, and TISOHeader().

◆ execute_kernel_CircleExp()

OMStatus onert_micro::execute::execute_kernel_CircleExp ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Exp.cpp.

{
  auto exp_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                             const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Exp(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, exp_float_lambda);
}

References execute_math_common(), onert_micro::execute::pal::Exp(), and output_shape.

◆ execute_kernel_CircleExpandDims()

OMStatus onert_micro::execute::execute_kernel_CircleExpandDims ( const OMExecuteArgs & execute_args )

Definition at line 28 of file ExpandDims.cpp.

{
  return execute_reshape_common(execute_args);
}

References execute_reshape_common().

◆ execute_kernel_CircleFill()

OMStatus onert_micro::execute::execute_kernel_CircleFill ( const OMExecuteArgs & execute_args )

Definition at line 44 of file Fill.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 *value;
  const circle::Tensor *output;
 
  uint8_t *value_data;
  uint8_t *output_data;
 
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    value = runtime_kernel.inputs[valueTensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(value != nullptr);
    assert(output != nullptr);
 
    status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
    if (status != Ok)
      return status;
 
    value_data = runtime_kernel.inputs_data[valueTensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(value_data != nullptr);
    assert(output_data != nullptr);
  }
 
  OMStatus status = Ok;
 
  assert(OMRuntimeShape(value).flatSize() == 1);
  OMRuntimeShape output_shape(output);
 
  switch (output->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = pal::Fill(core::utils::castInputData<float>(value_data), output_shape,
                         core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    case circle::TensorType_INT32:
    {
      status = pal::Fill(core::utils::castInputData<int32_t>(value_data), output_shape,
                         core::utils::castOutputData<int32_t>(output_data));
    }
    break;
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
      break;
    }
  }
 
  return status;
}

◆ execute_kernel_CircleFloor()

OMStatus onert_micro::execute::execute_kernel_CircleFloor ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Floor.cpp.

{
  auto floor_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                               const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Floor(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, floor_float_lambda);
}

References execute_math_common(), onert_micro::execute::pal::Floor(), and output_shape.

◆ execute_kernel_CircleFloorDiv()

OMStatus onert_micro::execute::execute_kernel_CircleFloorDiv ( const OMExecuteArgs & execute_args )

Definition at line 34 of file FloorDiv.cpp.

{
  uint8_t *input_data1;
  uint8_t *input_data2;
  uint8_t *output_data;
 
  core::OMRuntimeShape input_shape1;
  core::OMRuntimeShape input_shape2;
  core::OMRuntimeShape output_shape;
 
  circle::TensorType input1_type;
 
  OMStatus status =
    execute::readKernelDataTISO(execute_args, input_data1, input_data2, output_data, input_shape1,
                                input_shape2, output_shape, input1_type);
 
  switch (input1_type)
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      // Check the denominator
      for (int i = 0; i < input_shape2.flatSize(); ++i)
      {
        status = utils::checkCondition(core::utils::castInputData<float>(input_data2)[i] != 0);
        if (status != Ok)
          return status;
      }
      // check that input and output dimensions are equal
      if (input_shape1 == input_shape2)
      {
        const int flat_size = input_shape1.flatSize();
        pal::FloorDiv(flat_size, core::utils::castInputData<float>(input_data1),
                      core::utils::castInputData<float>(input_data2),
                      core::utils::castOutputData<float>(output_data));
      }
      else
      {
        pal::BroadcastFloorDiv4DSlow(input_shape1, core::utils::castInputData<float>(input_data1),
                                     input_shape2, core::utils::castInputData<float>(input_data2),
                                     output_shape, core::utils::castOutputData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::BroadcastFloorDiv4DSlow(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::pal::FloorDiv(), onert_micro::Ok, output_shape, and readKernelDataTISO().

◆ execute_kernel_CircleFloorMod()

OMStatus onert_micro::execute::execute_kernel_CircleFloorMod ( const OMExecuteArgs & execute_args )

Definition at line 33 of file FloorMod.cpp.

{
  uint8_t *input_data1;
  uint8_t *input_data2;
  uint8_t *output_data;
 
  core::OMRuntimeShape input_shape1;
  core::OMRuntimeShape input_shape2;
  core::OMRuntimeShape output_shape;
 
  circle::TensorType input1_type;
 
  OMStatus status =
    execute::readKernelDataTISO(execute_args, input_data1, input_data2, output_data, input_shape1,
                                input_shape2, output_shape, input1_type);
 
  switch (input1_type)
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      // Check the denominator
      for (int i = 0; i < input_shape2.flatSize(); ++i)
      {
        utils::checkCondition(core::utils::castInputData<float>(input_data2)[i] != 0);
      }
      // check that input and output dimensions are equal
      if (input_shape1 == input_shape2)
      {
        const int flat_size = input_shape1.flatSize();
        pal::FloorMod(flat_size, core::utils::castInputData<float>(input_data1),
                      core::utils::castInputData<float>(input_data2),
                      core::utils::castOutputData<float>(output_data));
      }
      else
      {
        pal::BroadcastFloorMod4DSlow(input_shape1, core::utils::castInputData<float>(input_data1),
                                     input_shape2, core::utils::castInputData<float>(input_data2),
                                     output_shape, core::utils::castOutputData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::BroadcastFloorMod4DSlow(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::pal::FloorMod(), output_shape, and readKernelDataTISO().

◆ execute_kernel_CircleFullyConnected()

OMStatus onert_micro::execute::execute_kernel_CircleFullyConnected ( const OMExecuteArgs & execute_args )

Definition at line 98 of file FullyConnected.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;
  const circle::Tensor *weight;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *weight_data;
  uint8_t *bias_data;
  uint8_t *output_data;
 
  const circle::FullyConnectedOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[inputTensorIdx];
    weight = runtime_kernel.inputs[weightTensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(weight != nullptr);
    // Bias can be nullptr
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input_data = runtime_kernel.inputs_data[inputTensorIdx];
    weight_data = runtime_kernel.inputs_data[weightTensorIdx];
    bias_data = runtime_kernel.inputs_data[biasTensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(weight_data != nullptr);
    // Bias can be nullptr
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_FullyConnectedOptions();
  }
 
  OMStatus status;
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      FullyConnectedParams params{};
      status = calculateActivationRange(options->fused_activation_function(),
                                        &params.float_activation_min, &params.float_activation_max);
      if (status != Ok)
        return status;
 
      switch (weight->type())
      {
        case circle::TensorType_FLOAT32:
        {
 
          status = pal::FullyConnected(
            params, core::utils::castInputData<float>(input_data), OMRuntimeShape(weight),
            core::utils::castInputData<float>(weight_data),
            core::utils::castInputData<float>(bias_data), OMRuntimeShape(output),
            core::utils::castOutputData<float>(output_data));
        }
        break;
        case circle::TensorType_INT8:
        {
          // weight quantized INT8 mode
          params.weights_scales =
            reinterpret_cast<const float *>(weight->quantization()->scale()->data());
          params.is_channel_wise_quant = weight->quantization()->scale()->size() > 1;
 
          status = pal::FullyConnected(
            params, core::utils::castInputData<float>(input_data), OMRuntimeShape(weight),
            core::utils::castInputData<int8_t>(weight_data),
            core::utils::castInputData<float>(bias_data), OMRuntimeShape(output),
            core::utils::castOutputData<float>(output_data));
        }
        break;
        default:
          assert(false && "Unsupported hybrid weight type");
      }
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      FullyConnectedParams op_params{};
 
      calculateOpDataFullyConnected(input, weight, output, options->fused_activation_function(),
                                    op_params);
 
      status =
        pal::FullyConnected(op_params, core::utils::castInputData<int8_t>(input_data),
                            OMRuntimeShape(weight), core::utils::castInputData<int8_t>(weight_data),
                            core::utils::castInputData<int32_t>(bias_data), OMRuntimeShape(output),
                            core::utils::castOutputData<int8_t>(output_data));
    }
    break;
    case circle::TensorType_INT16:
    {
      FullyConnectedParams op_params{};
 
      calculateOpDataFullyConnected(input, weight, output, options->fused_activation_function(),
                                    op_params);
 
      status =
        pal::FullyConnected(op_params, core::utils::castInputData<int16_t>(input_data),
                            OMRuntimeShape(weight), core::utils::castInputData<int8_t>(weight_data),
                            core::utils::castInputData<int32_t>(bias_data), OMRuntimeShape(output),
                            core::utils::castOutputData<int16_t>(output_data));
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleGather()

OMStatus onert_micro::execute::execute_kernel_CircleGather ( const OMExecuteArgs & execute_args )

Definition at line 70 of file Gather.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;
  const circle::Tensor *position;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *position_data;
  uint8_t *output_data;
 
  const circle::GatherOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[inputTensorIdx];
    position = runtime_kernel.inputs[positionsTensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(position != 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];
    position_data = runtime_kernel.inputs_data[positionsTensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(position_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_GatherOptions();
  }
 
  OMStatus status = Ok;
 
  OMRuntimeShape position_shape(position);
  OMRuntimeShape input_shape(input);
 
  const int input_dims_size = input_shape.dimensionsCount();
  int axis = options->axis();
  if (axis < 0)
  {
    axis += input_dims_size;
  }
 
  int batch_dims = options->batch_dims();
  // batch_dims should be in range: [-rank(coords), rank(coords)].
  // Negative batch_dims is added with rank of coords.
  const int coords_dims_size = position_shape.dimensionsCount();
  if (batch_dims < 0)
  {
    batch_dims += coords_dims_size;
  }
 
  const int axis_size = input_shape.dims(axis);
 
  int batch_size = 1;
  for (int i = 0; i < batch_dims; ++i)
  {
    batch_size *= input_shape.dims(i);
  }
  int outer_size = 1;
  for (int i = batch_dims; i < axis; ++i)
  {
    outer_size *= input_shape.dims(i);
  }
  int inner_size = 1;
  for (int i = axis + 1; i < input_dims_size; ++i)
  {
    inner_size *= input_shape.dims(i);
  }
  int coord_size = 1;
  for (int i = batch_dims; i < coords_dims_size; ++i)
  {
    coord_size *= position_shape.dims(i);
  }
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      gather<float, int32_t>(utils::castInputData<float>(input_data),
                             utils::castInputData<int32_t>(position_data),
                             utils::castOutputData<float>(output_data), axis_size, batch_size,
                             outer_size, inner_size, coord_size);
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      gather<int8_t, int32_t>(utils::castInputData<int8_t>(input_data),
                              utils::castInputData<int32_t>(position_data),
                              utils::castOutputData<int8_t>(output_data), axis_size, batch_size,
                              outer_size, inner_size, coord_size);
    }
    break;
#endif // DIS_QUANT
    case circle::TensorType_INT32:
    {
      gather<int32_t, int32_t>(utils::castInputData<int32_t>(input_data),
                               utils::castInputData<int32_t>(position_data),
                               utils::castOutputData<int32_t>(output_data), axis_size, batch_size,
                               outer_size, inner_size, coord_size);
    }
    break;
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleGatherND()

OMStatus onert_micro::execute::execute_kernel_CircleGatherND ( const OMExecuteArgs & execute_args )

Definition at line 39 of file GatherND.cpp.

{
 
  uint8_t *input_data;
  uint8_t *position_data;
  uint8_t *output_data;
 
  core::OMRuntimeShape input_shape;
  core::OMRuntimeShape position_shape;
  core::OMRuntimeShape output_shape;
 
  circle::TensorType inputType;
 
  OMStatus status =
    execute::readKernelDataTISO(execute_args, input_data, position_data, output_data, input_shape,
                                position_shape, output_shape, inputType);
 
  switch (inputType)
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      pal::GatherND<float, int32_t>(input_shape, utils::castInputData<float>(input_data),
                                    position_shape, utils::castInputData<int32_t>(position_data),
                                    utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

References output_shape, readKernelDataTISO(), and onert_micro::UnsupportedActivation.

◆ execute_kernel_CircleGreater()

OMStatus onert_micro::execute::execute_kernel_CircleGreater ( const OMExecuteArgs & execute_args )

Definition at line 44 of file Greater.cpp.

{
  OMStatus status = Ok;
 
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  OMRuntimeKernel runtime_kernel;
 
  TISOHeader(execute_args, &input1, &input2, &output, &runtime_kernel);
 
  switch (input1->type())
  {
    case circle::TensorType_INT64:
      onert_micro::execute::evalComparisonGeneric<int64_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::GreaterFn);
      break;
    case circle::TensorType_INT32:
      onert_micro::execute::evalComparisonGeneric<int32_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::GreaterFn);
      break;
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::evalComparisonGeneric<float>(&runtime_kernel,
                                                         onert_micro::execute::pal::GreaterFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::GreaterFn(), onert_micro::Ok, and TISOHeader().

◆ execute_kernel_CircleGreaterEqual()

OMStatus onert_micro::execute::execute_kernel_CircleGreaterEqual ( const OMExecuteArgs & execute_args )

Definition at line 44 of file GreaterEqual.cpp.

{
  OMStatus status = Ok;
 
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  OMRuntimeKernel runtime_kernel;
 
  TISOHeader(execute_args, &input1, &input2, &output, &runtime_kernel);
 
  switch (input1->type())
  {
    case circle::TensorType_INT64:
      onert_micro::execute::evalComparisonGeneric<int64_t>(
        &runtime_kernel, onert_micro::execute::pal::GreaterEqualFn);
      break;
    case circle::TensorType_INT32:
      onert_micro::execute::evalComparisonGeneric<int32_t>(
        &runtime_kernel, onert_micro::execute::pal::GreaterEqualFn);
      break;
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::evalComparisonGeneric<float>(&runtime_kernel,
                                                         onert_micro::execute::pal::GreaterEqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::GreaterEqualFn(), onert_micro::Ok, and TISOHeader().

◆ execute_kernel_CircleGRU()

OMStatus onert_micro::execute::execute_kernel_CircleGRU ( const OMExecuteArgs & execute_args )

Definition at line 54 of file GRU.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;
  const circle::Tensor *hidden_hidden;
  const circle::Tensor *hidden_hidden_bias;
  const circle::Tensor *hidden_input;
  const circle::Tensor *hidden_input_bias;
  const circle::Tensor *state;
 
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *hidden_hidden_data;
  uint8_t *hidden_hidden_bias_data;
  uint8_t *hidden_input_data;
  uint8_t *hidden_input_bias_data;
  uint8_t *state_data;
  uint8_t *output_data;
 
  uint16_t state_tensor_index = 0;
 
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[inputTensorIdx];
    hidden_hidden = runtime_kernel.inputs[hiddenHiddenTensorIdx];
    hidden_hidden_bias = runtime_kernel.inputs[hiddenHiddenBiasTensorIdx];
    hidden_input = runtime_kernel.inputs[hiddenInputTensorIdx];
    hidden_input_bias = runtime_kernel.inputs[hiddenInputBiasTensorIdx];
    state = runtime_kernel.inputs[stateTensorIdx];
 
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(hidden_hidden != nullptr);
    assert(hidden_input != nullptr);
    assert(state != nullptr);
    // Biases can be nullptr
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input_data = runtime_kernel.inputs_data[inputTensorIdx];
    hidden_hidden_data = runtime_kernel.inputs_data[hiddenHiddenTensorIdx];
    hidden_hidden_bias_data = runtime_kernel.inputs_data[hiddenHiddenBiasTensorIdx];
    hidden_input_data = runtime_kernel.inputs_data[hiddenInputTensorIdx];
    hidden_input_bias_data = runtime_kernel.inputs_data[hiddenInputBiasTensorIdx];
    state_data = runtime_kernel.inputs_data[stateTensorIdx];
 
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(hidden_hidden_data != nullptr);
    assert(hidden_input_data != nullptr);
    assert(state_data != nullptr);
    // Bias can be nullptr
    assert(output_data != nullptr);
 
    state_tensor_index = runtime_kernel.inputs_index[stateTensorIdx];
  }
 
  OMStatus status;
 
  uint8_t *output_hidden_data;
  uint8_t *output_input_data;
 
  status =
    core::memory::OMMemoryManager::allocateMemory(core::OMRuntimeShape(hidden_hidden).flatSize() *
                                                    sizeof(core::OMDataType(hidden_hidden->type())),
                                                  &output_hidden_data);
  if (status != Ok)
    return status;
  status = core::memory::OMMemoryManager::allocateMemory(
    core::OMRuntimeShape(hidden_input).flatSize() * sizeof(core::OMDataType(hidden_input->type())),
    &output_input_data);
  if (status != Ok)
    return status;
 
  // If train mode need to allocate memory for internal intermediate tensors for calculation
  // gradients further Number of intermediate tensors
  const int32_t num_of_intermediate_tensors = 9;
  // Note: size of the intermediate is equal to output size (should be checked during import phase)
  const int32_t size_of_intermediate_tensors = core::OMRuntimeShape(output).flatSize();
  assert(size_of_intermediate_tensors > 0);
  if (size_of_intermediate_tensors == 0)
    return UnknownError;
 
  const int32_t input_size = core::OMRuntimeShape(input).flatSize();
  const int32_t output_size = size_of_intermediate_tensors;
 
  // Allocate buffer with following schema:
  // times * [output_size * sizeof(data_type),
  // num_of_intermediate_tensors * size_of_intermediate_tensors * sizeof(data_type)]
  // Note: need to save all necessary intermediate data to calculate gradients
  // Deallocation should perform train/GRU kernel
  const size_t data_type_size = sizeof(core::OMDataType(input->type()));
  const int32_t time = OMRuntimeShape(input).dims(0);
  size_t intermediate_buffer_size = 0;
  uint8_t *intermediate_buffer = nullptr;
  if (execute_args.is_train_mode)
  {
    const auto num_operators = runtime_context.getCircleOperators()->size();
 
    uint32_t num_train_layers =
      execute_args.num_train_layers == 0 ? num_operators : execute_args.num_train_layers;
    uint32_t last_node_pos = std::min(num_operators, num_train_layers);
    uint32_t last_train_op_index = num_operators - last_node_pos;
 
    if (execute_args.kernel_index >= last_train_op_index)
    {
      intermediate_buffer_size = num_of_intermediate_tensors * size_of_intermediate_tensors;
 
      status = core::memory::OMMemoryManager::allocateMemory(
        time * intermediate_buffer_size * data_type_size, &intermediate_buffer);
      if (status != Ok)
        return status;
 
      // Save its buffer to state tensor index
      runtime_storage.saveDataToTensorIndex(intermediate_buffer, state_tensor_index);
    }
  }
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status =
        pal::GRU(core::utils::castInputData<float>(input_data),
                 core::utils::castInputData<float>(hidden_input_data),
                 core::utils::castInputData<float>(hidden_hidden_data),
                 core::utils::castInputData<float>(hidden_input_bias_data),
                 core::utils::castInputData<float>(hidden_hidden_bias_data),
                 core::utils::castInputData<float>(state_data),
                 core::utils::castOutputData<float>(output_data),
                 core::utils::castOutputData<float>(output_input_data),
                 core::utils::castOutputData<float>(output_hidden_data),
                 core::OMRuntimeShape(input), core::OMRuntimeShape(output),
                 core::OMRuntimeShape(hidden_input), core::OMRuntimeShape(hidden_hidden),
                 intermediate_buffer_size, core::utils::castOutputData<float>(intermediate_buffer));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  core::memory::OMMemoryManager::deallocateMemory(output_input_data);
  core::memory::OMMemoryManager::deallocateMemory(output_hidden_data);
 
  return status;
}

◆ execute_kernel_CircleL2Normalize()

OMStatus onert_micro::execute::execute_kernel_CircleL2Normalize ( const OMExecuteArgs & execute_args )

Definition at line 44 of file L2Normalize.cpp.

{
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  SISOHeader(execute_args, &input, &output, &input_data, &output_data);
 
  OMStatus status;
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
 
      core::OMRuntimeShape inputs_shape(input);
      core::OMRuntimeShape outputs_shape(output);
 
      const auto trailing_dim = inputs_shape.dimensionsCount() - 1;
 
      core::L2NormalizationParams params;
      params.num_rows =
        pal::flatSizeSkipDim(inputs_shape.dimsData(), trailing_dim, inputs_shape.dimensionsCount());
 
      assert(inputs_shape.dims(trailing_dim) == outputs_shape.dims(trailing_dim));
      params.row_size = inputs_shape.dims(trailing_dim);
 
      status = pal::L2Normalization(params, core::utils::castInputData<float>(input_data),
                                    core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dimsData(), onert_micro::execute::pal::flatSizeSkipDim(), onert_micro::execute::pal::L2Normalization(), onert_micro::core::L2NormalizationParams::num_rows, onert_micro::core::L2NormalizationParams::row_size, SISOHeader(), and onert_micro::UnsupportedType.

◆ execute_kernel_CircleL2Pool2D()

OMStatus onert_micro::execute::execute_kernel_CircleL2Pool2D ( const OMExecuteArgs & execute_args )

Definition at line 29 of file L2Pool2D.cpp.

{
  auto l2_pool_float_lambda = [](const core::Pool2DParams &params,
                                 const core::OMRuntimeShape &input_shape, const float *input_data,
                                 const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::L2Pool(params, input_shape, input_data, output_shape, output_data);
  };
 
#ifndef DIS_QUANT
  auto l2_pool_int8_lambda = [](const core::Pool2DParams &params,
                                const core::OMRuntimeShape &input_shape, const int8_t *input_data,
                                const core::OMRuntimeShape &output_shape,
                                int8_t *output_data) { return UnsupportedType; };
#else
  auto l2_pool_int8_lambda = [](const core::Pool2DParams &params,
                                const core::OMRuntimeShape &input_shape, const int8_t *input_data,
                                const core::OMRuntimeShape &output_shape,
                                int8_t *output_data) { return UnsupportedType; };
#endif // DIS_QUANT
 
  return execute_pooling_common(execute_args, l2_pool_float_lambda, l2_pool_int8_lambda);
}

References execute_pooling_common(), onert_micro::execute::pal::L2Pool(), output_shape, and onert_micro::UnsupportedType.

◆ execute_kernel_CircleLeakyRelu()

OMStatus onert_micro::execute::execute_kernel_CircleLeakyRelu ( const OMExecuteArgs & execute_args )

Definition at line 28 of file LeakyRelu.cpp.

{
  bool is_relu_6 = false;
  return execute_relu_common(execute_args, is_relu_6);
}

References execute_relu_common().

◆ execute_kernel_CircleLess()

OMStatus onert_micro::execute::execute_kernel_CircleLess ( const OMExecuteArgs & execute_args )

Definition at line 44 of file Less.cpp.

{
  OMStatus status = Ok;
 
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  OMRuntimeKernel runtime_kernel;
 
  TISOHeader(execute_args, &input1, &input2, &output, &runtime_kernel);
 
  switch (input1->type())
  {
    case circle::TensorType_INT64:
      onert_micro::execute::evalComparisonGeneric<int64_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::LessFn);
      break;
    case circle::TensorType_INT32:
      onert_micro::execute::evalComparisonGeneric<int32_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::LessFn);
      break;
#ifndef DIS_QUANT
    case circle::TensorType_UINT8:
      evalQuantizedComparisonGeneric<uint8_t, int32_t>(&runtime_kernel,
                                                       onert_micro::execute::pal::LessFn);
      break;
    case circle::TensorType_INT8:
      evalQuantizedComparisonGeneric<int8_t, int32_t>(&runtime_kernel,
                                                      onert_micro::execute::pal::LessFn);
      break;
#endif // DIS_QUANT
 
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::evalComparisonGeneric<float>(&runtime_kernel,
                                                         onert_micro::execute::pal::LessFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::LessFn(), onert_micro::Ok, and TISOHeader().

◆ execute_kernel_CircleLessEqual()

OMStatus onert_micro::execute::execute_kernel_CircleLessEqual ( const OMExecuteArgs & execute_args )

Definition at line 42 of file LessEqual.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;
 
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  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;
 
  input1 = runtime_kernel.inputs[input1TensorIdx];
  input2 = runtime_kernel.inputs[input2TensorIdx];
  output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(output != nullptr);
 
  switch (input1->type())
  {
    case circle::TensorType_INT64:
      onert_micro::execute::evalComparisonGeneric<int64_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::LessEqualFn);
      break;
    case circle::TensorType_INT32:
      onert_micro::execute::evalComparisonGeneric<int32_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::LessEqualFn);
      break;
 
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::evalComparisonGeneric<float>(&runtime_kernel,
                                                         onert_micro::execute::pal::LessEqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::execute::pal::LessEqualFn(), 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.

◆ execute_kernel_CircleLog()

OMStatus onert_micro::execute::execute_kernel_CircleLog ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Log.cpp.

{
  auto log_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                             const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Log(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, log_float_lambda);
}

References execute_math_common(), onert_micro::execute::pal::Log(), and output_shape.

◆ execute_kernel_CircleLogistic()

OMStatus onert_micro::execute::execute_kernel_CircleLogistic ( const OMExecuteArgs & execute_args )

Definition at line 45 of file Logistic.cpp.

{
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  SISOHeader(execute_args, &input, &output, &input_data, &output_data);
 
  OMStatus status;
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = pal::Logistic(core::OMRuntimeShape(input).flatSize(),
                             core::utils::castInputData<float>(input_data),
                             core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      assert(input->quantization() != nullptr);
      assert(input->quantization()->scale() != nullptr);
      assert(input->quantization()->scale()->size() == 1);
      assert(input->quantization()->zero_point() != nullptr);
      assert(input->quantization()->zero_point()->size() == 1);
 
      assert(output->quantization() != nullptr);
      assert(output->quantization()->scale() != nullptr);
      assert(output->quantization()->scale()->size() == 1);
      assert(output->quantization()->zero_point() != nullptr);
      assert(output->quantization()->zero_point()->size() == 1);
 
      auto input_scale = *input->quantization()->scale()->begin();
      auto input_zero_point = *input->quantization()->zero_point()->begin();
      auto output_scale = *input->quantization()->scale()->begin();
      auto output_zero_point = *input->quantization()->zero_point()->begin();
 
      status = pal::Logistic(core::OMRuntimeShape(input).flatSize(),
                             core::utils::castInputData<int8_t>(input_data), input_scale,
                             input_zero_point, core::utils::castOutputData<int8_t>(output_data),
                             output_scale, output_zero_point);
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

References onert_micro::execute::pal::Logistic(), SISOHeader(), and onert_micro::UnsupportedType.

◆ execute_kernel_CircleLogSoftmax()

OMStatus onert_micro::execute::execute_kernel_CircleLogSoftmax ( const OMExecuteArgs & execute_args )

Definition at line 44 of file LogSoftmax.cpp.

{
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  SISOHeader(execute_args, &input, &output, &input_data, &output_data);
 
  OMStatus status;
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
 
      core::OMRuntimeShape inputs_shape(input);
      core::OMRuntimeShape outputs_shape(output);
 
      const auto dim_count = inputs_shape.dimensionsCount();
 
      const auto trailing_dim = dim_count - 1;
 
      int flat_size = 1;
      for (int i = 0; i < inputs_shape.dimensionsCount(); ++i)
      {
        flat_size *= (i == trailing_dim) ? 1 : inputs_shape.dims(i);
      }
 
      core::LogSoftmaxParams params;
      params.num_rows = flat_size;
 
      assert(inputs_shape.dims(trailing_dim) == outputs_shape.dims(trailing_dim));
      params.row_size = inputs_shape.dims(trailing_dim);
 
      status = pal::LogSoftmax(params, core::utils::castInputData<float>(input_data),
                               core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::pal::LogSoftmax(), onert_micro::core::LogSoftmaxParams::num_rows, onert_micro::core::LogSoftmaxParams::row_size, SISOHeader(), and onert_micro::UnsupportedType.

◆ execute_kernel_CircleMaximum()

OMStatus onert_micro::execute::execute_kernel_CircleMaximum ( const OMExecuteArgs & execute_args )

Definition at line 33 of file Maximum.cpp.

{
 
  uint8_t *input_data1;
  uint8_t *input_data2;
  uint8_t *output_data;
 
  core::OMRuntimeShape input_shape1;
  core::OMRuntimeShape input_shape2;
  core::OMRuntimeShape output_shape;
 
  circle::TensorType input1_type;
 
  OMStatus status =
    execute::readKernelDataTISO(execute_args, input_data1, input_data2, output_data, input_shape1,
                                input_shape2, output_shape, input1_type);
 
  switch (input1_type)
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      // check that input and output dimensions are equal
      if (input_shape1 == input_shape2)
      {
        const int flat_size = input_shape1.flatSize();
        status = pal::Maximum(flat_size, utils::castInputData<float>(input_data1),
                              utils::castInputData<float>(input_data2),
                              utils::castOutputData<float>(output_data));
      }
      else
      {
        status =
          pal::BroadcastMaximum4DSlow(input_shape1, utils::castInputData<float>(input_data1),
                                      input_shape2, utils::castInputData<float>(input_data2),
                                      output_shape, utils::castOutputData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::BroadcastMaximum4DSlow(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::pal::Maximum(), output_shape, and readKernelDataTISO().

◆ execute_kernel_CircleMaxPool2D()

OMStatus onert_micro::execute::execute_kernel_CircleMaxPool2D ( const OMExecuteArgs & execute_args )

Definition at line 29 of file MaxPool2D.cpp.

{
  auto max_pool_float_lambda = [](const core::Pool2DParams &params,
                                  const core::OMRuntimeShape &input_shape, const float *input_data,
                                  const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::MaxPool(params, input_shape, input_data, output_shape, output_data);
  };
 
#ifndef DIS_QUANT
  auto max_pool_int8_lambda = [](const core::Pool2DParams &params,
                                 const core::OMRuntimeShape &input_shape, const int8_t *input_data,
                                 const core::OMRuntimeShape &output_shape, int8_t *output_data) {
    return pal::MaxPool(params, input_shape, input_data, output_shape, output_data);
  };
#else
  auto max_pool_int8_lambda = [](const core::Pool2DParams &params,
                                 const core::OMRuntimeShape &input_shape, const int8_t *input_data,
                                 const core::OMRuntimeShape &output_shape,
                                 int8_t *output_data) { return UnsupportedType; };
#endif // DIS_QUANT
 
  return execute_pooling_common(execute_args, max_pool_float_lambda, max_pool_int8_lambda);
}

References execute_pooling_common(), onert_micro::execute::pal::MaxPool(), output_shape, and onert_micro::UnsupportedType.

◆ execute_kernel_CircleMean()

OMStatus onert_micro::execute::execute_kernel_CircleMean ( const OMExecuteArgs & execute_args )

Definition at line 55 of file Mean.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;
  const circle::Tensor *axis;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *axis_data;
  uint8_t *output_data;
 
  uint16_t input_index = 0;
  uint16_t axis_index = 0;
 
  const circle::ReducerOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[input1TensorIdx];
    axis = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(axis != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input_data = runtime_kernel.inputs_data[input1TensorIdx];
    axis_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(axis_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_ReducerOptions();
 
    input_index = runtime_kernel.inputs_index[input1TensorIdx];
    axis_index = runtime_kernel.inputs_index[input2TensorIdx];
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape axis_shape(axis);
  core::OMRuntimeShape output_shape(output);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::pal::Mean<float>(
        input_shape.dimsData(), core::utils::castInputData<float>(input_data),
        input_shape.dimensionsCount(), core::utils::castOutputData<float>(output_data),
        output_shape.flatSize(), core::utils::castInputData<int>(axis_data),
        axis_shape.dimensionsCount());
 
      break;
#endif // DIS_FLOAT
    case circle::TensorType_INT32:
      break;
    case circle::TensorType_INT64:
      break;
    default:
      assert(false && "Unsupported type");
  }
 
  return status;
}

◆ execute_kernel_CircleMinimum()

OMStatus onert_micro::execute::execute_kernel_CircleMinimum ( const OMExecuteArgs & execute_args )

Definition at line 33 of file Minimum.cpp.

{
 
  uint8_t *input_data1;
  uint8_t *input_data2;
  uint8_t *output_data;
 
  core::OMRuntimeShape input_shape1;
  core::OMRuntimeShape input_shape2;
  core::OMRuntimeShape output_shape;
 
  circle::TensorType input1_type;
 
  OMStatus status =
    execute::readKernelDataTISO(execute_args, input_data1, input_data2, output_data, input_shape1,
                                input_shape2, output_shape, input1_type);
 
  switch (input1_type)
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      // check that input and output dimensions are equal
      if (input_shape1 == input_shape2)
      {
        const int flat_size = input_shape1.flatSize();
        status = pal::Minimum(flat_size, utils::castInputData<float>(input_data1),
                              utils::castInputData<float>(input_data2),
                              utils::castOutputData<float>(output_data));
      }
      else
      {
        status =
          pal::BroadcastMinimum4DSlow(input_shape1, utils::castInputData<float>(input_data1),
                                      input_shape2, utils::castInputData<float>(input_data2),
                                      output_shape, utils::castOutputData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::BroadcastMinimum4DSlow(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::pal::Minimum(), output_shape, and readKernelDataTISO().

◆ execute_kernel_CircleMul()

OMStatus onert_micro::execute::execute_kernel_CircleMul ( const OMExecuteArgs & execute_args )

Definition at line 80 of file Mul.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 *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  uint8_t *input1_data;
  uint8_t *input2_data;
  uint8_t *output_data;
 
  const circle::MulOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input1 = runtime_kernel.inputs[input1TensorIdx];
    input2 = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input1 != nullptr);
    assert(input2 != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input1_data = runtime_kernel.inputs_data[input1TensorIdx];
    input2_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input1_data != nullptr);
    assert(input2_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_MulOptions();
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input1_shape(input1);
  core::OMRuntimeShape input2_shape(input2);
  core::OMRuntimeShape output_shape(output);
 
  core::BinaryArithmeticBroadcastParams params{};
  const bool need_broadcast = pal::processBroadcastShapes(input1_shape, input2_shape, &params);
 
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.float_activation_min,
                                                 &params.float_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastMul4DSlow(
          params, input1_shape, core::utils::castInputData<float>(input1_data), input2_shape,
          core::utils::castInputData<float>(input2_data), output_shape,
          core::utils::castOutputData<float>(output_data));
      }
      else
      {
        status =
          pal::Mul(params, input1_shape.flatSize(), core::utils::castInputData<float>(input1_data),
                   core::utils::castInputData<float>(input2_data),
                   core::utils::castOutputData<float>(output_data));
      }
    }
    break;
    case circle::TensorType_INT64:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.int64_activation_min,
                                                 &params.int64_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastMul4DSlow(
          params, input1_shape, core::utils::castInputData<int64_t>(input1_data), input2_shape,
          core::utils::castInputData<int64_t>(input2_data), output_shape,
          core::utils::castOutputData<int64_t>(output_data));
      }
      else
      {
        status = pal::Mul(params, input1_shape.flatSize(),
                          core::utils::castInputData<int64_t>(input1_data),
                          core::utils::castInputData<int64_t>(input2_data),
                          core::utils::castOutputData<int64_t>(output_data));
      }
    }
    break;
    case circle::TensorType_INT32:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.int32_activation_min,
                                                 &params.int32_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastMul4DSlow(
          params, input1_shape, core::utils::castInputData<int32_t>(input1_data), input2_shape,
          core::utils::castInputData<int32_t>(input2_data), output_shape,
          core::utils::castOutputData<int32_t>(output_data));
      }
      else
      {
        status = pal::Mul(params, input1_shape.flatSize(),
                          core::utils::castInputData<int32_t>(input1_data),
                          core::utils::castInputData<int32_t>(input2_data),
                          core::utils::castOutputData<int32_t>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      core::ArithmeticQuantParams add_params{};
 
      calculateQuantParamsForMul(add_params, input1, input2, output,
                                 options->fused_activation_function());
 
      if (need_broadcast)
      {
        status = pal::BroadcastMul6DSlow(
          add_params, input1_shape, core::utils::castInputData<int8_t>(input1_data), input2_shape,
          core::utils::castInputData<int8_t>(input2_data), output_shape,
          core::utils::castOutputData<int8_t>(output_data));
      }
      else
      {
        assert(input1_shape.flatSize() == input2_shape.flatSize());
        assert(input1_shape.flatSize() == output_shape.flatSize());
        status = pal::Mul(add_params, input1_shape.flatSize(),
                          core::utils::castInputData<int8_t>(input1_data),
                          core::utils::castInputData<int8_t>(input2_data),
                          core::utils::castOutputData<int8_t>(output_data));
      }
    }
    break;
#endif // DIF_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleNeg()

OMStatus onert_micro::execute::execute_kernel_CircleNeg ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Neg.cpp.

{
  auto neg_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                             const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Neg(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, neg_float_lambda);
}

References execute_math_common(), onert_micro::execute::pal::Neg(), and output_shape.

◆ execute_kernel_CircleNotEqual()

OMStatus onert_micro::execute::execute_kernel_CircleNotEqual ( const OMExecuteArgs & execute_args )

Definition at line 44 of file NotEqual.cpp.

{
  OMStatus status = Ok;
 
  const circle::Tensor *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *output = nullptr;
 
  OMRuntimeKernel runtime_kernel;
 
  TISOHeader(execute_args, &input1, &input2, &output, &runtime_kernel);
 
  switch (input1->type())
  {
    case circle::TensorType_INT64:
      onert_micro::execute::evalComparisonGeneric<int64_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::NotEqualFn);
      break;
    case circle::TensorType_INT32:
      onert_micro::execute::evalComparisonGeneric<int32_t>(&runtime_kernel,
                                                           onert_micro::execute::pal::NotEqualFn);
      break;
 
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::evalComparisonGeneric<float>(&runtime_kernel,
                                                         onert_micro::execute::pal::NotEqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  return status;
}

References onert_micro::execute::pal::NotEqualFn(), onert_micro::Ok, and TISOHeader().

◆ execute_kernel_CirclePack()

OMStatus onert_micro::execute::execute_kernel_CirclePack ( const OMExecuteArgs & execute_args )

Definition at line 86 of file Pack.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;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const auto type = runtime_kernel.inputs[0]->type();
  OMStatus status = Ok;
 
  status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
  if (status != Ok)
    return status;
 
  switch (type)
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      packImpl<float>(runtime_kernel);
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
      packImpl<int8_t>(runtime_kernel);
      break;
#endif // DIS_QUANT
    case circle::TensorType_INT32:
      packImpl<int32_t>(runtime_kernel);
      break;
    case circle::TensorType_INT64:
      packImpl<int64_t>(runtime_kernel);
      break;
    default:
      assert(false && "Unsupported type.");
      status = UnsupportedType;
  }
 
  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::readKernel(), onert_micro::execute::OMExecuteArgs::runtime_context, onert_micro::execute::OMExecuteArgs::runtime_storage, and onert_micro::UnsupportedType.

◆ execute_kernel_CirclePad()

OMStatus onert_micro::execute::execute_kernel_CirclePad ( const OMExecuteArgs & execute_args )

Definition at line 45 of file Pad.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 *input1;
  const circle::Tensor *input2;
  const circle::Tensor *input3;
  const circle::Tensor *output;
 
  uint8_t *input1_data;
  uint8_t *input2_data;
  uint8_t *input3_data;
  uint8_t *output_data;
 
  const circle::PadOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input1 = runtime_kernel.inputs[input1TensorIdx];
    input2 = runtime_kernel.inputs[input2TensorIdx];
    input3 = runtime_kernel.inputs[input3TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input1 != nullptr);
    assert(input2 != nullptr);
    // input3 - can be nullptr
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input1_data = runtime_kernel.inputs_data[input1TensorIdx];
    input2_data = runtime_kernel.inputs_data[input2TensorIdx];
    input3_data = runtime_kernel.inputs_data[input3TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input1_data != nullptr);
    assert(input2_data != nullptr);
    // input3_data can be nullptr
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_PadOptions();
  }
 
  OMStatus status = Ok;
 
  core::OMRuntimeShape input1_shape(input1);
  core::OMRuntimeShape input2_shape(input2);
  core::OMRuntimeShape output_shape(output);
 
  // Create PadParams
  core::PadParams pad_params{};
  const auto num_input_dimensions = input1_shape.dimensionsCount();
  assert(num_input_dimensions <= 5);
 
  if (num_input_dimensions > 5)
    return UnsupportedType;
 
  pad_params.left_padding_count = num_input_dimensions;
  pad_params.right_padding_count = num_input_dimensions;
 
  auto *paddings_data = reinterpret_cast<int32_t *>(input2_data);
  for (int idx = num_input_dimensions - 1; idx >= 0; --idx)
  {
    pad_params.left_padding[idx] = paddings_data[idx * 2];
    pad_params.right_padding[idx] = paddings_data[idx * 2 + 1];
  }
 
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      float pad_value = input3_data == nullptr ? 0.f : *reinterpret_cast<float *>(input3_data[0]);
      status = pal::Pad(pad_params, input1_shape, core::utils::castInputData<float>(input1_data),
                        pad_value, output_shape, core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleQuantize()

OMStatus onert_micro::execute::execute_kernel_CircleQuantize ( const OMExecuteArgs & execute_args )

Definition at line 44 of file Quantize.cpp.

{
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  SISOHeader(execute_args, &input, &output, &input_data, &output_data);
 
  OMStatus status = Ok;
 
  assert(input->type() == circle::TensorType_FLOAT32);
 
  switch (output->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_INT8:
    {
      assert(output->quantization() != nullptr);
      assert(output->quantization()->scale() != nullptr and
             output->quantization()->scale()->size() == 1);
      assert(output->quantization()->zero_point() != nullptr and
             output->quantization()->zero_point()->size() == 1);
      core::QuantizationParams params{};
      params.zero_point = output->quantization()->zero_point()->operator[](0);
      params.scale = output->quantization()->scale()->operator[](0);
 
      status = pal::Quantize(params, core::OMRuntimeShape(input).flatSize(),
                             core::utils::castInputData<float>(input_data),
                             core::utils::castOutputData<int8_t>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

References onert_micro::Ok, onert_micro::execute::pal::Quantize(), SISOHeader(), onert_micro::UnsupportedType, and onert_micro::core::QuantizationParams::zero_point.

◆ execute_kernel_CircleReduceProd()

OMStatus onert_micro::execute::execute_kernel_CircleReduceProd ( const OMExecuteArgs & execute_args )

Definition at line 55 of file ReduceProd.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;
  const circle::Tensor *axis;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *axis_data;
  uint8_t *output_data;
 
  uint16_t input_index = 0;
  uint16_t axis_index = 0;
 
  const circle::ReducerOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[input1TensorIdx];
    axis = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(axis != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input_data = runtime_kernel.inputs_data[input1TensorIdx];
    axis_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(axis_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_ReducerOptions();
 
    input_index = runtime_kernel.inputs_index[input1TensorIdx];
    axis_index = runtime_kernel.inputs_index[input2TensorIdx];
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape axis_shape(axis);
  core::OMRuntimeShape output_shape(output);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      reduceProdGeneric<float>(input_shape, core::utils::castInputData<float>(input_data),
                               axis_shape, core::utils::castInputData<int>(axis_data), output_shape,
                               core::utils::castOutputData<float>(output_data),
                               options->keep_dims());
      break;
#endif // DIS_FLOAT
    case circle::TensorType_INT32:
      reduceProdGeneric<int32_t>(input_shape, core::utils::castInputData<int32_t>(input_data),
                                 axis_shape, core::utils::castInputData<int>(axis_data),
                                 output_shape, core::utils::castOutputData<int32_t>(output_data),
                                 options->keep_dims());
      break;
    case circle::TensorType_INT64:
      reduceProdGeneric<int64_t>(input_shape, core::utils::castInputData<int64_t>(input_data),
                                 axis_shape, core::utils::castInputData<int>(axis_data),
                                 output_shape, core::utils::castOutputData<int64_t>(output_data),
                                 options->keep_dims());
      break;
    default:
      assert(false && "Unsupported type");
  }
 
  return status;
}

◆ execute_kernel_CircleRelu()

OMStatus onert_micro::execute::execute_kernel_CircleRelu ( const OMExecuteArgs & execute_args )

Definition at line 28 of file Relu.cpp.

{
  bool is_relu_6 = false;
  return execute_relu_common(execute_args, is_relu_6);
}

References execute_relu_common().

◆ execute_kernel_CircleRelu6()

OMStatus onert_micro::execute::execute_kernel_CircleRelu6 ( const OMExecuteArgs & execute_args )

Definition at line 28 of file Relu6.cpp.

{
  bool is_relu_6 = true;
  return execute_relu_common(execute_args, is_relu_6);
}

References execute_relu_common().

◆ execute_kernel_CircleReshape()

OMStatus onert_micro::execute::execute_kernel_CircleReshape ( const OMExecuteArgs & execute_args )

Definition at line 36 of file Reshape.cpp.

{
  return execute_reshape_common(execute_args);
}

References execute_reshape_common().

◆ execute_kernel_CircleRound()

OMStatus onert_micro::execute::execute_kernel_CircleRound ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Round.cpp.

{
  auto round_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                               const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Round(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, round_float_lambda);
}

References execute_math_common(), output_shape, and onert_micro::execute::pal::Round().

◆ execute_kernel_CircleRsqrt()

OMStatus onert_micro::execute::execute_kernel_CircleRsqrt ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Rsqrt.cpp.

{
  auto rsqrt_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                               const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Rsqrt(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, rsqrt_float_lambda);
}

References execute_math_common(), output_shape, and onert_micro::execute::pal::Rsqrt().

◆ execute_kernel_CircleSelectV2()

OMStatus onert_micro::execute::execute_kernel_CircleSelectV2 ( const OMExecuteArgs & execute_args )

Definition at line 60 of file SelectV2.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_cond;
  const circle::Tensor *input_x;
  const circle::Tensor *input_y;
  const circle::Tensor *output;
 
  uint8_t *input_cond_data;
  uint8_t *input_x_data;
  uint8_t *input_y_data;
  uint8_t *output_data;
 
  OMStatus status = Ok;
 
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input_cond = runtime_kernel.inputs[inputCond];
    input_x = runtime_kernel.inputs[inputX];
    input_y = runtime_kernel.inputs[inputY];
    output = runtime_kernel.outputs[outputIndex];
 
    assert(input_cond != nullptr);
    assert(input_x != nullptr);
    assert(input_y != nullptr);
    assert(output != nullptr);
 
    status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
    if (status != Ok)
      return status;
 
    input_cond_data = runtime_kernel.inputs_data[inputCond];
    input_x_data = runtime_kernel.inputs_data[inputX];
    input_y_data = runtime_kernel.inputs_data[inputY];
    output_data = runtime_kernel.outputs_data[outputIndex];
 
    assert(input_cond_data != nullptr);
    assert(input_x_data != nullptr);
    assert(input_y_data != nullptr);
    assert(output_data != nullptr);
  }
 
  const core::OMRuntimeShape input_cond_shape(input_cond);
  assert(input_cond_shape.flatSize() > 0);
  const core::OMRuntimeShape input_x_shape(input_x);
  const core::OMRuntimeShape input_y_shape(input_y);
  const core::OMRuntimeShape output_shape(output);
 
  switch (input_x->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      CallSelect<float>(input_cond_shape, core::utils::castInputData<bool>(input_cond_data),
                        input_x_shape, core::utils::castInputData<float>(input_x_data),
                        input_y_shape, core::utils::castInputData<float>(input_y_data),
                        output_shape, core::utils::castOutputData<float>(output_data));
    }
    break;
#endif
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleShape()

OMStatus onert_micro::execute::execute_kernel_CircleShape ( const OMExecuteArgs & execute_args )

Definition at line 41 of file Shape.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;
  uint8_t *output_data = nullptr;
 
  OMStatus status = Ok;
  {
    OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[inputTensorIdx];
 
    assert(input != nullptr);
 
    status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
    if (status != Ok)
      return status;
 
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
  }
 
  assert(output_data != nullptr);
 
  core::OMRuntimeShape input_shape(input);
 
  const auto rank = input_shape.dimensionsCount();
 
  auto output_data_int = core::utils::castOutputData<int32_t>(output_data);
 
  for (int i = 0; i < rank; ++i)
  {
    output_data_int[i] = input_shape.dims(i);
  }
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::Ok, 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_kernel_CircleSin()

OMStatus onert_micro::execute::execute_kernel_CircleSin ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Sin.cpp.

{
  auto sin_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                             const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Sin(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, sin_float_lambda);
}

References execute_math_common(), output_shape, and onert_micro::execute::pal::Sin().

◆ execute_kernel_CircleSlice()

OMStatus onert_micro::execute::execute_kernel_CircleSlice ( const OMExecuteArgs & execute_args )

Definition at line 62 of file Slice.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 *input1 = nullptr;
  const circle::Tensor *input2 = nullptr;
  const circle::Tensor *input3 = nullptr;
 
  const circle::Tensor *output = nullptr;
 
  uint8_t *input1_data;
  const int32_t *input2_data;
  const int32_t *input3_data;
  uint8_t *output_data;
 
  OMStatus status = Ok;
  const circle::SliceOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input1 = runtime_kernel.inputs[input1TensorIdx];
    input2 = runtime_kernel.inputs[input2TensorIdx];
    input3 = runtime_kernel.inputs[input3TensorIdx];
 
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input1 != nullptr);
    assert(input2 != nullptr);
    assert(input3 != nullptr);
    assert(output != nullptr);
 
    status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
    if (status != Ok)
      return status;
 
    input1_data = runtime_kernel.inputs_data[input1TensorIdx];
    input2_data = utils::castInputData<int32_t>(runtime_kernel.inputs_data[input2TensorIdx]);
    input3_data = utils::castInputData<int32_t>(runtime_kernel.inputs_data[input3TensorIdx]);
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
 
    assert(input1_data != nullptr);
    assert(input2_data != nullptr);
    assert(input3_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_SliceOptions();
  }
 
  OMRuntimeShape input_shape(input1);
 
  SliceParams op_params{};
  op_params.begin_count = MAX_DIM;
  op_params.size_count = MAX_DIM;
  for (int i = 0; i < MAX_DIM; i++)
  {
    op_params.begin[i] = 0;
    op_params.size[i] = 1;
  }
  auto num_dim = input_shape.dimensionsCount();
 
  getBeginAndSizeVectors(num_dim, input2_data, input3_data, op_params.begin, op_params.size);
 
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = pal::Slice(op_params, input_shape, utils::castInputData<float>(input1_data),
                          utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    case circle::TensorType_INT32:
    {
      status = pal::Slice(op_params, input_shape, utils::castInputData<int32_t>(input1_data),
                          utils::castOutputData<int32_t>(output_data));
    }
    break;
    case circle::TensorType_INT64:
    {
      status = pal::Slice(op_params, input_shape, utils::castInputData<int64_t>(input1_data),
                          utils::castOutputData<int64_t>(output_data));
    }
    break;
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleSoftmax()

OMStatus onert_micro::execute::execute_kernel_CircleSoftmax ( const OMExecuteArgs & execute_args )

Definition at line 57 of file Softmax.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;
 
  const circle::SoftmaxOptions *options;
  {
    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];
 
    options = runtime_kernel.first_operator->builtin_options_as_SoftmaxOptions();
  }
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  const float beta = options->beta();
 
  core::OMRuntimeShape inputs_shape(input);
  core::OMRuntimeShape outputs_shape(output);
 
  const auto dim_count = inputs_shape.dimensionsCount();
 
  const auto trailing_dim = dim_count - 1;
 
  int flat_size = 1;
  for (int i = 0; i < inputs_shape.dimensionsCount(); ++i)
  {
    flat_size *= (i == trailing_dim) ? 1 : inputs_shape.dims(i);
  }
 
  core::SoftmaxParams params{};
  params.beta = beta;
  params.num_rows = flat_size;
  params.row_size = std::min(inputs_shape.dims(trailing_dim), outputs_shape.dims(trailing_dim));
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
 
      status = pal::Softmax(params, core::utils::castInputData<float>(input_data),
                            core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      assert(output->type() == circle::TensorType_INT8);
      if (output->type() != circle::TensorType_INT8)
        return UnsupportedType;
 
      assert(input->quantization() != nullptr and output->quantization() != nullptr);
      assert(input->quantization()->scale() != nullptr and
             output->quantization()->scale() != nullptr);
      assert(input->quantization()->zero_point() != nullptr and
             output->quantization()->zero_point() != nullptr);
      assert(input->quantization()->scale()->size() == 1 and
             output->quantization()->scale()->size() == 1);
      assert(input->quantization()->zero_point()->size() == 1 and
             output->quantization()->zero_point()->size() == 1);
 
      params.output_scale = output->quantization()->scale()->operator[](0);
      params.input_scale = input->quantization()->scale()->operator[](0);
      params.output_zp = output->quantization()->zero_point()->operator[](0);
      params.input_zp = input->quantization()->zero_point()->operator[](0);
 
      int left_shift = 0;
      preprocessSoftmaxScaling(static_cast<double>(params.beta),
                               static_cast<double>(params.input_scale), kScaledDiffIntegerBits,
                               &params.input_multiplier, &left_shift);
      params.input_left_shift = left_shift;
      params.diff_min = -1.0 * onert_micro::execute::calculateInputRadius(
                                 kScaledDiffIntegerBits, params.input_left_shift, 31);
 
      status = pal::Softmax(params, core::utils::castInputData<int8_t>(input_data),
                            core::utils::castOutputData<int8_t>(output_data));
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleSpaceToBatchND()

OMStatus onert_micro::execute::execute_kernel_CircleSpaceToBatchND ( const onert_micro::execute::OMExecuteArgs & execute_args )

Definition at line 29 of file SpaceToBatchND.cpp.

{
  auto batch_to_space_float_lambda =
    [](const core::OMRuntimeShape &input1_shape, const float *input1_data,
       const core::OMRuntimeShape &input2_shape, const int32_t *block_shape_data,
       const core::OMRuntimeShape &input3_shape, const int32_t *crops_data,
       const core::OMRuntimeShape &output_shape, float *output_data) {
      return pal::SpaceToBatchND<float>(input1_shape, input1_data, input2_shape, block_shape_data,
                                        input3_shape, crops_data, output_shape, output_data);
    };
 
  return execute_spaces_batches_nd_common(execute_args, batch_to_space_float_lambda);
}

References execute_spaces_batches_nd_common(), and output_shape.

◆ execute_kernel_CircleSpaceToDepth()

OMStatus onert_micro::execute::execute_kernel_CircleSpaceToDepth ( const onert_micro::execute::OMExecuteArgs & execute_args )

Definition at line 38 of file SpaceToDepth.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;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *output_data;
 
  // Read kernel
  execute::OMRuntimeKernel runtime_kernel;
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  input = runtime_kernel.inputs[inputTensorIdx];
  output = runtime_kernel.outputs[outputTensorIdx];
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape output_shape(output);
 
  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];
  const auto *options = runtime_kernel.first_operator->builtin_options_as_SpaceToDepthOptions();
  const int32_t block_size = options->block_size();
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status =
        pal::SpaceToDepth<float>(block_size, input_shape, reinterpret_cast<float *>(input_data),
                                 output_shape, reinterpret_cast<float *>(output_data));
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      status =
        pal::SpaceToDepth<int8_t>(block_size, input_shape, reinterpret_cast<int8_t *>(input_data),
                                  output_shape, reinterpret_cast<int8_t *>(output_data));
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleSplit()

OMStatus onert_micro::execute::execute_kernel_CircleSplit ( const OMExecuteArgs & execute_args )

Definition at line 46 of file Split.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;
  const circle::Tensor *axis;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *axis_data;
 
  // Read kernel
  const circle::SplitOptions *options;
 
  core::SplitParams params{};
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[inputTensorIdx];
    axis = runtime_kernel.inputs[axisTensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(axis != 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];
    axis_data = runtime_kernel.inputs_data[axisTensorIdx];
    assert(input_data != nullptr);
    assert(axis_data != nullptr);
    options = runtime_kernel.first_operator->builtin_options_as_SplitOptions();
 
    params.num_outputs = options->num_splits();
 
    for (uint32_t i = 0; i < params.num_outputs; ++i)
    {
      params.output_data[i] = runtime_kernel.outputs_data[i];
    }
  }
  OMStatus status;
  OMRuntimeShape axis_shape(axis);
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  int32_t axis_value = utils::castInputData<int32_t>(axis_data)[0];
  if (axis_value < 0)
  {
    axis_value += input_shape.dimensionsCount() + 1;
  }
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      status = pal::Split<float>(params, input_shape, core::utils::castInputData<float>(input_data),
                                 output_shape, axis_value);
      break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleSplitV()

OMStatus onert_micro::execute::execute_kernel_CircleSplitV ( const OMExecuteArgs & execute_args )

Definition at line 46 of file SplitV.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;
  const circle::Tensor *axis;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *axis_data;
 
  // Read kernel
  core::SplitParams params{};
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[inputTensorIdx];
    axis = runtime_kernel.inputs[axisTensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(axis != 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];
    axis_data = runtime_kernel.inputs_data[axisTensorIdx];
    assert(input_data != nullptr);
    assert(axis_data != nullptr);
 
    params.num_outputs = runtime_kernel.outputs_num;
 
    for (uint32_t i = 0; i < params.num_outputs; ++i)
    {
      params.output_data[i] = runtime_kernel.outputs_data[i];
    }
  }
  OMStatus status;
  OMRuntimeShape axis_shape(axis);
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  int32_t axis_value = axis_data[0];
  if (axis_value < 0)
  {
    axis_value += input_shape.dimensionsCount() + 1;
  }
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      status = pal::Split<float>(params, input_shape, core::utils::castInputData<float>(input_data),
                                 output_shape, axis_value);
      break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleSqrt()

OMStatus onert_micro::execute::execute_kernel_CircleSqrt ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Sqrt.cpp.

{
  auto sqrt_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                              const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Sqrt(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, sqrt_float_lambda);
}

References execute_math_common(), output_shape, and onert_micro::execute::pal::Sqrt().

◆ execute_kernel_CircleSquare()

OMStatus onert_micro::execute::execute_kernel_CircleSquare ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Square.cpp.

{
  auto square_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                                const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Square(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, square_float_lambda);
}

References execute_math_common(), output_shape, and onert_micro::execute::pal::Square().

◆ execute_kernel_CircleSquaredDifference()

OMStatus onert_micro::execute::execute_kernel_CircleSquaredDifference ( const OMExecuteArgs & execute_args )

Definition at line 50 of file SquaredDifference.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 *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  uint8_t *input1_data;
  uint8_t *input2_data;
  uint8_t *output_data;
 
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input1 = runtime_kernel.inputs[input1TensorIdx];
    input2 = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input1 != nullptr);
    assert(input2 != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input1_data = runtime_kernel.inputs_data[input1TensorIdx];
    input2_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input1_data != nullptr);
    assert(input2_data != nullptr);
    assert(output_data != nullptr);
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input1_shape(input1);
  core::OMRuntimeShape input2_shape(input2);
  core::OMRuntimeShape output_shape(output);
 
  core::BinaryArithmeticBroadcastParams params{};
  const bool need_broadcast = pal::processBroadcastShapes(input1_shape, input2_shape, &params);
 
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = execute::calculateActivationRange(
        circle::ActivationFunctionType::ActivationFunctionType_NONE, &params.float_activation_min,
        &params.float_activation_max);
      if (need_broadcast)
      {
        status = pal::BroadcastSquaredDifference4DSlow(
          params, input1_shape, core::utils::castInputData<float>(input1_data), input2_shape,
          core::utils::castInputData<float>(input2_data), output_shape,
          core::utils::castOutputData<float>(output_data));
      }
      else
      {
        status = pal::SquaredDifference(params, input1_shape.flatSize(),
                                        core::utils::castInputData<float>(input1_data),
                                        core::utils::castInputData<float>(input2_data),
                                        core::utils::castOutputData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleStridedSlice()

OMStatus onert_micro::execute::execute_kernel_CircleStridedSlice ( const OMExecuteArgs & execute_args )

Definition at line 74 of file StridedSlice.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 *begin = nullptr;
  const circle::Tensor *end = nullptr;
  const circle::Tensor *strides = nullptr;
 
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data;
  const int32_t *begin_data;
  const int32_t *end_data;
  const int32_t *strides_data;
  uint8_t *output_data;
 
  OMStatus status = Ok;
  const circle::StridedSliceOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[inputTensorIdx];
    begin = runtime_kernel.inputs[beginTensorIdx];
    end = runtime_kernel.inputs[endTensorIdx];
    strides = runtime_kernel.inputs[stridesTensorIdx];
 
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(begin != nullptr);
    assert(end != nullptr);
    assert(strides != 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];
    begin_data = utils::castInputData<int32_t>(runtime_kernel.inputs_data[beginTensorIdx]);
    end_data = utils::castInputData<int32_t>(runtime_kernel.inputs_data[endTensorIdx]);
    strides_data = utils::castInputData<int32_t>(runtime_kernel.inputs_data[stridesTensorIdx]);
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
 
    assert(input_data != nullptr);
    assert(begin_data != nullptr);
    assert(end_data != nullptr);
    assert(strides_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_StridedSliceOptions();
  }
 
  core::OMRuntimeShape input_shape(input);
 
  auto op_params = buildStridedSliceParams(input_shape.dimensionsCount(), begin_data, end_data,
                                           strides_data, options);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = pal::StridedSlice(op_params, input_shape, utils::castInputData<float>(input_data),
                                 utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      status = pal::StridedSlice(op_params, input_shape, utils::castInputData<int8_t>(input_data),
                                 utils::castOutputData<int8_t>(output_data));
    }
    break;
#endif // DIS_QUANT
    case circle::TensorType_INT32:
    {
      status = pal::StridedSlice(op_params, input_shape, utils::castInputData<int32_t>(input_data),
                                 utils::castOutputData<int32_t>(output_data));
    }
    break;
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleSub()

OMStatus onert_micro::execute::execute_kernel_CircleSub ( const OMExecuteArgs & execute_args )

Definition at line 50 of file Sub.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 *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  uint8_t *input1_data;
  uint8_t *input2_data;
  uint8_t *output_data;
 
  const circle::SubOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input1 = runtime_kernel.inputs[input1TensorIdx];
    input2 = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input1 != nullptr);
    assert(input2 != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input1_data = runtime_kernel.inputs_data[input1TensorIdx];
    input2_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input1_data != nullptr);
    assert(input2_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_SubOptions();
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input1_shape(input1);
  core::OMRuntimeShape input2_shape(input2);
  core::OMRuntimeShape output_shape(output);
 
  core::BinaryArithmeticBroadcastParams params{};
  const bool need_broadcast = pal::processBroadcastShapes(input1_shape, input2_shape, &params);
 
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.float_activation_min,
                                                 &params.float_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastSub4DSlow(
          params, input1_shape, core::utils::castInputData<float>(input1_data), input2_shape,
          core::utils::castInputData<float>(input2_data), output_shape,
          core::utils::castOutputData<float>(output_data));
      }
      else
      {
        status =
          pal::Sub(params, input1_shape.flatSize(), core::utils::castInputData<float>(input1_data),
                   core::utils::castInputData<float>(input2_data),
                   core::utils::castOutputData<float>(output_data));
      }
    }
    break;
    case circle::TensorType_INT64:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.int64_activation_min,
                                                 &params.int64_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastSub4DSlow(
          params, input1_shape, core::utils::castInputData<int64_t>(input1_data), input2_shape,
          core::utils::castInputData<int64_t>(input2_data), output_shape,
          core::utils::castOutputData<int64_t>(output_data));
      }
      else
      {
        status = pal::Sub(params, input1_shape.flatSize(),
                          core::utils::castInputData<int64_t>(input1_data),
                          core::utils::castInputData<int64_t>(input2_data),
                          core::utils::castOutputData<int64_t>(output_data));
      }
    }
    break;
    case circle::TensorType_INT32:
    {
      status = execute::calculateActivationRange(options->fused_activation_function(),
                                                 &params.int32_activation_min,
                                                 &params.int32_activation_max);
 
      if (need_broadcast)
      {
        status = pal::BroadcastSub4DSlow(
          params, input1_shape, core::utils::castInputData<int32_t>(input1_data), input2_shape,
          core::utils::castInputData<int32_t>(input2_data), output_shape,
          core::utils::castOutputData<int32_t>(output_data));
      }
      else
      {
        status = pal::Sub(params, input1_shape.flatSize(),
                          core::utils::castInputData<int32_t>(input1_data),
                          core::utils::castInputData<int32_t>(input2_data),
                          core::utils::castOutputData<int32_t>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      core::ArithmeticQuantParams sub_params{};
 
      calculateQuantParams(sub_params, input1, input2, output,
                           options->fused_activation_function());
 
      if (need_broadcast)
      {
        status = pal::BroadcastSub4DSlow(
          sub_params, input1_shape, core::utils::castInputData<int8_t>(input1_data), input2_shape,
          core::utils::castInputData<int8_t>(input2_data), output_shape,
          core::utils::castOutputData<int8_t>(output_data));
      }
      else
      {
        status = pal::Sub(sub_params, input1_shape.flatSize(),
                          core::utils::castInputData<int8_t>(input1_data),
                          core::utils::castInputData<int8_t>(input2_data),
                          core::utils::castOutputData<int8_t>(output_data));
      }
    }
    break;
#endif // DIF_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleSum()

OMStatus onert_micro::execute::execute_kernel_CircleSum ( const OMExecuteArgs & execute_args )

Definition at line 44 of file Sum.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;
  const circle::Tensor *axis;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *axis_data;
  uint8_t *output_data;
 
  uint16_t input_index = 0;
  uint16_t axis_index = 0;
 
  const circle::ReducerOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[input1TensorIdx];
    axis = runtime_kernel.inputs[input2TensorIdx];
    output = runtime_kernel.outputs[outputTensorIdx];
    assert(input != nullptr);
    assert(axis != nullptr);
    assert(output != nullptr);
 
    runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
 
    input_data = runtime_kernel.inputs_data[input1TensorIdx];
    axis_data = runtime_kernel.inputs_data[input2TensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
    assert(input_data != nullptr);
    assert(axis_data != nullptr);
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_ReducerOptions();
 
    input_index = runtime_kernel.inputs_index[input1TensorIdx];
    axis_index = runtime_kernel.inputs_index[input2TensorIdx];
  }
 
  OMStatus status;
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape axis_shape(axis);
  core::OMRuntimeShape output_shape(output);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      onert_micro::execute::pal::reduceSumImpl<float>(
        core::utils::castInputData<float>(input_data), input_shape.dimsData(),
        input_shape.dimensionsCount(), core::utils::castOutputData<float>(output_data),
        core::utils::castInputData<int>(axis_data), axis_shape.dimensionsCount(),
        output_shape.flatSize());
      break;
#endif // DIS_FLOAT
    case circle::TensorType_INT32:
      break;
    case circle::TensorType_INT64:
      break;
    default:
      assert(false && "Unsupported type");
  }
 
  return status;
}

◆ execute_kernel_CircleSVDF()

OMStatus onert_micro::execute::execute_kernel_CircleSVDF ( const OMExecuteArgs & execute_args )

Definition at line 84 of file SVDF.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;
  const circle::Tensor *weights_feature;
  const circle::Tensor *weights_time;
  const circle::Tensor *bias;
  const circle::Tensor *activation_state;
 
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *weights_feature_data;
  uint8_t *weights_time_data;
  uint8_t *bias_data;
  uint8_t *activation_state_data;
  uint8_t *output_data;
  const circle::SVDFOptions *options = nullptr;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[inputTensorIdx];
    weights_feature = runtime_kernel.inputs[weightsFeatureTensorIdx];
    weights_time = runtime_kernel.inputs[weightsTimeTensorIdx];
    bias = runtime_kernel.inputs[biasTensorIdx];
    activation_state = runtime_kernel.inputs[inputActivationStateTensorIdx];
 
    output = runtime_kernel.outputs[outputTensorIdx];
 
    assert(input != nullptr);
    assert(weights_feature != nullptr);
    assert(weights_time != nullptr);
    // bias can be nullptr
    assert(activation_state != 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];
    weights_feature_data = runtime_kernel.inputs_data[weightsFeatureTensorIdx];
    weights_time_data = runtime_kernel.inputs_data[weightsTimeTensorIdx];
    bias_data = runtime_kernel.inputs_data[biasTensorIdx];
    activation_state_data = runtime_kernel.inputs_data[inputActivationStateTensorIdx];
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
 
    assert(input_data != nullptr);
    assert(weights_feature_data != nullptr);
    assert(weights_time_data != nullptr);
    // bias can be nullptr
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_SVDFOptions();
  }
 
  OMStatus status;
  OMRuntimeShape input_shape(input);
  OMRuntimeShape weights_feature_shape(weights_feature);
  OMRuntimeShape weights_time_shape(weights_time);
  OMRuntimeShape activation_state_shape(activation_state);
  OMRuntimeShape output_shape(output);
 
  // Define input constants based on input tensor definition above:
  const int rank = options->rank();
  const int input_size = input_shape.dims(1);
  const int batch_size = input_shape.dims(0);
  const int num_filters = weights_feature_shape.dims(0);
 
  const int num_units = num_filters / rank;
  const int memory_size = weights_time_shape.dims(1);
 
  const auto activation_state_size =
    activation_state_shape.flatSize() * sizeof(core::OMDataType(output->type()));
  status =
    core::memory::OMMemoryManager::allocateMemory(activation_state_size, &activation_state_data);
  if (status != Ok)
    return status;
 
  std::memset(activation_state_data, 0, activation_state_size);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      // Temporary buffer
      uint8_t *scratch_buffer;
      status = core::memory::OMMemoryManager::allocateMemory(
        batch_size * num_filters * sizeof(core::OMDataType(output->type())), &scratch_buffer);
 
      assert(status == Ok);
      if (status != Ok)
        return status;
      status = pal::SVDF(
        utils::castInputData<float>(input_data), utils::castInputData<float>(weights_feature_data),
        utils::castInputData<float>(weights_time_data), utils::castInputData<float>(bias_data),
        utils::castOutputData<float>(activation_state_data),
        utils::castOutputData<float>(scratch_buffer), utils::castOutputData<float>(output_data),
        rank, input_size, batch_size, num_filters, num_units, memory_size,
        options->fused_activation_function());
 
      status = core::memory::OMMemoryManager::deallocateMemory(scratch_buffer);
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      core::SVDFQuantParams params{};
      prepareQuantParams(params, input, weights_feature, weights_time, activation_state, output);
 
      params.rank = rank;
 
      status = pal::SVDF(
        params, utils::castInputData<int8_t>(input_data),
        utils::castInputData<int8_t>(weights_feature_data),
        utils::castInputData<int8_t>(weights_time_data), utils::castInputData<int32_t>(bias_data),
        utils::castOutputData<int8_t>(activation_state_data),
        utils::castOutputData<int8_t>(output_data), input_shape, weights_feature_shape,
        weights_time_shape, core::OMRuntimeShape(bias), output_shape);
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
      break;
    }
  }
 
  status = core::memory::OMMemoryManager::deallocateMemory(activation_state_data);
 
  return status;
}

◆ execute_kernel_CircleTanh()

OMStatus onert_micro::execute::execute_kernel_CircleTanh ( const OMExecuteArgs & execute_args )

Definition at line 29 of file Tanh.cpp.

{
  auto tanh_float_lambda = [](const core::OMRuntimeShape &input_shape, const float *input_data,
                              const core::OMRuntimeShape &output_shape, float *output_data) {
    return pal::Tanh(input_shape, input_data, output_shape, output_data);
  };
 
  return execute_math_common(execute_args, tanh_float_lambda);
}

References execute_math_common(), output_shape, and onert_micro::execute::pal::Tanh().

◆ execute_kernel_CircleTranspose()

OMStatus onert_micro::execute::execute_kernel_CircleTranspose ( const OMExecuteArgs & execute_args )

Definition at line 45 of file Transpose.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;
  const circle::Tensor *perm;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *perm_data;
  uint8_t *output_data;
 
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[kInputTensorIdx];
    perm = runtime_kernel.inputs[kPermTensorIdx];
    output = runtime_kernel.outputs[kOutputTensorIdx];
    assert(input != nullptr);
    assert(perm != 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[kInputTensorIdx];
    perm_data = runtime_kernel.inputs_data[kPermTensorIdx];
    output_data = runtime_kernel.outputs_data[kOutputTensorIdx];
    assert(input_data != nullptr);
    assert(perm_data != nullptr);
    assert(output_data != nullptr);
  }
  OMStatus status;
  OMRuntimeShape perm_shape(perm);
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  for (int idx = 0; idx < input_shape.dimensionsCount(); ++idx)
    assert(reinterpret_cast<int32_t *>(perm_data)[idx] >= 0 and
           perm_data[idx] < input_shape.dimensionsCount());
 
  core::TransposeParams params;
  params.perm_count = perm_shape.dims(0);
  for (int i = 0; i < params.perm_count; ++i)
    params.perm[i] = reinterpret_cast<int32_t *>(perm_data)[i];
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      status = pal::Transpose<float>(params, input_shape, reinterpret_cast<float *>(input_data),
                                     output_shape, reinterpret_cast<float *>(output_data));
      break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleTransposeConv()

OMStatus onert_micro::execute::execute_kernel_CircleTransposeConv ( const OMExecuteArgs & execute_args )

Definition at line 53 of file TransposeConv.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;
  const circle::Tensor *weight;
  const circle::Tensor *output;
 
  uint8_t *input_data;
  uint8_t *weight_data;
  uint8_t *bias_data;
  uint8_t *output_data;
 
  const circle::TransposeConvOptions *options;
  // Read kernel
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    input = runtime_kernel.inputs[kInputTensorIdx];
    weight = runtime_kernel.inputs[kWeightTensorIdx];
    output = runtime_kernel.outputs[kOutputTensorIdx];
    assert(input != nullptr);
    assert(weight != nullptr);
    // Bias can be 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[kInputTensorIdx];
    weight_data = runtime_kernel.inputs_data[kWeightTensorIdx];
    bias_data = runtime_kernel.inputs_data[kBiasTensorIdx];
    output_data = runtime_kernel.outputs_data[kOutputTensorIdx];
    assert(input_data != nullptr);
    assert(weight_data != nullptr);
    // Bias can be nullptr
    assert(output_data != nullptr);
 
    options = runtime_kernel.first_operator->builtin_options_as_TransposeConvOptions();
  }
 
  OMStatus status;
 
  int32_t padding_h = 0;
  int32_t padding_w = 0;
 
  OMRuntimeShape weight_shape(weight);
  OMRuntimeShape input_shape(input);
 
  const int input_width = input_shape.dims(2);
  const int input_height = input_shape.dims(1);
  const int weight_width = weight_shape.dims(2);
  const int weight_height = weight_shape.dims(1);
 
  // Note: Dilation height and width are always 1 for transpose_conv
  execute::computePaddingHeightWidth(options->stride_h(), options->stride_w(), 1, 1, input_height,
                                     input_width, weight_height, weight_width, options->padding(),
                                     &padding_h, &padding_w);
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
 
      FloatConv2D params{};
      status = calculateActivationRange(options->fused_activation_function(),
                                        &params.activation_min, &params.activation_max);
      params.stride_w = options->stride_w();
      params.stride_h = options->stride_h();
      params.dilation_width_factor = 1;
      params.dilation_height_factor = 1;
      params.pad_h = padding_h;
      params.pad_w = padding_w;
 
      if (status != Ok)
        return status;
 
      status = pal::TransposeConv<float>(
        &params, input_shape, core::utils::castInputData<float>(input_data), weight_shape,
        core::utils::castInputData<float>(weight_data),
        core::utils::castInputData<float>(bias_data), OMRuntimeShape(output),
        core::utils::castOutputData<float>(output_data));
      assert(status == Ok);
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleUnpack()

OMStatus onert_micro::execute::execute_kernel_CircleUnpack ( const OMExecuteArgs & execute_args )

Definition at line 45 of file Unpack.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;
  const circle::Tensor *output;
 
  uint8_t *input_data;
 
  // Read kernel
  const circle::UnpackOptions *options;
 
  core::SplitParams params{};
  {
    execute::OMRuntimeKernel runtime_kernel;
    OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
    if (status != Ok)
      return status;
 
    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];
    assert(input_data != nullptr);
    options = runtime_kernel.first_operator->builtin_options_as_UnpackOptions();
 
    params.num_outputs = options->num();
 
    for (uint32_t i = 0; i < params.num_outputs; ++i)
    {
      params.output_data[i] = runtime_kernel.outputs_data[i];
    }
  }
  OMStatus status;
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  int32_t axis_value = options->axis();
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
      status =
        pal::Unpack<float>(params, input_shape, core::utils::castInputData<float>(input_data),
                           output_shape, axis_value);
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
      status =
        pal::Unpack<int8_t>(params, input_shape, core::utils::castInputData<int8_t>(input_data),
                            output_shape, axis_value);
      break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedActivation;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_kernel_CircleWhile()

OMStatus onert_micro::execute::execute_kernel_CircleWhile ( const OMExecuteArgs & execute_args )

Definition at line 33 of file While.cpp.

{
  core::OMRuntimeModule &runtime_module = execute_args.runtime_module;
  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);
  auto options = runtime_kernel.first_operator->builtin_options_as_WhileOptions();
 
  // Obtain conditional and body runtime subgraphs
  const auto body_subgraph_index = options->body_subgraph_index();
  const auto cond_subgraph_index = options->cond_subgraph_index();
  core::OMRuntimeGraph *cond_runtime_graph = nullptr;
  core::OMRuntimeGraph *body_runtime_graph = nullptr;
  runtime_module.getRuntimeGraphAt(cond_subgraph_index, &cond_runtime_graph);
  runtime_module.getRuntimeGraphAt(body_subgraph_index, &body_runtime_graph);
 
  core::OMRuntimeContext &cond_runtime_context = cond_runtime_graph->getRuntimeContext();
  core::OMRuntimeStorage &cond_runtime_storage = cond_runtime_graph->getRuntimeStorage();
  core::memory::OMRuntimeAllocator &cond_runtime_allocator =
    cond_runtime_graph->getRuntimeAllocator();
 
  core::OMRuntimeContext &body_runtime_context = body_runtime_graph->getRuntimeContext();
  core::OMRuntimeStorage &body_runtime_storage = body_runtime_graph->getRuntimeStorage();
  core::memory::OMRuntimeAllocator &body_runtime_allocator =
    body_runtime_graph->getRuntimeAllocator();
 
  OMStatus status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  if (status != Ok)
    return status;
 
  // Copy input data to the output
  assert(runtime_kernel.inputs_num == runtime_kernel.outputs_num);
  for (uint32_t i = 0; i < runtime_kernel.inputs_num; ++i)
  {
    const auto cur_input_tensor = runtime_kernel.inputs[i];
    const auto input_data_size = sizeof(core::OMDataType(cur_input_tensor->type())) *
                                 core::OMRuntimeShape(cur_input_tensor).flatSize();
    std::memcpy(runtime_kernel.outputs_data[i], runtime_kernel.inputs_data[i], input_data_size);
  }
 
  do
  {
    // Handle conditional graph
    {
      // Allocate cond graph inputs
      cond_runtime_graph->allocateGraphInputs();
      auto cond_graphs_inputs = cond_runtime_graph->getNumberOfInputs();
      for (uint32_t i = 0; i < cond_graphs_inputs; ++i)
      {
        auto *cur_cond_input_data =
          reinterpret_cast<uint8_t *>(cond_runtime_graph->getInputDataAt(i));
        uint8_t *cur_main_input_data = runtime_kernel.outputs_data[i];
        assert(cur_main_input_data != nullptr);
        assert(cur_cond_input_data != nullptr);
        const auto cur_input_tensor = runtime_kernel.inputs[i];
        const auto input_data_size = sizeof(core::OMDataType(cur_input_tensor->type())) *
                                     core::OMRuntimeShape(cur_input_tensor).flatSize();
        std::memcpy(cur_cond_input_data, cur_main_input_data, input_data_size);
      }
      // Run cond graph
      execute::OMExecuteArgs cond_execute_args = {cond_runtime_storage, cond_runtime_context, 0,
                                                  runtime_module};
      status = execute::OMKernelExecute::runForward(cond_execute_args, cond_runtime_allocator);
      if (status != Ok)
        return status;
 
      // Check cond graph result
      bool cond_result_value = reinterpret_cast<bool *>(cond_runtime_graph->getOutputDataAt(0))[0];
      // Reset cond graph values
      cond_runtime_graph->reset();
      // If false - then finish while loop
      if (cond_result_value == false)
        break;
    }
 
    // Handle body graph
    {
      // Allocate body graph inputs
      body_runtime_graph->allocateGraphInputs();
      // Copy data
      auto body_graphs_inputs = body_runtime_graph->getNumberOfInputs();
      for (uint32_t i = 0; i < body_graphs_inputs; ++i)
      {
        auto *cur_body_input_data =
          reinterpret_cast<uint8_t *>(body_runtime_graph->getInputDataAt(i));
        uint8_t *cur_main_input_data = runtime_kernel.outputs_data[i];
        assert(cur_main_input_data != nullptr);
        assert(cur_body_input_data != nullptr);
        const auto cur_input_tensor = runtime_kernel.inputs[i];
        const auto input_data_size = sizeof(core::OMDataType(cur_input_tensor->type())) *
                                     core::OMRuntimeShape(cur_input_tensor).flatSize();
        std::memcpy(cur_body_input_data, cur_main_input_data, input_data_size);
      }
      // Run body graph
      execute::OMExecuteArgs body_execute_args = {body_runtime_storage, body_runtime_context, 0,
                                                  runtime_module};
      status = execute::OMKernelExecute::runForward(body_execute_args, body_runtime_allocator);
      if (status != Ok)
        return status;
 
      // Copy body calculated data to the main output
      for (uint32_t i = 0; i < runtime_kernel.inputs_num; ++i)
      {
        auto cur_calculated_data = body_runtime_graph->getOutputDataAt(i);
        const auto cur_tensor = runtime_kernel.outputs[i];
        const auto data_size = sizeof(core::OMDataType(cur_tensor->type())) *
                               core::OMRuntimeShape(cur_tensor).flatSize();
        std::memcpy(runtime_kernel.outputs_data[i], cur_calculated_data, data_size);
      }
 
      body_runtime_graph->reset();
    }
  } while (true);
 
  return status;
}

◆ execute_kernel_CircleZerosLike()

OMStatus onert_micro::execute::execute_kernel_CircleZerosLike ( const OMExecuteArgs & execute_args )

Definition at line 48 of file ZerosLike.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;
  uint8_t *output_data = nullptr;
 
  OMStatus status = Ok;
  {
    OMRuntimeKernel runtime_kernel;
    runtime_kernel.readKernel(op_index, runtime_context);
 
    input = runtime_kernel.inputs[inputTensorIdx];
 
    assert(input != nullptr);
 
    status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
    if (status != Ok)
      return status;
 
    output_data = runtime_kernel.outputs_data[outputTensorIdx];
  }
 
  assert(output_data != nullptr);
 
  core::OMRuntimeShape input_shape(input);
  const int flat_size = input_shape.flatSize();
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      resetZeros(core::utils::castOutputData<float>(output_data), flat_size);
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      resetZeros(core::utils::castOutputData<int8_t>(output_data), flat_size);
    }
    break;
#endif // DIS_QUANT
 
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
      break;
    }
  }
 
  return status;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMExecuteArgs::kernel_index, onert_micro::Ok, 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() [1/2]

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

Definition at line 39 of file MathCommon.cpp.

{
  const circle::Tensor *input = nullptr;
  const circle::Tensor *output = nullptr;
 
  uint8_t *input_data = nullptr;
  uint8_t *output_data = nullptr;
 
  SISOHeader(execute_args, &input, &output, &input_data, &output_data);
 
  OMStatus status;
  switch (input->type())
  {
#ifndef DIS_FLOAT
 
    case circle::TensorType_FLOAT32:
      status =
        f_float(core::OMRuntimeShape(input), core::utils::castInputData<float>(input_data),
                core::OMRuntimeShape(output), core::utils::castOutputData<float>(output_data));
      break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

References SISOHeader(), and onert_micro::UnsupportedType.

◆ execute_math_common() [2/2]

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
	)

Referenced by execute_kernel_CircleAbs(), execute_kernel_CircleCeil(), execute_kernel_CircleCos(), execute_kernel_CircleExp(), execute_kernel_CircleFloor(), execute_kernel_CircleLog(), execute_kernel_CircleNeg(), execute_kernel_CircleRound(), execute_kernel_CircleRsqrt(), execute_kernel_CircleSin(), execute_kernel_CircleSqrt(), execute_kernel_CircleSquare(), and execute_kernel_CircleTanh().

◆ execute_pooling_common() [1/2]

OMStatus onert_micro::execute::execute_pooling_common	(	const OMExecuteArgs &	execute_args,
		const std::function< OMStatus(const core::Pool2DParams &, const core::OMRuntimeShape &, const float , const core::OMRuntimeShape &, float )> &	f_float,
		const std::function< OMStatus(const core::Pool2DParams &, const core::OMRuntimeShape &, const int8_t , const core::OMRuntimeShape &, int8_t )> &	f_int8
	)

Definition at line 36 of file PoolingCommon.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;
 
  const circle::Pool2DOptions *options = nullptr;
  {
    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];
 
    options = runtime_kernel.first_operator->builtin_options_as_Pool2DOptions();
  }
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
  assert(options != nullptr);
 
  core::OMRuntimeShape input_shape(input);
 
  int32_t padding_h = 0;
  int32_t padding_w = 0;
 
  const int input_width = input_shape.dims(2);
  const int input_height = input_shape.dims(1);
  execute::computePaddingHeightWidth(
    options->stride_h(), options->stride_w(), 1 /* dilation_rate_height */,
    1 /* dilation_rate_width */, input_height, input_width, options->filter_height(),
    options->filter_width(), options->padding(), &padding_h, &padding_w);
 
  core::Pool2DParams params{};
  params.pad_h = padding_h;
  params.pad_w = padding_w;
  params.stride_h = options->stride_h();
  params.stride_w = options->stride_w();
  params.filter_h = options->filter_height();
  params.filter_w = options->filter_width();
 
  switch (input->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      calculateActivationRange(options->fused_activation_function(), &params.activation_min,
                               &params.activation_max);
      status =
        f_float(params, input_shape, core::utils::castInputData<float>(input_data),
                core::OMRuntimeShape(output), core::utils::castOutputData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case circle::TensorType_INT8:
    {
      assert(output->quantization() != nullptr);
      assert(output->quantization()->scale() != nullptr);
      assert(output->quantization()->scale()->size() == 1);
      const auto output_scale = output->quantization()->scale()->operator[](0);
 
      assert(output->quantization()->zero_point() != nullptr);
      assert(output->quantization()->zero_point()->size() == 1);
      const auto output_zp = output->quantization()->zero_point()->operator[](0);
 
      calculateActivationRangeQuantized(
        options->fused_activation_function(), output_zp, output_scale, output->type(),
        &params.quantized_activation_min, &params.quantized_activation_max);
      status =
        f_int8(params, input_shape, core::utils::castInputData<int8_t>(input_data),
               core::OMRuntimeShape(output), core::utils::castOutputData<int8_t>(output_data));
    }
    break;
#endif // DIS_QUANT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ execute_pooling_common() [2/2]

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
	)

Referenced by execute_kernel_CircleAveragePool2D(), execute_kernel_CircleL2Pool2D(), and execute_kernel_CircleMaxPool2D().

◆ execute_relu_common()

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

Definition at line 37 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;
}

Referenced by execute_kernel_CircleLeakyRelu(), execute_kernel_CircleRelu(), and execute_kernel_CircleRelu6().

◆ execute_reshape_common()

OMStatus onert_micro::execute::execute_reshape_common ( const OMExecuteArgs & execute_args )

Definition at line 36 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;
}

Referenced by execute_kernel_CircleExpandDims(), and execute_kernel_CircleReshape().

◆ execute_spaces_batches_nd_common() [1/2]

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
	)

Referenced by execute_kernel_CircleBatchToSpaceND(), and execute_kernel_CircleSpaceToBatchND().

◆ execute_spaces_batches_nd_common() [2/2]

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)> &	func
	)

Definition at line 38 of file SpacesBatchesNDCommon.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 *input1;
  const circle::Tensor *input2;
  const circle::Tensor *input3;
  const circle::Tensor *output;
 
  uint8_t *input1_data;
  uint8_t *input2_data;
  uint8_t *input3_data;
  uint8_t *output_data;
 
  uint16_t input1_index = 0;
  uint16_t input2_index = 0;
 
  // Read kernel
 
  execute::OMRuntimeKernel runtime_kernel;
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  input1 = runtime_kernel.inputs[input1TensorIdx];
  input2 = runtime_kernel.inputs[input2TensorIdx];
  input3 = runtime_kernel.inputs[input3TensorIdx];
  output = runtime_kernel.outputs[outputTensorIdx];
 
  core::OMRuntimeShape input1_shape(input1);
  core::OMRuntimeShape input2_shape(input1);
  core::OMRuntimeShape input3_shape(input1);
  core::OMRuntimeShape output_shape(output);
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(input3 != nullptr);
  assert(output != nullptr);
 
  status = runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  if (status != Ok)
    return status;
 
  input1_data = runtime_kernel.inputs_data[input1TensorIdx];
  input2_data = runtime_kernel.inputs_data[input2TensorIdx];
  input3_data = runtime_kernel.inputs_data[input3TensorIdx];
  output_data = runtime_kernel.outputs_data[outputTensorIdx];
 
  switch (input1->type())
  {
#ifndef DIS_FLOAT
    case circle::TensorType_FLOAT32:
    {
      status = func(input1_shape, reinterpret_cast<float *>(input1_data), input2_shape,
                    reinterpret_cast<int32_t *>(input2_data), input3_shape,
                    reinterpret_cast<int32_t *>(input3_data), output_shape,
                    reinterpret_cast<float *>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
    {
      status = UnsupportedType;
      assert(false && "Unsupported type.");
    }
  }
 
  return status;
}

◆ 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 37 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.

Referenced by execute_kernel_CircleFloorDiv(), execute_kernel_CircleFloorMod(), execute_kernel_CircleGatherND(), execute_kernel_CircleMaximum(), and execute_kernel_CircleMinimum().

◆ 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;
}

Referenced by execute_kernel_CircleCast(), execute_kernel_CircleDequantize(), execute_kernel_CircleL2Normalize(), execute_kernel_CircleLogistic(), execute_kernel_CircleLogSoftmax(), execute_kernel_CircleQuantize(), and execute_math_common().

◆ 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.

Referenced by execute_kernel_CircleEqual(), execute_kernel_CircleGreater(), execute_kernel_CircleGreaterEqual(), execute_kernel_CircleLess(), and execute_kernel_CircleNotEqual().

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().

Namespaces

Data Structures

Typedefs

Functions

Variables

Typedef Documentation

◆ KernelExecuteFunc

Function Documentation

◆ calculateActivationRange()

◆ calculateActivationRangeQuantized()

◆ calculateInputRadius()

◆ calculateQuantParams()

◆ computeOutSize()

◆ computePadding()

◆ computePaddingHeightWidth()

◆ createConvParams()

◆ evalComparisonGeneric()

◆ evalQuantizedComparisonGeneric()

◆ execute_arg_common()

◆ execute_kernel_CircleAbs()

◆ execute_kernel_CircleAdd()

◆ execute_kernel_CircleAddN()

◆ execute_kernel_CircleArgMax()

◆ execute_kernel_CircleArgMin()

◆ execute_kernel_CircleAveragePool2D()

◆ execute_kernel_CircleBatchToSpaceND()

◆ execute_kernel_CircleCast()

◆ execute_kernel_CircleCeil()

◆ execute_kernel_CircleConcatenation()

◆ execute_kernel_CircleConv2D()

◆ execute_kernel_CircleCos()

◆ execute_kernel_CircleDepthwiseConv2D()

◆ execute_kernel_CircleDequantize()

◆ execute_kernel_CircleDiv()

◆ execute_kernel_CircleElu()

◆ execute_kernel_CircleEqual()

◆ execute_kernel_CircleExp()

◆ execute_kernel_CircleExpandDims()

◆ execute_kernel_CircleFill()

◆ execute_kernel_CircleFloor()

◆ execute_kernel_CircleFloorDiv()

◆ execute_kernel_CircleFloorMod()

◆ execute_kernel_CircleFullyConnected()

◆ execute_kernel_CircleGather()

◆ execute_kernel_CircleGatherND()

◆ execute_kernel_CircleGreater()

◆ execute_kernel_CircleGreaterEqual()

◆ execute_kernel_CircleGRU()

◆ execute_kernel_CircleL2Normalize()

◆ execute_kernel_CircleL2Pool2D()

◆ execute_kernel_CircleLeakyRelu()

◆ execute_kernel_CircleLess()

◆ execute_kernel_CircleLessEqual()

◆ execute_kernel_CircleLog()

◆ execute_kernel_CircleLogistic()

◆ execute_kernel_CircleLogSoftmax()

◆ execute_kernel_CircleMaximum()

◆ execute_kernel_CircleMaxPool2D()

◆ execute_kernel_CircleMean()

◆ execute_kernel_CircleMinimum()

◆ execute_kernel_CircleMul()

◆ execute_kernel_CircleNeg()

◆ execute_kernel_CircleNotEqual()

◆ execute_kernel_CirclePack()

◆ execute_kernel_CirclePad()

◆ execute_kernel_CircleQuantize()

◆ execute_kernel_CircleReduceProd()

◆ execute_kernel_CircleRelu()

◆ execute_kernel_CircleRelu6()

◆ execute_kernel_CircleReshape()

◆ execute_kernel_CircleRound()

◆ execute_kernel_CircleRsqrt()

◆ execute_kernel_CircleSelectV2()

◆ execute_kernel_CircleShape()

◆ execute_kernel_CircleSin()

◆ execute_kernel_CircleSlice()

◆ execute_kernel_CircleSoftmax()

◆ execute_kernel_CircleSpaceToBatchND()

◆ execute_kernel_CircleSpaceToDepth()

◆ execute_kernel_CircleSplit()