onert_micro::import Namespace Reference

Namespaces
namespace	helpers

Data Structures
class	KernelBuiltinConfigureRegistry
class	KernelCustomConfigureRegistry
struct	OMConfigureArgs
struct	OMDynamicShapesHandler
struct	OMExecutionPlanCreator
struct	OMKernelConfiguration

Typedefs
using	KernelConfigureFunc = OMStatus(const OMConfigureArgs &)

Functions
OMStatus	SISOHeader (const OMConfigureArgs &execute_args, const circle::Tensor **input, const circle::Tensor **output)
OMStatus	TISOHeader (const OMConfigureArgs &execute_args, const circle::Tensor **input1, const circle::Tensor **input2, const circle::Tensor **output)
OMStatus	configure_kernel_CircleAbs (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleAdd (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleAddN (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleArgMax (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleArgMin (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleAveragePool2D (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleBatchToSpaceND (const onert_micro::import::OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleCast (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleCeil (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleConcatenation (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleConv2D (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleCos (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleDepthwiseConv2D (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleDequantize (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleDiv (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleElu (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleEqual (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleExp (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleExpandDims (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleFill (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleFloor (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleFloorDiv (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleFloorMod (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleFullyConnected (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleGather (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleGatherND (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleGreater (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleGreaterEqual (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleGRU (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleL2Normalize (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleL2Pool2D (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleLeakyRelu (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleLess (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleLessEqual (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleLog (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleLogistic (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleLogSoftmax (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleMaximum (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleMaxPool2D (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleMean (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleMinimum (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleMul (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleNeg (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleNotEqual (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CirclePack (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CirclePad (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleQuantize (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleReduceProd (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleRelu (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleRelu6 (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleReshape (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleRound (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleRsqrt (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSelectV2 (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleShape (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSin (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSlice (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSoftmax (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSpaceToBatchND (const onert_micro::import::OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSpaceToDepth (const onert_micro::import::OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSplit (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSplitV (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSqrt (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSquare (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSquaredDifference (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleStridedSlice (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSub (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSum (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleSVDF (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleTanh (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleTranspose (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleTransposeConv (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleUnpack (const OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleWhile (const onert_micro::import::OMConfigureArgs &config_args)
OMStatus	configure_kernel_CircleZerosLike (const OMConfigureArgs &config_args)

Variables
constexpr KernelBuiltinConfigureRegistry	kernel_builtin_configure
constexpr KernelCustomConfigureRegistry	kernel_custom_configure

Typedef Documentation

KernelConfigureFunc

using onert_micro::import::KernelConfigureFunc = typedef OMStatus(const OMConfigureArgs &)

Definition at line 33 of file OMKernelConfigureBuilder.h.

Function Documentation

configure_kernel_CircleAbs()

OMStatus onert_micro::import::configure_kernel_CircleAbs

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Abs.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleAdd()

OMStatus onert_micro::import::configure_kernel_CircleAdd

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Add.cpp.

{
  return import::helpers::configure_TISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_TISO_kernel().

configure_kernel_CircleAddN()

OMStatus onert_micro::import::configure_kernel_CircleAddN

(

const OMConfigureArgs &

config_args

)

Definition at line 38 of file AddN.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const auto kInputsNum = runtime_kernel.inputs_num;
 
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
  assert(output != nullptr);
  const circle::Tensor *input1 = runtime_kernel.inputs[input1TensorIdx];
  assert(input1 != nullptr);
  const OMRuntimeShape input1_shape(input1);
 
  for (int idx = 1; idx < kInputsNum; ++idx)
  {
    const circle::Tensor *input = runtime_kernel.inputs[idx];
    assert(input != nullptr);
    status = utils::checkCondition(input1->type() == input->type());
    if (status != Ok)
      return status;
  }
 
  status = utils::checkCondition(input1->type() == output->type());
  if (status != Ok)
    return status;
 
  for (int idx = 1; idx < kInputsNum; ++idx)
  {
    const circle::Tensor *input = runtime_kernel.inputs[idx];
    assert(input != nullptr);
    const OMRuntimeShape input_shape(input);
    status = utils::checkCondition(input_shape == input1_shape);
    if (status != Ok)
      return status;
  }
 
  status = utils::checkCondition(input1->type() != circle::TensorType_INT8 and
                                 input1->type() != circle::TensorType_INT16);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_num, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleArgMax()

OMStatus onert_micro::import::configure_kernel_CircleArgMax

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file ArgMax.cpp.

{
  return helpers::configure_arg_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_arg_kernel_common().

configure_kernel_CircleArgMin()

OMStatus onert_micro::import::configure_kernel_CircleArgMin

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file ArgMin.cpp.

{
  return helpers::configure_arg_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_arg_kernel_common().

configure_kernel_CircleAveragePool2D()

OMStatus onert_micro::import::configure_kernel_CircleAveragePool2D

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file AveragePool2D.cpp.

{
  return import::helpers::configure_pooling_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_pooling_kernel_common().

configure_kernel_CircleBatchToSpaceND()

OMStatus onert_micro::import::configure_kernel_CircleBatchToSpaceND

(

const onert_micro::import::OMConfigureArgs &

config_args

)

Definition at line 28 of file BatchToSpaceND.cpp.

{
  return helpers::configure_spaces_batches_nd_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_spaces_batches_nd_kernel_common().

configure_kernel_CircleCast()

OMStatus onert_micro::import::configure_kernel_CircleCast

(

const OMConfigureArgs &

config_args

)

Definition at line 38 of file Cast.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  // Check shapes
  status = utils::checkCondition(input_shape == output_shape);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleCeil()

OMStatus onert_micro::import::configure_kernel_CircleCeil

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Ceil.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleConcatenation()

OMStatus onert_micro::import::configure_kernel_CircleConcatenation

(

const OMConfigureArgs &

config_args

)

Definition at line 32 of file Concatenation.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const int num_inputs = runtime_kernel.inputs_num;
 
  const auto *t0 = runtime_kernel.inputs[0];
  const auto *output = runtime_kernel.outputs[0];
 
  const auto *params = runtime_kernel.first_operator->builtin_options_as_ConcatenationOptions();
 
  // TODO: Support concat with fused activation function
  if (params->fused_activation_function() != circle::ActivationFunctionType_NONE)
    return UnknownError;
 
  OMRuntimeShape input_shape(t0);
  int axis = params->axis();
  if (axis < 0)
    axis += input_shape.dimensionsCount();
 
  if (axis < 0 or axis > input_shape.dimensionsCount())
    return FailedCheckCondition;
 
  for (int i = 1; i < num_inputs; ++i)
  {
    const auto *tensor = runtime_kernel.inputs[i];
    if (tensor->type() != t0->type())
      return FailedCheckCondition;
  }
 
  if (t0->type() != circle::TensorType_INT8 and t0->type() != circle::TensorType_INT16)
    return Ok;
 
#ifndef DIS_QUANT
  // If input tensors are INT8 or INT16 type then quantization parameters of all input tensors and
  // the output should be the same
  for (int i = 0; i < num_inputs; ++i)
  {
    const auto *tensor = runtime_kernel.inputs[i];
 
    if (tensor->quantization() == nullptr)
      return FailedCheckCondition;
 
    if (tensor->quantization()->scale()->size() != 1)
      return FailedCheckCondition;
 
    if (tensor->quantization()->zero_point()->size() != 1)
      return FailedCheckCondition;
 
    if (*tensor->quantization()->scale()->begin() != *output->quantization()->scale()->begin())
      return FailedCheckCondition;
 
    if (*tensor->quantization()->zero_point()->begin() !=
        *output->quantization()->zero_point()->begin())
      return FailedCheckCondition;
  }
#endif // DIS_QUANT
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::FailedCheckCondition, onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_num, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::UnknownError.

configure_kernel_CircleConv2D()

OMStatus onert_micro::import::configure_kernel_CircleConv2D

(

const OMConfigureArgs &

config_args

)

Definition at line 46 of file Conv2D.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *weight = runtime_kernel.inputs[weightTensorIdx];
  const circle::Tensor *bias = runtime_kernel.inputs[biasTensorIdx];
 
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(weight != nullptr);
  // Bias can be nullptr
  assert(output != nullptr);
 
  OMStatus status = Ok;
 
  if ((input->type() == circle::TensorType_FLOAT32 &&
       weight->type() != circle::TensorType_FLOAT32) or
      (input->type() == circle::TensorType_INT8 && weight->type() != circle::TensorType_INT8) or
      (input->type() == circle::TensorType_INT16 && weight->type() != circle::TensorType_INT16))
  {
    return UnsupportedType;
  }
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape weight_shape(weight);
  core::OMRuntimeShape bias_shape(bias);
  core::OMRuntimeShape output_shape(output);
 
  status = utils::checkCondition(input_shape.dimensionsCount() == 4);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_shape.dimensionsCount() == output_shape.dimensionsCount());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_shape.dimensionsCount() == weight_shape.dimensionsCount());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(bias == nullptr or weight_shape.dims(0) == bias_shape.flatSize());
 
  if (input->type() == circle::TensorType_FLOAT32)
    return status;
 
  auto input_quant = input->quantization();
  auto filter_quant = weight->quantization();
  auto output_quant = output->quantization();
 
  status = utils::checkCondition(input_quant != nullptr and filter_quant != nullptr and
                                 output_quant != nullptr);
  if (status != Ok)
    return status;
 
  auto input_scales = input_quant->scale();
  auto filter_scales = filter_quant->scale();
  auto output_scales = output_quant->scale();
 
  status = utils::checkCondition(input_scales != nullptr and filter_scales != nullptr and
                                 output_scales != nullptr);
  if (status != Ok)
    return status;
 
  // Support only per channel
  status = utils::checkCondition(filter_scales->size() > 1);
  if (status != Ok)
    return status;
 
  return status;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::UnsupportedType.

configure_kernel_CircleCos()

OMStatus onert_micro::import::configure_kernel_CircleCos

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Cos.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleDepthwiseConv2D()

OMStatus onert_micro::import::configure_kernel_CircleDepthwiseConv2D

(

const OMConfigureArgs &

config_args

)

Definition at line 46 of file DepthwiseConv2D.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *weight = runtime_kernel.inputs[weightTensorIdx];
  const circle::Tensor *bias = runtime_kernel.inputs[biasTensorIdx];
 
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(weight != nullptr);
  // Bias can be nullptr
  assert(output != nullptr);
 
  OMStatus status = Ok;
  const auto *options = runtime_kernel.first_operator->builtin_options_as_DepthwiseConv2DOptions();
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape weight_shape(weight);
  core::OMRuntimeShape bias_shape(bias);
  core::OMRuntimeShape output_shape(output);
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input->type() == weight->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_shape.dimensionsCount() == 4);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_shape.dimensionsCount() == output_shape.dimensionsCount());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_shape.dimensionsCount() == weight_shape.dimensionsCount());
  if (status != Ok)
    return status;
 
  const auto output_depth = output_shape.dims(3);
 
  status = utils::checkCondition(
    bias == nullptr or (bias_shape.dimensionsCount() == 1 && bias_shape.dims(0) == output_depth));
  if (status != Ok)
    return status;
 
  switch (options->fused_activation_function())
  {
    case circle::ActivationFunctionType_NONE:
    case circle::ActivationFunctionType_RELU:
    case circle::ActivationFunctionType_RELU6:
    case circle::ActivationFunctionType_RELU_N1_TO_1:
      break;
    default:
      return UnsupportedActivation;
  }
 
  if (input->type() == circle::TensorType_FLOAT32)
  {
    status = utils::checkCondition(bias == nullptr or input->type() == bias->type());
    return status;
  }
 
  auto input_quant = input->quantization();
  auto filter_quant = weight->quantization();
  auto output_quant = output->quantization();
 
  status = utils::checkCondition(input_quant != nullptr and filter_quant != nullptr and
                                 output_quant != nullptr);
  if (status != Ok)
    return status;
 
  auto input_scales = input_quant->scale();
  auto filter_scales = filter_quant->scale();
  auto output_scales = output_quant->scale();
 
  status = utils::checkCondition(input_scales != nullptr and filter_scales != nullptr and
                                 output_scales != nullptr);
  if (status != Ok)
    return status;
 
  // Support only per channel
  status = utils::checkCondition(filter_scales->size() > 1);
  if (status != Ok)
    return status;
 
  return status;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::UnsupportedActivation.

configure_kernel_CircleDequantize()

OMStatus onert_micro::import::configure_kernel_CircleDequantize

(

const OMConfigureArgs &

config_args

)

Definition at line 38 of file Dequantize.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  // Check shapes
  status = utils::checkCondition(input_shape == output_shape);
  if (status != Ok)
    return status;
 
  // Check output type is float
  status = utils::checkCondition(output->type() == circle::TensorType_FLOAT32);
  if (status != Ok)
    return status;
 
  // Check input quantization params
  const auto *input_quantization = input->quantization();
  status = utils::checkCondition(input->type() != circle::TensorType_FLOAT32 or
                                 input_quantization != nullptr and
                                   input_quantization->scale() != nullptr and
                                   input_quantization->scale()->size() == 1);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleDiv()

OMStatus onert_micro::import::configure_kernel_CircleDiv

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Div.cpp.

{
  return import::helpers::configure_TISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_TISO_kernel().

configure_kernel_CircleElu()

OMStatus onert_micro::import::configure_kernel_CircleElu

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Elu.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleEqual()

OMStatus onert_micro::import::configure_kernel_CircleEqual

(

const OMConfigureArgs &

config_args

)

Definition at line 42 of file Equal.cpp.

{
  const circle::Tensor *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  TISOHeader(config_args, &input1, &input2, &output);
 
  OMStatus status;
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(output->type() == circle::TensorType_BOOL);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::Ok, and TISOHeader().

configure_kernel_CircleExp()

OMStatus onert_micro::import::configure_kernel_CircleExp

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Exp.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleExpandDims()

OMStatus onert_micro::import::configure_kernel_CircleExpandDims

(

const OMConfigureArgs &

config_args

)

Definition at line 40 of file ExpandDims.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
  OMRuntimeStorage &runtime_storage = config_args.runtime_storage;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *axis = runtime_kernel.inputs[axisTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(axis != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  OMRuntimeShape input_shape(input);
 
  status = utils::checkCondition(axis->type() == circle::TensorType_INT32 or
                                 axis->type() == circle::TensorType_INT64);
  if (status != Ok)
    return status;
 
  // Check axis value
  runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  uint8_t *axis_data = runtime_kernel.inputs_data[axisTensorIdx];
  status = utils::checkCondition(axis_data != nullptr);
  if (status != Ok)
    return status;
 
  if (axis->type() == circle::TensorType_INT32)
  {
    int32_t axis_value = *reinterpret_cast<int32_t *>(axis_data);
    if (axis_value < 0)
    {
      axis_value += input_shape.dimensionsCount() + 1;
    }
 
    status = utils::checkCondition(axis_value <= input_shape.dimensionsCount() and axis_value >= 0);
    if (status != Ok)
      return status;
  }
  else
  {
    int64_t axis_value = *reinterpret_cast<int64_t *>(axis_data);
    if (axis_value < 0)
    {
      axis_value += input_shape.dimensionsCount() + 1;
    }
 
    status = utils::checkCondition(axis_value <= input_shape.dimensionsCount() and axis_value >= 0);
    if (status != Ok)
      return status;
  }
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::import::OMConfigureArgs::runtime_storage.

configure_kernel_CircleFill()

OMStatus onert_micro::import::configure_kernel_CircleFill

(

const OMConfigureArgs &

config_args

)

Definition at line 40 of file Fill.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input1 = runtime_kernel.inputs[input1TensorIdx];
  const circle::Tensor *input2 = runtime_kernel.inputs[input2TensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input1->type() == circle::TensorType_INT32 or
                                 input1->type() == circle::TensorType_INT64);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input2->type() == output->type());
  if (status != Ok)
    return status;
 
  OMRuntimeShape value_shape(input2);
  status = utils::checkCondition(value_shape.dimensionsCount() == 0 or value_shape.flatSize() == 1);
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleFloor()

OMStatus onert_micro::import::configure_kernel_CircleFloor

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Floor.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleFloorDiv()

OMStatus onert_micro::import::configure_kernel_CircleFloorDiv

(

const OMConfigureArgs &

config_args

)

Definition at line 36 of file FloorDiv.cpp.

{
  return onert_micro::import::helpers::configure_floor_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_floor_kernel_common().

configure_kernel_CircleFloorMod()

OMStatus onert_micro::import::configure_kernel_CircleFloorMod

(

const OMConfigureArgs &

config_args

)

Definition at line 36 of file FloorMod.cpp.

{
  return onert_micro::import::helpers::configure_floor_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_floor_kernel_common().

configure_kernel_CircleFullyConnected()

OMStatus onert_micro::import::configure_kernel_CircleFullyConnected

(

const OMConfigureArgs &

config_args

)

Definition at line 45 of file FullyConnected.cpp.

{
 
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
  OMRuntimeStorage &runtime_storage = config_args.runtime_storage;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *weight = runtime_kernel.inputs[weightTensorIdx];
  const circle::Tensor *bias = runtime_kernel.inputs[biasTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(weight != nullptr);
  // Bias can be nullptr
  assert(output != nullptr);
 
  OMStatus status = Ok;
 
#ifndef DIS_FLOAT
  if (weight->type() == circle::TensorType_FLOAT32)
  {
 
    status = utils::checkCondition(input->type() == circle::TensorType_FLOAT32 and
                                   output->type() == circle::TensorType_FLOAT32 and
                                   (!bias or bias->type() == circle::TensorType_FLOAT32));
    if (status != Ok)
      return status;
  }
#endif // DIS_FLOAT
#ifndef DIS_QUANT
  if (weight->type() == circle::TensorType_UINT8)
  {
 
    status = utils::checkCondition(input->type() == circle::TensorType_UINT8 and
                                   output->type() == circle::TensorType_UINT8 and
                                   (!bias or bias->type() == circle::TensorType_INT32));
    if (status != Ok)
      return status;
  }
  else if (weight->type() == circle::TensorType_INT8)
  {
    status = utils::checkCondition(input->type() == circle::TensorType_INT8 or
                                   input->type() == circle::TensorType_FLOAT32);
    if (status != Ok)
      return status;
 
    status = utils::checkCondition(output->type() == circle::TensorType_INT8 or
                                   output->type() == circle::TensorType_FLOAT32);
    if (status != Ok)
      return status;
 
    status = utils::checkCondition(!bias or bias->type() == circle::TensorType_INT32 or
                                   bias->type() == circle::TensorType_INT64 or
                                   bias->type() == circle::TensorType_FLOAT32);
    if (status != Ok)
      return status;
 
    if (input->type() == circle::TensorType_FLOAT32)
    {
      // hybrid mode
      // Check it is channel wise quantization
      status = utils::checkCondition(weight->quantization() != nullptr and
                                     weight->quantization()->scale() != nullptr);
      if (status != Ok)
        return status;
    }
  }
  else if (weight->type() == circle::TensorType_INT16)
  {
 
    status = utils::checkCondition(input->type() == circle::TensorType_INT16 and
                                   output->type() == circle::TensorType_INT16 and
                                   (!bias or bias->type() == circle::TensorType_INT32));
    if (status != Ok)
      return status;
  }
#endif // DIS_QUANT
 
  core::OMRuntimeShape weight_shape(weight);
  core::OMRuntimeShape bias_shape(bias);
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape output_shape(output);
 
  status = utils::checkCondition(weight_shape.dimensionsCount() == 2);
  if (status != Ok)
    return status;
 
  if (input_shape.flatSize() == 1 and output_shape.flatSize() != 1)
  {
#ifndef DIS_DYN_SHAPES
    input_shape =
      runtime_storage.getDynamicRuntimeShape(runtime_kernel.inputs_index[inputTensorIdx]);
    if (input_shape.flatSize() == 0)
      return UnsupportedDynamicShapeCase;
#else
    return UnsupportedDynamicShapeCase;
#endif // DIS_DYN_SHAPES
  }
 
  status = utils::checkCondition(bias == nullptr or weight_shape.dims(0) == bias_shape.flatSize());
 
  if (input->type() == circle::TensorType_FLOAT32)
    return status;
 
#ifndef DIS_QUANT
 
  // Check quantized version
  if (input->quantization() == nullptr or output->quantization() == nullptr or
      weight->quantization() == nullptr)
    return NoQuantization;
 
  if (output->quantization()->scale() == nullptr or output->quantization()->scale()->size() != 1)
    return UnsupportedQuantizationType;
 
  if (output->quantization()->zero_point() == nullptr or
      output->quantization()->zero_point()->size() != 1)
    return UnsupportedQuantizationType;
 
  if (weight->quantization()->scale() == nullptr or weight->quantization()->scale()->size() != 1)
    return UnsupportedQuantizationType;
 
  if (weight->quantization()->zero_point() == nullptr or
      weight->quantization()->zero_point()->size() != 1)
    return UnsupportedQuantizationType;
 
#endif // DIS_QUANT
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::flatSize(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::core::OMRuntimeStorage::getDynamicRuntimeShape(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_index, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::NoQuantization, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, onert_micro::import::OMConfigureArgs::runtime_storage, onert_micro::UnsupportedDynamicShapeCase, and onert_micro::UnsupportedQuantizationType.

configure_kernel_CircleGather()

OMStatus onert_micro::import::configure_kernel_CircleGather

(

const OMConfigureArgs &

config_args

)

Definition at line 40 of file Gather.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *positions = runtime_kernel.inputs[positionsTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(positions != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  const auto *options = runtime_kernel.first_operator->builtin_options_as_GatherOptions();
 
  if (options == nullptr)
    return UnknownError;
 
  status = utils::checkCondition(positions->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  auto input_type = input->type();
  status = utils::checkCondition(input_type == circle::TensorType_INT32 or
                                 input_type == circle::TensorType_FLOAT32 or
                                 input_type == circle::TensorType_INT8);
  if (status != Ok)
    return status;
 
#ifndef DIS_QUANT
  if (input_type == circle::TensorType_INT8)
  {
    status = utils::checkCondition(*output->quantization()->scale()->begin() ==
                                   *input->quantization()->scale()->begin());
    if (status != Ok)
      return status;
    status = utils::checkCondition(*output->quantization()->zero_point()->begin() ==
                                   *input->quantization()->zero_point()->begin());
    if (status != Ok)
      return status;
  }
#endif // DIS_QUANT
 
  int32_t axis = options->axis();
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape positions_shape(positions);
 
  int32_t num_dims = input_shape.dimensionsCount();
  if (axis < 0)
  {
    axis += num_dims;
  }
 
  status = utils::checkCondition(axis >= 0 and axis < num_dims);
  if (status != Ok)
    return status;
 
  int32_t batch_dims = options->batch_dims();
  int32_t coords_num_dims = positions_shape.dimensionsCount();
  // batch_dims should be in range: [-rank(coords), rank(coords)].
  // Negative batch_dims is added with rank of coords.
  if (batch_dims < 0)
  {
    batch_dims += coords_num_dims;
  }
 
  status = utils::checkCondition(batch_dims <= axis and batch_dims >= 0 and
                                 batch_dims < num_dims and batch_dims <= coords_num_dims);
 
  if (status != Ok)
    return status;
 
  for (int i = 0; i < batch_dims; ++i)
  {
    status = utils::checkCondition(input_shape.dims(i) == positions_shape.dims(i));
  }
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::UnknownError.

configure_kernel_CircleGatherND()

OMStatus onert_micro::import::configure_kernel_CircleGatherND

(

const OMConfigureArgs &

config_args

)

Definition at line 43 of file GatherND.cpp.

{
 
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *positions = runtime_kernel.inputs[positionsTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(positions != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(positions->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  auto input_type = input->type();
  status = utils::checkCondition(input_type == circle::TensorType_FLOAT32);
  if (status != Ok)
    return status;
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape positions_shape(positions);
 
  int32_t shape_num_dims = input_shape.dimensionsCount();
 
  status = utils::checkCondition(shape_num_dims >= 1);
  if (status != Ok)
    return status;
 
  int32_t positions_num_dims = positions_shape.dimensionsCount();
  int32_t positions_num_dims_nd = positions_shape.dims(positions_num_dims - 1);
 
  status = utils::checkCondition(positions_num_dims >= 1);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(positions_num_dims_nd <= shape_num_dims);
  if (status != Ok)
    return status;
 
  status =
    utils::checkCondition(positions_num_dims_nd <= onert_micro::execute::pal::MAX_INDICES_ND);
  if (status != Ok)
    return status;
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::execute::pal::MAX_INDICES_ND, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleGreater()

OMStatus onert_micro::import::configure_kernel_CircleGreater

(

const OMConfigureArgs &

config_args

)

Definition at line 41 of file Greater.cpp.

{
  const circle::Tensor *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  TISOHeader(config_args, &input1, &input2, &output);
 
  OMStatus status;
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(output->type() == circle::TensorType_BOOL);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::Ok, and TISOHeader().

configure_kernel_CircleGreaterEqual()

OMStatus onert_micro::import::configure_kernel_CircleGreaterEqual

(

const OMConfigureArgs &

config_args

)

Definition at line 41 of file GreaterEqual.cpp.

{
  const circle::Tensor *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  TISOHeader(config_args, &input1, &input2, &output);
 
  OMStatus status;
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(output->type() == circle::TensorType_BOOL);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::Ok, and TISOHeader().

configure_kernel_CircleGRU()

OMStatus onert_micro::import::configure_kernel_CircleGRU

(

const OMConfigureArgs &

config_args

)

Definition at line 48 of file GRU.cpp.

{
  core::OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_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;
 
  // 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);
 
  OMStatus status = Ok;
 
  OMRuntimeShape hidden_hidden_shape(hidden_hidden);
  OMRuntimeShape hidden_input_shape(hidden_input);
  OMRuntimeShape output_shape(output);
  OMRuntimeShape state_shape(state);
 
  status = utils::checkCondition(hidden_hidden_shape.dims(0) == hidden_input_shape.dims(0));
  if (status != Ok)
    return status;
 
  const int32_t div_factor = 3;
  status =
    utils::checkCondition(hidden_hidden_shape.dims(0) ==
                          (div_factor * output_shape.dims(output_shape.dimensionsCount() - 1)));
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(output_shape.dims(output_shape.dimensionsCount() - 1) ==
                                 state_shape.dims(state_shape.dimensionsCount() - 1));
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  return status;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleL2Normalize()

OMStatus onert_micro::import::configure_kernel_CircleL2Normalize

(

const OMConfigureArgs &

config_args

)

Definition at line 39 of file L2Normalize.cpp.

{
  OMStatus status = onert_micro::import::helpers::configure_SISO_kernel(config_args);
 
  return status;
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleL2Pool2D()

OMStatus onert_micro::import::configure_kernel_CircleL2Pool2D

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file L2Pool2D.cpp.

{
  return helpers::configure_pooling_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_pooling_kernel_common().

configure_kernel_CircleLeakyRelu()

OMStatus onert_micro::import::configure_kernel_CircleLeakyRelu

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file LeakyRelu.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleLess()

OMStatus onert_micro::import::configure_kernel_CircleLess

(

const OMConfigureArgs &

config_args

)

Definition at line 41 of file Less.cpp.

{
  const circle::Tensor *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  TISOHeader(config_args, &input1, &input2, &output);
 
  OMStatus status;
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(output->type() == circle::TensorType_BOOL);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::Ok, and TISOHeader().

configure_kernel_CircleLessEqual()

OMStatus onert_micro::import::configure_kernel_CircleLessEqual

(

const OMConfigureArgs &

config_args

)

Definition at line 41 of file LessEqual.cpp.

{
  const circle::Tensor *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  TISOHeader(config_args, &input1, &input2, &output);
 
  OMStatus status;
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(output->type() == circle::TensorType_BOOL);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::Ok, and TISOHeader().

configure_kernel_CircleLog()

OMStatus onert_micro::import::configure_kernel_CircleLog

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Log.cpp.

{
  return import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleLogistic()

OMStatus onert_micro::import::configure_kernel_CircleLogistic

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Logistic.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleLogSoftmax()

OMStatus onert_micro::import::configure_kernel_CircleLogSoftmax

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file LogSoftmax.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleMaximum()

OMStatus onert_micro::import::configure_kernel_CircleMaximum

(

const OMConfigureArgs &

config_args

)

Definition at line 39 of file Maximum.cpp.

{
 
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input1 = runtime_kernel.inputs[input1TensorIdx];
  const circle::Tensor *input2 = runtime_kernel.inputs[input2TensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input1->type() == output->type());
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleMaxPool2D()

OMStatus onert_micro::import::configure_kernel_CircleMaxPool2D

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file MaxPool2D.cpp.

{
  return helpers::configure_pooling_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_pooling_kernel_common().

configure_kernel_CircleMean()

OMStatus onert_micro::import::configure_kernel_CircleMean

(

const OMConfigureArgs &

config_args

)

Definition at line 36 of file Mean.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *axis = runtime_kernel.inputs[axisTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(axis != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(axis->type() == circle::TensorType_INT32);
  status = utils::checkCondition(input->type() == output->type());
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleMinimum()

OMStatus onert_micro::import::configure_kernel_CircleMinimum

(

const OMConfigureArgs &

config_args

)

Definition at line 39 of file Minimum.cpp.

{
 
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input1 = runtime_kernel.inputs[input1TensorIdx];
  const circle::Tensor *input2 = runtime_kernel.inputs[input2TensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input1->type() == output->type());
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleMul()

OMStatus onert_micro::import::configure_kernel_CircleMul

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Mul.cpp.

{
  return import::helpers::configure_TISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_TISO_kernel().

configure_kernel_CircleNeg()

OMStatus onert_micro::import::configure_kernel_CircleNeg

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Neg.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleNotEqual()

OMStatus onert_micro::import::configure_kernel_CircleNotEqual

(

const OMConfigureArgs &

config_args

)

Definition at line 42 of file NotEqual.cpp.

{
  const circle::Tensor *input1;
  const circle::Tensor *input2;
  const circle::Tensor *output;
 
  TISOHeader(config_args, &input1, &input2, &output);
 
  OMStatus status;
 
  status = utils::checkCondition(input1->type() == input2->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(output->type() == circle::TensorType_BOOL);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::Ok, and TISOHeader().

configure_kernel_CirclePack()

OMStatus onert_micro::import::configure_kernel_CirclePack

(

const OMConfigureArgs &

config_args

)

Definition at line 33 of file Pack.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const int num_inputs = runtime_kernel.inputs_num;
 
  const auto *t0 = runtime_kernel.inputs[0];
  const auto *output = runtime_kernel.outputs[0];
 
  if (output->type() != t0->type())
    return FailedCheckCondition;
 
  const auto *params = runtime_kernel.first_operator->builtin_options_as_PackOptions();
 
  OMRuntimeShape input_shape(t0);
  int axis = params->axis();
  if (axis < 0)
    axis += input_shape.dimensionsCount();
 
  if (axis < 0 or axis > input_shape.dimensionsCount())
    return FailedCheckCondition;
 
  for (int i = 1; i < num_inputs; ++i)
  {
    const auto *tensor = runtime_kernel.inputs[i];
    if (tensor->type() != t0->type())
      return FailedCheckCondition;
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::FailedCheckCondition, onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_num, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CirclePad()

OMStatus onert_micro::import::configure_kernel_CirclePad

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Pad.cpp.

{
  return onert_micro::import::helpers::configure_pad_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_pad_kernel_common().

configure_kernel_CircleQuantize()

OMStatus onert_micro::import::configure_kernel_CircleQuantize

(

const OMConfigureArgs &

config_args

)

Definition at line 38 of file Quantize.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  // Check shapes
  status = utils::checkCondition(input_shape == output_shape);
  if (status != Ok)
    return status;
 
  // Check input type is float
  status = utils::checkCondition(input->type() == circle::TensorType_FLOAT32);
  if (status != Ok)
    return status;
 
  // Check output quantization params
  const auto *output_quantization = output->quantization();
  status = utils::checkCondition(output->type() != circle::TensorType_FLOAT32 or
                                 output_quantization != nullptr and
                                   output_quantization->scale() != nullptr and
                                   output_quantization->scale()->size() == 1);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleReduceProd()

OMStatus onert_micro::import::configure_kernel_CircleReduceProd

(

const OMConfigureArgs &

config_args

)

Definition at line 36 of file ReduceProd.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *axis = runtime_kernel.inputs[axisTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(axis != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(axis->type() == circle::TensorType_INT32);
  status = utils::checkCondition(input->type() == output->type());
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleRelu()

OMStatus onert_micro::import::configure_kernel_CircleRelu

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Relu.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleRelu6()

OMStatus onert_micro::import::configure_kernel_CircleRelu6

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Relu6.cpp.

{
 
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleReshape()

OMStatus onert_micro::import::configure_kernel_CircleReshape

(

const OMConfigureArgs &

config_args

)

Definition at line 40 of file Reshape.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
  OMRuntimeStorage &runtime_storage = config_args.runtime_storage;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *shape = runtime_kernel.inputs[shapeTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(shape != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
#ifndef DIS_DYN_SHAPES
  auto is_dynamic =
    runtime_context.isConstTensor(runtime_kernel.inputs_index[shapeTensorIdx]) == false;
 
  if (is_dynamic)
  {
    auto input_shape_size = input_shape.flatSize();
 
    status = utils::checkCondition(output_shape.flatSize() == 1);
    if (status != Ok)
      return status;
 
    status = utils::checkCondition(input_shape_size != 1);
    if (status != Ok)
      return status;
 
    runtime_storage.setDynamicRuntimeShape(runtime_kernel.outputs_index[outputTensorIdx],
                                           input_shape);
  }
  else
  {
    status = utils::checkCondition(input_shape.flatSize() == output_shape.flatSize());
    assert(status == Ok);
    if (status != Ok)
      return status;
  }
#else
  status = utils::checkCondition(
    runtime_context.getCircleReader().isConstTensor(runtime_kernel.inputs_index[shapeTensorIdx]));
  assert(status == Ok);
  if (status != Ok)
    return status;
#endif // DIS_DYN_SHAPES
 
  return status;
}

References luci_interpreter::RuntimeShape::flatSize(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_index, onert_micro::core::OMRuntimeContext::isConstTensor(), onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_index, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, onert_micro::import::OMConfigureArgs::runtime_storage, and onert_micro::core::OMRuntimeStorage::setDynamicRuntimeShape().

configure_kernel_CircleRound()

OMStatus onert_micro::import::configure_kernel_CircleRound

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Round.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleRsqrt()

OMStatus onert_micro::import::configure_kernel_CircleRsqrt

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Rsqrt.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleSelectV2()

OMStatus onert_micro::import::configure_kernel_CircleSelectV2

(

const OMConfigureArgs &

config_args

)

Definition at line 40 of file SelectV2.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input_cond = runtime_kernel.inputs[inputCond];
  const circle::Tensor *input_x = runtime_kernel.inputs[inputX];
  const circle::Tensor *input_y = runtime_kernel.inputs[inputY];
  const circle::Tensor *output = runtime_kernel.outputs[outputIndex];
 
  assert(input_cond != nullptr);
  assert(input_x != nullptr);
  assert(input_y != nullptr);
  assert(output != nullptr);
 
  if (input_cond->type() != circle::TensorType_BOOL)
    return status;
 
  if (input_x->type() != input_y->type())
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleShape()

OMStatus onert_micro::import::configure_kernel_CircleShape

(

const OMConfigureArgs &

config_args

)

Definition at line 39 of file Shape.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(output != nullptr);
 
  status = utils::checkCondition(output->type() == circle::TensorType_INT32);
 
  return status;
}

References onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleSin()

OMStatus onert_micro::import::configure_kernel_CircleSin

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Sin.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleSlice()

OMStatus onert_micro::import::configure_kernel_CircleSlice

(

const OMConfigureArgs &

config_args

)

Definition at line 46 of file Slice.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  execute::OMRuntimeKernel runtime_kernel;
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input1 = runtime_kernel.inputs[input1TensorIdx];
  const circle::Tensor *input2 = runtime_kernel.inputs[input2TensorIdx];
  const circle::Tensor *input3 = runtime_kernel.inputs[input3TensorIdx];
 
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input1 != nullptr);
  assert(input2 != nullptr);
  assert(input3 != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input1->type() == output->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input2->type() == circle::TensorType_INT32 and
                                 input3->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(OMRuntimeShape(input2).dimensionsCount() == 1 and
                                 OMRuntimeShape(input3).dimensionsCount() == 1);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(OMRuntimeShape(input1).dimensionsCount() <= MAX_DIM);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleSoftmax()

OMStatus onert_micro::import::configure_kernel_CircleSoftmax

(

const OMConfigureArgs &

config_args

)

Definition at line 42 of file Softmax.cpp.

{
  const circle::Tensor *input;
  const circle::Tensor *output;
 
  SISOHeader(config_args, &input, &output);
 
  OMStatus status;
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  status = utils::checkCondition(input_shape.dimensionsCount() == output_shape.dimensionsCount());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_shape.dimensionsCount() >= 1);
  if (status != Ok)
    return status;
 
  if (input->type() != circle::TensorType_INT8 and input->type() != circle::TensorType_INT16 and
      input->type() != circle::TensorType_UINT8)
    return status;
 
  // Check quantized version
  if (input->quantization() == nullptr or output->quantization() == nullptr)
    return NoQuantization;
 
  if (output->quantization()->scale() == nullptr or output->quantization()->scale()->size() != 1)
    return NoQuantization;
 
  if (input->quantization()->scale() == nullptr or input->quantization()->scale()->size() != 1)
    return NoQuantization;
 
  if (output->quantization()->zero_point() == nullptr or
      output->quantization()->zero_point()->size() != 1)
    return NoQuantization;
 
  if (input->quantization()->zero_point() == nullptr or
      input->quantization()->zero_point()->size() != 1)
    return NoQuantization;
 
  return status;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::NoQuantization, onert_micro::Ok, output_shape, and SISOHeader().

configure_kernel_CircleSpaceToBatchND()

OMStatus onert_micro::import::configure_kernel_CircleSpaceToBatchND

(

const onert_micro::import::OMConfigureArgs &

config_args

)

Definition at line 28 of file SpaceToBatchND.cpp.

{
  return helpers::configure_spaces_batches_nd_kernel_common(config_args);
}

References onert_micro::import::helpers::configure_spaces_batches_nd_kernel_common().

configure_kernel_CircleSpaceToDepth()

OMStatus onert_micro::import::configure_kernel_CircleSpaceToDepth

(

const onert_micro::import::OMConfigureArgs &

config_args

)

Definition at line 39 of file SpaceToDepth.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  OMRuntimeShape input_shape(input);
  OMRuntimeShape output_shape(output);
 
  const auto *options = runtime_kernel.first_operator->builtin_options_as_SpaceToDepthOptions();
  const int32_t block_size = options->block_size();
 
  status = utils::checkCondition(block_size > 0);
  if (status != Ok)
    return status;
 
  constexpr int kHeightRank = 1;
  constexpr int kWidthRank = 2;
 
  const int input_height = input_shape.dims(kHeightRank);
  const int input_width = input_shape.dims(kWidthRank);
  int output_height = output_shape.dims(kHeightRank);
  int output_width = output_shape.dims(kWidthRank);
 
  status = utils::checkCondition(input_height == output_height * block_size);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_width == output_width * block_size);
  if (status != Ok)
    return status;
  return status;
}

References luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleSplit()

OMStatus onert_micro::import::configure_kernel_CircleSplit

(

const OMConfigureArgs &

config_args

)

Definition at line 40 of file Split.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  OMRuntimeStorage &runtime_storage = config_args.runtime_storage;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *axis = runtime_kernel.inputs[axisTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(axis != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(output->type() == input->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(axis->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  // Check it is scalar
  status = utils::checkCondition(OMRuntimeShape(axis).flatSize() == 1);
  if (status != Ok)
    return status;
 
  // Check axis value
  runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  auto *axis_data = reinterpret_cast<int32_t *>(runtime_kernel.inputs_data[axisTensorIdx]);
  status = utils::checkCondition(axis_data != nullptr);
  if (status != Ok)
    return status;
 
  int32_t axis_value = axis_data[0];
 
  OMRuntimeShape input_shape(input);
  if (axis_value < 0)
  {
    axis_value += input_shape.dimensionsCount() + 1;
  }
 
  status = utils::checkCondition(axis_value <= input_shape.dimensionsCount() and axis_value >= 0);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::import::OMConfigureArgs::runtime_storage.

configure_kernel_CircleSplitV()

OMStatus onert_micro::import::configure_kernel_CircleSplitV

(

const OMConfigureArgs &

config_args

)

Definition at line 41 of file SplitV.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  OMRuntimeStorage &runtime_storage = config_args.runtime_storage;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *size = runtime_kernel.inputs[sizeTensorIdx];
  const circle::Tensor *axis = runtime_kernel.inputs[axisTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(axis != nullptr);
  assert(size != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(output->type() == input->type());
  if (status != Ok)
    return status;
 
  // Check all outputs have the same type
  for (uint32_t i = 1; i < runtime_kernel.outputs_num; ++i)
  {
    status = utils::checkCondition(output->type() == runtime_kernel.outputs[i]->type());
    if (status != Ok)
      return status;
  }
 
  status = utils::checkCondition(axis->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(size->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  // Check size tensor contains exactly output_nums_tensors values
  status = utils::checkCondition(OMRuntimeShape(size).flatSize() == runtime_kernel.outputs_num);
 
  // Check it is scalar
  status = utils::checkCondition(OMRuntimeShape(axis).flatSize() == 1);
  if (status != Ok)
    return status;
 
  // Check axis value
  runtime_kernel.getDataFromStorage(op_index, runtime_storage, runtime_context);
  auto *axis_data = reinterpret_cast<int32_t *>(runtime_kernel.inputs_data[axisTensorIdx]);
  status = utils::checkCondition(axis_data != nullptr);
  if (status != Ok)
    return status;
 
  int32_t axis_value = axis_data[0];
 
  OMRuntimeShape input_shape(input);
  if (axis_value < 0)
  {
    axis_value += input_shape.dimensionsCount() + 1;
  }
 
  status = utils::checkCondition(axis_value <= input_shape.dimensionsCount() and axis_value >= 0);
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::execute::OMRuntimeKernel::getDataFromStorage(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::execute::OMRuntimeKernel::inputs_data, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_num, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, onert_micro::import::OMConfigureArgs::runtime_storage, and size.

configure_kernel_CircleSqrt()

OMStatus onert_micro::import::configure_kernel_CircleSqrt

(

const OMConfigureArgs &

config_args

)

Definition at line 26 of file Sqrt.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleSquare()

OMStatus onert_micro::import::configure_kernel_CircleSquare

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Square.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleSquaredDifference()

OMStatus onert_micro::import::configure_kernel_CircleSquaredDifference

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file SquaredDifference.cpp.

{
  return import::helpers::configure_TISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_TISO_kernel().

configure_kernel_CircleStridedSlice()

OMStatus onert_micro::import::configure_kernel_CircleStridedSlice

(

const OMConfigureArgs &

config_args

)

Definition at line 46 of file StridedSlice.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  execute::OMRuntimeKernel runtime_kernel;
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *begin = runtime_kernel.inputs[beginTensorIdx];
  const circle::Tensor *end = runtime_kernel.inputs[endTensorIdx];
  const circle::Tensor *strides = runtime_kernel.inputs[stridesTensorIdx];
 
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(begin != nullptr);
  assert(end != nullptr);
  assert(strides != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(begin->type() == circle::TensorType_INT32 and
                                 end->type() == circle::TensorType_INT32 and
                                 strides->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  return status;
}

References begin, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleSub()

OMStatus onert_micro::import::configure_kernel_CircleSub

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Sub.cpp.

{
  return import::helpers::configure_TISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_TISO_kernel().

configure_kernel_CircleSum()

OMStatus onert_micro::import::configure_kernel_CircleSum

(

const OMConfigureArgs &

config_args

)

Definition at line 37 of file Sum.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *axis = runtime_kernel.inputs[axisTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(axis != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(axis->type() == circle::TensorType_INT32);
  status = utils::checkCondition(input->type() == output->type());
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleSVDF()

OMStatus onert_micro::import::configure_kernel_CircleSVDF

(

const OMConfigureArgs &

config_args

)

Definition at line 48 of file SVDF.cpp.

{
  // Validate Tensor Inputs (dtype depends on quantization):
  // [0] = Input, {2, batch_size, input_size}
  // [1] = Weights Feature, {2, num_filters, input_size}
  // [2] = Weights Time, {2, num_filters, memory_size}
  // [3] = Bias (optional), {1, num_units}
  // [4] = Activation State (variable), {2, batch_size, memory_size * num_filters}
 
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *weights_feature = runtime_kernel.inputs[weightsFeatureTensorIdx];
  const circle::Tensor *weights_time = runtime_kernel.inputs[weightsTimeTensorIdx];
  const circle::Tensor *bias = runtime_kernel.inputs[biasTensorIdx];
  const circle::Tensor *activation_state = runtime_kernel.inputs[inputActivationStateTensorIdx];
 
  const circle::Tensor *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);
 
  OMStatus status = Ok;
 
  const auto *options = runtime_kernel.first_operator->builtin_options_as_SVDFOptions();
  status = utils::checkCondition(options != nullptr);
  if (status != Ok)
    return 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);
  status = utils::checkCondition(num_filters % rank == 0);
  if (status != Ok)
    return status;
 
  const int num_units = num_filters / rank;
  const int memory_size = weights_time_shape.dims(1);
 
  status = utils::checkCondition(input_shape.dimensionsCount() == 2);
  if (status != Ok)
    return status;
  // Validate Tensor Output:
  // [0] = float/int8_t, {2, batch_size, num_units}
  status =
    utils::checkCondition(output_shape.dimensionsCount() == 2 and
                          output_shape.dims(0) == batch_size and output_shape.dims(1) == num_units);
  if (status != Ok)
    return status;
 
  // Validate Weights Feature Input Tensor
  status = utils::checkCondition(weights_feature_shape.dimensionsCount() == 2 and
                                 weights_feature_shape.dims(1) == input_size);
  if (status != Ok)
    return status;
 
  // Validate Weights Time Input Tensor:
  status = utils::checkCondition(weights_time_shape.dimensionsCount() == 2 and
                                 weights_time_shape.dims(0) == num_filters and
                                 weights_time_shape.dims(1) == memory_size);
  if (status != Ok)
    return status;
 
  // Validate Optional Bias Input Tensor:
  if (bias != nullptr)
  {
    status = utils::checkCondition(OMRuntimeShape(bias).dims(0) == num_units);
    if (status != Ok)
      return status;
  }
 
  // Validate Activation State Input Tensor:
  status = utils::checkCondition(activation_state_shape.dimensionsCount() == 2 and
                                 activation_state_shape.dims(0) == batch_size and
                                 activation_state_shape.dims(1) == memory_size * num_filters);
  if (status != Ok)
    return status;
 
  if (input->type() == circle::TensorType_FLOAT32)
  {
    status = utils::checkCondition(weights_feature->type() == circle::TensorType_FLOAT32 and
                                   weights_time->type() == circle::TensorType_FLOAT32 and
                                   activation_state->type() == circle::TensorType_FLOAT32 and
                                   output->type() == circle::TensorType_FLOAT32);
    if (status != Ok)
      return status;
    if (bias)
    {
      status = utils::checkCondition(bias->type() == circle::TensorType_FLOAT32);
      if (status != Ok)
        return status;
    }
  }
 
  return status;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleTanh()

OMStatus onert_micro::import::configure_kernel_CircleTanh

(

const OMConfigureArgs &

config_args

)

Definition at line 27 of file Tanh.cpp.

{
  return onert_micro::import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

configure_kernel_CircleTranspose()

OMStatus onert_micro::import::configure_kernel_CircleTranspose

(

const OMConfigureArgs &

config_args

)

Definition at line 43 of file Transpose.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const circle::Tensor *input = runtime_kernel.inputs[kInputTensorIdx];
  const circle::Tensor *perm = runtime_kernel.inputs[kPermTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[kOutputTensorIdx];
 
  assert(input != nullptr);
  assert(perm != nullptr);
  assert(output != nullptr);
 
  OMStatus status = Ok;
 
  status = utils::checkCondition(perm->type() == circle::TensorType_INT32);
  if (status != Ok)
    return status;
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape perm_shape(perm);
 
  status = utils::checkCondition(perm_shape.dimensionsCount() == 1);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(perm_shape.dims(0) == input_shape.dimensionsCount());
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleTransposeConv()

OMStatus onert_micro::import::configure_kernel_CircleTransposeConv

(

const OMConfigureArgs &

config_args

)

Definition at line 50 of file TransposeConv.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  execute::OMRuntimeKernel runtime_kernel;
  runtime_kernel.readKernel(op_index, runtime_context);
 
  const circle::Tensor *input = runtime_kernel.inputs[kInputTensorIdx];
  const circle::Tensor *weight = runtime_kernel.inputs[kWeightTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[kOutputTensorIdx];
 
  assert(input != nullptr);
  assert(weight != nullptr);
  // Bias can be nullptr
  assert(output != nullptr);
 
  OMStatus status = Ok;
 
  status = utils::checkCondition(input->type() == output->type());
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input->type() == weight->type());
  if (status != Ok)
    return status;
 
  core::OMRuntimeShape input_shape(input);
  core::OMRuntimeShape weight_shape(weight);
 
  status = utils::checkCondition(input_shape.dimensionsCount() == 4);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(input_shape.dimensionsCount() == weight_shape.dimensionsCount());
  if (status != Ok)
    return status;
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), and onert_micro::import::OMConfigureArgs::runtime_context.

configure_kernel_CircleUnpack()

OMStatus onert_micro::import::configure_kernel_CircleUnpack

(

const OMConfigureArgs &

config_args

)

Definition at line 39 of file Unpack.cpp.

{
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  OMRuntimeStorage &runtime_storage = config_args.runtime_storage;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  const circle::Tensor *input = runtime_kernel.inputs[inputTensorIdx];
  const circle::Tensor *output = runtime_kernel.outputs[outputTensorIdx];
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  status = utils::checkCondition(output->type() == input->type());
  if (status != Ok)
    return status;
 
  auto options = runtime_kernel.first_operator->builtin_options_as_UnpackOptions();
  status = utils::checkCondition(options != nullptr);
  if (status != Ok)
    return status;
 
  status = utils::checkCondition(runtime_kernel.outputs_num == options->num());
  if (status != Ok)
    return status;
 
  // Check all outputs have the same type and shapes
  OMRuntimeShape output_shape(output);
  for (uint32_t i = 1; i < options->num(); ++i)
  {
    const circle::Tensor *cur_output = runtime_kernel.outputs[i];
    status = utils::checkCondition(output->type() == cur_output->type());
    if (status != Ok)
      return status;
 
    OMRuntimeShape cur_output_shape(cur_output);
    status = utils::checkCondition(output_shape == cur_output_shape);
    if (status != Ok)
      return status;
  }
 
  // Check shapes input and output
  OMRuntimeShape input_shape(input);
  for (int i = 0; i < input_shape.dimensionsCount(); ++i)
  {
    if (i == options->axis())
      continue;
 
    if (i < options->axis())
    {
      status = utils::checkCondition(input_shape.dims(i) == output_shape.dims(i));
    }
    else
    {
      status = utils::checkCondition(input_shape.dims(i) == output_shape.dims(i - 1));
    }
    if (status != Ok)
      return status;
  }
 
  return status;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, output_shape, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::outputs_num, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::import::OMConfigureArgs::runtime_storage.

configure_kernel_CircleWhile()

OMStatus onert_micro::import::configure_kernel_CircleWhile

(

const onert_micro::import::OMConfigureArgs &

config_args

)

Definition at line 30 of file While.cpp.

{
  OMRuntimeModule &runtime_module = config_args.runtime_module;
  OMRuntimeContext &runtime_context = config_args.runtime_context;
  uint16_t op_index = config_args.kernel_index;
 
  onert_micro::execute::OMRuntimeKernel runtime_kernel;
 
  OMStatus status = runtime_kernel.readKernel(op_index, runtime_context);
  if (status != Ok)
    return status;
 
  auto options = runtime_kernel.first_operator->builtin_options_as_WhileOptions();
  status = utils::checkCondition(options != nullptr);
  if (status != Ok)
    return status;
 
  // Num of inputs equals to num of outputs
  status = utils::checkCondition(runtime_kernel.inputs_num == runtime_kernel.outputs_num);
  if (status != Ok)
    return status;
 
  // Obtain conditional and body runtime subgraphs
  const auto body_subgraph_index = options->body_subgraph_index();
  const auto cond_subgraph_index = options->cond_subgraph_index();
  OMRuntimeGraph *cond_runtime_graph = nullptr;
  OMRuntimeGraph *body_runtime_graph = nullptr;
  status = runtime_module.getRuntimeGraphAt(cond_subgraph_index, &cond_runtime_graph);
  if (status != Ok)
    return status;
  status = runtime_module.getRuntimeGraphAt(body_subgraph_index, &body_runtime_graph);
  if (status != Ok)
    return status;
 
  OMRuntimeContext &cond_runtime_context = cond_runtime_graph->getRuntimeContext();
  OMRuntimeContext &body_runtime_context = body_runtime_graph->getRuntimeContext();
 
  // Check cond runtime graph
  status =
    utils::checkCondition(cond_runtime_graph->getNumberOfInputs() == runtime_kernel.inputs_num and
                          cond_runtime_graph->getNumberOfOutputs() == 1);
  if (status != Ok)
    return status;
 
  const auto cond_output_index = cond_runtime_context.getGraphOutputTensorIndex(0);
  const auto cond_output_tensor =
    cond_runtime_context.getTensorByIndex(static_cast<int32_t>(cond_output_index));
  status = utils::checkCondition(cond_output_tensor->type() == circle::TensorType_BOOL);
 
  // Check body runtime graph
  status =
    utils::checkCondition(body_runtime_graph->getNumberOfInputs() == runtime_kernel.inputs_num and
                          body_runtime_graph->getNumberOfOutputs() == runtime_kernel.outputs_num);
  return status;
}

References onert_micro::execute::OMRuntimeKernel::first_operator, onert_micro::core::OMRuntimeContext::getGraphOutputTensorIndex(), onert_micro::core::OMRuntimeGraph::getNumberOfInputs(), onert_micro::core::OMRuntimeGraph::getNumberOfOutputs(), onert_micro::core::OMRuntimeGraph::getRuntimeContext(), onert_micro::core::OMRuntimeModule::getRuntimeGraphAt(), onert_micro::core::OMRuntimeContext::getTensorByIndex(), onert_micro::execute::OMRuntimeKernel::inputs_num, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::Ok, onert_micro::execute::OMRuntimeKernel::outputs_num, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::import::OMConfigureArgs::runtime_module.

configure_kernel_CircleZerosLike()

OMStatus onert_micro::import::configure_kernel_CircleZerosLike

(

const OMConfigureArgs &

config_args

)

Definition at line 40 of file ZerosLike.cpp.

{
  return import::helpers::configure_SISO_kernel(config_args);
}

References onert_micro::import::helpers::configure_SISO_kernel().

SISOHeader()

OMStatus onert_micro::import::SISOHeader	(	const OMConfigureArgs &	execute_args,
		const circle::Tensor **	input,
		const circle::Tensor **	output
	)

Definition at line 23 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;
  status = runtime_kernel.readKernel(op_index, runtime_context);
 
  *input = runtime_kernel.inputs[0];
  *output = runtime_kernel.outputs[0];
 
  assert(*input != nullptr);
  assert(*output != nullptr);
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::import::OMConfigureArgs::runtime_storage.

Referenced by configure_kernel_CircleSoftmax().

TISOHeader()

OMStatus onert_micro::import::TISOHeader	(	const OMConfigureArgs &	execute_args,
		const circle::Tensor **	input1,
		const circle::Tensor **	input2,
		const circle::Tensor **	output
	)

Definition at line 45 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;
  status = runtime_kernel.readKernel(op_index, runtime_context);
 
  *input2 = runtime_kernel.inputs[0];
  *input1 = runtime_kernel.inputs[1];
  *output = runtime_kernel.outputs[0];
 
  assert(*input1 != nullptr);
  assert(*input2 != nullptr);
  assert(*output != nullptr);
 
  return status;
}

References onert_micro::execute::OMRuntimeKernel::inputs, onert_micro::import::OMConfigureArgs::kernel_index, onert_micro::execute::OMRuntimeKernel::outputs, onert_micro::execute::OMRuntimeKernel::readKernel(), onert_micro::import::OMConfigureArgs::runtime_context, and onert_micro::import::OMConfigureArgs::runtime_storage.

Referenced by configure_kernel_CircleEqual(), configure_kernel_CircleGreater(), configure_kernel_CircleGreaterEqual(), configure_kernel_CircleLess(), configure_kernel_CircleLessEqual(), and configure_kernel_CircleNotEqual().

Variable Documentation

kernel_builtin_configure

constexpr KernelBuiltinConfigureRegistry onert_micro::import::kernel_builtin_configure

constexpr

Definition at line 130 of file OMKernelConfigureBuilder.h.

Referenced by onert_micro::import::OMKernelConfiguration::configureKernels().

kernel_custom_configure

constexpr KernelCustomConfigureRegistry onert_micro::import::kernel_custom_configure

constexpr

Definition at line 131 of file OMKernelConfigureBuilder.h.

Referenced by onert_micro::import::OMKernelConfiguration::configureKernels().