onert_micro::core Namespace Reference

Namespaces
namespace	memory
namespace	reader
namespace	train
namespace	type_traits
namespace	utils

Data Structures
struct	ArithmeticQuantParams
struct	BinaryArithmeticBroadcastParams
struct	ComparisonParams
struct	ConcatenationParams
struct	ConvQuant
struct	FloatConv2D
struct	FullyConnectedParams
class	IOTensorData
struct	L2NormalizationParams
struct	LogSoftmaxParams
class	OMAxisContextMixin
class	OMAxisData
class	OMDataContext
struct	OMDataTypeImpl
	C++ scalar type corresponding to each OMDataType. More...
struct	OMDataTypeImpl< OMDataType::BOOL >
struct	OMDataTypeImpl< OMDataType::FLOAT16 >
struct	OMDataTypeImpl< OMDataType::FLOAT32 >
struct	OMDataTypeImpl< OMDataType::FLOAT64 >
struct	OMDataTypeImpl< OMDataType::S16 >
struct	OMDataTypeImpl< OMDataType::S32 >
struct	OMDataTypeImpl< OMDataType::S64 >
struct	OMDataTypeImpl< OMDataType::S8 >
struct	OMDataTypeImpl< OMDataType::U16 >
struct	OMDataTypeImpl< OMDataType::U32 >
struct	OMDataTypeImpl< OMDataType::U64 >
struct	OMDataTypeImpl< OMDataType::U8 >
class	OMQuantizationData
class	OMReduceDataContext
class	OMRuntimeContext
class	OMRuntimeGraph
class	OMRuntimeModule
class	OMRuntimeShape
class	OMRuntimeStorage
class	OMTensorContext
class	OMTensorData
class	OMTrainingRuntimeModule
struct	PadParams
struct	Pool2DParams
struct	QuantizationParams
struct	SliceParams
struct	SoftmaxParams
struct	SplitParams
struct	StridedSliceParams
struct	SVDFQuantParams
struct	TransposeParams

Typedefs
template<typename T >
using	OMInputContext = OMTensorContext< const T, IOTensorData< const T > >
template<typename T >
using	OMOutputContext = OMTensorContext< T, IOTensorData< T > >
using	OMAxisContext = OMTensorContext< uint32_t, OMAxisData< uint32_t > >

Enumerations
enum class	OMDataType {   Unknown , U8 , U16 , U32 ,   U64 , S8 , S16 , S32 ,   S64 , FLOAT16 , FLOAT32 , FLOAT64 ,   BOOL }
	"scalar" value type More...
enum class	BroadcastableOpCategory : uint8_t {   kNone , kNonBroadcast , kFirstInputBroadcastsFast , kSecondInputBroadcastsFast ,   kGenericBroadcast , kScalarFirstBroadcast , kScalarSecondBroadcast }
enum	OpTrainableRankType { ALL = 0 , ONLY_BIAS = 1 , UP_1_2_PART = 2 , LOWER_1_2_PART = 3 }
enum	OMKernelType { Normal , Inplace }
enum	OMBuilderCustomID { CUSTOM_custom_gru }
enum class	OMBuilderID { BuiltinOperatorsSize , Size }

Functions
template<typename T , class RuntimeKernel >
IOTensorData< const T >	MakeInputData (RuntimeKernel &rtk, size_t input_idx)
template<typename T , class RuntimeKernel >
IOTensorData< T >	MakeOutputData (RuntimeKernel &rtk, size_t output_idx)
template<typename IntType , class RuntimeKernel >
OMAxisData< IntType >	MakeAxisData (RuntimeKernel &rtk, size_t axisTensorIdx)
OMDataType	onertMicroDatatype (const circle::TensorType type)
uint32_t	size (OMDataType data_type)
	Returns the size of the data type.
size_t	getOMDataTypeSize (OMDataType data_type)
OMStatus	getBuiltinOperatorBuilderId (const circle::BuiltinOperator &opcode, core::OMBuilderID &builderID)
OMStatus	getCustomOperatorBuilderId (const flatbuffers::String *custom_opcode, core::OMBuilderID &builderID)
OMStatus	getCustomOperatorByBuilderId (core::OMBuilderID &builderID, OMBuilderCustomID &opcode)
OMStatus	getBuilderId (const circle::OperatorCode *opcode, core::OMBuilderID &builderID)
template<typename T , class RuntimeKernel >
OMInputContext< T >	MakeInputContext (RuntimeKernel &rtk, size_t inputIdx=0)
template<typename T , class RuntimeKernel >
OMOutputContext< T >	MakeOutputContext (RuntimeKernel &rtk, size_t outputIdx=0)
template<class RuntimeKernel >
OMAxisContext	MakeAxisContext (RuntimeKernel &rtk, size_t axisInputIdx=1)

Typedef Documentation

OMAxisContext

using onert_micro::core::OMAxisContext = typedef OMTensorContext<uint32_t, OMAxisData<uint32_t> >

Definition at line 109 of file OMRuntimeData.h.

OMInputContext

template<typename T >

using onert_micro::core::OMInputContext = typedef OMTensorContext<const T, IOTensorData<const T> >

Definition at line 104 of file OMRuntimeData.h.

OMOutputContext

template<typename T >

using onert_micro::core::OMOutputContext = typedef OMTensorContext<T, IOTensorData<T> >

Definition at line 107 of file OMRuntimeData.h.

Enumeration Type Documentation

BroadcastableOpCategory

enum class onert_micro::core::BroadcastableOpCategory : uint8_t

strong

Enumerator
kNone
kNonBroadcast
kFirstInputBroadcastsFast
kSecondInputBroadcastsFast
kGenericBroadcast
kScalarFirstBroadcast
kScalarSecondBroadcast

Definition at line 28 of file OMKernelData.h.

{
  kNone,
  kNonBroadcast,              // Matching input shapes.
  kFirstInputBroadcastsFast,  // Fivefold nested loops.
  kSecondInputBroadcastsFast, // Fivefold nested loops.
  kGenericBroadcast,          // Fall-back.
  kScalarFirstBroadcast,      // Scalar
  kScalarSecondBroadcast,     // Scalar
};

OMBuilderCustomID

enum onert_micro::core::OMBuilderCustomID

Enumerator
CUSTOM_custom_gru

Definition at line 44 of file OMKernelType.h.

{
  CUSTOM_custom_gru,
};

OMBuilderID

enum class onert_micro::core::OMBuilderID

strong

Enumerator
BuiltinOperatorsSize
Size

Definition at line 51 of file OMKernelType.h.

{
#include "KernelsToBuild.lst"
  BuiltinOperatorsSize, // casts to count of values in BuilderId enum
#include "CustomKernelsToBuild.lst"
  Size
};

OMDataType

enum class onert_micro::core::OMDataType

strong

"scalar" value type

Enumerator
Unknown
U8
U16
U32
U64
S8
S16
S32
S64
FLOAT16
FLOAT32
FLOAT64
BOOL

Definition at line 34 of file OMDataType.h.

{
  Unknown, // Unknown type (serves as a default value)
 
  U8,  // 8-bit unsigned integer
  U16, // 16-bit unsigned integer
  U32, // 32-bit unsigned integer
  U64, // 64-bit unsigned integer
 
  S8,  // 8-bit signed integer
  S16, // 16-bit signed integer
  S32, // 32-bit signed integer
  S64, // 64-bit signed integer
 
  FLOAT16, // IEEE 16-bit floating-point
  FLOAT32, // IEEE 32-bit floating-point
  FLOAT64, // IEEE 64-bit floating-point
 
  BOOL, // Boolean
};

OMKernelType

enum onert_micro::core::OMKernelType

Enumerator
Normal
Inplace

Definition at line 38 of file OMKernelType.h.

{
  Normal,
  Inplace,
};

OpTrainableRankType

enum onert_micro::core::OpTrainableRankType

Enumerator
ALL
ONLY_BIAS
UP_1_2_PART
LOWER_1_2_PART

Definition at line 29 of file OMKernelType.h.

{
  ALL = 0,            // 0 - Train all weights in the operation
  ONLY_BIAS = 1,      // 1 - Train bias only in the operation
  UP_1_2_PART = 2,    // 2 - Train the upper 1/2 part of the operation
  LOWER_1_2_PART = 3, // 3 - Train the lower 1/2 part of the operation
  // TODO add more
};

Function Documentation

getBuilderId()

OMStatus onert_micro::core::getBuilderId	(	const circle::OperatorCode *	opcode,
		core::OMBuilderID &	builderID
	)

Definition at line 60 of file OMKernelType.cpp.

{
  OMStatus status;
 
  if (opcode->builtin_code() == circle::BuiltinOperator_CUSTOM)
    status = core::getCustomOperatorBuilderId(opcode->custom_code(), builderID);
  else
    status = core::getBuiltinOperatorBuilderId(opcode->builtin_code(), builderID);
 
  assert(status == Ok && "Unknown operation");
  if (status == UnsupportedOp or builderID == core::OMBuilderID::Size)
    return UnsupportedOp;
 
  return status;
}

References getBuiltinOperatorBuilderId(), getCustomOperatorBuilderId(), onert_micro::Ok, and onert_micro::UnsupportedOp.

Referenced by onert_micro::import::OMKernelConfiguration::configureKernels(), onert_micro::train::OMBackpropExecute::runBackward(), and onert_micro::execute::OMKernelExecute::runForward().

getBuiltinOperatorBuilderId()

OMStatus onert_micro::core::getBuiltinOperatorBuilderId	(	const circle::BuiltinOperator &	opcode,
		core::OMBuilderID &	builderID
	)

Definition at line 23 of file OMKernelType.cpp.

{
  switch (opcode)
  {
#define REGISTER_KERNEL(builtin_operator, name)                        \
  case circle::BuiltinOperator_##builtin_operator:                     \
    builderID = core::OMBuilderID::BuiltinOperator_##builtin_operator; \
    break;
#include "KernelsToBuild.lst"
#undef REGISTER_KERNEL
    default:
      std::cerr << "Error: Unsupported opcode: " << opcode << std::endl;
      assert(false && "Unsupported operation");
      return UnsupportedOp;
  }
  return Ok;
}

References onert_micro::Ok, and onert_micro::UnsupportedOp.

Referenced by getBuilderId().

getCustomOperatorBuilderId()

OMStatus onert_micro::core::getCustomOperatorBuilderId	(	const flatbuffers::String *	custom_opcode,
		core::OMBuilderID &	builderID
	)

Definition at line 77 of file OMKernelType.cpp.

{
#define REGISTER_CUSTOM_KERNEL(name, string_name)    \
  const char arr[] = string_name;                    \
  if (std::strcmp(custom_opcode->c_str(), arr) == 0) \
  {                                                  \
    builderID = core::OMBuilderID::CUSTOM_##name;    \
    return Ok;                                       \
  }
#include "CustomKernelsToBuild.lst"
#undef REGISTER_CUSTOM_KERNEL
 
  std::cerr << "Error: Unsupported custom opcode: " << custom_opcode->c_str() << std::endl;
  assert(false && "Unsupported custom operation");
  return UnsupportedOp;
}

References flatbuffers::String::c_str(), and onert_micro::UnsupportedOp.

Referenced by getBuilderId().

getCustomOperatorByBuilderId()

OMStatus onert_micro::core::getCustomOperatorByBuilderId	(	core::OMBuilderID &	builderID,
		OMBuilderCustomID &	opcode
	)

Definition at line 42 of file OMKernelType.cpp.

{
  switch (builderID)
  {
#define REGISTER_CUSTOM_KERNEL(name, string_name)    \
  case core::OMBuilderID::CUSTOM_##name:             \
    opcode = core::OMBuilderCustomID::CUSTOM_##name; \
    break;
#include "CustomKernelsToBuild.lst"
#undef REGISTER_CUSTOM_KERNEL
    default:
      assert(false && "Unsupported operation");
      return UnsupportedOp;
  }
  return Ok;
}

References onert_micro::Ok, and onert_micro::UnsupportedOp.

getOMDataTypeSize()

size_t onert_micro::core::getOMDataTypeSize ( OMDataType  data_type )

inline

Definition at line 179 of file OMDataType.h.

{ return size(data_type); }

References size.

Referenced by onert_micro::core::memory::OMRuntimeAllocator::allocate(), and onert_micro::core::memory::OMRuntimeAllocator::allocateGraphInputs().

MakeAxisContext()

template<class RuntimeKernel >

OMAxisContext onert_micro::core::MakeAxisContext	(	RuntimeKernel &	rtk,
		size_t	axisInputIdx = 1
	)

Definition at line 130 of file OMRuntimeData.h.

{
  auto data = MakeAxisData<uint32_t>(rtk, axisInputIdx);
  const circle::Tensor *tensor = rtk.inputs[axisInputIdx];
  return OMAxisContext(std::move(data), tensor);
}

MakeAxisData()

template<typename IntType , class RuntimeKernel >

OMAxisData< IntType > onert_micro::core::MakeAxisData	(	RuntimeKernel &	rtk,
		size_t	axisTensorIdx
	)

Definition at line 149 of file OMCustomTensorData.h.

{
  auto data = reinterpret_cast<int32_t*>(rtk.inputs_data[axisTensorIdx]);
  const circle::Tensor *tensor = rtk.inputs[axisTensorIdx];
 
  assert(data != nullptr);
  assert(tensor != nullptr);
 
  OMAxisData<IntType> result(data, tensor);
  return result;
}

MakeInputContext()

template<typename T , class RuntimeKernel >

OMInputContext< T > onert_micro::core::MakeInputContext	(	RuntimeKernel &	rtk,
		size_t	inputIdx = 0
	)

Definition at line 114 of file OMRuntimeData.h.

{
  auto data = MakeInputData<T>(rtk, inputIdx);
  const circle::Tensor *tensor = rtk.inputs[inputIdx];
  return OMInputContext<T>(std::move(data), tensor);
}

MakeInputData()

template<typename T , class RuntimeKernel >

IOTensorData< const T > onert_micro::core::MakeInputData	(	RuntimeKernel &	rtk,
		size_t	input_idx
	)

Definition at line 123 of file OMCustomTensorData.h.

{
  auto data = reinterpret_cast<const T*>(rtk.inputs_data[input_idx]);
  const circle::Tensor *tensor = rtk.inputs[input_idx];
 
  assert(data != nullptr);
  assert(tensor != nullptr);
 
  IOTensorData<const T> result(data, tensor);
  return result;
}

MakeOutputContext()

template<typename T , class RuntimeKernel >

OMOutputContext< T > onert_micro::core::MakeOutputContext	(	RuntimeKernel &	rtk,
		size_t	outputIdx = 0
	)

Definition at line 122 of file OMRuntimeData.h.

{
  auto data = MakeOutputData<T>(rtk, outputIdx);
  const circle::Tensor *tensor = rtk.outputs[outputIdx];
  return OMOutputContext<T>(std::move(data), tensor);
}

MakeOutputData()

template<typename T , class RuntimeKernel >

IOTensorData< T > onert_micro::core::MakeOutputData	(	RuntimeKernel &	rtk,
		size_t	output_idx
	)

Definition at line 136 of file OMCustomTensorData.h.

{
  auto data = reinterpret_cast<T*>(rtk.outputs_data[output_idx]);
  const circle::Tensor *tensor = rtk.outputs[output_idx];
 
  assert(data != nullptr);
  assert(tensor != nullptr);
 
  IOTensorData<T> result(data, tensor);
  return result;
}

onertMicroDatatype()

onert_micro::core::OMDataType onert_micro::core::onertMicroDatatype

(

const circle::TensorType

type

)

Definition at line 19 of file OMDataType.cpp.

{
  switch (type)
  {
    case circle::TensorType_FLOAT32:
      return OMDataType::FLOAT32;
    case circle::TensorType_FLOAT16:
      return OMDataType::FLOAT16;
    case circle::TensorType_INT32:
      return OMDataType::S32;
    case circle::TensorType_UINT8:
      return OMDataType::U8;
    case circle::TensorType_INT64:
      return OMDataType::S64;
    case circle::TensorType_BOOL:
      return OMDataType::BOOL;
    case circle::TensorType_INT16:
      return OMDataType::S16;
    case circle::TensorType_COMPLEX64:
      break;
    case circle::TensorType_INT8:
      return OMDataType::S8;
    default:
      break;
  }
  assert(false);
  return OMDataType::Unknown;
}

References type.

Referenced by onert_micro::core::memory::OMRuntimeAllocator::allocate(), onert_micro::core::memory::OMRuntimeAllocator::allocateGraphInputs(), and onert_micro::execute::execute_reshape_common().

size()

uint32_t onert_micro::core::size ( OMDataType  data_type )

inline

Returns the size of the data type.

Note

If you need the size at compile time, use sizeof(typename OMDataTypeImpl<DT>::Type).

Definition at line 144 of file OMDataType.h.

{
  switch (data_type)
  {
    case OMDataType::S8:
      return sizeof(OMDataTypeImpl<OMDataType::S8>::Type);
    case OMDataType::U8:
      return sizeof(OMDataTypeImpl<OMDataType::U8>::Type);
    case OMDataType::S16:
      return sizeof(OMDataTypeImpl<OMDataType::S16>::Type);
    case OMDataType::U16:
      return sizeof(OMDataTypeImpl<OMDataType::U16>::Type);
    case OMDataType::S32:
      return sizeof(OMDataTypeImpl<OMDataType::S32>::Type);
    case OMDataType::U32:
      return sizeof(OMDataTypeImpl<OMDataType::U32>::Type);
    case OMDataType::S64:
      return sizeof(OMDataTypeImpl<OMDataType::S64>::Type);
    case OMDataType::U64:
      return sizeof(OMDataTypeImpl<OMDataType::U64>::Type);
    case OMDataType::FLOAT16:
      return sizeof(OMDataTypeImpl<OMDataType::FLOAT16>::Type);
    case OMDataType::FLOAT32:
      return sizeof(OMDataTypeImpl<OMDataType::FLOAT32>::Type);
    case OMDataType::FLOAT64:
      return sizeof(OMDataTypeImpl<OMDataType::FLOAT64>::Type);
    case OMDataType::BOOL:
      return sizeof(OMDataTypeImpl<OMDataType::BOOL>::Type);
    default:
      // TODO Support remaining data types.
      assert(false);
      return 1; // Avoid compiler warning.
  }
}

References BOOL, FLOAT16, FLOAT32, FLOAT64, S16, S32, S64, S8, U16, U32, U64, and U8.