luci_interpreter Namespace Reference

Namespaces
namespace	kernels
namespace	lstm
namespace	test_kernel

Data Structures
struct	AddParams
struct	AffineQuantization
struct	ArgMaxParams
struct	BatchMatMulParams
class	BuddyMemoryManager
class	CircleReader
	Loads Circle file and provides helpers to access attributes. More...
class	CircleReferencingConstNodeBuilder
	Builder creates CircleCustom node with pointer to constants data from Tensor with buffer. More...
struct	ConcatenationParams
struct	Conv2DParams
struct	CumSumParams
struct	DataTypeImpl
	C++ scalar type corresponding to each DataType. More...
struct	DataTypeImpl< DataType::BOOL >
struct	DataTypeImpl< DataType::FLOAT16 >
struct	DataTypeImpl< DataType::FLOAT32 >
struct	DataTypeImpl< DataType::FLOAT64 >
struct	DataTypeImpl< DataType::S16 >
struct	DataTypeImpl< DataType::S32 >
struct	DataTypeImpl< DataType::S64 >
struct	DataTypeImpl< DataType::S8 >
struct	DataTypeImpl< DataType::U16 >
struct	DataTypeImpl< DataType::U32 >
struct	DataTypeImpl< DataType::U64 >
struct	DataTypeImpl< DataType::U8 >
struct	DepthToSpaceParams
struct	DepthwiseConv2DParams
struct	DivParams
class	EventNotifier
class	ExecutionObserver
struct	FullyConnectedParams
struct	GatherParams
struct	GeluParams
class	GraphLoader
struct	GRUParams
class	IMemoryManager
struct	InstanceNormParams
class	Interpreter
class	Kernel
class	KernelBuilder
class	KernelBuilderHelper
class	KernelBuilderRegistry
	Registry of kernel builders. More...
class	KernelConfigureRegistry
class	KernelExecuteRegistry
class	KernelWithParams
struct	L2NormParams
struct	LeakyReluParams
struct	LocalResponseNormalizationParams
struct	MirrorPadParams
class	ModuleLoader
struct	MulParams
struct	OneHotParams
struct	PackParams
struct	Pool2DParams
struct	ReducerParams
struct	ResizeBilinearParams
struct	ResizeNearestNeighborParams
struct	RmsNormParams
struct	RoPEParams
class	RuntimeGraph
class	RuntimeModule
class	RuntimeShape
struct	RuntimeToIR
class	Shape
struct	ShapeParams
class	SimpleMemoryManager
struct	SoftmaxParams
struct	SpaceToDepthParams
struct	SqueezeParams
class	StaticMemoryManager
struct	StridedSliceParams
struct	SubParams
struct	SVDFParams
class	Tensor
class	TestMemoryManager
struct	TransposeConvParams
struct	UnidirectionalSequenceLSTMParams
struct	UnpackParams
class	VectorWrapper
	Wrapper to use flatbuffers::Vector pointer as std::vector entity. More...

Typedefs
using	DataType = loco::DataType
template<DataType DT>
using	DataTypeImpl = loco::DataTypeImpl< DT >
using	Activation = luci::FusedActFunc
using	Padding = luci::Padding
using	MirrorPadMode = luci::MirrorPadMode
using	RoPEMode = luci::RoPEMode
using	BaseRuntimeGraph = RuntimeGraph
using	MemoryManager = SimpleMemoryManager

Enumerations
enum class	BuilderId { Size }
enum class	DataType {   Unknown , U8 , U16 , U32 ,   U64 , S8 , S16 , S32 ,   S64 , FLOAT16 , FLOAT32 , FLOAT64 ,   BOOL }
	"scalar" value type More...
enum class	FusedActFunc {   UNDEFINED , NONE , RELU , RELU_N1_TO_1 ,   RELU6 , TANH , SIGN_BIT }
enum class	Padding { UNDEFINED , SAME , VALID }
enum class	MirrorPadMode { UNDEFINED , REFLECT , SYMMETRIC }
enum class	BuilderID { Size }

Functions
size_t	getDataTypeSize (DataType data_type)
std::unique_ptr< luci::GraphBuilderSource >	source_without_constant_copying ()
	Creates and returns GraphBuilderSource, which allows to not copy constant buffers from model's file.
template<typename CircleNodeOut >
std::vector< const loco::Node * >	collectOutputNodes (const loco::Node *node)
std::unique_ptr< Kernel >	build_kernel_CircleAbs (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleAdd (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleArgMax (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleAveragePool2D (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleBatchMatMul (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleBatchToSpaceND (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleBroadcastTo (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleCast (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleConcatenation (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleConv2D (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleCos (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleCumSum (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleDepthToSpace (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleDepthwiseConv2D (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleDequantize (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleDiv (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleElu (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleEqual (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleExp (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleExpandDims (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleFill (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleFloor (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleFloorDiv (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleFloorMod (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleFullyConnected (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleGather (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleGelu (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleGreater (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleGreaterEqual (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleGRU (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleHardSwish (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleIf (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleInstanceNorm (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleL2Normalize (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleL2Pool2D (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLeakyRelu (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLess (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLessEqual (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLocalResponseNormalization (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLog (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLogicalAnd (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLogicalNot (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLogicalOr (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLogistic (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleLogSoftmax (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleMaximum (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleMaxPool2D (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleMean (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleMinimum (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleMirrorPad (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleMul (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleNeg (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleNotEqual (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleOneHot (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CirclePack (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CirclePad (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CirclePadV2 (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CirclePow (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CirclePRelu (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleQuantize (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleReduceMax (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleReduceProd (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleRelu (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleRelu0To1 (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleRelu6 (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleReshape (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleResizeBilinear (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleResizeNearestNeighbor (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleReverseV2 (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleRmsNorm (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleRoPE (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleRsqrt (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSelect (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSelectV2 (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleShape (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSin (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSlice (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSoftmax (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSpaceToBatchND (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSpaceToDepth (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSplit (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSplitV (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSqrt (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSquare (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSquaredDifference (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSqueeze (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleStridedSlice (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSub (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSum (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleSVDF (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleTanh (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleTile (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleTranspose (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleTransposeConv (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleUnidirectionalSequenceLSTM (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleUnpack (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
std::unique_ptr< Kernel >	build_kernel_CircleWhile (const luci::CircleNode *circle_node, KernelBuilderHelper &helper)
uint32_t	size (DataType data_type)
	Returns the size of the data type.
DataType	luci_datatype (circle::TensorType type)
FusedActFunc	luci_actfunc (circle::ActivationFunctionType type)
Padding	luci_padding (circle::Padding padding)
MirrorPadMode	luci_mirrorpad_mode (circle::MirrorPadMode mode)
template<typename T >
VectorWrapper< T >	wrap (const flatbuffers::Vector< T > *vec)
	REGISTER_WRAPPER (flatbuffers::Offset< circle::SubGraph >)
	REGISTER_WRAPPER (flatbuffers::Offset< circle::Buffer >)
	REGISTER_WRAPPER (flatbuffers::Offset< circle::Tensor >)
	REGISTER_WRAPPER (flatbuffers::Offset< circle::Operator >)
	REGISTER_WRAPPER (flatbuffers::Offset< circle::OperatorCode >)
	REGISTER_WRAPPER (flatbuffers::Offset< circle::Metadata >)
	REGISTER_WRAPPER (int32_t)
	REGISTER_WRAPPER (uint8_t)
void	configure_kernel_CircleAbs (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleAbs (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleAdd (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleAdd (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleAddN (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleAddN (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleArgMax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleArgMax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleArgMin (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleArgMin (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleAveragePool2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleAveragePool2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleBatchToSpaceND (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleBatchToSpaceND (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleBroadcastTo (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleBroadcastTo (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleCast (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleCast (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleCeil (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleCeil (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleConcatenation (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleConcatenation (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleConv2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleConv2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
int32_t	computeConvPadding (const circle::Tensor *input, const circle::Tensor *filter, circle::Padding padding_type, int32_t stride, int32_t dilation, int axis)
luci_interpreter_pal::ConvParams	createConv2DParams (const circle::Tensor *input, const circle::Tensor *filter, const circle::Tensor *output, const circle::Conv2DOptions *options)
void	configure_kernel_CircleCos (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleCos (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleDepthToSpace (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleDepthToSpace (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleDepthwiseConv2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleDepthwiseConv2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleDequantize (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleDequantize (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleDiv (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleDiv (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleElu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleElu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleExp (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleExp (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleExpandDims (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleExpandDims (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleFill (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleFill (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleFloor (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleFloor (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleFloorDiv (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleFloorDiv (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleFloorMod (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleFloorMod (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleFullyConnected (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleFullyConnected (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleGather (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleGather (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleGatherND (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleGatherND (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleGreater (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleGreater (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleGreaterEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleGreaterEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleIf (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleIf (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
constexpr BuilderID	get_builder_id (circle::BuiltinOperator opcode)
void	configure_kernel_CircleL2Normalize (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleL2Normalize (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleL2Pool2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleL2Pool2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLeakyRelu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLeakyRelu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLess (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLess (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLessEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLessEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLog (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLog (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLogicalAnd (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLogicalAnd (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLogicalNot (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLogicalNot (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLogicalOr (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLogicalOr (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLogistic (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLogistic (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleLogSoftmax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleLogSoftmax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleMaximum (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleMaximum (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleMaxPool2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleMaxPool2D (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleMean (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleMean (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleMinimum (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleMinimum (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleMirrorPad (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleMirrorPad (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleMul (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleMul (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleNeg (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleNeg (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleNotEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleNotEqual (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CirclePack (const circle::Operator *, BaseRuntimeGraph *)
void	execute_kernel_CirclePack (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CirclePad (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CirclePad (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CirclePadCommon (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CirclePadCommon (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CirclePadV2 (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CirclePadV2 (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CirclePool2DCommon (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
luci_interpreter_pal::PoolParams	createPoolParams (const circle::Operator *cur_op, const kernels::SISOKernel &siso_kernel)
void	configure_kernel_CirclePRelu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CirclePRelu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleQuantize (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleQuantize (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleReduceCommon (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleReduceCommon (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleReduceMax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleReduceMax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleRelu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleRelu (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleRelu6 (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleRelu6 (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleReshape (const circle::Operator *, BaseRuntimeGraph *)
void	execute_kernel_CircleReshape (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleResizeBilinear (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleResizeBilinear (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleResizeNearestNeighbor (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleResizeNearestNeighbor (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleRound (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleRound (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleRsqrt (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleRsqrt (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSelectV2 (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSelectV2 (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleShape (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleShape (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSin (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSin (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSlice (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSlice (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSoftmax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSoftmax (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSpaceToBatchND (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSpaceToBatchND (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSpaceToDepth (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSpaceToDepth (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSplit (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSplit (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
template<typename T >
void	splitImpl (const circle::Operator *cur_op, const circle::Tensor *input, int axis_value, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSplitV (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSplitV (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSqrt (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSqrt (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSquare (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSquare (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSquaredDifference (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSquaredDifference (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSqueeze (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSqueeze (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleStridedSlice (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleStridedSlice (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSub (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSub (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSum (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSum (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleSVDF (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleSVDF (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	evalInteger (const circle::Tensor *input, const circle::Tensor *output, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleTanh (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleTanh (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleTranspose (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleTranspose (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleTransposeConv (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleTransposeConv (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleUnidirectionalSequenceLSTM (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleUnidirectionalSequenceLSTM (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleUnpack (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleUnpack (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleWhile (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleWhile (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	configure_kernel_CircleZerosLike (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)
void	execute_kernel_CircleZerosLike (const circle::Operator *cur_op, BaseRuntimeGraph *runtime_graph)

Variables
constexpr KernelConfigureRegistry	kernel_configure
constexpr KernelExecuteRegistry	kernel_executor

Typedef Documentation

Activation

using luci_interpreter::Activation = typedef luci::FusedActFunc

Definition at line 33 of file KernelParams.h.

BaseRuntimeGraph

using luci_interpreter::BaseRuntimeGraph = typedef RuntimeGraph

Definition at line 39 of file RuntimeModule.h.

DataType

using luci_interpreter::DataType = typedef loco::DataType

Definition at line 29 of file DataType.h.

DataTypeImpl

template<DataType DT>

using luci_interpreter::DataTypeImpl = typedef loco::DataTypeImpl<DT>

Definition at line 31 of file DataType.h.

MemoryManager

using luci_interpreter::MemoryManager = typedef SimpleMemoryManager

Definition at line 40 of file RuntimeModule.h.

MirrorPadMode

using luci_interpreter::MirrorPadMode = typedef luci::MirrorPadMode

Definition at line 35 of file KernelParams.h.

Padding

using luci_interpreter::Padding = typedef luci::Padding

Definition at line 34 of file KernelParams.h.

RoPEMode

using luci_interpreter::RoPEMode = typedef luci::RoPEMode

Definition at line 36 of file KernelParams.h.

Enumeration Type Documentation

BuilderId

enum class luci_interpreter::BuilderId

strong

Enumerator
Size

Definition at line 59 of file KernelBuilder.cpp.

{
#include <luci/IR/CircleNodes.lst>
  Size // casts to count of values in BuilderId enum
};

BuilderID

enum class luci_interpreter::BuilderID

strong

Enumerator
Size

Definition at line 31 of file KernelBuilder.h.

{
#if USE_GENERATED_LIST
#include "GeneratedKernelsToBuild.lst"
#else
#include "KernelsToBuild.lst"
#endif
  Size // casts to count of values in BuilderId enum
};

DataType

enum class luci_interpreter::DataType

strong

"scalar" value type

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

Definition at line 31 of file DataType.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
 
  // WARNING the size of Bool may vary for NN frameworks
  // TODO we need to find a way to resolve this issue
  BOOL, // Boolean
};

FusedActFunc

enum class luci_interpreter::FusedActFunc

strong

Enumerator
UNDEFINED
NONE
RELU
RELU_N1_TO_1
RELU6
TANH
SIGN_BIT

Definition at line 27 of file ParamsType.h.

{
  UNDEFINED, // This is not defined by TFLite or Circle. This was added to
  // prevent programming error.
  NONE,
  RELU,
  RELU_N1_TO_1,
  RELU6,
  TANH,
  SIGN_BIT
};

MirrorPadMode

enum class luci_interpreter::MirrorPadMode

strong

Enumerator
UNDEFINED
REFLECT
SYMMETRIC

Definition at line 47 of file ParamsType.h.

{
  UNDEFINED, // This is not defined by Circle. This was added to prevent programming error.
 
  REFLECT,
  SYMMETRIC,
};

Padding

enum class luci_interpreter::Padding

strong

Enumerator
UNDEFINED
SAME
VALID

Definition at line 39 of file ParamsType.h.

{
  UNDEFINED, // This is not defined by TFLite. This was added to prevent programming error.
 
  SAME,
  VALID,
};

Function Documentation

build_kernel_CircleAbs()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleAbs	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Abs.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleAbs *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Abs>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleAdd()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleAdd	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Add.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleAdd *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  AddParams params{};
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::Add>(input1, input2, output, params);
}

References luci_interpreter::AddParams::activation, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleArgMax()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleArgMax	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file ArgMax.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleArgMax *>(circle_node);
  assert(node->arity() == 2);
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *axis = helper.getInputTensor(node->dimension());
  Tensor *output = helper.getOutputTensor(node);
 
  ArgMaxParams params{};
  params.output_type = node->output_type();
 
  return std::make_unique<kernels::ArgMax>(input, axis, output, params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::ArgMaxParams::output_type.

build_kernel_CircleAveragePool2D()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleAveragePool2D	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 25 of file AveragePool2D.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleAveragePool2D *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->value());
  Tensor *output = helper.getOutputTensor(node);
 
  Pool2DParams params{};
  params.padding = node->padding();
  params.filter_height = node->filter()->h();
  params.filter_width = node->filter()->w();
  params.stride_height = node->stride()->h();
  params.stride_width = node->stride()->w();
  params.activation = node->fusedActivationFunction();
 
  // It is unknown what data will be stored in scratchpad tensor,
  // using UINT8 as a most general option
  auto scratchpad = std::make_unique<Tensor>(DataType::U8, Shape({}), AffineQuantization{}, "");
  scratchpad->set_observable(false);
  scratchpad->set_data_buffer(nullptr);
  // If node has execution plan then read memory offsets for scratchpad temporary tensor
  // from the beginning of shared memory buffer.
  // Used in Static Memory Manager.
  // TODO move tensors offset initialization to one place
  if (luci::has_execution_plan(node))
  {
    const auto execution_plan = luci::get_execution_plan(node);
    // Check whether the offset for the current CircleConv2D temporary was found.
    if (execution_plan.offsets().size() > 1)
      // If this is true, then we keep this offset in scratchpad.
      scratchpad->set_offset(execution_plan.offsets().at(1));
  }
  Tensor *tmp = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad));
 
  return std::make_unique<kernels::AveragePool2D>(input, output, tmp, params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci::get_execution_plan(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci::has_execution_plan(), and luci_interpreter::Pool2DParams::padding.

build_kernel_CircleBatchMatMul()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleBatchMatMul	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 25 of file BatchMatMul.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleBatchMatMul *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *lhs = helper.getInputTensor(node->x());
  const Tensor *rhs = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  auto lhs_scratchpad =
    std::make_unique<Tensor>(lhs->element_type(), Shape({}), AffineQuantization{}, "");
  lhs_scratchpad->set_observable(false);
  lhs_scratchpad->set_data_buffer(nullptr);
  auto rhs_scratchpad =
    std::make_unique<Tensor>(rhs->element_type(), Shape({}), AffineQuantization{}, "");
  rhs_scratchpad->set_observable(false);
  rhs_scratchpad->set_data_buffer(nullptr);
  // If node has execution plan then read memory offsets for scratchpad temporary tensor
  // from the beginning of shared memory buffer.
  // Used in Static Memory Manager.
  // TODO move tensors offset initialization to one place
  if (luci::has_execution_plan(node))
  {
    const auto execution_plan = luci::get_execution_plan(node);
    // Check whether the offset for the current BatchMatMul temporary was found.
    if (execution_plan.offsets().size() > 1)
    {
      assert(execution_plan.offsets().size() == 3);
 
      // If this is true, then we keep this offset in scratchpad.
      lhs_scratchpad->set_offset(execution_plan.offsets().at(1));
      rhs_scratchpad->set_offset(execution_plan.offsets().at(2));
    }
  }
  Tensor *lhs_tmp = helper.getRuntimeGraph(node->graph())->addTensor(std::move(lhs_scratchpad));
  Tensor *rhs_tmp = helper.getRuntimeGraph(node->graph())->addTensor(std::move(rhs_scratchpad));
 
  BatchMatMulParams params;
  params.adj_x = node->adj_x();
  params.adj_y = node->adj_y();
 
  return std::make_unique<kernels::BatchMatMul>(lhs, rhs, output, lhs_tmp, rhs_tmp, params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::BatchMatMulParams::adj_x, luci_interpreter::BatchMatMulParams::adj_y, luci_interpreter::Tensor::element_type(), luci::get_execution_plan(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci::has_execution_plan(), and luci_interpreter::Tensor::set_observable().

build_kernel_CircleBatchToSpaceND()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleBatchToSpaceND	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file BatchToSpaceND.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleBatchToSpaceND *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *block_shape = helper.getInputTensor(node->block_shape());
  const Tensor *crops = helper.getInputTensor(node->crops());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::BatchToSpaceND>(input, block_shape, crops, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleBroadcastTo()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleBroadcastTo	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file BroadcastTo.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleBroadcastTo *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *shape = helper.getInputTensor(node->shape());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::BroadcastTo>(input, shape, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleCast()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleCast	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Cast.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleCast *>(circle_node);
 
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Cast>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleConcatenation()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleConcatenation	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Concatenation.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleConcatenation *>(circle_node);
  std::vector<const Tensor *> inputs(node->numValues());
  for (uint32_t i = 0; i < node->numValues(); ++i)
  {
    inputs[i] = helper.getInputTensor(node->values(i));
  }
  Tensor *output = helper.getOutputTensor(node);
 
  ConcatenationParams params{};
  params.axis = node->axis();
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::Concatenation>(std::move(inputs), output, params);
}

References luci_interpreter::ConcatenationParams::axis, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleConv2D()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleConv2D	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 25 of file Conv2D.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleConv2D *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *filter = helper.getInputTensor(node->filter());
  const Tensor *bias = helper.getOptionalInputTensor(node->bias());
  Tensor *output = helper.getOutputTensor(node);
 
  // It is unknown what data will be stored in scratchpad tensor,
  // using UINT8 as a most general option
  auto scratchpad = std::make_unique<Tensor>(DataType::U8, Shape({}), AffineQuantization{}, "");
  scratchpad->set_observable(false);
  scratchpad->set_data_buffer(nullptr);
  // If node has execution plan then read memory offsets for scratchpad temporary tensor
  // from the beginning of shared memory buffer.
  // Used in Static Memory Manager.
  // TODO move tensors offset initialization to one place
  if (luci::has_execution_plan(node))
  {
    const auto execution_plan = luci::get_execution_plan(node);
    // Check whether the offset for the current CircleConv2D temporary was found.
    if (execution_plan.offsets().size() > 1)
      // If this is true, then we keep this offset in scratchpad.
      scratchpad->set_offset(execution_plan.offsets().at(1));
  }
  Tensor *tmp = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad));
 
  Conv2DParams params{};
  params.padding = node->padding();
  params.stride_height = node->stride()->h();
  params.stride_width = node->stride()->w();
  params.dilation_height_factor = node->dilation()->h();
  params.dilation_width_factor = node->dilation()->w();
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::Conv2D>(input, filter, bias, output, tmp, params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci::get_execution_plan(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOptionalInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci::has_execution_plan(), luci_interpreter::Conv2DParams::padding, and luci_interpreter::Tensor::set_observable().

build_kernel_CircleCos()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleCos	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Cos.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleCos *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Cos>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleCumSum()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleCumSum	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file CumSum.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleCumSum *>(circle_node);
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *axis = helper.getInputTensor(node->axis());
  Tensor *output = helper.getOutputTensor(node);
 
  CumSumParams params{};
  params.exclusive = node->exclusive();
  params.reverse = node->reverse();
 
  return std::make_unique<kernels::CumSum>(input, axis, output, params);
}

References luci_interpreter::CumSumParams::exclusive, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleDepthToSpace()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleDepthToSpace	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file DepthToSpace.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleDepthToSpace *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->input());
  Tensor *output = helper.getOutputTensor(node);
 
  DepthToSpaceParams params{};
  params.block_size = node->block_size();
 
  return std::make_unique<kernels::DepthToSpace>(input, output, params);
}

References luci_interpreter::DepthToSpaceParams::block_size, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleDepthwiseConv2D()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleDepthwiseConv2D	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 25 of file DepthwiseConv2D.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleDepthwiseConv2D *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *filter = helper.getInputTensor(node->filter());
  const Tensor *bias = helper.getInputTensor(node->bias());
  Tensor *output = helper.getOutputTensor(node);
 
  DepthwiseConv2DParams params{};
  params.padding = node->padding();
  params.depth_multiplier = node->depthMultiplier();
  params.stride_height = node->stride()->h();
  params.stride_width = node->stride()->w();
  params.dilation_height_factor = node->dilation()->h();
  params.dilation_width_factor = node->dilation()->w();
  params.activation = node->fusedActivationFunction();
 
  // It is unknown what data will be stored in scratchpad tensor,
  // using UINT8 as a most general option
  auto scratchpad = std::make_unique<Tensor>(DataType::U8, Shape({}), AffineQuantization{}, "");
  scratchpad->set_observable(false);
  scratchpad->set_data_buffer(nullptr);
  // If node has execution plan then read memory offsets for scratchpad temporary tensor
  // from the beginning of shared memory buffer.
  // Used in Static Memory Manager.
  // TODO move tensors offset initialization to one place
  if (luci::has_execution_plan(node))
  {
    const auto execution_plan = luci::get_execution_plan(node);
    // Check whether the offset for the current CircleConv2D temporary was found.
    if (execution_plan.offsets().size() > 1)
      // If this is true, then we keep this offset in scratchpad.
      scratchpad->set_offset(execution_plan.offsets().at(1));
  }
  Tensor *tmp = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad));
 
  return std::make_unique<kernels::DepthwiseConv2D>(input, filter, bias, output, tmp, params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci::get_execution_plan(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci::has_execution_plan(), and luci_interpreter::DepthwiseConv2DParams::padding.

build_kernel_CircleDequantize()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleDequantize	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Dequantize.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleDequantize *>(circle_node);
 
  const Tensor *input = helper.getInputTensor(node->input());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Dequantize>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleDiv()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleDiv	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Div.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleDiv *>(circle_node);
  assert(node->arity() == 2);
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  DivParams params{};
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::Div>(input1, input2, output, params);
}

References luci_interpreter::DivParams::activation, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleElu()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleElu	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Elu.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleElu *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->features());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Elu>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleEqual()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleEqual	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Equal.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleEqual *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Equal>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleExp()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleExp	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Exp.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleExp *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Exp>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleExpandDims()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleExpandDims	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file ExpandDims.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleExpandDims *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *axis = helper.getInputTensor(node->axis());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::ExpandDims>(input, axis, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleFill()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleFill	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Fill.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleFill *>(circle_node);
  assert(node->arity() == 2);
 
  const auto dims = helper.getInputTensor(node->dims());
  const auto value = helper.getInputTensor(node->value());
  auto output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Fill>(dims, value, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleFloor()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleFloor	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Floor.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleFloor *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Floor>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleFloorDiv()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleFloorDiv	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file FloorDiv.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleFloorDiv *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::FloorDiv>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleFloorMod()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleFloorMod	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file FloorMod.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleFloorMod *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::FloorMod>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleFullyConnected()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleFullyConnected	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file FullyConnected.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleFullyConnected *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *weights = helper.getInputTensor(node->weights());
  const Tensor *bias = helper.getOptionalInputTensor(node->bias());
  Tensor *output = helper.getOutputTensor(node);
 
  FullyConnectedParams params{};
  params.activation = node->fusedActivationFunction();
  params.keep_num_dims = node->keep_num_dims();
  if (weights->element_type() == loco::DataType::S4 ||
      weights->element_type() == loco::DataType::U4)
  {
    auto scratchpad =
      std::make_unique<Tensor>(input->element_type(), weights->shape(), AffineQuantization{}, "");
    scratchpad->set_observable(false);
    scratchpad->set_data_buffer(nullptr);
    Tensor *scratchpad_tmp =
      helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad));
    helper.getRuntimeGraph(node->graph())->configureAllocations(scratchpad_tmp);
    return std::make_unique<kernels::FullyConnected>(input, weights, bias, output, scratchpad_tmp,
                                                     params);
  }
  return std::make_unique<kernels::FullyConnected>(input, weights, bias, output, params);
}

References luci_interpreter::FullyConnectedParams::activation, luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::RuntimeGraph::configureAllocations(), luci_interpreter::Tensor::element_type(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOptionalInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), and luci_interpreter::Tensor::shape().

build_kernel_CircleGather()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleGather	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Gather.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleGather *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *params = helper.getInputTensor(node->params());
  const Tensor *indices = helper.getInputTensor(node->indices());
  Tensor *output = helper.getOutputTensor(node);
 
  GatherParams gparams{};
  gparams.axis = node->axis();
  // TODO support batch_dims
  gparams.batch_dims = 0;
 
  return std::make_unique<kernels::Gather>(params, indices, output, gparams);
}

References luci_interpreter::GatherParams::axis, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleGelu()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleGelu	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Gelu.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleGelu *>(circle_node);
  assert(node->arity() == 1);
  const Tensor *input = helper.getInputTensor(node->features());
  Tensor *output = helper.getOutputTensor(node);
 
  GeluParams params{};
  params.approximate = node->approximate();
 
  return std::make_unique<kernels::Gelu>(input, output, params);
}

References luci_interpreter::GeluParams::approximate, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleGreater()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleGreater	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Greater.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleGreater *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Greater>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleGreaterEqual()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleGreaterEqual	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file GreaterEqual.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleGreaterEqual *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::GreaterEqual>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleGRU()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleGRU	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file GRU.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleGRU *>(circle_node);
  assert(node->arity() == 6);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *hidden_hidden = helper.getInputTensor(node->hidden_hidden());
  const Tensor *hidden_hidden_bias = helper.getInputTensor(node->hidden_hidden_bias());
  const Tensor *hidden_input = helper.getInputTensor(node->hidden_input());
  const Tensor *hidden_input_bias = helper.getInputTensor(node->hidden_input_bias());
  const Tensor *state = helper.getInputTensor(node->state());
 
  Tensor *output = helper.getOutputTensor(node);
 
  GRUParams params{};
  params.fused_act_function = node->fusedActivationFunction();
  params.return_sequences = node->returnSequences();
  params.time_major = node->timeMajor();
 
  return std::make_unique<kernels::GRU>(input, hidden_hidden, hidden_hidden_bias, hidden_input,
                                        hidden_input_bias, state, output, params);
}

References luci_interpreter::GRUParams::fused_act_function, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleHardSwish()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleHardSwish	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file HardSwish.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleHardSwish *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->features());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::HardSwish>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleIf()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleIf	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file If.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleIf *>(circle_node);
  auto output_nodes = collectOutputNodes<luci::CircleIfOut>(node);
  assert(node->arity() == 1 + node->input_count());
  assert(output_nodes.size() == static_cast<size_t>(node->output_count()));
 
  const Tensor *cond = helper.getInputTensor(node->cond());
  std::vector<const Tensor *> inputs(node->input_count());
  for (uint32_t i = 0; i < node->input_count(); ++i)
  {
    inputs[i] = helper.getInputTensor(node->input(i));
  }
  std::vector<Tensor *> outputs = helper.getOutputTensors(output_nodes);
 
  RuntimeGraph *then_graph = helper.getRuntimeGraph(node->then_graph());
  RuntimeGraph *else_graph = helper.getRuntimeGraph(node->else_graph());
 
  return std::make_unique<kernels::If>(cond, std::move(inputs), std::move(outputs), then_graph,
                                       else_graph);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensors(), and luci_interpreter::KernelBuilderHelper::getRuntimeGraph().

build_kernel_CircleInstanceNorm()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleInstanceNorm	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file InstanceNorm.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleInstanceNorm *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *gamma = helper.getInputTensor(node->gamma());
  const Tensor *beta = helper.getInputTensor(node->beta());
 
  Tensor *output = helper.getOutputTensor(node);
 
  InstanceNormParams params{};
  params.epsilon = node->epsilon();
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::InstanceNorm>(input, gamma, beta, output, params);
}

References luci_interpreter::InstanceNormParams::epsilon, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleL2Normalize()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleL2Normalize	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file L2Normalize.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleL2Normalize *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  L2NormParams params{};
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::L2Normalize>(input, output, params);
}

References luci_interpreter::L2NormParams::activation, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleL2Pool2D()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleL2Pool2D	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file L2Pool2D.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleL2Pool2D *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->value());
  Tensor *output = helper.getOutputTensor(node);
 
  Pool2DParams params{};
  params.padding = node->padding();
  params.filter_height = node->filter()->h();
  params.filter_width = node->filter()->w();
  params.stride_height = node->stride()->h();
  params.stride_width = node->stride()->w();
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::L2Pool2D>(input, output, params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::Pool2DParams::padding.

build_kernel_CircleLeakyRelu()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLeakyRelu	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file LeakyRelu.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLeakyRelu *>(circle_node);
  assert(node->arity() == 1);
  const Tensor *input = helper.getInputTensor(node->features());
  Tensor *output = helper.getOutputTensor(node);
 
  LeakyReluParams params{};
  params.alpha = node->alpha();
 
  return std::make_unique<kernels::LeakyRelu>(input, output, params);
}

References luci_interpreter::LeakyReluParams::alpha, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLess()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLess	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Less.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLess *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Less>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLessEqual()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLessEqual	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file LessEqual.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLessEqual *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::LessEqual>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLocalResponseNormalization()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLocalResponseNormalization	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 25 of file LocalResponseNormalization.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLocalResponseNormalization *>(circle_node);
  assert(node->arity() == 1);
  const Tensor *input = helper.getInputTensor(node->input());
  Tensor *output = helper.getOutputTensor(node);
 
  LocalResponseNormalizationParams params{};
  params.radius = node->radius();
  params.bias = node->bias();
  params.alpha = node->alpha();
  params.beta = node->beta();
 
  return std::make_unique<kernels::LocalResponseNormalization>(input, output, params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::LocalResponseNormalizationParams::radius.

build_kernel_CircleLog()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLog	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Log.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLog *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Log>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLogicalAnd()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLogicalAnd	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file LogicalAnd.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLogicalAnd *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::LogicalAnd>(input1, input2, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLogicalNot()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLogicalNot	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file LogicalNot.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLogicalNot *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::LogicalNot>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLogicalOr()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLogicalOr	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file LogicalOr.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLogicalOr *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::LogicalOr>(input1, input2, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLogistic()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLogistic	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Logistic.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLogistic *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Logistic>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleLogSoftmax()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleLogSoftmax	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file LogSoftmax.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleLogSoftmax *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->logits());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::LogSoftmax>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleMaximum()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleMaximum	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Maximum.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleMaximum *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Maximum>(input1, input2, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleMaxPool2D()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleMaxPool2D	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file MaxPool2D.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleMaxPool2D *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->value());
  Tensor *output = helper.getOutputTensor(node);
 
  Pool2DParams params{};
  params.padding = node->padding();
  params.filter_height = node->filter()->h();
  params.filter_width = node->filter()->w();
  params.stride_height = node->stride()->h();
  params.stride_width = node->stride()->w();
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::MaxPool2D>(input, output, params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::Pool2DParams::padding.

build_kernel_CircleMean()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleMean	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Mean.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleMean *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *axes = helper.getInputTensor(node->reduction_indices());
  Tensor *output = helper.getOutputTensor(node);
 
  auto temp_index_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  temp_index_unique->set_observable(false);
  temp_index_unique->set_data_buffer(nullptr);
  Tensor *temp_index =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(temp_index_unique));
 
  auto resolved_axes_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  resolved_axes_unique->set_observable(false);
  resolved_axes_unique->set_data_buffer(nullptr);
  Tensor *resolved_axes =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(resolved_axes_unique));
 
  auto temp_sum_unique =
    std::make_unique<Tensor>(input->element_type(), Shape({}), AffineQuantization{}, "");
  temp_sum_unique->set_observable(false);
  temp_sum_unique->set_data_buffer(nullptr);
  Tensor *temp_sum = helper.getRuntimeGraph(node->graph())->addTensor(std::move(temp_sum_unique));
 
  ReducerParams params{};
  params.keep_dims = node->keep_dims();
 
  return std::make_unique<kernels::Mean>(input, axes, output, temp_index, resolved_axes, temp_sum,
                                         params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci_interpreter::ReducerParams::keep_dims, and luci_interpreter::Tensor::set_observable().

build_kernel_CircleMinimum()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleMinimum	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Minimum.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleMinimum *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Minimum>(input1, input2, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleMirrorPad()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleMirrorPad	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file MirrorPad.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleMirrorPad *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *paddings = helper.getInputTensor(node->paddings());
  Tensor *output = helper.getOutputTensor(node);
 
  MirrorPadParams params{};
  params.mode = node->mode();
 
  return std::make_unique<kernels::MirrorPad>(input, paddings, output, params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::MirrorPadParams::mode.

build_kernel_CircleMul()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleMul	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Mul.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleMul *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  MulParams params{};
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::Mul>(input1, input2, output, params);
}

References luci_interpreter::MulParams::activation, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleNeg()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleNeg	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Neg.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleNeg *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Neg>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleNotEqual()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleNotEqual	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file NotEqual.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleNotEqual *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *x = helper.getInputTensor(node->x());
  const Tensor *y = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::NotEqual>(x, y, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleOneHot()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleOneHot	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file OneHot.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleOneHot *>(circle_node);
  assert(node->arity() == 4);
 
  const Tensor *indices = helper.getInputTensor(node->indices());
  const Tensor *depth = helper.getInputTensor(node->depth());
  const Tensor *on_value = helper.getInputTensor(node->on_value());
  const Tensor *off_value = helper.getInputTensor(node->off_value());
  Tensor *output = helper.getOutputTensor(node);
 
  OneHotParams params{};
  params.axis = node->axis();
 
  return std::make_unique<kernels::OneHot>(indices, depth, on_value, off_value, output, params);
}

References luci_interpreter::OneHotParams::axis, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CirclePack()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CirclePack	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Pack.cpp.

{
  const auto *node = loco::must_cast<const luci::CirclePack *>(circle_node);
  assert(node->arity() == node->values_count());
 
  std::vector<const Tensor *> inputs(node->values_count());
  for (uint32_t i = 0; i < node->values_count(); ++i)
  {
    inputs[i] = helper.getInputTensor(node->values(i));
  }
  Tensor *output = helper.getOutputTensor(node);
 
  PackParams params{};
  params.axis = node->axis();
  params.values_count = node->values_count();
 
  return std::make_unique<kernels::Pack>(std::move(inputs), output, params);
}

References luci_interpreter::PackParams::axis, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CirclePad()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CirclePad	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Pad.cpp.

{
  const auto *node = loco::must_cast<const luci::CirclePad *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *paddings = helper.getInputTensor(node->paddings());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Pad>(input, paddings, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CirclePadV2()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CirclePadV2	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file PadV2.cpp.

{
  const auto *node = loco::must_cast<const luci::CirclePadV2 *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *paddings = helper.getInputTensor(node->paddings());
  const Tensor *constant_values = helper.getInputTensor(node->constant_values());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::PadV2>(input, paddings, constant_values, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CirclePow()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CirclePow	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Pow.cpp.

{
  const auto *node = loco::must_cast<const luci::CirclePow *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
 
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Pow>(input1, input2, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CirclePRelu()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CirclePRelu	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file PRelu.cpp.

{
  const auto *node = loco::must_cast<const luci::CirclePRelu *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *alpha = helper.getInputTensor(node->alpha());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::PRelu>(input, alpha, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleQuantize()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleQuantize	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Quantize.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleQuantize *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->input());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Quantize>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleReduceMax()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleReduceMax	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file ReduceMax.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleReduceMax *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *axes = helper.getInputTensor(node->reduction_indices());
  Tensor *output = helper.getOutputTensor(node);
 
  auto temp_index_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  temp_index_unique->set_observable(false);
  temp_index_unique->set_data_buffer(nullptr);
  Tensor *temp_index =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(temp_index_unique));
 
  auto resolved_axes_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  resolved_axes_unique->set_observable(false);
  resolved_axes_unique->set_data_buffer(nullptr);
  Tensor *resolved_axes =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(resolved_axes_unique));
 
  ReducerParams params{};
  params.keep_dims = node->keep_dims();
 
  return std::make_unique<kernels::ReduceMax>(input, axes, output, temp_index, resolved_axes,
                                              params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci_interpreter::ReducerParams::keep_dims, and luci_interpreter::Tensor::set_observable().

build_kernel_CircleReduceProd()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleReduceProd	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file ReduceProd.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleReduceProd *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *axes = helper.getInputTensor(node->reduction_indices());
  Tensor *output = helper.getOutputTensor(node);
 
  auto temp_index_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  temp_index_unique->set_observable(false);
  temp_index_unique->set_data_buffer(nullptr);
  Tensor *temp_index =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(temp_index_unique));
 
  auto resolved_axes_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  resolved_axes_unique->set_observable(false);
  resolved_axes_unique->set_data_buffer(nullptr);
  Tensor *resolved_axes =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(resolved_axes_unique));
 
  ReducerParams params{};
  params.keep_dims = node->keep_dims();
 
  return std::make_unique<kernels::ReduceProd>(input, axes, output, temp_index, resolved_axes,
                                               params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci_interpreter::ReducerParams::keep_dims, and luci_interpreter::Tensor::set_observable().

build_kernel_CircleRelu()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleRelu	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Relu.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleRelu *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->features());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Relu>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleRelu0To1()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleRelu0To1	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Relu0To1.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleRelu0To1 *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->features());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Relu0To1>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleRelu6()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleRelu6	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Relu6.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleRelu6 *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->features());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Relu6>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleReshape()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleReshape	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Reshape.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleReshape *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->tensor());
  const Tensor *shape = helper.getInputTensor(node->shape());
  Tensor *output = helper.getOutputTensor(node);
 
  // NOTE 'newShape' attribute is ignored.
  return std::make_unique<kernels::Reshape>(input, shape, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleResizeBilinear()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleResizeBilinear	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file ResizeBilinear.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleResizeBilinear *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *size = helper.getInputTensor(node->size());
  Tensor *output = helper.getOutputTensor(node);
 
  ResizeBilinearParams params{};
  params.align_corners = node->align_corners();
  params.half_pixel_centers = node->half_pixel_centers();
 
  return std::make_unique<kernels::ResizeBilinear>(input, size, output, params);
}

References luci_interpreter::ResizeBilinearParams::align_corners, luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and size.

build_kernel_CircleResizeNearestNeighbor()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleResizeNearestNeighbor	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 25 of file ResizeNearestNeighbor.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleResizeNearestNeighbor *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *size = helper.getInputTensor(node->size());
  Tensor *output = helper.getOutputTensor(node);
 
  ResizeNearestNeighborParams params{};
  params.align_corners = node->align_corners();
  // TODO update half_pixel_centers after CircleResizeNearestNeighbor updated
  // Current CircleResizeNearestNeighbor don't have half_pixel_centers.
  // default value on current is false.
  // it need to be updated when CircleResizeNearestNeighbor updated.
  params.half_pixel_centers = false;
 
  return std::make_unique<kernels::ResizeNearestNeighbor>(input, size, output, params);
}

References luci_interpreter::ResizeNearestNeighborParams::align_corners, luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and size.

build_kernel_CircleReverseV2()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleReverseV2	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file ReverseV2.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleReverseV2 *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->tensor());
  const Tensor *axes = helper.getInputTensor(node->axis());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::ReverseV2>(input, axes, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleRmsNorm()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleRmsNorm	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file RmsNorm.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleRmsNorm *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *gamma = helper.getInputTensor(node->gamma());
 
  Tensor *output = helper.getOutputTensor(node);
 
  RmsNormParams params{};
  params.epsilon = node->epsilon();
 
  return std::make_unique<kernels::RmsNorm>(input, gamma, output, params);
}

References luci_interpreter::RmsNormParams::epsilon, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleRoPE()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleRoPE	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file RoPE.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleRoPE *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *sin_table = helper.getInputTensor(node->sin_table());
  const Tensor *cos_table = helper.getInputTensor(node->cos_table());
 
  Tensor *output = helper.getOutputTensor(node);
 
  RoPEParams params{};
  params.mode = node->mode();
 
  return std::make_unique<kernels::RoPE>(input, sin_table, cos_table, output, params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::RoPEParams::mode.

build_kernel_CircleRsqrt()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleRsqrt	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Rsqrt.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleRsqrt *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Rsqrt>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSelect()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSelect	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Select.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSelect *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *c = helper.getInputTensor(node->condition());
  const Tensor *t = helper.getInputTensor(node->t());
  const Tensor *e = helper.getInputTensor(node->e());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Select>(c, t, e, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSelectV2()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSelectV2	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file SelectV2.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSelectV2 *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *c = helper.getInputTensor(node->condition());
  const Tensor *t = helper.getInputTensor(node->t());
  const Tensor *e = helper.getInputTensor(node->e());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::SelectV2>(c, t, e, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleShape()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleShape	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Shape.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleShape *>(circle_node);
  assert(node->arity() == 1);
 
  const auto input = helper.getInputTensor(node->input());
  auto output = helper.getOutputTensor(node);
 
  ShapeParams shape_params{};
  shape_params.out_type = node->out_type();
 
  return std::make_unique<kernels::ShapeKernel>(input, output, shape_params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::ShapeParams::out_type.

build_kernel_CircleSin()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSin	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Sin.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSin *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Sin>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSlice()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSlice	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Slice.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSlice *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *begin = helper.getInputTensor(node->begin());
  const Tensor *size = helper.getInputTensor(node->size());
 
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Slice>(input, begin, size, output);
}

References begin, luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and size.

build_kernel_CircleSoftmax()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSoftmax	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Softmax.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSoftmax *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->logits());
  Tensor *output = helper.getOutputTensor(node);
 
  SoftmaxParams params{};
  params.beta = node->beta();
 
  return std::make_unique<kernels::Softmax>(input, output, params);
}

References luci_interpreter::SoftmaxParams::beta, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSpaceToBatchND()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSpaceToBatchND	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file SpaceToBatchND.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSpaceToBatchND *>(circle_node);
  assert(node->arity() == 3);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *block_shape = helper.getInputTensor(node->block_shape());
  const Tensor *paddings = helper.getInputTensor(node->paddings());
 
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::SpaceToBatchND>(input, block_shape, paddings, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSpaceToDepth()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSpaceToDepth	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file SpaceToDepth.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSpaceToDepth *>(circle_node);
  assert(node->arity() == 1);
  const Tensor *input = helper.getInputTensor(node->input());
 
  Tensor *output = helper.getOutputTensor(node);
 
  SpaceToDepthParams params{};
  params.block_size = node->block_size();
 
  return std::make_unique<kernels::SpaceToDepth>(input, output, params);
}

References luci_interpreter::SpaceToDepthParams::block_size, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSplit()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSplit	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Split.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSplit *>(circle_node);
  auto output_nodes = collectOutputNodes<luci::CircleSplitOut>(node);
  assert(node->arity() == 2);
  assert(output_nodes.size() == static_cast<size_t>(node->num_split()));
 
  const Tensor *axis = helper.getInputTensor(node->split_dim());
  const Tensor *input = helper.getInputTensor(node->input());
  std::vector<Tensor *> outputs = helper.getOutputTensors(output_nodes);
 
  // NOTE 'num_splits' attribute is ignored.
  return std::make_unique<kernels::Split>(axis, input, std::move(outputs));
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensors().

build_kernel_CircleSplitV()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSplitV	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file SplitV.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSplitV *>(circle_node);
  auto output_nodes = collectOutputNodes<luci::CircleSplitVOut>(node);
  assert(node->arity() == 3);
  assert(output_nodes.size() == static_cast<size_t>(node->num_split()));
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *sizes_data = helper.getInputTensor(node->size_splits());
  const Tensor *axis = helper.getInputTensor(node->split_dim());
  std::vector<Tensor *> outputs = helper.getOutputTensors(output_nodes);
 
  // NOTE 'num_splits' attribute is ignored.
  return std::make_unique<kernels::SplitV>(input, sizes_data, axis, std::move(outputs));
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensors().

build_kernel_CircleSqrt()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSqrt	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Sqrt.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSqrt *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Sqrt>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSquare()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSquare	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Square.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSquare *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Square>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSquaredDifference()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSquaredDifference	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file SquaredDifference.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSquaredDifference *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::SquaredDifference>(input1, input2, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSqueeze()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSqueeze	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Squeeze.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSqueeze *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->input());
  Tensor *output = helper.getOutputTensor(node);
 
  SqueezeParams params{};
  params.squeeze_dims = node->squeeze_dims();
 
  return std::make_unique<kernels::Squeeze>(input, output, params);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), and luci_interpreter::SqueezeParams::squeeze_dims.

build_kernel_CircleStridedSlice()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleStridedSlice	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file StridedSlice.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleStridedSlice *>(circle_node);
  assert(node->arity() == 4);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *begin = helper.getInputTensor(node->begin());
  const Tensor *end = helper.getInputTensor(node->end());
  const Tensor *strides = helper.getInputTensor(node->strides());
 
  Tensor *output = helper.getOutputTensor(node);
 
  StridedSliceParams params{};
  params.begin_mask = node->begin_mask();
  params.ellipsis_mask = node->ellipsis_mask();
  params.end_mask = node->end_mask();
  params.new_axis_mask = node->new_axis_mask();
  params.shrink_axis_mask = node->shrink_axis_mask();
 
  return std::make_unique<kernels::StridedSlice>(input, begin, end, strides, output, params);
}

References begin, luci_interpreter::StridedSliceParams::begin_mask, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSub()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSub	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Sub.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSub *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input1 = helper.getInputTensor(node->x());
  const Tensor *input2 = helper.getInputTensor(node->y());
  Tensor *output = helper.getOutputTensor(node);
 
  SubParams params{};
  params.activation = node->fusedActivationFunction();
 
  return std::make_unique<kernels::Sub>(input1, input2, output, params);
}

References luci_interpreter::SubParams::activation, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleSum()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSum	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Sum.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSum *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *axes = helper.getInputTensor(node->reduction_indices());
  Tensor *output = helper.getOutputTensor(node);
 
  auto temp_index_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  temp_index_unique->set_observable(false);
  temp_index_unique->set_data_buffer(nullptr);
  Tensor *temp_index =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(temp_index_unique));
 
  auto resolved_axes_unique =
    std::make_unique<Tensor>(DataType::S32, Shape({}), AffineQuantization{}, "");
  resolved_axes_unique->set_observable(false);
  resolved_axes_unique->set_data_buffer(nullptr);
  Tensor *resolved_axes =
    helper.getRuntimeGraph(node->graph())->addTensor(std::move(resolved_axes_unique));
 
  ReducerParams params{};
  params.keep_dims = node->keep_dims();
 
  return std::make_unique<kernels::Sum>(input, axes, output, temp_index, resolved_axes, params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci_interpreter::ReducerParams::keep_dims, and luci_interpreter::Tensor::set_observable().

build_kernel_CircleSVDF()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleSVDF	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file SVDF.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleSVDF *>(circle_node);
  assert(node->arity() == 5);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *feature = helper.getInputTensor(node->weight_feature());
  const Tensor *time = helper.getInputTensor(node->weight_time());
  const Tensor *bias = helper.getOptionalInputTensor(node->bias());
  const Tensor *input_activation_state = helper.getInputTensor(node->input_activation_state());
  Tensor *output = helper.getOutputTensor(node);
 
  auto scratchpad_tensor = std::make_unique<Tensor>(input_activation_state->element_type(),
                                                    Shape({}), AffineQuantization{}, "");
  scratchpad_tensor->set_observable(false);
  scratchpad_tensor->set_data_buffer(nullptr);
  Tensor *tmp = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad_tensor));
 
  DataType data_type = input->element_type() == DataType::S8 ? DataType::S32 : DataType::FLOAT32;
 
  scratchpad_tensor = std::make_unique<Tensor>(data_type, Shape({}), AffineQuantization{}, "");
  scratchpad_tensor->set_observable(false);
  scratchpad_tensor->set_data_buffer(nullptr);
  Tensor *tmp_1 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad_tensor));
 
  if (data_type == DataType::FLOAT32 &&
      (feature->element_type() == DataType::S8 || feature->element_type() == DataType::U8))
  {
    data_type = feature->element_type();
  }
 
  scratchpad_tensor = std::make_unique<Tensor>(data_type, Shape({}), AffineQuantization{}, "");
  scratchpad_tensor->set_observable(false);
  scratchpad_tensor->set_data_buffer(nullptr);
  Tensor *tmp_2 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad_tensor));
 
  data_type = DataType::FLOAT32;
 
  scratchpad_tensor = std::make_unique<Tensor>(data_type, Shape({}), AffineQuantization{}, "");
  scratchpad_tensor->set_observable(false);
  scratchpad_tensor->set_data_buffer(nullptr);
  Tensor *tmp_3 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad_tensor));
 
  scratchpad_tensor = std::make_unique<Tensor>(data_type, Shape({}), AffineQuantization{}, "");
  scratchpad_tensor->set_observable(false);
  scratchpad_tensor->set_data_buffer(nullptr);
  Tensor *tmp_4 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad_tensor));
 
  scratchpad_tensor = std::make_unique<Tensor>(data_type, Shape({}), AffineQuantization{}, "");
  scratchpad_tensor->set_observable(false);
  scratchpad_tensor->set_data_buffer(nullptr);
  Tensor *tmp_5 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad_tensor));
 
  scratchpad_tensor = std::make_unique<Tensor>(data_type, Shape({}), AffineQuantization{}, "");
  scratchpad_tensor->set_observable(false);
  scratchpad_tensor->set_data_buffer(nullptr);
  Tensor *tmp_6 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratchpad_tensor));
 
  SVDFParams params{};
  params.activation = node->fusedActivationFunction();
  params.svdf_rank = node->svdf_rank();
  params.asymmetric_quantize_inputs = node->asymmetric_quantize_inputs();
 
  return std::make_unique<kernels::SVDF>(input, feature, time, bias, input_activation_state, output,
                                         tmp, tmp_1, tmp_2, tmp_3, tmp_4, tmp_5, tmp_6, params);
}

References luci_interpreter::SVDFParams::activation, luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::Tensor::element_type(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOptionalInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), and luci_interpreter::Tensor::set_observable().

build_kernel_CircleTanh()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleTanh	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Tanh.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleTanh *>(circle_node);
  assert(node->arity() == 1);
 
  const Tensor *input = helper.getInputTensor(node->x());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Tanh>(input, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleTile()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleTile	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Tile.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleTile *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *multiples = helper.getInputTensor(node->multiples());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Tile>(input, multiples, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleTranspose()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleTranspose	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Transpose.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleTranspose *>(circle_node);
  assert(node->arity() == 2);
 
  const Tensor *input = helper.getInputTensor(node->a());
  const Tensor *perm = helper.getInputTensor(node->perm());
  Tensor *output = helper.getOutputTensor(node);
 
  return std::make_unique<kernels::Transpose>(input, perm, output);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensor().

build_kernel_CircleTransposeConv()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleTransposeConv	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file TransposeConv.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleTransposeConv *>(circle_node);
  assert(node->arity() == 4);
 
  const Tensor *input_sizes = helper.getInputTensor(node->inputSizes());
  const Tensor *filter = helper.getInputTensor(node->filter());
  const Tensor *out_backprop = helper.getInputTensor(node->outBackprop());
  const Tensor *bias = helper.getOptionalInputTensor(node->bias());
 
  Tensor *output = helper.getOutputTensor(node);
 
  DataType scratch_data_type =
    helper.getInputTensor(node)->element_type() == DataType::S16 ? DataType::S64 : DataType::S32;
 
  auto scratch_tensor =
    std::make_unique<Tensor>(scratch_data_type, Shape({}), AffineQuantization{}, "");
  scratch_tensor->set_observable(false);
  scratch_tensor->set_data_buffer(nullptr);
  Tensor *tmp = helper.getRuntimeGraph(node->graph())->addTensor(std::move(scratch_tensor));
 
  TransposeConvParams params{};
  params.padding = node->padding();
  params.stride_height = node->stride()->h();
  params.stride_width = node->stride()->w();
  params.activation = node->fusedActivationFunction();
 
  // TODO support activation
  if (params.activation != luci::FusedActFunc::NONE)
  {
    throw std::runtime_error("Unsupported activation of TransposeConv");
  }
 
  return std::make_unique<kernels::TransposeConv>(input_sizes, filter, out_backprop, bias, output,
                                                  tmp, params);
}

References luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::Tensor::element_type(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOptionalInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), luci::NONE, and luci_interpreter::TransposeConvParams::padding.

build_kernel_CircleUnidirectionalSequenceLSTM()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleUnidirectionalSequenceLSTM	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 26 of file UnidirectionalSequenceLSTM.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleUnidirectionalSequenceLSTM *>(circle_node);
  assert(node->arity() == 24);
 
  const Tensor *input = helper.getInputTensor(node->input());
  const Tensor *input_to_input_weights =
    helper.getOptionalInputTensor(node->input_to_input_weights());
  const Tensor *input_to_cell_weights = helper.getInputTensor(node->input_to_cell_weights());
  const Tensor *input_to_forget_weights = helper.getInputTensor(node->input_to_forget_weights());
  const Tensor *input_to_output_weights = helper.getInputTensor(node->input_to_output_weights());
  const Tensor *recurrent_to_input_weights =
    helper.getOptionalInputTensor(node->recurrent_to_input_weights());
  const Tensor *recurrent_to_cell_weights =
    helper.getInputTensor(node->recurrent_to_cell_weights());
  const Tensor *recurrent_to_forget_weights =
    helper.getInputTensor(node->recurrent_to_forget_weights());
  const Tensor *recurrent_to_output_weights =
    helper.getInputTensor(node->recurrent_to_output_weights());
  const Tensor *cell_to_input_weights =
    helper.getOptionalInputTensor(node->cell_to_input_weights());
  const Tensor *cell_to_forget_weights =
    helper.getOptionalInputTensor(node->cell_to_forget_weights());
  const Tensor *cell_to_output_weights =
    helper.getOptionalInputTensor(node->cell_to_output_weights());
  const Tensor *input_gate_bias = helper.getOptionalInputTensor(node->input_gate_bias());
  const Tensor *forget_gate_bias = helper.getInputTensor(node->forget_gate_bias());
  const Tensor *cell_gate_bias = helper.getInputTensor(node->cell_gate_bias());
  const Tensor *output_gate_bias = helper.getInputTensor(node->output_gate_bias());
  const Tensor *projection_weights = helper.getOptionalInputTensor(node->projection_weights());
  const Tensor *projection_bias = helper.getOptionalInputTensor(node->projection_bias());
  const Tensor *output_state = helper.getInputTensor(node->output_state());
  const Tensor *cell_state = helper.getInputTensor(node->cell_state());
  const Tensor *input_layer_norm_coefficients =
    helper.getOptionalInputTensor(node->input_layer_norm_coefficients());
  const Tensor *forget_layer_norm_coefficients =
    helper.getOptionalInputTensor(node->forget_layer_norm_coefficients());
  const Tensor *cell_layer_norm_coefficients =
    helper.getOptionalInputTensor(node->cell_layer_norm_coefficients());
  const Tensor *output_layer_norm_coefficients =
    helper.getOptionalInputTensor(node->output_layer_norm_coefficients());
  Tensor *output = helper.getOutputTensor(node);
 
  // scratch pad tensor
  // NOTE provide more scratch pads if support hybrid or integer
  auto sp_output_state =
    std::make_unique<Tensor>(output_state->element_type(), Shape({}), AffineQuantization{}, "");
  sp_output_state->set_observable(false);
  sp_output_state->set_data_buffer(nullptr);
  Tensor *tmp_1 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(sp_output_state));
 
  auto sp_cell_state =
    std::make_unique<Tensor>(cell_state->element_type(), Shape({}), AffineQuantization{}, "");
  sp_cell_state->set_observable(false);
  sp_cell_state->set_data_buffer(nullptr);
  Tensor *tmp_2 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(sp_cell_state));
 
  auto sp_3 = std::make_unique<Tensor>(input->element_type(), Shape({}), AffineQuantization{}, "");
  sp_3->set_observable(false);
  sp_3->set_data_buffer(nullptr);
  Tensor *tmp_3 = helper.getRuntimeGraph(node->graph())->addTensor(std::move(sp_3));
 
  UnidirectionalSequenceLSTMParams params{};
  params.activation = node->fusedActivationFunction();
  params.cell_clip = node->cell_clip();
  params.proj_clip = node->proj_clip();
  params.time_major = node->time_major();
  params.asymmetric_quantize_inputs = node->asymmetric_quantize_inputs();
 
  return std::make_unique<kernels::UnidirectionalSequenceLSTM>(
    input, input_to_input_weights, input_to_forget_weights, input_to_cell_weights,
    input_to_output_weights, recurrent_to_input_weights, recurrent_to_forget_weights,
    recurrent_to_cell_weights, recurrent_to_output_weights, cell_to_input_weights,
    cell_to_forget_weights, cell_to_output_weights, input_gate_bias, forget_gate_bias,
    cell_gate_bias, output_gate_bias, projection_weights, projection_bias, output_state, cell_state,
    input_layer_norm_coefficients, forget_layer_norm_coefficients, cell_layer_norm_coefficients,
    output_layer_norm_coefficients, output, tmp_1, tmp_2, tmp_3, params);
}

References luci_interpreter::UnidirectionalSequenceLSTMParams::activation, luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::Tensor::element_type(), luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOptionalInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensor(), luci_interpreter::KernelBuilderHelper::getRuntimeGraph(), and luci_interpreter::Tensor::set_observable().

build_kernel_CircleUnpack()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleUnpack	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file Unpack.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleUnpack *>(circle_node);
  auto output_nodes = collectOutputNodes<luci::CircleUnpackOut>(node);
  assert(node->arity() == 1);
  assert(output_nodes.size() == static_cast<size_t>(node->num()));
 
  const Tensor *input = helper.getInputTensor(node->value());
  std::vector<Tensor *> outputs = helper.getOutputTensors(output_nodes);
 
  UnpackParams params{};
  params.axis = node->axis();
 
  // NOTE 'num' attribute is ignored.
  return std::make_unique<kernels::Unpack>(input, std::move(outputs), params);
}

References luci_interpreter::UnpackParams::axis, luci_interpreter::KernelBuilderHelper::getInputTensor(), and luci_interpreter::KernelBuilderHelper::getOutputTensors().

build_kernel_CircleWhile()

std::unique_ptr< Kernel > luci_interpreter::build_kernel_CircleWhile	(	const luci::CircleNode *	circle_node,
		KernelBuilderHelper &	helper
	)

Definition at line 24 of file While.cpp.

{
  const auto *node = loco::must_cast<const luci::CircleWhile *>(circle_node);
 
  auto output_nodes = collectOutputNodes<luci::CircleWhileOut>(node);
  assert(node->arity() == node->input_count());
  assert(output_nodes.size() == static_cast<size_t>(node->output_count()));
 
  std::vector<const Tensor *> inputs(node->input_count());
  for (uint32_t i = 0; i < node->input_count(); ++i)
  {
    inputs[i] = helper.getInputTensor(node->input(i));
  }
  std::vector<Tensor *> outputs = helper.getOutputTensors(output_nodes);
 
  RuntimeGraph *cond_graph = helper.getRuntimeGraph(node->cond_graph());
  RuntimeGraph *body_graph = helper.getRuntimeGraph(node->body_graph());
 
  return std::make_unique<kernels::While>(std::move(inputs), std::move(outputs), cond_graph,
                                          body_graph);
}

References luci_interpreter::KernelBuilderHelper::getInputTensor(), luci_interpreter::KernelBuilderHelper::getOutputTensors(), and luci_interpreter::KernelBuilderHelper::getRuntimeGraph().

collectOutputNodes()

template<typename CircleNodeOut >

std::vector< const loco::Node * > luci_interpreter::collectOutputNodes

(

const loco::Node *

node

)

Definition at line 68 of file KernelBuilderHelper.h.

{
  std::vector<const CircleNodeOut *> output_nodes;
  for (const loco::Node *loco_node : loco::succs(node))
  {
    output_nodes.push_back(loco::must_cast<const CircleNodeOut *>(loco_node));
  }
  std::sort(output_nodes.begin(), output_nodes.end(),
            [](const CircleNodeOut *node1, const CircleNodeOut *node2) {
              return node1->index() < node2->index();
            });
  return {output_nodes.cbegin(), output_nodes.cend()};
}

References loco::succs().

computeConvPadding()

int32_t luci_interpreter::computeConvPadding	(	const circle::Tensor *	input,
		const circle::Tensor *	filter,
		circle::Padding	padding_type,
		int32_t	stride,
		int32_t	dilation,
		int	axis
	)

Definition at line 41 of file ConvolutionCommon.cpp.

{
  const int32_t input_dim = Tensor::dim(input, axis);
  const int32_t filter_dim = Tensor::dim(filter, axis);
  const int32_t output_dim =
    kernels::computeOutputSize(luci_padding(padding_type), input_dim, filter_dim, stride, dilation);
 
  const auto padding = kernels::computePadding(stride, dilation, input_dim, filter_dim, output_dim);
 
  return padding;
}

References luci_interpreter::kernels::computeOutputSize(), luci_interpreter::kernels::computePadding(), circle_eval_diff::TensorShape::dim(), and luci::luci_padding().

Referenced by createConv2DParams().

configure_kernel_CircleAbs()

void luci_interpreter::configure_kernel_CircleAbs	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 25 of file Abs.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleAdd()

void luci_interpreter::configure_kernel_CircleAdd	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 96 of file Add.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
 
#ifndef DIS_QUANT
  if (Tensor::element_type(kernel.input1()) == DataType::S16)
  {
    LUCI_INTERPRETER_CHECK(Tensor::zero_points(kernel.input1()).size() == 1 &&
                           Tensor::zero_points(kernel.input2()).size() == 1);
    LUCI_INTERPRETER_CHECK(Tensor::zero_point(kernel.input1()) == 0 &&
                           Tensor::zero_point(kernel.input2()) == 0 &&
                           Tensor::zero_point(kernel.output()) == 0);
  }
#endif // DIS_QUANT
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleAddN()

void luci_interpreter::configure_kernel_CircleAddN	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 64 of file AddN.cpp.

{
  const int num_inputs = cur_op->inputs()->size();
 
  LUCI_INTERPRETER_CHECK(num_inputs >= 2);
  LUCI_INTERPRETER_CHECK(cur_op->outputs()->size() == 1);
 
  const auto input1_index = cur_op->inputs()->operator[](0);
  assert(input1_index != -1);
 
  const auto input1_tensor = runtime_graph->getCircleTensorByIndex(input1_index);
  assert(input1_tensor != nullptr);
 
  for (int i = 1; i < num_inputs; ++i)
  {
    const auto input_index = cur_op->inputs()->operator[](i);
    assert(input_index != -1);
 
    const auto input_tensor = runtime_graph->getCircleTensorByIndex(input_index);
    assert(input_tensor != nullptr);
 
    LUCI_INTERPRETER_CHECK(Tensor::element_type(input1_tensor) ==
                           Tensor::element_type(input_tensor));
    LUCI_INTERPRETER_CHECK(Tensor::num_dims(input1_tensor) == Tensor::num_dims(input_tensor));
    LUCI_INTERPRETER_CHECK(Tensor::num_elements(input1_tensor) ==
                           Tensor::num_elements(input_tensor));
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleArgMax()

void luci_interpreter::configure_kernel_CircleArgMax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file ArgMax.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  // dim tensor must be a scalar or has one element
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input2()) == 0 or
                         Tensor::num_elements(kernel.input2()) == 1);
  // value and output type must match
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::S32);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
}

References luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleArgMin()

void luci_interpreter::configure_kernel_CircleArgMin	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 28 of file ArgMin.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  // dim tensor must be a scalar or has one element
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input2()) == 0 or
                         Tensor::num_elements(kernel.input2()) == 1);
  // value and output type must match
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::S32);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
}

References luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleAveragePool2D()

void luci_interpreter::configure_kernel_CircleAveragePool2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 25 of file AveragePool2D.cpp.

{
  configure_kernel_CirclePool2DCommon(cur_op, runtime_graph);
}

References configure_kernel_CirclePool2DCommon().

configure_kernel_CircleBatchToSpaceND()

void luci_interpreter::configure_kernel_CircleBatchToSpaceND	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file BatchToSpaceND.cpp.

{
  kernels::MISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input3()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.output()) >= 3);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) >= 3);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.output()) <= 4);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) <= 4);
}

References luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::MISOKernel::output().

configure_kernel_CircleBroadcastTo()

void luci_interpreter::configure_kernel_CircleBroadcastTo	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 30 of file BroadcastTo.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32 or
                         Tensor::element_type(kernel.input2()) == DataType::S64);
 
  // Ensure output dims is not less than input dims.
  int input_num_dims = Tensor::num_dims(kernel.input1());
  int output_num_dims = Tensor::num_dims(kernel.output());
  int shape_num_dims = Tensor::dim(kernel.input2(), 0);
 
  LUCI_INTERPRETER_CHECK(output_num_dims == shape_num_dims);
  LUCI_INTERPRETER_CHECK(input_num_dims <= output_num_dims);
  LUCI_INTERPRETER_CHECK(output_num_dims <= kMaxDims);
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleCast()

void luci_interpreter::configure_kernel_CircleCast	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 34 of file Cast.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleCeil()

void luci_interpreter::configure_kernel_CircleCeil	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Ceil.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleConcatenation()

void luci_interpreter::configure_kernel_CircleConcatenation	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 83 of file Concatenation.cpp.

{
  const int num_inputs = cur_op->inputs()->size();
  LUCI_INTERPRETER_CHECK(num_inputs > 0);
 
  auto input_index = cur_op->inputs()->operator[](0);
  auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(output_index != -1);
 
  const auto *t0 = runtime_graph->getCircleTensorByIndex(input_index);
  const auto *output = runtime_graph->getCircleTensorByIndex(output_index);
 
  const auto *params = cur_op->builtin_options_as_ConcatenationOptions();
 
  // TODO: Support concat with fused activation function
  LUCI_INTERPRETER_CHECK(luci_actfunc(params->fused_activation_function()) == FusedActFunc::NONE);
 
  int axis = params->axis();
  if (axis < 0)
    axis += Tensor::num_dims(t0);
  LUCI_INTERPRETER_CHECK(axis >= 0 && axis < Tensor::num_dims(t0));
 
  for (int i = 1; i < num_inputs; ++i)
  {
    input_index = cur_op->inputs()->operator[](i);
    const auto *tensor = runtime_graph->getCircleTensorByIndex(input_index);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(tensor) == Tensor::element_type(t0));
    LUCI_INTERPRETER_CHECK(Tensor::num_dims(tensor) == Tensor::num_dims(t0));
  }
 
#ifndef DIS_QUANT
  // If input tensors are INT8 type then quantization parameters of all input tensors and the output
  // should be the same
  for (int i = 1; i < num_inputs; ++i)
  {
    input_index = cur_op->inputs()->operator[](i);
    const auto *tensor = runtime_graph->getCircleTensorByIndex(input_index);
    if (Tensor::element_type(tensor) == DataType::S8)
    {
      LUCI_INTERPRETER_CHECK(Tensor::quantized_dimension(tensor) ==
                             Tensor::quantized_dimension(output));
 
      LUCI_INTERPRETER_CHECK(Tensor::zero_points(tensor).size() == Tensor::scales(tensor).size());
      LUCI_INTERPRETER_CHECK(Tensor::zero_points(tensor) == Tensor::zero_points(output));
      LUCI_INTERPRETER_CHECK(Tensor::scales(tensor) == Tensor::scales(output));
    }
  }
#endif // DIS_QUANT
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci::luci_actfunc(), LUCI_INTERPRETER_CHECK, NONE, and size.

configure_kernel_CircleConv2D()

void luci_interpreter::configure_kernel_CircleConv2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 213 of file Conv2D.cpp.

{
  kernels::DownsamplingConv2DKernel kernel(cur_op, runtime_graph);
 
  const auto input = kernel.input();
  const auto filter = kernel.filter();
  const auto bias = kernel.bias();
  const auto output = kernel.output();
 
  auto filter_data = runtime_graph->getConstDataByTensor(filter);
 
  assert(filter_data != nullptr);
 
  const auto *options = cur_op->builtin_options_as_Conv2DOptions();
 
  if (Tensor::element_type(input) == DataType::FLOAT32 &&
      Tensor::element_type(filter) == DataType::FLOAT32)
  {
    LUCI_INTERPRETER_CHECK(bias == nullptr || Tensor::element_type(bias) == DataType::FLOAT32);
  }
#ifndef DIS_QUANT
  else if (Tensor::element_type(input) == DataType::U8 &&
           Tensor::element_type(filter) == DataType::U8)
  {
    LUCI_INTERPRETER_CHECK(bias == nullptr || Tensor::element_type(bias) == DataType::S32);
  }
  else if (Tensor::element_type(input) == DataType::S8 &&
           Tensor::element_type(filter) == DataType::S8)
  {
    LUCI_INTERPRETER_CHECK(bias == nullptr || Tensor::element_type(bias) == DataType::S32);
    LUCI_INTERPRETER_CHECK(Tensor::num_dims(filter) == 4);
    LUCI_INTERPRETER_CHECK(Tensor::scales(filter).size() ==
                           static_cast<size_t>(Tensor::dim(filter, 0)));
    for (auto zerop : Tensor::zero_points(filter))
    {
      LUCI_INTERPRETER_CHECK(zerop == 0);
    }
  }
  else if (Tensor::element_type(input) == DataType::S16 &&
           Tensor::element_type(filter) == DataType::S16)
  {
    LUCI_INTERPRETER_CHECK(bias == nullptr || Tensor::element_type(bias) == DataType::S64);
  }
#endif // DIS_QUANT
  else
  {
    assert(false && "Unsupported type.");
  }
  LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == Tensor::element_type(input));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(input) == 4 && Tensor::num_dims(filter) == 4);
 
  const int32_t output_depth = Tensor::dim(filter, 0);
  LUCI_INTERPRETER_CHECK(Tensor::dim(filter, 3) == Tensor::dim(input, 3));
 
  LUCI_INTERPRETER_CHECK(bias == nullptr ||
                         (Tensor::num_dims(bias) == 1 && Tensor::dim(bias, 0) == output_depth));
 
  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:
      assert(false && "Unsupported fused activation");
  }
}

References luci_interpreter::kernels::DownsamplingConv2DKernel::bias(), circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::DownsamplingConv2DKernel::filter(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::kernels::DownsamplingConv2DKernel::input(), LUCI_INTERPRETER_CHECK, luci_interpreter::kernels::DownsamplingConv2DKernel::output(), and size.

configure_kernel_CircleCos()

void luci_interpreter::configure_kernel_CircleCos	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Cos.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleDepthToSpace()

void luci_interpreter::configure_kernel_CircleDepthToSpace	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file DepthToSpace.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
 
  const auto *options = cur_op->builtin_options_as_DepthToSpaceOptions();
 
  const int32_t block_size = options->block_size();
  LUCI_INTERPRETER_CHECK(block_size > 0);
 
  constexpr int kHeightRank = 1;
  constexpr int kWidthRank = 2;
  constexpr int kDepthRank = 3;
 
  const int input_height = Tensor::dim(kernel.input(), kHeightRank);
  const int input_width = Tensor::dim(kernel.input(), kWidthRank);
  const int input_channels = Tensor::dim(kernel.input(), kDepthRank);
  int output_height = input_height * block_size;
  int output_width = input_width * block_size;
  int output_channels = input_channels / block_size / block_size;
 
  LUCI_INTERPRETER_CHECK(input_height == output_height / block_size);
  LUCI_INTERPRETER_CHECK(input_width == output_width / block_size);
  LUCI_INTERPRETER_CHECK(input_channels == output_channels * block_size * block_size);
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleDepthwiseConv2D()

void luci_interpreter::configure_kernel_CircleDepthwiseConv2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 78 of file DepthwiseConv2D.cpp.

{
  kernels::DownsamplingConv2DKernel kernel(cur_op, runtime_graph);
 
  const auto input = kernel.input();
  const auto filter = kernel.filter();
  const auto bias = kernel.bias();
  const auto output = kernel.output();
 
  auto filter_data = runtime_graph->getConstDataByTensor(filter);
 
  assert(filter_data != nullptr);
 
  const auto *options = cur_op->builtin_options_as_DepthwiseConv2DOptions();
 
  if (Tensor::element_type(input) == DataType::FLOAT32 &&
      Tensor::element_type(filter) == DataType::FLOAT32)
  {
    LUCI_INTERPRETER_CHECK(bias == nullptr || Tensor::element_type(bias) == DataType::FLOAT32);
  }
  else
  {
    assert(false && "Unsupported type.");
  }
  LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == Tensor::element_type(input));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(input) == 4 && Tensor::num_dims(filter) == 4);
 
  const int32_t output_depth = Tensor::dim(output, 3);
  LUCI_INTERPRETER_CHECK(bias == nullptr ||
                         (Tensor::num_dims(bias) == 1 && Tensor::dim(bias, 0) == output_depth));
 
  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:
      assert(false && "Unsupported fused activation");
  }
}

References luci_interpreter::kernels::DownsamplingConv2DKernel::bias(), circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::DownsamplingConv2DKernel::filter(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::kernels::DownsamplingConv2DKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::DownsamplingConv2DKernel::output().

configure_kernel_CircleDequantize()

void luci_interpreter::configure_kernel_CircleDequantize	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Dequantize.cpp.

{
#ifndef DIS_QUANT
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(!Tensor::scales(kernel.input()).empty());
  LUCI_INTERPRETER_CHECK(!Tensor::zero_points(kernel.input()).empty());
#else
  assert(false && "Remove DIS_QUANT flag");
#endif // DIS_QUANT
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleDiv()

void luci_interpreter::configure_kernel_CircleDiv	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 28 of file Div.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleElu()

void luci_interpreter::configure_kernel_CircleElu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Elu.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleEqual()

void luci_interpreter::configure_kernel_CircleEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file Equal.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleExp()

void luci_interpreter::configure_kernel_CircleExp	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file Exp.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleExpandDims()

void luci_interpreter::configure_kernel_CircleExpandDims	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 23 of file ExpandDims.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto axis_index = cur_op->inputs()->operator[](1);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(axis_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto axis = runtime_graph->getCircleTensorByIndex(axis_index);
  auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(axis != nullptr);
  assert(output != nullptr);
 
  auto axis_data = runtime_graph->getConstDataByTensor(axis);
  assert(axis_data != nullptr);
 
  int32_t axis_value;
 
  switch (Tensor::element_type(axis))
  {
    case DataType::S32:
      axis_value = *reinterpret_cast<int32_t *>(axis_data);
      break;
    case DataType::S64:
      axis_value = static_cast<int32_t>(*reinterpret_cast<int64_t *>(axis_data));
      break;
    default:
      assert(false && "Unsupported type.");
  }
 
  if (axis_value < 0)
  {
    axis_value += Tensor::num_dims(input) + 1;
  }
 
  LUCI_INTERPRETER_CHECK(axis_value <= Tensor::num_dims(input) and axis_value >= 0);
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleFill()

void luci_interpreter::configure_kernel_CircleFill	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Fill.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  // value tensor must be a scalar or has one element
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input2()) == 0 or
                         Tensor::num_elements(kernel.input2()) == 1);
  // value and output type must match
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) ==
                         Tensor::element_type(kernel.output()));
}

References luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleFloor()

void luci_interpreter::configure_kernel_CircleFloor	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 25 of file Floor.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == Tensor::element_type(output));
  // check that input and output dimensions are equal
  int N = kernels::getTensorShape(input).dimensionsCount();
  LUCI_INTERPRETER_CHECK(N == kernels::getTensorShape(output).dimensionsCount());
 
  // check that sizes of all dimensions are equal
  for (int i = 0; i < N; ++i)
  {
    LUCI_INTERPRETER_CHECK(kernels::getTensorShape(input).dims(i) ==
                           kernels::getTensorShape(output).dims(i));
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::kernels::getTensorShape(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleFloorDiv()

void luci_interpreter::configure_kernel_CircleFloorDiv	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file FloorDiv.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  CheckBinaryOpDataTypesEqual(kernel);
}

configure_kernel_CircleFloorMod()

void luci_interpreter::configure_kernel_CircleFloorMod	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file FloorMod.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  CheckBinaryOpDataTypesEqual(kernel);
}

configure_kernel_CircleFullyConnected()

void luci_interpreter::configure_kernel_CircleFullyConnected	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 204 of file FullyConnected.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto weight_index = cur_op->inputs()->operator[](1);
  const auto bias_index = cur_op->inputs()->operator[](2);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(weight_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto weights = runtime_graph->getCircleTensorByIndex(weight_index);
  const auto bias = runtime_graph->getCircleTensorByIndex(bias_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(weights != nullptr);
  assert(output != nullptr);
 
#ifndef DIS_FLOAT
  if (Tensor::element_type(weights) == DataType::S8 and
      Tensor::element_type(input) == DataType::FLOAT32)
  {
    // hybrid mode
    LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(!bias || Tensor::element_type(bias) == DataType::FLOAT32)
  }
  else if (Tensor::element_type(weights) == DataType::FLOAT32)
  {
    LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(!bias || Tensor::element_type(bias) == DataType::FLOAT32)
  }
#endif // DIS_FLOAT
#ifndef DIS_QUANT
  else if (Tensor::element_type(weights) == DataType::U8)
  {
    LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == DataType::U8);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == DataType::U8);
    LUCI_INTERPRETER_CHECK(!bias || Tensor::element_type(bias) == DataType::S32)
  }
  else if (Tensor::element_type(weights) == DataType::S8)
  {
    LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == DataType::S8 ||
                           Tensor::element_type(input) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == DataType::S8 ||
                           Tensor::element_type(output) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(!bias || Tensor::element_type(bias) == DataType::S32 ||
                           Tensor::element_type(bias) == DataType::S64 ||
                           Tensor::element_type(bias) == DataType::FLOAT32)
    if (Tensor::element_type(input) == DataType::FLOAT32)
    {
      // Check it is channel wise quantization
      LUCI_INTERPRETER_CHECK(weights->quantization() != nullptr);
      LUCI_INTERPRETER_CHECK(weights->quantization()->scale() != nullptr);
    }
  }
#endif // DIS_QUANT
  else
  {
    assert(false && "Unsupported type.");
  }
 
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(weights) == 2);
  LUCI_INTERPRETER_CHECK(bias == nullptr || Tensor::num_elements(bias) == Tensor::dim(weights, 0));
 
#ifdef DIS_DYN_SHAPES
  int32_t input_num_elements = Tensor::num_elements(input);
  LUCI_INTERPRETER_CHECK(input_num_elements % Tensor::dim(weights, 1) == 0);
#endif // DIS_DYN_SHAPES
 
  if (bias)
    LUCI_INTERPRETER_CHECK(Tensor::num_elements(bias) == Tensor::dim(weights, 0));
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleGather()

void luci_interpreter::configure_kernel_CircleGather	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 100 of file Gather.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_GatherOptions();
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) == DataType::FLOAT32 or
                         Tensor::element_type(kernel.input1()) == DataType::S8 or
                         Tensor::element_type(kernel.input1()) == DataType::S32);
 
  int32_t axis = options->axis();
  int32_t num_dims = Tensor::num_dims(kernel.input1());
  if (axis < 0)
  {
    axis += num_dims;
  }
 
  LUCI_INTERPRETER_CHECK(axis >= 0 and axis < num_dims);
 
  int32_t batch_dims = options->batch_dims();
  int32_t coords_num_dims = Tensor::num_dims(kernel.input2());
  // 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;
  }
  LUCI_INTERPRETER_CHECK(batch_dims <= axis);
  LUCI_INTERPRETER_CHECK(batch_dims >= 0 and batch_dims < num_dims);
  LUCI_INTERPRETER_CHECK(batch_dims <= coords_num_dims);
  for (int i = 0; i < batch_dims; ++i)
  {
    LUCI_INTERPRETER_CHECK(Tensor::dim(kernel.input1(), i) == Tensor::dim(kernel.input2(), i));
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleGatherND()

void luci_interpreter::configure_kernel_CircleGatherND	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 28 of file GatherND.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
 
  const int params_rank = Tensor::num_dims(kernel.input1());
  const int indices_rank = Tensor::num_dims(kernel.input2());
  const int indices_nd = Tensor::dim(kernel.input2(), indices_rank - 1);
 
  LUCI_INTERPRETER_CHECK(params_rank >= 1);
  LUCI_INTERPRETER_CHECK(indices_rank >= 1);
  LUCI_INTERPRETER_CHECK(indices_nd <= params_rank);
  LUCI_INTERPRETER_CHECK(indices_nd <= luci_interpreter_pal::MAX_INDICES_ND);
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, luci_interpreter_pal::MAX_INDICES_ND, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleGreater()

void luci_interpreter::configure_kernel_CircleGreater	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file Greater.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleGreaterEqual()

void luci_interpreter::configure_kernel_CircleGreaterEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file GreaterEqual.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleIf()

void luci_interpreter::configure_kernel_CircleIf	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file If.cpp.

{
  auto *main_runtime_graph = runtime_graph;
 
  auto *runtime_module = runtime_graph->getRuntimeModule();
 
  const auto *options = cur_op->builtin_options_as_IfOptions();
 
  const auto cond_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  const auto then_subgraph_index = options->then_subgraph_index();
  const auto else_subgraph_index = options->else_subgraph_index();
 
  assert(cond_index != -1);
  assert(output_index != -1);
 
  assert(then_subgraph_index != -1);
  assert(else_subgraph_index != -1);
 
  const auto cond = runtime_graph->getCircleTensorByIndex(cond_index);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(cond) == DataType::BOOL);
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(cond) == 1);
 
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
  auto *then_subgraph = runtime_module->getRuntimeGraphAt(then_subgraph_index);
  auto *else_subgraph = runtime_module->getRuntimeGraphAt(else_subgraph_index);
  for (RuntimeGraph *graph : {then_subgraph, else_subgraph})
  {
    graph->selectOwnSubgraph();
    const auto graph_input_size = graph->getNumOfInputTensors();
    const auto graph_output_size = graph->getNumOfOutputTensors();
    LUCI_INTERPRETER_CHECK(graph_input_size == cur_op->inputs()->size() - 1);
    LUCI_INTERPRETER_CHECK(graph_output_size == cur_op->outputs()->size());
    graph->invalidate();
    graph->configure(false);
  }
  main_runtime_graph->selectOwnSubgraph();
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getRuntimeModule(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleL2Normalize()

void luci_interpreter::configure_kernel_CircleL2Normalize	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file L2Normalize.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleL2Pool2D()

void luci_interpreter::configure_kernel_CircleL2Pool2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file L2Pool2D.cpp.

{
  configure_kernel_CirclePool2DCommon(cur_op, runtime_graph);
}

References configure_kernel_CirclePool2DCommon().

configure_kernel_CircleLeakyRelu()

void luci_interpreter::configure_kernel_CircleLeakyRelu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file LeakyRelu.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleLess()

void luci_interpreter::configure_kernel_CircleLess	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 80 of file Less.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleLessEqual()

void luci_interpreter::configure_kernel_CircleLessEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file LessEqual.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleLog()

void luci_interpreter::configure_kernel_CircleLog	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Log.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleLogicalAnd()

void luci_interpreter::configure_kernel_CircleLogicalAnd	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 30 of file LogicalAnd.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) == DataType::BOOL);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
 
  // TODO support broadcast
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input1()) ==
                         Tensor::num_elements(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) == Tensor::num_dims(kernel.input2()));
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleLogicalNot()

void luci_interpreter::configure_kernel_CircleLogicalNot	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file LogicalNot.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) == DataType::BOOL);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
 
  // check that input and output dimensions are equal
  int N = Tensor::num_dims(kernel.input());
  LUCI_INTERPRETER_CHECK(N == Tensor::num_dims(kernel.output()));
 
  // check that sizes of all dimensions are equal
  for (int i = 0; i < N; ++i)
  {
    LUCI_INTERPRETER_CHECK(kernels::getTensorShape(kernel.input()).dims(i) ==
                           kernels::getTensorShape(kernel.output()).dims(i));
  }
}

References luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleLogicalOr()

void luci_interpreter::configure_kernel_CircleLogicalOr	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 31 of file LogicalOr.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) == DataType::BOOL);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
 
  // TODO support broadcast
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input1()) ==
                         Tensor::num_elements(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) == Tensor::num_dims(kernel.input2()));
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleLogistic()

void luci_interpreter::configure_kernel_CircleLogistic	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 25 of file Logistic.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()))
 
#ifndef DIS_QUANT
  if (Tensor::element_type(kernel.input()) == DataType::U8)
  {
    LUCI_INTERPRETER_CHECK(Tensor::scale(kernel.output()) == 1. / 256);
  }
#endif // DIS_QUANT
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleLogSoftmax()

void luci_interpreter::configure_kernel_CircleLogSoftmax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file LogSoftmax.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleMaximum()

void luci_interpreter::configure_kernel_CircleMaximum	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file Maximum.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  kernels::CheckBinaryOpDataTypesEqual(kernel);
}

References luci_interpreter::kernels::CheckBinaryOpDataTypesEqual().

configure_kernel_CircleMaxPool2D()

void luci_interpreter::configure_kernel_CircleMaxPool2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 23 of file MaxPool2D.cpp.

{
  configure_kernel_CirclePool2DCommon(cur_op, runtime_graph);
}

References configure_kernel_CirclePool2DCommon().

configure_kernel_CircleMean()

void luci_interpreter::configure_kernel_CircleMean	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 48 of file Mean.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
 
  const int32_t axis_value =
    kernels::getTensorData<int>(runtime_graph->getConstDataByTensor(kernel.input2()))[0];
  LUCI_INTERPRETER_CHECK(axis_value >= 0);
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleMinimum()

void luci_interpreter::configure_kernel_CircleMinimum	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file Minimum.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  kernels::CheckBinaryOpDataTypesEqual(kernel);
}

References luci_interpreter::kernels::CheckBinaryOpDataTypesEqual().

configure_kernel_CircleMirrorPad()

void luci_interpreter::configure_kernel_CircleMirrorPad	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 31 of file MirrorPad.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input2()) == 2);
  LUCI_INTERPRETER_CHECK(Tensor::dim(kernel.input2(), 0) == Tensor::num_dims(kernel.input1()));
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleMul()

void luci_interpreter::configure_kernel_CircleMul	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 85 of file Mul.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
#ifndef DIS_QUANT
  if (Tensor::element_type(kernel.input1()) == DataType::S16)
  {
    LUCI_INTERPRETER_CHECK(Tensor::zero_points(kernel.input1()).size() == 1 &&
                           Tensor::zero_points(kernel.input2()).size() == 1);
    LUCI_INTERPRETER_CHECK(Tensor::zero_point(kernel.input1()) == 0 &&
                           Tensor::zero_point(kernel.input2()) == 0 &&
                           Tensor::zero_point(kernel.output()) == 0);
  }
#endif // DIS_QUANT
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleNeg()

void luci_interpreter::configure_kernel_CircleNeg	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file Neg.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == Tensor::element_type(output));
 
  assert(Tensor::num_dims(input) == 4);
 
  // TODO: enable it only if kernel with dynamic shapes
  // output-> resize(input->shape());
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleNotEqual()

void luci_interpreter::configure_kernel_CircleNotEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file NotEqual.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::BOOL);
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CirclePack()

void luci_interpreter::configure_kernel_CirclePack	(	const circle::Operator *	,
		BaseRuntimeGraph *
	)

Definition at line 85 of file Pack.cpp.

{
  // Do nothing
}

configure_kernel_CirclePad()

void luci_interpreter::configure_kernel_CirclePad	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 22 of file Pad.cpp.

{
  configure_kernel_CirclePadCommon(cur_op, runtime_graph);
}

References configure_kernel_CirclePadCommon().

configure_kernel_CirclePadCommon()

void luci_interpreter::configure_kernel_CirclePadCommon	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 94 of file PadCommon.cpp.

{
  PadKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  if (kernel.input3() != nullptr)
    PadKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  if (kernel.input3() != nullptr)
  {
    LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input3()) ==
                           Tensor::element_type(kernel.input1()));
    // Value is scalar
    LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input3()) == 1);
  }
 
  // Check shapes
  const int32_t *paddings_data =
    kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(kernel.input2()));
  for (int i = 0; i < Tensor::num_dims(kernel.output()); i++)
  {
    int output_dim = Tensor::dim(kernel.output(), i);
    int expected_dim =
      Tensor::dim(kernel.input1(), i) + paddings_data[i * 2] + paddings_data[i * 2 + 1];
    LUCI_INTERPRETER_CHECK(output_dim == expected_dim);
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), and LUCI_INTERPRETER_CHECK.

Referenced by configure_kernel_CirclePad(), and configure_kernel_CirclePadV2().

configure_kernel_CirclePadV2()

void luci_interpreter::configure_kernel_CirclePadV2	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 22 of file PadV2.cpp.

{
  configure_kernel_CirclePadCommon(cur_op, runtime_graph);
}

References configure_kernel_CirclePadCommon().

configure_kernel_CirclePool2DCommon()

void luci_interpreter::configure_kernel_CirclePool2DCommon ( const circle::Operator *  cur_op, BaseRuntimeGraph *  runtime_graph  )

inline

Definition at line 27 of file Pool2DCommon.h.

{
  const kernels::SISOKernel siso_kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(siso_kernel.input()) ==
                         Tensor::element_type(siso_kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(siso_kernel.input()) == 4);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(siso_kernel.input()) ==
                         Tensor::num_dims(siso_kernel.output()));
 
#ifndef DIS_QUANT
  if (Tensor::element_type(siso_kernel.input()) == DataType::U8)
  {
    LUCI_INTERPRETER_CHECK(
      std::abs(Tensor::scale(siso_kernel.output()) - Tensor::scale(siso_kernel.input())) <= 1.0e-6);
    LUCI_INTERPRETER_CHECK(Tensor::zero_point(siso_kernel.output()) ==
                           Tensor::zero_point(siso_kernel.input()));
  }
  else if (Tensor::element_type(siso_kernel.input()) == DataType::S16)
  {
    LUCI_INTERPRETER_CHECK(
      std::abs(Tensor::scale(siso_kernel.output()) - Tensor::scale(siso_kernel.input())) <= 1.0e-6);
    LUCI_INTERPRETER_CHECK(Tensor::zero_point(siso_kernel.input()) == 0 &&
                           Tensor::zero_point(siso_kernel.output()) == 0);
  }
#endif // DIS_QUANT
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

Referenced by configure_kernel_CircleAveragePool2D(), configure_kernel_CircleL2Pool2D(), and configure_kernel_CircleMaxPool2D().

configure_kernel_CirclePRelu()

void luci_interpreter::configure_kernel_CirclePRelu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file PRelu.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
 
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input1()) ==
                         Tensor::num_elements(kernel.output()));
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleQuantize()

void luci_interpreter::configure_kernel_CircleQuantize	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Quantize.cpp.

{
#ifndef DIS_QUANT
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(!Tensor::scales(kernel.output()).empty());
  LUCI_INTERPRETER_CHECK(!Tensor::zero_points(kernel.output()).empty());
#else
  assert(false && "Remove DIS_QUANT flag");
#endif // DIS_QUANT
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleReduceCommon()

void luci_interpreter::configure_kernel_CircleReduceCommon	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 51 of file ReduceCommon.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) == DataType::S32 or
                         Tensor::element_type(kernel.input1()) == DataType::FLOAT32 or
                         Tensor::element_type(kernel.input1()) == DataType::S64);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleReduceMax()

void luci_interpreter::configure_kernel_CircleReduceMax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 51 of file ReduceMax.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
 
  const int32_t axis_value =
    kernels::getTensorData<int>(runtime_graph->getConstDataByTensor(kernel.input2()))[0];
  LUCI_INTERPRETER_CHECK(axis_value >= 0);
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleRelu()

void luci_interpreter::configure_kernel_CircleRelu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Relu.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleRelu6()

void luci_interpreter::configure_kernel_CircleRelu6	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Relu6.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleReshape()

void luci_interpreter::configure_kernel_CircleReshape	(	const circle::Operator *	,
		BaseRuntimeGraph *
	)

Definition at line 27 of file Reshape.cpp.

{
  // Do nothing
}

configure_kernel_CircleResizeBilinear()

void luci_interpreter::configure_kernel_CircleResizeBilinear	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 44 of file ResizeBilinear.cpp.

{
  // Check of the size of input. Should be 2
  assert(cur_op->inputs()->size() == 2);
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto size_index = cur_op->inputs()->operator[](1);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(size_index != -1);
  assert(output_index != -1);
  // Get tensors
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto size = runtime_graph->getCircleTensorByIndex(size_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
  // Check of the Input shape
  assert(kernels::getTensorShape(input).dimensionsCount() == 4);
  // Check of the Const input size shape
  assert(kernels::getTensorShape(size).dimensionsCount() == 1);
  assert(Tensor::element_type(size) == DataType::S32);
  assert(kernels::getTensorShape(size).dims(0) == 2);
 
  const auto *params = cur_op->builtin_options_as_ResizeBilinearOptions();
  if (params->half_pixel_centers() && params->align_corners())
    assert(false && "If half_pixel_centers is True, align_corners must be False.");
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::kernels::getTensorShape(), and size.

configure_kernel_CircleResizeNearestNeighbor()

void luci_interpreter::configure_kernel_CircleResizeNearestNeighbor	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file ResizeNearestNeighbor.cpp.

{
  // Check of the size of input. Should be 2
  LUCI_INTERPRETER_CHECK(cur_op->inputs()->size() == 2);
  const kernels::TISOKernel tiso_kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(tiso_kernel.input1()) ==
                         Tensor::element_type(tiso_kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(tiso_kernel.input1()) == 4);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(tiso_kernel.input2()) == 1);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(tiso_kernel.input2()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::dim(tiso_kernel.input2(), 0) == 2);
 
  const auto *params = cur_op->builtin_options_as_ResizeNearestNeighborOptions();
  if (params->half_pixel_centers() && params->align_corners())
    assert(false && "If half_pixel_centers is True, align_corners must be False.");
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleRound()

void luci_interpreter::configure_kernel_CircleRound	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Round.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleRsqrt()

void luci_interpreter::configure_kernel_CircleRsqrt	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Rsqrt.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleSelectV2()

void luci_interpreter::configure_kernel_CircleSelectV2	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 62 of file SelectV2.cpp.

{
  const auto input_cond_index = cur_op->inputs()->operator[](kInputTensorCondition);
  const auto input_x_index = cur_op->inputs()->operator[](kInputTensorX);
  const auto input_y_index = cur_op->inputs()->operator[](kInputTensorY);
  const auto output_index = cur_op->outputs()->operator[](kOutputTensor);
 
  assert(input_cond_index != -1);
  assert(input_x_index != -1);
  assert(input_y_index != -1);
  assert(output_index != -1);
 
  const auto input_cond = runtime_graph->getCircleTensorByIndex(input_cond_index);
  const auto input_x = runtime_graph->getCircleTensorByIndex(input_x_index);
  const auto input_y = runtime_graph->getCircleTensorByIndex(input_y_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input_cond != nullptr);
  assert(input_x != nullptr);
  assert(input_y != nullptr);
 
  // Input condition should be bool
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input_cond) == DataType::BOOL);
 
  // X, Y and Output should be the same type
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input_x) == Tensor::element_type(input_y));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input_x) == Tensor::element_type(output));
 
  bool possible_mixed_scaler =
    Tensor::num_elements(input_cond) == 1 && Tensor::num_elements(input_x) == 1 &&
    Tensor::num_elements(input_y) == 1 && Tensor::num_elements(output) == 1;
 
  bool same_shape = Tensor::num_elements(input_cond) == Tensor::num_elements(input_x) &&
                    Tensor::num_elements(input_x) == Tensor::num_elements(input_y);
 
  // Broadcast not supported now
  if (not same_shape and not possible_mixed_scaler)
  {
    LUCI_INTERPRETER_CHECK(false);
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleShape()

void luci_interpreter::configure_kernel_CircleShape	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 23 of file Shape.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.output()) == DataType::S32);
}

References LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleSin()

void luci_interpreter::configure_kernel_CircleSin	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Sin.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleSlice()

void luci_interpreter::configure_kernel_CircleSlice	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 94 of file Slice.cpp.

{
  kernels::MISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32 ||
                         Tensor::element_type(kernel.input2()) == DataType::S64);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input3()) == DataType::S32 ||
                         Tensor::element_type(kernel.input3()) == DataType::S64);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input2()) == 1);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input3()) == 1);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) <= max_dim);
}

References luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::MISOKernel::output().

configure_kernel_CircleSoftmax()

void luci_interpreter::configure_kernel_CircleSoftmax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 123 of file Softmax.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) >= 1);
 
#ifndef DIS_QUANT
  if (Tensor::element_type(kernel.input()) == DataType::U8 ||
      Tensor::element_type(kernel.input()) == DataType::S8)
  {
    LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) == DataType::S8 ||
                           Tensor::zero_point(kernel.output()) == 0);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) == DataType::U8 ||
                           Tensor::zero_point(kernel.output()) ==
                             std::numeric_limits<int8_t>::min());
  }
#endif
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleSpaceToBatchND()

void luci_interpreter::configure_kernel_CircleSpaceToBatchND	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file SpaceToBatchND.cpp.

{
  kernels::MISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input3()) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.output()) >= 3);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) >= 3);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.output()) <= 4);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) <= 4);
}

References luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::MISOKernel::output().

configure_kernel_CircleSpaceToDepth()

void luci_interpreter::configure_kernel_CircleSpaceToDepth	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file SpaceToDepth.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
 
  const auto *options = cur_op->builtin_options_as_SpaceToDepthOptions();
 
  const int32_t block_size = options->block_size();
  LUCI_INTERPRETER_CHECK(block_size > 0);
 
  constexpr int kHeightRank = 1;
  constexpr int kWidthRank = 2;
  constexpr int kDepthRank = 3;
 
  const int input_height = Tensor::dim(kernel.input(), kHeightRank);
  const int input_width = Tensor::dim(kernel.input(), kWidthRank);
  int output_height = input_height / block_size;
  int output_width = input_width / block_size;
 
  LUCI_INTERPRETER_CHECK(input_height == output_height * block_size);
  LUCI_INTERPRETER_CHECK(input_width == output_width * block_size);
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleSplit()

void luci_interpreter::configure_kernel_CircleSplit	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file Split.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto axis_index = cur_op->inputs()->operator[](1);
 
  LUCI_INTERPRETER_CHECK(input_index != -1);
  LUCI_INTERPRETER_CHECK(axis_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto axis = runtime_graph->getCircleTensorByIndex(axis_index);
 
  LUCI_INTERPRETER_CHECK(input != nullptr);
  LUCI_INTERPRETER_CHECK(axis != nullptr);
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleSplitV()

void luci_interpreter::configure_kernel_CircleSplitV	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 25 of file SplitV.cpp.

{
  const auto axis_index = cur_op->inputs()->operator[](2);
  LUCI_INTERPRETER_CHECK(axis_index != -1);
 
  const auto axis = runtime_graph->getCircleTensorByIndex(axis_index);
  LUCI_INTERPRETER_CHECK(axis != nullptr);
 
  // Dynamic output tensors are needed if axis tensor is not constant
  // Now doesn't support dynamic shapes for SplitV
  LUCI_INTERPRETER_CHECK(runtime_graph->getConstDataByTensor(axis) != nullptr);
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleSqrt()

void luci_interpreter::configure_kernel_CircleSqrt	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Sqrt.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleSquare()

void luci_interpreter::configure_kernel_CircleSquare	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 24 of file Square.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
 
  // check that input and output dimensions are equal
  int N = Tensor::num_dims(kernel.input());
  LUCI_INTERPRETER_CHECK(N == Tensor::num_dims(kernel.output()));
 
  // check that sizes of all dimensions are equal
  for (int i = 0; i < N; ++i)
  {
    LUCI_INTERPRETER_CHECK(kernels::getTensorShape(kernel.input()).dims(i) ==
                           kernels::getTensorShape(kernel.output()).dims(i));
  }
}

References luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleSquaredDifference()

void luci_interpreter::configure_kernel_CircleSquaredDifference	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file SquaredDifference.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input1()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input1()) ==
                         Tensor::num_elements(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input1()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleSqueeze()

void luci_interpreter::configure_kernel_CircleSqueeze	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Squeeze.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  assert(cur_op->inputs()->size() == 1);
 
  const circle::Tensor *input = kernel.input();
  const circle::Tensor *output = kernel.output();
 
  assert(Tensor::num_elements(input) == Tensor::num_elements(output));
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  int input_num_dims = kernels::getTensorShape(input).dimensionsCount();
 
  // Get parameters
  const circle::SqueezeOptions *op_params = cur_op->builtin_options_as_SqueezeOptions();
 
  // Verification of the Squeeze parameters
  int num_squeeze_dims = op_params->squeeze_dims()->size();
  assert(input_num_dims <= 8);
  bool should_squeeze[8] = {false};
  int num_squeezed_dims = 0;
  if (num_squeeze_dims == 0)
  {
    for (int idx = 0; idx < input_num_dims; ++idx)
    {
 
      if (kernels::getTensorShape(input).dims(idx) == 1)
      {
        should_squeeze[idx] = true;
        ++num_squeezed_dims;
      }
    }
  }
  else
  {
    for (int idx = 0; idx < num_squeeze_dims; ++idx)
    {
      int current = (*op_params->squeeze_dims())[idx] < 0
                      ? (*op_params->squeeze_dims())[idx] + input_num_dims
                      : (*op_params->squeeze_dims())[idx];
      assert(current >= 0 && current < input_num_dims &&
             kernels::getTensorShape(input).dims(current) == 1);
      if (!should_squeeze[current])
        ++num_squeezed_dims;
      should_squeeze[current] = true;
    }
  }
}

References luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleStridedSlice()

void luci_interpreter::configure_kernel_CircleStridedSlice	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 55 of file StridedSlice.cpp.

{
  kernels::MISOKernel miso_kernel(cur_op, runtime_graph);
 
  const circle::Tensor *input = miso_kernel.input1();
  const circle::Tensor *begin = miso_kernel.input2();
  const circle::Tensor *end = miso_kernel.input3();
  const circle::Tensor *strides = miso_kernel.input4();
 
  LUCI_INTERPRETER_CHECK(strides != nullptr);
 
  const circle::Tensor *output = miso_kernel.output();
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(begin) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(end) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(strides) == DataType::S32);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == Tensor::element_type(output));
}

References begin, luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), luci_interpreter::kernels::MISOKernel::input4(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::MISOKernel::output().

configure_kernel_CircleSub()

void luci_interpreter::configure_kernel_CircleSub	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file Sub.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.input2()));
#ifndef DIS_QUANT
  if (Tensor::element_type(kernel.input1()) == DataType::S16)
  {
    LUCI_INTERPRETER_CHECK(Tensor::zero_points(kernel.input1()).size() == 1 &&
                           Tensor::zero_points(kernel.input2()).size() == 1);
    LUCI_INTERPRETER_CHECK(Tensor::zero_point(kernel.input1()) == 0 &&
                           Tensor::zero_point(kernel.input2()) == 0 &&
                           Tensor::zero_point(kernel.output()) == 0);
  }
#endif // DIS_QUANT
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleSum()

void luci_interpreter::configure_kernel_CircleSum	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 51 of file Sum.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input1()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
 
  const int32_t axis_value =
    kernels::getTensorData<int>(runtime_graph->getConstDataByTensor(kernel.input2()))[0];
  LUCI_INTERPRETER_CHECK(axis_value >= 0);
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::TISOKernel::output().

configure_kernel_CircleSVDF()

void luci_interpreter::configure_kernel_CircleSVDF	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 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}
  const auto input_index = cur_op->inputs()->operator[](kSvdfInputTensor);
  const auto weights_feature_index = cur_op->inputs()->operator[](kSvdfWeightsFeatureTensor);
  const auto weights_time_index = cur_op->inputs()->operator[](kSvdfWeightsTimeTensor);
  const auto bias_index = cur_op->inputs()->operator[](kSvdfBiasTensor);
  const auto activation_state_index = cur_op->inputs()->operator[](kSvdfInputActivationStateTensor);
  const auto output_index = cur_op->outputs()->operator[](kSvdfOutputTensor);
 
  assert(input_index != -1);
  assert(weights_feature_index != -1);
  assert(weights_time_index != -1);
  assert(activation_state_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto weights_feature = runtime_graph->getCircleTensorByIndex(weights_feature_index);
  const auto weights_time = runtime_graph->getCircleTensorByIndex(weights_time_index);
  const auto bias = runtime_graph->getCircleTensorByIndex(bias_index);
  const auto activation_state = runtime_graph->getCircleTensorByIndex(activation_state_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(weights_feature != nullptr);
  assert(weights_time != nullptr);
  assert(activation_state != nullptr);
  assert(output != nullptr);
 
  const auto *options = cur_op->builtin_options_as_SVDFOptions();
 
  // Define input constants based on input tensor definition above:
  const int rank = options->rank();
  const int input_size = Tensor::dim(input, 1);
  const int batch_size = Tensor::dim(input, 0);
  const int num_filters = Tensor::dim(weights_feature, 0);
  LUCI_INTERPRETER_CHECK(num_filters % rank == 0);
 
  const int num_units = num_filters / rank;
  const int memory_size = Tensor::dim(weights_time, 1);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == DataType::FLOAT32 or
                         Tensor::element_type(input) == DataType::S8);
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(input) == 2);
 
  // Validate Tensor Output:
  // [0] = float/int8_t, {2, batch_size, num_units}
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(output) == 2);
  LUCI_INTERPRETER_CHECK(Tensor::dim(output, 0) == batch_size);
  LUCI_INTERPRETER_CHECK(Tensor::dim(output, 1) == num_units);
 
  // Validate Weights Feature Input Tensor
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(weights_feature) == 2);
  LUCI_INTERPRETER_CHECK(Tensor::dim(weights_feature, 1) == input_size);
 
  // Validate Weights Time Input Tensor:
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(weights_time) == 2);
  LUCI_INTERPRETER_CHECK(Tensor::dim(weights_time, 0) == num_filters);
  LUCI_INTERPRETER_CHECK(Tensor::dim(weights_time, 1) == memory_size);
 
  // Validate Optional Bias Input Tensor:
  if (bias != nullptr)
  {
    LUCI_INTERPRETER_CHECK(Tensor::dim(bias, 0) == num_units);
  }
 
  // Validate Activation State Input Tensor:
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(activation_state) == 2);
  LUCI_INTERPRETER_CHECK(Tensor::dim(activation_state, 0) == batch_size);
  LUCI_INTERPRETER_CHECK(Tensor::dim(activation_state, 1) == memory_size * num_filters);
 
  if (Tensor::element_type(input) == DataType::FLOAT32)
  {
    LUCI_INTERPRETER_CHECK(Tensor::element_type(weights_feature) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(weights_time) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(activation_state) == DataType::FLOAT32);
    if (bias)
      LUCI_INTERPRETER_CHECK(Tensor::element_type(bias) == DataType::FLOAT32);
    LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == DataType::FLOAT32);
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleTanh()

void luci_interpreter::configure_kernel_CircleTanh	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 148 of file Tanh.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

configure_kernel_CircleTranspose()

void luci_interpreter::configure_kernel_CircleTranspose	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file Transpose.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input2()) == DataType::S32);
 
  const int32_t dims = Tensor::num_dims(kernel.input1());
  const int32_t *perm_data =
    kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(kernel.input2()));
 
  // Ensure validity of the permutations tensor as a 1D tensor
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input2()) == 1);
  LUCI_INTERPRETER_CHECK(Tensor::dim(kernel.input2(), 0) == dims);
 
  for (int idx = 0; idx < dims; ++idx)
    LUCI_INTERPRETER_CHECK(perm_data[idx] >= 0 and perm_data[idx] < dims);
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleTransposeConv()

void luci_interpreter::configure_kernel_CircleTransposeConv	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 107 of file TransposeConv.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](kInputTensor);
  const auto filter_index = cur_op->inputs()->operator[](kFilterTensor);
  const auto output_index = cur_op->outputs()->operator[](kOutputTensor);
 
  assert(input_index != -1);
  assert(filter_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto filter = runtime_graph->getCircleTensorByIndex(filter_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(filter != nullptr);
 
  auto filter_data = runtime_graph->getConstDataByTensor(filter);
 
  assert(filter_data != nullptr);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(output) == Tensor::element_type(input));
  LUCI_INTERPRETER_CHECK(Tensor::element_type(filter) == Tensor::element_type(input));
 
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(input) == 4 && Tensor::num_dims(filter) == 4);
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleUnidirectionalSequenceLSTM()

void luci_interpreter::configure_kernel_CircleUnidirectionalSequenceLSTM	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 392 of file UnidirectionalSequenceLSTM.cpp.

{
  lstm::LSTMStruct lstm_struct(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(lstm_struct.input()) == DataType::FLOAT32 or
                         Tensor::element_type(lstm_struct.input()) == DataType::S8);
 
  lstm_struct.validateTensorTypes();
 
  const bool time_major = lstm_struct.options->time_major();
 
  validateTensorsSize(&lstm_struct, time_major);
 
  // No peephole
  for (int32_t i = 9; i < 12; ++i)
    LUCI_INTERPRETER_CHECK(lstm_struct.get_internal_tensor(i) == nullptr);
 
  // No projection
  for (int32_t i = 16; i < 18; ++i)
    LUCI_INTERPRETER_CHECK(lstm_struct.get_internal_tensor(i) == nullptr);
 
  // No internal layer norm
  for (int32_t i = 20; i < 24; ++i)
    LUCI_INTERPRETER_CHECK(lstm_struct.get_internal_tensor(i) == nullptr);
}

References luci_interpreter::lstm::LSTMStruct::get_internal_tensor(), luci_interpreter::lstm::LSTMStruct::input(), LUCI_INTERPRETER_CHECK, luci_interpreter::lstm::LSTMStruct::options, and luci_interpreter::lstm::LSTMStruct::validateTensorTypes().

configure_kernel_CircleUnpack()

void luci_interpreter::configure_kernel_CircleUnpack	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 84 of file Unpack.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(output != nullptr);
 
  const auto *options = cur_op->builtin_options_as_UnpackOptions();
 
  LUCI_INTERPRETER_CHECK(cur_op->outputs()->size() == options->num());
  LUCI_INTERPRETER_CHECK(Tensor::element_type(input) == Tensor::element_type(output));
 
  for (int i = 0; i < Tensor::num_dims(input); ++i)
  {
    if (i == options->axis())
      continue;
 
    if (i < options->axis())
    {
      LUCI_INTERPRETER_CHECK(Tensor::dim(input, i) == Tensor::dim(output, i));
    }
    else
    {
      LUCI_INTERPRETER_CHECK(Tensor::dim(input, i) == Tensor::dim(output, i - 1));
    }
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleWhile()

void luci_interpreter::configure_kernel_CircleWhile	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 26 of file While.cpp.

{
  auto *main_runtime_graph = runtime_graph;
 
  auto *runtime_module = runtime_graph->getRuntimeModule();
 
  const auto *options = cur_op->builtin_options_as_WhileOptions();
  const auto body_subgraph_index = options->body_subgraph_index();
  const auto cond_subgraph_index = options->cond_subgraph_index();
 
  auto *cond_runtime_graph = runtime_module->getRuntimeGraphAt(cond_subgraph_index);
  auto *body_runtime_graph = runtime_module->getRuntimeGraphAt(body_subgraph_index);
 
  body_runtime_graph->selectOwnSubgraph();
  const auto body_input_size = body_runtime_graph->getNumOfInputTensors();
  const auto body_output_size = body_runtime_graph->getNumOfOutputTensors();
  LUCI_INTERPRETER_CHECK(body_input_size == cur_op->inputs()->size());
  LUCI_INTERPRETER_CHECK(body_output_size == cur_op->outputs()->size());
  LUCI_INTERPRETER_CHECK(body_output_size == cur_op->inputs()->size());
  body_runtime_graph->invalidate();
  body_runtime_graph->configure(false);
 
  cond_runtime_graph->selectOwnSubgraph();
  const auto cond_input_size = cond_runtime_graph->getNumOfInputTensors();
  const auto cond_output_size = cond_runtime_graph->getNumOfOutputTensors();
  LUCI_INTERPRETER_CHECK(cond_input_size == cur_op->inputs()->size());
  LUCI_INTERPRETER_CHECK(cond_output_size == 1);
  const circle::Tensor *cond_output_tensor = cond_runtime_graph->getOutputTensorByIndex(0);
  LUCI_INTERPRETER_CHECK(Tensor::element_type(cond_output_tensor) == DataType::BOOL);
  cond_runtime_graph->invalidate();
  cond_runtime_graph->configure(false);
 
  main_runtime_graph->selectOwnSubgraph();
}

References luci_interpreter::RuntimeGraph::getRuntimeModule(), and LUCI_INTERPRETER_CHECK.

configure_kernel_CircleZerosLike()

void luci_interpreter::configure_kernel_CircleZerosLike	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 34 of file ZerosLike.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  LUCI_INTERPRETER_CHECK(Tensor::element_type(kernel.input()) ==
                         Tensor::element_type(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_elements(kernel.input()) ==
                         Tensor::num_elements(kernel.output()));
  LUCI_INTERPRETER_CHECK(Tensor::num_dims(kernel.input()) == Tensor::num_dims(kernel.output()));
}

References luci_interpreter::kernels::SISOKernel::input(), LUCI_INTERPRETER_CHECK, and luci_interpreter::kernels::SISOKernel::output().

createConv2DParams()

luci_interpreter_pal::ConvParams luci_interpreter::createConv2DParams	(	const circle::Tensor *	input,
		const circle::Tensor *	filter,
		const circle::Tensor *	output,
		const circle::Conv2DOptions *	options
	)

Definition at line 54 of file ConvolutionCommon.cpp.

{
  luci_interpreter_pal::ConvParams params{};
 
  if (isSupportedQuantized(input, filter))
  {
#ifndef DIS_QUANT
    const auto input_scale = static_cast<double>(Tensor::scale(input));
    const auto filter_scale = static_cast<double>(Tensor::scale(filter));
    const auto output_scale = static_cast<double>(Tensor::scale(output));
 
    const double real_multiplier = input_scale * filter_scale / output_scale;
    int32_t output_multiplier{};
    int output_shift{};
    kernels::quantizeMultiplier(real_multiplier, &output_multiplier, &output_shift);
 
    params.output_multiplier = output_multiplier;
    params.output_shift = output_shift;
 
    int32_t activation_min{};
    int32_t activation_max{};
    kernels::calculateActivationRangeQuantized(luci_actfunc(options->fused_activation_function()),
                                               output, &activation_min, &activation_max);
 
    // The kernel expects input and filter zero points to be negated.
    params.input_offset = -Tensor::zero_point(input);    // Note the '-'.
    params.weights_offset = -Tensor::zero_point(filter); // Note the '-'.
    params.output_offset = Tensor::zero_point(output);
    params.quantized_activation_min = activation_min;
    params.quantized_activation_max = activation_max;
#endif // DIS_QUANT
  }
  else if (isSupportedQuantizedPerChannel(input, filter))
  {
#ifndef DIS_QUANT
    int32_t activation_min{};
    int32_t activation_max{};
    kernels::calculateActivationRangeQuantized(luci_actfunc(options->fused_activation_function()),
                                               output, &activation_min, &activation_max);
 
    const std::vector<double> effective_output_scale = kernels::getQuantizedConvolutionMultiplers(
      Tensor::scale(input), Tensor::scales(filter), Tensor::scale(output));
 
    size_t n = effective_output_scale.size();
    params.per_channel_output_shift.resize(n);
    params.per_channel_output_multiplier.resize(n);
    for (size_t i = 0; i < n; ++i)
    {
      kernels::quantizeMultiplier(effective_output_scale[i],
                                  &params.per_channel_output_multiplier[i],
                                  &params.per_channel_output_shift[i]);
 
      // The kernel expects input and filter zero points to be negated.
      params.input_offset = -Tensor::zero_point(input);    // Note the '-'.
      params.weights_offset = -Tensor::zero_point(filter); // Note the '-'.
      params.output_offset = Tensor::zero_point(output);
      params.quantized_activation_min = activation_min;
      params.quantized_activation_max = activation_max;
    }
#endif // DIS_QUANT
  }
  else if (Tensor::element_type(input) == DataType::FLOAT32 and
           Tensor::element_type(filter) == DataType::FLOAT32)
  {
#ifndef DIS_FLOAT
    float activation_min{};
    float activation_max{};
    kernels::calculateActivationRange(luci_actfunc(options->fused_activation_function()),
                                      &activation_min, &activation_max);
 
    params.float_activation_min = activation_min;
    params.float_activation_max = activation_max;
#endif // DIS_FLOAT
  }
  else
  {
    assert(false && "Not supported type");
  }
 
  const auto padding = options->padding();
  const auto stride_height = options->stride_h();
  const auto stride_width = options->stride_w();
  const auto dilation_height_factor = options->dilation_h_factor();
  const auto dilation_width_factor = options->dilation_h_factor();
 
  params.padding_values.height =
    computeConvPadding(input, filter, padding, stride_height, dilation_height_factor, 1);
  params.padding_values.width =
    computeConvPadding(input, filter, padding, stride_width, dilation_width_factor, 2);
  params.stride_height = stride_height;
  params.stride_width = stride_width;
  params.dilation_height_factor = dilation_height_factor;
  params.dilation_width_factor = dilation_width_factor;
 
  return params;
}

References luci_interpreter::kernels::calculateActivationRange(), luci_interpreter::kernels::calculateActivationRangeQuantized(), computeConvPadding(), luci_interpreter::kernels::getQuantizedConvolutionMultiplers(), luci::luci_actfunc(), and luci_interpreter::kernels::quantizeMultiplier().

createPoolParams()

luci_interpreter_pal::PoolParams luci_interpreter::createPoolParams ( const circle::Operator *  cur_op, const kernels::SISOKernel &  siso_kernel  )

inline

Definition at line 56 of file Pool2DCommon.h.

{
  const auto input = siso_kernel.input();
  const auto output = siso_kernel.output();
 
  const auto *options = cur_op->builtin_options_as_Pool2DOptions();
 
  const int32_t input_height = Tensor::dim(input, 1);
  const int32_t input_width = Tensor::dim(input, 2);
 
  const int32_t output_height = kernels::computeOutputSize(
    luci_padding(options->padding()), input_height, options->filter_height(), options->stride_h());
  const int32_t output_width = kernels::computeOutputSize(
    luci_padding(options->padding()), input_width, options->filter_width(), options->stride_w());
 
  const auto padding_height = kernels::computePadding(options->stride_h(), 1, input_height,
                                                      options->filter_height(), output_height);
  const auto padding_width = kernels::computePadding(options->stride_w(), 1, input_width,
                                                     options->filter_width(), output_width);
 
  const DataType input_type = Tensor::element_type(input);
 
  float activation_min{};
  float activation_max{};
 
  int32_t quantized_activation_min{};
  int32_t quantized_activation_max{};
 
  if (input_type == DataType::S8 or input_type == DataType::S16)
  {
#ifndef DIS_QUANT
    kernels::calculateActivationRangeQuantized(luci_actfunc(options->fused_activation_function()),
                                               output, &quantized_activation_min,
                                               &quantized_activation_max);
#endif // DIS_QUANT
  }
  else if (input_type == DataType::FLOAT32)
  {
#ifndef DIS_FLOAT
    kernels::calculateActivationRange(luci_actfunc(options->fused_activation_function()),
                                      &activation_min, &activation_max);
#endif // DIS_FLOAT
  }
  else
  {
    assert(false && "Not supported type");
  }
 
  luci_interpreter_pal::PoolParams params{};
  params.padding_values.height = padding_height;
  params.padding_values.width = padding_width;
  params.stride_height = options->stride_h();
  params.stride_width = options->stride_w();
  params.filter_height = options->filter_height();
  params.filter_width = options->filter_width();
  params.float_activation_min = activation_min;
  params.float_activation_max = activation_max;
  params.quantized_activation_max = quantized_activation_max;
  params.quantized_activation_min = quantized_activation_min;
 
  return params;
}

References luci_interpreter::kernels::calculateActivationRange(), luci_interpreter::kernels::calculateActivationRangeQuantized(), luci_interpreter::kernels::computeOutputSize(), luci_interpreter::kernels::computePadding(), circle_eval_diff::TensorShape::dim(), luci_interpreter_pal::PaddingValues::height, luci_interpreter::kernels::SISOKernel::input(), luci::luci_actfunc(), luci::luci_padding(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::PoolParams::padding_values.

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

evalInteger()

void luci_interpreter::evalInteger	(	const circle::Tensor *	input,
		const circle::Tensor *	output,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 107 of file Tanh.cpp.

{
  int32_t input_zero_point = 0;
  int32_t input_range_radius = 0;
  int32_t input_multiplier = 0;
  int input_left_shift = 0;
 
  calculateArithmeticData(input, output, input_zero_point, input_range_radius, input_multiplier,
                          input_left_shift);
 
  const auto *input_data = runtime_graph->getDataByTensor(input);
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(output);
  assert(output_data);
 
  const int flat_size = kernels::getTensorRuntimeShape(input, runtime_graph).flatSize();
 
  const auto input_dtype = Tensor::element_type(input);
  switch (input_dtype)
  {
    // TODO: enable it
#if 0
    case DataType::S8:
      luci_interpreter_pal::Tanh(
        input_zero_point, input_range_radius, input_multiplier, input_left_shift,
        flat_size, kernels::getTensorData<int8_t>(input_data), kernels::getTensorData<int8_t>(output_data));
      break;
#endif // 0
    case DataType::S16:
      luci_interpreter_pal::Tanh(input_multiplier, input_left_shift, flat_size,
                                 kernels::getTensorData<int16_t>(input_data),
                                 kernels::getTensorData<int16_t>(output_data));
      break;
    default:
      assert(false && "Not support yet");
  }
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), and luci_interpreter_pal::Tanh().

Referenced by execute_kernel_CircleTanh().

execute_kernel_CircleAbs()

void luci_interpreter::execute_kernel_CircleAbs	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 36 of file Abs.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto input = kernel.input();
  const auto output = kernel.output();
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  if (is_inplace)
  {
    output_data = const_cast<uint8_t *>(input_data);
  }
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  const int flat_size = kernels::getTensorRuntimeShape(input, runtime_graph).flatSize();
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::Abs(flat_size, kernels::getTensorData<float>(input_data),
                                kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
 
  if (is_inplace)
  {
    runtime_graph->makeInplaceOperation(input, output);
  }
}

References luci_interpreter_pal::Abs(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleAdd()

void luci_interpreter::execute_kernel_CircleAdd	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 117 of file Add.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_AddOptions();
 
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  // TODO remove code duplication, introduce func
#ifndef DIS_DYN_SHAPES
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
  // Dynamic shape case
  if (not is_inplace and not(input_shape1 == output_shape) and not(input_shape2 == output_shape))
  {
    int32_t num_dims;
 
    if (input_shape1.flatSize() > input_shape2.flatSize())
    {
      output_shape = input_shape1;
      num_dims = input_shape1.dimensionsCount();
    }
    else
    {
      output_shape = input_shape2;
      num_dims = input_shape2.dimensionsCount();
    }
 
    luci_interpreter::RuntimeShape dynamic_shape(num_dims);
    int32_t data_size = 1;
    for (int i = 0; i < num_dims; ++i)
    {
      dynamic_shape.setDim(i, output_shape.dims(i));
      data_size *= output_shape.dims(i);
    }
    data_size *= size(Tensor::element_type(kernel.output()));
 
    runtime_graph->addDynamicShapeTensor(kernel.output(), std::move(dynamic_shape));
 
    if (data_size == 0)
    {
      runtime_graph->resetTensorData(nullptr, kernel.output());
      return;
    }
    auto new_output_data = new uint8_t[data_size];
    runtime_graph->resetTensorData(new_output_data, kernel.output());
  }
#endif // DIS_DYN_SHAPES
 
  const auto type = Tensor::element_type(kernel.input1());
  switch (type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      auto tiso_func = luci_interpreter_pal::Add<float>;
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastAdd4DSlow<float>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<float>(tiso_func, broadcast_tiso_func, &kernel, options,
                                              std::move(input_shape1), std::move(input_shape2),
                                              std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<float>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                       options, std::move(input_shape1), std::move(input_shape2),
                                       std::move(output_shape));
      }
    }
    break;
#endif // DIS_FLOAT
    case DataType::S64:
    {
      auto tiso_func = luci_interpreter_pal::Add<int64_t>;
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastAdd4DSlow<int64_t>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<int64_t>(tiso_func, broadcast_tiso_func, &kernel, options,
                                                std::move(input_shape1), std::move(input_shape2),
                                                std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<int64_t>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                         options, std::move(input_shape1), std::move(input_shape2),
                                         std::move(output_shape));
      }
    }
    break;
    case DataType::S32:
    {
      auto tiso_func = luci_interpreter_pal::Add<int32_t>;
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastAdd4DSlow<int32_t>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<int32_t>(tiso_func, broadcast_tiso_func, &kernel, options,
                                                std::move(input_shape1), std::move(input_shape2),
                                                std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<int32_t>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                         options, std::move(input_shape1), std::move(input_shape2),
                                         std::move(output_shape));
      }
    }
    break;
#ifndef DIS_QUANT
    case DataType::S8:
    case DataType::S16:
    {
      evalQuantized(kernel.input1(), kernel.input2(), kernel.output(), options, runtime_graph,
                    type);
    }
    break;
#endif
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::addDynamicShapeTensor(), luci_interpreter::RuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::kernels::TISOKernel::output(), output_shape, luci_interpreter::kernels::TISOKernel::readData(), luci_interpreter::RuntimeGraph::resetTensorData(), luci_interpreter::RuntimeShape::setDim(), and size.

execute_kernel_CircleAddN()

void luci_interpreter::execute_kernel_CircleAddN	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 93 of file AddN.cpp.

{
  const auto output_index = cur_op->outputs()->operator[](0);
  assert(output_index != -1);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  switch (Tensor::element_type(output))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      evalGeneric<float>(cur_op, runtime_graph);
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex().

execute_kernel_CircleArgMax()

void luci_interpreter::execute_kernel_CircleArgMax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 39 of file ArgMax.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const circle::Tensor *input = kernel.input1();
  const circle::Tensor *output = kernel.output();
 
  kernels::TISOData tiso_data = kernel.readData();
  const auto input_data = tiso_data.input1_data;
  const auto axis_data = tiso_data.input2_data;
  auto output_data = tiso_data.output_data;
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::ArgMinMax(
        kernels::getTensorRuntimeShape(input, runtime_graph),
        kernels::getTensorData<float>(input_data), kernels::getTensorData<int32_t>(axis_data),
        kernels::getTensorRuntimeShape(output, runtime_graph),
        kernels::getTensorData<int32_t>(output_data), std::greater<float>());
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported ArgMax input type");
  }
}

References luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOData::input1_data, luci_interpreter::kernels::TISOData::input2_data, luci_interpreter::kernels::TISOKernel::output(), luci_interpreter::kernels::TISOData::output_data, and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleArgMin()

void luci_interpreter::execute_kernel_CircleArgMin	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 40 of file ArgMin.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const circle::Tensor *input = kernel.input1();
  const circle::Tensor *output = kernel.output();
 
  kernels::TISOData tiso_data = kernel.readData();
  const auto input_data = tiso_data.input1_data;
  const auto axis_data = tiso_data.input2_data;
  auto output_data = tiso_data.output_data;
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::ArgMinMax(
        kernels::getTensorRuntimeShape(input, runtime_graph),
        kernels::getTensorData<float>(input_data), kernels::getTensorData<int32_t>(axis_data),
        kernels::getTensorRuntimeShape(output, runtime_graph),
        kernels::getTensorData<int32_t>(output_data), std::less<float>());
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported ArgMax input type");
  }
}

References luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOData::input1_data, luci_interpreter::kernels::TISOData::input2_data, luci_interpreter::kernels::TISOKernel::output(), luci_interpreter::kernels::TISOData::output_data, and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleAveragePool2D()

void luci_interpreter::execute_kernel_CircleAveragePool2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 31 of file AveragePool2D.cpp.

{
  const kernels::SISOKernel siso_kernel(cur_op, runtime_graph);
 
  const auto input = siso_kernel.input();
  const auto output = siso_kernel.output();
 
  const auto *input_data = runtime_graph->getDataByTensor(input);
  auto *output_data = runtime_graph->getDataByTensor(output);
 
  const DataType input_type = Tensor::element_type(input);
 
  const auto params = createPoolParams(cur_op, siso_kernel);
 
  switch (input_type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::AveragePool(
        params, kernels::getTensorShape(input), kernels::getTensorData<float>(input_data),
        kernels::getTensorShape(output), kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
    case DataType::S16:
      luci_interpreter_pal::AveragePool(
        params, kernels::getTensorShape(input), kernels::getTensorData<uint8_t>(input_data),
        kernels::getTensorShape(output), kernels::getTensorData<uint8_t>(output_data), input_type);
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type.");
  }
}

References createPoolParams(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleBatchToSpaceND()

void luci_interpreter::execute_kernel_CircleBatchToSpaceND	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 42 of file BatchToSpaceND.cpp.

{
  kernels::MISOKernel kernel(cur_op, runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::BatchToSpaceND(
        kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.input1())),
        kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph),
        kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(kernel.input2())),
        kernels::getTensorRuntimeShape(kernel.input3(), runtime_graph),
        kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(kernel.input3())),
        kernels::getTensorRuntimeShape(kernel.output(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.output())));
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), and luci_interpreter::kernels::MISOKernel::output().

execute_kernel_CircleBroadcastTo()

void luci_interpreter::execute_kernel_CircleBroadcastTo	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 50 of file BroadcastTo.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input1());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  luci_interpreter_pal::BroadcastTo<kMaxDims>(
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph), input_data,
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph), output_data,
    Tensor::element_type(kernel.input1()));
}

References luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleCast()

void luci_interpreter::execute_kernel_CircleCast	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 43 of file Cast.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
  assert(output_data);
 
  const int flat_size = kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
 
      switch (Tensor::element_type(kernel.output()))
      {
        case DataType::S8:
          copyCast(input_data_float, kernels::getTensorData<int8_t>(output_data), flat_size);
          break;
        case DataType::S16:
          copyCast(input_data_float, kernels::getTensorData<int16_t>(output_data), flat_size);
          break;
        case DataType::S32:
          copyCast(input_data_float, kernels::getTensorData<int32_t>(output_data), flat_size);
          break;
        default:
          assert(false && "Not supported type");
      }
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleCeil()

void luci_interpreter::execute_kernel_CircleCeil	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Ceil.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Ceil(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter_pal::Ceil(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleConcatenation()

void luci_interpreter::execute_kernel_CircleConcatenation	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 136 of file Concatenation.cpp.

{
  int num_inputs = cur_op->inputs()->size();
  LUCI_INTERPRETER_CHECK(num_inputs > 0);
 
  const auto input_index = cur_op->inputs()->operator[](0);
  assert(input_index != -1);
  const auto *t0 = runtime_graph->getCircleTensorByIndex(input_index);
 
  switch (Tensor::element_type(t0))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      evalGeneric<float>(cur_op, runtime_graph);
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
      evalGeneric<int8_t>(cur_op, runtime_graph);
      break;
#endif // DIS_QUANT
    case DataType::S32:
      evalGeneric<int32_t>(cur_op, runtime_graph);
      break;
    case DataType::S64:
      evalGeneric<int64_t>(cur_op, runtime_graph);
      break;
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and LUCI_INTERPRETER_CHECK.

execute_kernel_CircleConv2D()

void luci_interpreter::execute_kernel_CircleConv2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 282 of file Conv2D.cpp.

{
  kernels::DownsamplingConv2DKernel kernel(cur_op, runtime_graph);
 
  const auto input = kernel.input();
  const auto weights = kernel.filter();
  const auto bias = kernel.bias();
  const auto output = kernel.output();
 
  const auto *options = cur_op->builtin_options_as_Conv2DOptions();
 
  const auto type = Tensor::element_type(input);
  switch (type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      if (Tensor::element_type(weights) == DataType::FLOAT32)
      {
        evalFloat(input, weights, bias, output, options, runtime_graph);
        break;
      }
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::U8:
    case DataType::S8:
      if (Tensor::scales(weights).size() == 1 and type == DataType::U8)
      {
        evalQuantized(input, weights, bias, output, options, runtime_graph);
      }
      else if (Tensor::scales(weights).size() > 1)
      {
        LUCI_INTERPRETER_CHECK(Tensor::num_dims(weights) == 4);
        LUCI_INTERPRETER_CHECK(Tensor::scales(weights).size() ==
                               static_cast<size_t>(Tensor::dim(weights, 0)));
        evalQuantizedPerChannel(input, weights, bias, output, options, runtime_graph, type);
      }
      else
      {
        assert(false && "Unsupported yet.");
      }
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::DownsamplingConv2DKernel::bias(), circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::DownsamplingConv2DKernel::filter(), luci_interpreter::kernels::DownsamplingConv2DKernel::input(), LUCI_INTERPRETER_CHECK, luci_interpreter::kernels::DownsamplingConv2DKernel::output(), and size.

execute_kernel_CircleCos()

void luci_interpreter::execute_kernel_CircleCos	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Cos.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Cos(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter_pal::Cos(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleDepthToSpace()

void luci_interpreter::execute_kernel_CircleDepthToSpace	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 55 of file DepthToSpace.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_DepthToSpaceOptions();
  const int32_t block_size = options->block_size();
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      assert(block_size != 0);
      luci_interpreter_pal::DepthToSpace(
        block_size, kernels::getTensorRuntimeShape(kernel.input(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.input())),
        kernels::getTensorRuntimeShape(kernel.output(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.output())));
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleDepthwiseConv2D()

void luci_interpreter::execute_kernel_CircleDepthwiseConv2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 122 of file DepthwiseConv2D.cpp.

{
  kernels::DownsamplingConv2DKernel kernel(cur_op, runtime_graph);
 
  const auto input = kernel.input();
  const auto weights = kernel.filter();
  const auto bias = kernel.bias();
  const auto output = kernel.output();
 
  const auto *options = cur_op->builtin_options_as_DepthwiseConv2DOptions();
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      if (Tensor::element_type(weights) == DataType::FLOAT32)
      {
        evalFloat(input, weights, bias, output, options, runtime_graph);
        break;
      }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::DownsamplingConv2DKernel::bias(), luci_interpreter::kernels::DownsamplingConv2DKernel::filter(), luci_interpreter::kernels::DownsamplingConv2DKernel::input(), and luci_interpreter::kernels::DownsamplingConv2DKernel::output().

execute_kernel_CircleDequantize()

void luci_interpreter::execute_kernel_CircleDequantize	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 42 of file Dequantize.cpp.

{
#ifndef DIS_QUANT
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
  assert(output_data);
 
  const int flat_size = kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
  switch (Tensor::element_type(kernel.output()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::QuantizationParams params{};
      params.zero_point = Tensor::zero_point(kernel.input());
      params.scale = Tensor::scale(kernel.input());
      switch (Tensor::element_type(kernel.input()))
      {
        case DataType::S8:
          luci_interpreter_pal::Dequantize(params, flat_size,
                                           kernels::getTensorData<int8_t>(input_data),
                                           kernels::getTensorData<float>(output_data));
          break;
        case DataType::U8:
          luci_interpreter_pal::Dequantize(params, flat_size,
                                           kernels::getTensorData<uint8_t>(input_data),
                                           kernels::getTensorData<float>(output_data));
          break;
        case DataType::S16:
          luci_interpreter_pal::Dequantize(params, flat_size,
                                           kernels::getTensorData<int16_t>(input_data),
                                           kernels::getTensorData<float>(output_data));
          break;
        default:
          assert(false && "Unsupported type");
      }
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
#else
  assert(false && "Remove DIS_QUANT flag");
#endif // DIS_QUANT
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::QuantizationParams::zero_point.

execute_kernel_CircleDiv()

void luci_interpreter::execute_kernel_CircleDiv	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 38 of file Div.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_DivOptions();
 
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      auto tiso_func = luci_interpreter_pal::Div<float>;
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastDiv4DSlow<float>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<float>(tiso_func, broadcast_tiso_func, &kernel, options,
                                              std::move(input_shape1), std::move(input_shape2),
                                              std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<float>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                       options, std::move(input_shape1), std::move(input_shape2),
                                       std::move(output_shape));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::kernels::TISOKernel::output(), output_shape, and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleElu()

void luci_interpreter::execute_kernel_CircleElu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Elu.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Elu(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleEqual()

void luci_interpreter::execute_kernel_CircleEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 33 of file Equal.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
    case DataType::S64:
      kernels::evalComparisonGeneric<int64_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::EqualFn);
      break;
    case DataType::S32:
      kernels::evalComparisonGeneric<int32_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::EqualFn);
      break;
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      kernels::evalComparisonGeneric<float>(kernel.input1(), kernel.input2(), kernel.output(),
                                            runtime_graph, luci_interpreter_pal::EqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter_pal::EqualFn(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleExp()

void luci_interpreter::execute_kernel_CircleExp	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 38 of file Exp.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Exp(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter_pal::Exp(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleExpandDims()

void luci_interpreter::execute_kernel_CircleExpandDims	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 67 of file ExpandDims.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  if (is_inplace)
  {
    runtime_graph->makeInplaceOperation(input, output);
    return;
  }
 
  // Just copy input to output
  const auto input_data = runtime_graph->getDataByTensor(input);
  auto output_data = runtime_graph->getDataByTensor(output);
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  const size_t element_size = getDataTypeSize(Tensor::element_type(input));
  const int32_t num_elements = Tensor::num_elements(input);
  std::memcpy(output_data, input_data, num_elements * element_size);
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getDataByTensor(), getDataTypeSize(), luci_interpreter::RuntimeGraph::is_inplace_op(), and luci_interpreter::RuntimeGraph::makeInplaceOperation().

execute_kernel_CircleFill()

void luci_interpreter::execute_kernel_CircleFill	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 48 of file Fill.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const circle::Tensor *value = kernel.input2();
  const circle::Tensor *output = kernel.output();
 
  kernels::TISOData tiso_data = kernel.readData();
  const uint8_t *value_data = tiso_data.input2_data;
  uint8_t *output_data = tiso_data.output_data;
 
  const size_t flat_size = Tensor::num_elements(output);
 
  switch (Tensor::element_type(value))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      fillImpl<float>(flat_size, kernels::getTensorData<float>(value_data),
                      kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
    case DataType::S32:
      fillImpl<int32_t>(flat_size, kernels::getTensorData<int32_t>(value_data),
                        kernels::getTensorData<int32_t>(output_data));
      break;
#ifndef DIS_QUANT
    case DataType::U8:
      fillImpl<uint8_t>(flat_size, kernels::getTensorData<uint8_t>(value_data),
                        kernels::getTensorData<uint8_t>(output_data));
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Not impl yet");
  }
}

References luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOData::input2_data, luci_interpreter::kernels::TISOKernel::output(), luci_interpreter::kernels::TISOData::output_data, and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleFloor()

void luci_interpreter::execute_kernel_CircleFloor	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 49 of file Floor.cpp.

{
 
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
 
      luci_interpreter_pal::Floor(
        kernels::getTensorShape(input), kernels::getTensorData<float>(input_data),
        kernels::getTensorShape(output), kernels::getTensorData<float>(output_data));
 
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter_pal::Floor(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getDataByTensor(), and luci_interpreter::kernels::getTensorShape().

execute_kernel_CircleFloorDiv()

void luci_interpreter::execute_kernel_CircleFloorDiv	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 35 of file FloorDiv.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_FloorDivOptions();
 
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
 
  const uint8_t *input_data1 = runtime_graph->getDataByTensor(kernel.input1());
  const uint8_t *input_data2 = runtime_graph->getDataByTensor(kernel.input2());
  uint8_t *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  assert(input_data1 != nullptr);
  assert(input_data2 != nullptr);
  assert(output_data != nullptr);
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      // Check the denominator
      for (int i = 0; i < input_shape2.flatSize(); ++i)
      {
        LUCI_INTERPRETER_CHECK(kernels::getTensorData<float>(input_data2)[i] != 0);
      }
      // check that input and output dimensions are equal
      if (kernels::areShapesEqual(input_shape1, input_shape2))
      {
        const int flat_size = input_shape1.flatSize();
        luci_interpreter_pal::FloorDiv(flat_size, kernels::getTensorData<float>(input_data1),
                                       kernels::getTensorData<float>(input_data2),
                                       kernels::getTensorData<float>(output_data));
      }
      else
      {
        luci_interpreter_pal::BroadcastFloorDiv4DSlow(
          input_shape1, kernels::getTensorData<float>(input_data1), input_shape2,
          kernels::getTensorData<float>(input_data2), output_shape,
          kernels::getTensorData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::areShapesEqual(), luci_interpreter_pal::BroadcastFloorDiv4DSlow(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter_pal::FloorDiv(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, luci_interpreter::kernels::TISOKernel::output(), and output_shape.

execute_kernel_CircleFloorMod()

void luci_interpreter::execute_kernel_CircleFloorMod	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 35 of file FloorMod.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_FloorModOptions();
 
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
 
  const uint8_t *input_data1 = runtime_graph->getDataByTensor(kernel.input1());
  const uint8_t *input_data2 = runtime_graph->getDataByTensor(kernel.input2());
  uint8_t *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  assert(input_data1 != nullptr);
  assert(input_data2 != nullptr);
  assert(output_data != nullptr);
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      // Check the denominator
      for (int i = 0; i < input_shape2.flatSize(); ++i)
      {
        LUCI_INTERPRETER_CHECK(kernels::getTensorData<float>(input_data2)[i] != 0);
      }
      // check that input and output dimensions are equal
      if (kernels::areShapesEqual(input_shape1, input_shape2))
      {
        const int flat_size = input_shape1.flatSize();
        luci_interpreter_pal::FloorMod(flat_size, kernels::getTensorData<float>(input_data1),
                                       kernels::getTensorData<float>(input_data2),
                                       kernels::getTensorData<float>(output_data));
      }
      else
      {
        luci_interpreter_pal::BroadcastFloorMod4DSlow(
          input_shape1, kernels::getTensorData<float>(input_data1), input_shape2,
          kernels::getTensorData<float>(input_data2), output_shape,
          kernels::getTensorData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::areShapesEqual(), luci_interpreter_pal::BroadcastFloorMod4DSlow(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter_pal::FloorMod(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), LUCI_INTERPRETER_CHECK, luci_interpreter::kernels::TISOKernel::output(), and output_shape.

execute_kernel_CircleFullyConnected()

void luci_interpreter::execute_kernel_CircleFullyConnected	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 282 of file FullyConnected.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto weight_index = cur_op->inputs()->operator[](1);
  const auto bias_index = cur_op->inputs()->operator[](2);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(weight_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto weights = runtime_graph->getCircleTensorByIndex(weight_index);
  const auto bias = runtime_graph->getCircleTensorByIndex(bias_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(weights != nullptr);
  assert(output != nullptr);
 
  const auto *options = cur_op->builtin_options_as_FullyConnectedOptions();
  const auto input_type = Tensor::element_type(input);
  switch (input_type)
  {
#ifndef DIS_QUANT
    case DataType::U8:
    case DataType::S8:
    case DataType::S16:
      evalQuantized(input, weights, bias, output, options, runtime_graph, input_type);
      break;
#endif // DIS_QUANT
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      evalFloat(input, weights, bias, output, options, runtime_graph);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex().

execute_kernel_CircleGather()

void luci_interpreter::execute_kernel_CircleGather	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 137 of file Gather.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_GatherOptions();
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      return gather<float, int32_t>(options, &kernel);
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
      return gather<int8_t, int32_t>(options, &kernel);
#endif // DIS_QUANT
    case DataType::S32:
      return gather<int32_t, int32_t>(options, &kernel);
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::kernels::TISOKernel::input1().

execute_kernel_CircleGatherND()

void luci_interpreter::execute_kernel_CircleGatherND	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 47 of file GatherND.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const uint8_t *params_data = runtime_graph->getDataByTensor(kernel.input1());
  const uint8_t *indies_data = runtime_graph->getConstDataByTensor(kernel.input2());
  uint8_t *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      return luci_interpreter_pal::GatherND<float, int32_t>(
        kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph),
        kernels::getTensorData<float>(params_data),
        kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph),
        kernels::getTensorData<int32_t>(indies_data), kernels::getTensorData<float>(output_data));
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleGreater()

void luci_interpreter::execute_kernel_CircleGreater	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 33 of file Greater.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
    case DataType::S64:
      kernels::evalComparisonGeneric<int64_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::GreaterFn);
      break;
    case DataType::S32:
      kernels::evalComparisonGeneric<int32_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::GreaterFn);
      break;
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      kernels::evalComparisonGeneric<float>(kernel.input1(), kernel.input2(), kernel.output(),
                                            runtime_graph, luci_interpreter_pal::GreaterFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter_pal::GreaterFn(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleGreaterEqual()

void luci_interpreter::execute_kernel_CircleGreaterEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 34 of file GreaterEqual.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
    case DataType::S64:
      kernels::evalComparisonGeneric<int64_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::GreaterEqualFn);
      break;
    case DataType::S32:
      kernels::evalComparisonGeneric<int32_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::GreaterEqualFn);
      break;
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      kernels::evalComparisonGeneric<float>(kernel.input1(), kernel.input2(), kernel.output(),
                                            runtime_graph, luci_interpreter_pal::GreaterEqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter_pal::GreaterEqualFn(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleIf()

void luci_interpreter::execute_kernel_CircleIf	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 64 of file If.cpp.

{
  auto *main_runtime_graph = runtime_graph;
  auto *runtime_module = runtime_graph->getRuntimeModule();
 
  const auto input_size = cur_op->inputs()->size() - 1;
  const auto output_size = cur_op->outputs()->size();
 
  std::vector<uint8_t *> operation_inputs_data(input_size);
  std::vector<uint8_t *> operation_outputs_data(output_size);
 
  std::vector<int32_t> input_sizes(input_size);
  std::vector<int32_t> output_sizes(output_size);
 
  const auto *options = cur_op->builtin_options_as_IfOptions();
  const auto cond_index = cur_op->inputs()->operator[](0);
 
  const auto then_subgraph_index = options->then_subgraph_index();
  const auto else_subgraph_index = options->else_subgraph_index();
 
  auto *then_subgraph = runtime_module->getRuntimeGraphAt(then_subgraph_index);
  auto *else_subgraph = runtime_module->getRuntimeGraphAt(else_subgraph_index);
 
  const auto cond = runtime_graph->getCircleTensorByIndex(cond_index);
 
  const uint8_t *cond_data = runtime_graph->getDataByTensor(cond);
  const bool cond_value = kernels::getTensorData<bool>(cond_data)[0];
 
  RuntimeGraph *active_graph = cond_value ? then_subgraph : else_subgraph;
 
  for (int32_t i = 0; i < input_size; ++i)
  {
    const auto op_input_index = cur_op->inputs()->operator[](i + 1);
    assert(op_input_index != -1);
    const auto input = main_runtime_graph->getCircleTensorByIndex(op_input_index);
    input_sizes[i] = Tensor::num_elements(input) * size(Tensor::element_type(input));
 
    auto *input_data = main_runtime_graph->getDataByTensor(input);
 
    uint8_t *tensor_data = nullptr;
    if (input_data == nullptr)
      input_data = main_runtime_graph->getConstDataByTensor(input);
    assert(input_data != nullptr);
    tensor_data = main_runtime_graph->getDataByTensor(input);
    assert(tensor_data != nullptr);
 
    operation_inputs_data[i] = tensor_data;
  }
  for (int32_t i = 0; i < output_size; ++i)
  {
    const auto op_output_index = cur_op->outputs()->operator[](i);
    assert(op_output_index != -1);
    const auto output = main_runtime_graph->getCircleTensorByIndex(op_output_index);
    output_sizes[i] = Tensor::num_elements(output) * size(Tensor::element_type(output));
 
    auto *output_data = main_runtime_graph->getDataByTensor(output);
 
    uint8_t *tensor_data = nullptr;
    if (output_data == nullptr)
      output_data = main_runtime_graph->getConstDataByTensor(output);
    assert(output_data != nullptr);
    tensor_data = main_runtime_graph->getDataByTensor(output);
    assert(tensor_data != nullptr);
 
    operation_outputs_data[i] = tensor_data;
  }
  active_graph->selectOwnSubgraph();
  for (int32_t i = 0; i < input_size; ++i)
    active_graph->configureGraphInput(i, operation_inputs_data[i]);
  active_graph->execute();
 
  for (int32_t i = 0; i < output_size; ++i)
  {
    auto cur_output_active_data = active_graph->getOutputDataByIndex(i);
    if (cur_output_active_data == nullptr)
      continue;
    std::memcpy(operation_outputs_data[i], cur_output_active_data, output_sizes[i]);
  }
  active_graph->resetOutputTensorsData();
  active_graph->clearTensors();
  main_runtime_graph->selectOwnSubgraph();
}

References luci_interpreter::RuntimeGraph::clearTensors(), luci_interpreter::RuntimeGraph::configureGraphInput(), luci_interpreter::RuntimeGraph::execute(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::RuntimeGraph::getOutputDataByIndex(), luci_interpreter::RuntimeGraph::getRuntimeModule(), luci_interpreter::RuntimeGraph::resetOutputTensorsData(), luci_interpreter::RuntimeGraph::selectOwnSubgraph(), and size.

execute_kernel_CircleL2Normalize()

void luci_interpreter::execute_kernel_CircleL2Normalize	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 38 of file L2Normalize.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const auto *input_data_float = kernels::getTensorData<float>(input_data);
      auto *output_data_float = kernels::getTensorData<float>(output_data);
 
      assert(output_data_float);
 
      luci_interpreter_pal::L2Normalization(
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph), input_data_float,
        kernels::getTensorRuntimeShape(kernel.output(), runtime_graph), output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleL2Pool2D()

void luci_interpreter::execute_kernel_CircleL2Pool2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 30 of file L2Pool2D.cpp.

{
  const kernels::SISOKernel siso_kernel(cur_op, runtime_graph);
 
  const auto input = siso_kernel.input();
  const auto output = siso_kernel.output();
 
  const auto *input_data = runtime_graph->getDataByTensor(input);
  auto *output_data = runtime_graph->getDataByTensor(output);
 
  const DataType input_type = Tensor::element_type(input);
 
  const auto params = createPoolParams(cur_op, siso_kernel);
 
  switch (input_type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::L2Pool(
        params, kernels::getTensorShape(input), kernels::getTensorData<float>(input_data),
        kernels::getTensorShape(output), kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References createPoolParams(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleLeakyRelu()

void luci_interpreter::execute_kernel_CircleLeakyRelu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 38 of file LeakyRelu.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  const auto options = cur_op->builtin_options_as_LeakyReluOptions();
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::ReLUCommon(flat_size, input_data_float, output_data_float,
                                       options->alpha(), false);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::ReLUCommon().

execute_kernel_CircleLess()

void luci_interpreter::execute_kernel_CircleLess	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 89 of file Less.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
    case DataType::S64:
      kernels::evalComparisonGeneric<int64_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::LessFn);
      break;
    case DataType::S32:
      kernels::evalComparisonGeneric<int32_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::LessFn);
      break;
#ifndef DIS_QUANT
    case DataType::U8:
      evalQuantized(kernel.input1(), kernel.input2(), kernel.output(), runtime_graph);
      break;
#endif // DIS_QUANT
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      kernels::evalComparisonGeneric<float>(kernel.input1(), kernel.input2(), kernel.output(),
                                            runtime_graph, luci_interpreter_pal::LessFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::LessFn(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleLessEqual()

void luci_interpreter::execute_kernel_CircleLessEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 34 of file LessEqual.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
    case DataType::S64:
      kernels::evalComparisonGeneric<int64_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::LessEqualFn);
      break;
    case DataType::S32:
      kernels::evalComparisonGeneric<int32_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::LessEqualFn);
      break;
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      kernels::evalComparisonGeneric<float>(kernel.input1(), kernel.input2(), kernel.output(),
                                            runtime_graph, luci_interpreter_pal::LessEqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::LessEqualFn(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleLog()

void luci_interpreter::execute_kernel_CircleLog	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Log.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Log(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter_pal::Log(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleLogicalAnd()

void luci_interpreter::execute_kernel_CircleLogicalAnd	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 48 of file LogicalAnd.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  auto x_data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.input1()));
  if (x_data == nullptr)
    x_data = kernels::getTensorData<bool>(runtime_graph->getConstDataByTensor(kernel.input1()));
 
  assert(x_data != nullptr);
 
  auto y_data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.input2()));
  if (y_data == nullptr)
    y_data = kernels::getTensorData<bool>(runtime_graph->getConstDataByTensor(kernel.input2()));
 
  assert(y_data != nullptr);
 
  auto output_data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.output()));
 
  const int64_t flat_size = kernels::getTensorShape(kernel.input1()).flatSize();
  luci_interpreter_pal::LogicalCommon(flat_size, x_data, y_data, output_data, LogicalAnd);
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::LogicalCommon(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleLogicalNot()

void luci_interpreter::execute_kernel_CircleLogicalNot	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 44 of file LogicalNot.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  auto data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.input()));
  if (data == nullptr)
    data = kernels::getTensorData<bool>(runtime_graph->getConstDataByTensor(kernel.input()));
 
  assert(data != nullptr);
 
  auto output_data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.output()));
 
  const int64_t flat_size = kernels::getTensorShape(kernel.input()).flatSize();
  luci_interpreter_pal::LogicalNot(flat_size, data, output_data);
}

References flatbuffers::data(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter_pal::LogicalNot(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleLogicalOr()

void luci_interpreter::execute_kernel_CircleLogicalOr	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 49 of file LogicalOr.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  auto x_data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.input1()));
  if (x_data == nullptr)
    x_data = kernels::getTensorData<bool>(runtime_graph->getConstDataByTensor(kernel.input1()));
 
  assert(x_data != nullptr);
 
  auto y_data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.input2()));
  if (y_data == nullptr)
    y_data = kernels::getTensorData<bool>(runtime_graph->getConstDataByTensor(kernel.input2()));
 
  assert(y_data != nullptr);
 
  auto output_data = kernels::getTensorData<bool>(runtime_graph->getDataByTensor(kernel.output()));
 
  const int64_t flat_size = kernels::getTensorShape(kernel.input1()).flatSize();
  luci_interpreter_pal::LogicalCommon(flat_size, x_data, y_data, output_data, LogicalOr);
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::LogicalCommon(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CircleLogistic()

void luci_interpreter::execute_kernel_CircleLogistic	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 41 of file Logistic.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto input = kernel.input();
  const auto output = kernel.output();
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  if (is_inplace)
  {
    output_data = const_cast<uint8_t *>(input_data);
  }
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  const int flat_size = kernels::getTensorRuntimeShape(input, runtime_graph).flatSize();
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::Logistic(flat_size, kernels::getTensorData<float>(input_data),
                                     kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
      luci_interpreter_pal::Logistic(flat_size, kernels::getTensorData<int8_t>(input_data),
                                     Tensor::scale(input), Tensor::zero_point(input),
                                     kernels::getTensorData<int8_t>(output_data),
                                     Tensor::scale(output), Tensor::zero_point(output));
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type.");
  }
 
  if (is_inplace)
  {
    runtime_graph->makeInplaceOperation(input, output);
  }
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter_pal::Logistic(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleLogSoftmax()

void luci_interpreter::execute_kernel_CircleLogSoftmax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 38 of file LogSoftmax.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      assert(output_data_float);
 
      luci_interpreter_pal::LogSoftmax(
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph), input_data_float,
        kernels::getTensorRuntimeShape(kernel.output(), runtime_graph), output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleMaximum()

void luci_interpreter::execute_kernel_CircleMaximum	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 34 of file Maximum.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
 
  const uint8_t *input_data1 = runtime_graph->getDataByTensor(kernel.input1());
  const uint8_t *input_data2 = runtime_graph->getDataByTensor(kernel.input2());
  uint8_t *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  assert(input_data1 != nullptr);
  assert(input_data2 != nullptr);
  assert(output_data != nullptr);
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      // check that input and output dimensions are equal
      if (kernels::areShapesEqual(input_shape1, input_shape2))
      {
        const int flat_size = input_shape1.flatSize();
        luci_interpreter_pal::Maximum(flat_size, kernels::getTensorData<float>(input_data1),
                                      kernels::getTensorData<float>(input_data2),
                                      kernels::getTensorData<float>(output_data));
      }
      else
      {
        luci_interpreter_pal::BroadcastMaximum4DSlow(
          input_shape1, kernels::getTensorData<float>(input_data1), input_shape2,
          kernels::getTensorData<float>(input_data2), output_shape,
          kernels::getTensorData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::areShapesEqual(), luci_interpreter_pal::BroadcastMaximum4DSlow(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::Maximum(), luci_interpreter::kernels::TISOKernel::output(), and output_shape.

execute_kernel_CircleMaxPool2D()

void luci_interpreter::execute_kernel_CircleMaxPool2D	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 29 of file MaxPool2D.cpp.

{
  const kernels::SISOKernel siso_kernel(cur_op, runtime_graph);
 
  const auto input = siso_kernel.input();
  const auto output = siso_kernel.output();
 
  const auto *input_data = runtime_graph->getDataByTensor(input);
  auto *output_data = runtime_graph->getDataByTensor(output);
 
  const DataType input_type = Tensor::element_type(input);
 
  const auto params = createPoolParams(cur_op, siso_kernel);
 
  switch (input_type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::MaxPool(
        params, kernels::getTensorShape(input), kernels::getTensorData<float>(input_data),
        kernels::getTensorShape(output), kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
    case DataType::S16:
      luci_interpreter_pal::MaxPool(
        params, kernels::getTensorShape(input), kernels::getTensorData<uint8_t>(input_data),
        kernels::getTensorShape(output), kernels::getTensorData<uint8_t>(output_data), input_type);
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type.");
  }
}

References createPoolParams(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter_pal::MaxPool(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleMean()

void luci_interpreter::execute_kernel_CircleMean	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 61 of file Mean.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  kernels::TISOData tiso_data = kernel.readData();
 
  const auto *input = kernel.input1();
  const auto *axis = kernel.input2();
  const auto *output = kernel.output();
 
  const auto *options = cur_op->builtin_options_as_ReducerOptions();
 
  int num_axis = static_cast<int>(Tensor::num_elements(axis));
  int temp_index[kMaxNumberOfAxis];
  int resolved_axis[kMaxNumberOfReducedAxis];
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::MeanParams op_params;
      ResolveAxis(kernels::getTensorData<int>(tiso_data.input2_data), num_axis, &op_params);
 
      // Special case mean implementation exists for 4D mean across axes 1
      // and 2.
      bool special_case_4d_axes_1_and_2 = Tensor::num_dims(input) == 4 &&
                                          op_params.axis_count == 2 &&
                                          ((op_params.axis[0] == 1 && op_params.axis[1] == 2) ||
                                           (op_params.axis[0] == 2 && op_params.axis[1] == 1));
 
      // Defer to specialized implementation for 4D Mean across axes 1 & 2.
      if (options->keep_dims() && special_case_4d_axes_1_and_2)
      {
        luci_interpreter_pal::Mean(op_params, kernels::getTensorShape(input),
                                   kernels::getTensorData<float>(tiso_data.input1_data),
                                   kernels::getTensorShape(output),
                                   kernels::getTensorData<float>(tiso_data.output_data));
      }
      else
      {
        luci_interpreter_pal::Mean(
          kernels::getTensorData<float>(tiso_data.input1_data),
          reinterpret_cast<const int *>(wrap(input->shape()).data()), Tensor::num_dims(input),
          kernels::getTensorData<float>(tiso_data.output_data),
          reinterpret_cast<const int *>(wrap(output->shape()).data()), Tensor::num_dims(output),
          kernels::getTensorData<int>(tiso_data.input2_data), num_axis, options->keep_dims(),
          temp_index, resolved_axis, kernels::getTensorData<float>(tiso_data.output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter_pal::MeanParams::axis, luci_interpreter_pal::MeanParams::axis_count, luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOData::input1_data, luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOData::input2_data, luci_interpreter_pal::Mean(), luci_interpreter::kernels::TISOKernel::output(), luci_interpreter::kernels::TISOData::output_data, luci_interpreter::kernels::TISOKernel::readData(), and luci::wrap().

execute_kernel_CircleMinimum()

void luci_interpreter::execute_kernel_CircleMinimum	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 34 of file Minimum.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
 
  const uint8_t *input_data1 = runtime_graph->getDataByTensor(kernel.input1());
  const uint8_t *input_data2 = runtime_graph->getDataByTensor(kernel.input2());
  uint8_t *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  assert(input_data1 != nullptr);
  assert(input_data2 != nullptr);
  assert(output_data != nullptr);
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      // check that input and output dimensions are equal
      if (kernels::areShapesEqual(input_shape1, input_shape2))
      {
        const int flat_size = input_shape1.flatSize();
        luci_interpreter_pal::Minimum(flat_size, kernels::getTensorData<float>(input_data1),
                                      kernels::getTensorData<float>(input_data2),
                                      kernels::getTensorData<float>(output_data));
      }
      else
      {
        luci_interpreter_pal::BroadcastMinimum4DSlow<float>(
          input_shape1, kernels::getTensorData<float>(input_data1), input_shape2,
          kernels::getTensorData<float>(input_data2), output_shape,
          kernels::getTensorData<float>(output_data));
      }
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::areShapesEqual(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::Minimum(), luci_interpreter::kernels::TISOKernel::output(), and output_shape.

execute_kernel_CircleMirrorPad()

void luci_interpreter::execute_kernel_CircleMirrorPad	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 42 of file MirrorPad.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  kernels::TISOData data = kernel.readData();
 
  const auto *options = cur_op->builtin_options_as_MirrorPadOptions();
 
  const auto offset = options->mode() != circle::MirrorPadMode_REFLECT ? 0 : 1;
  const auto input_dims = Tensor::num_dims(kernel.input1());
  const auto output_size = Tensor::num_elements(kernel.output());
 
  int output_dims_num_elements[5];
  int input_dims_num_elements[5];
 
  for (int i = 0; i < input_dims; i++)
  {
    output_dims_num_elements[i] = 1;
    input_dims_num_elements[i] = 1;
  }
 
  for (int i = input_dims - 2; i >= 0; i--)
  {
    output_dims_num_elements[i] =
      output_dims_num_elements[i + 1] * Tensor::dim(kernel.output(), i + 1);
 
    input_dims_num_elements[i] =
      input_dims_num_elements[i + 1] * Tensor::dim(kernel.input1(), i + 1);
  }
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::MirrorPad(
        Tensor::element_type(kernel.input2()), data.input2_data,
        wrap(kernel.input1()->shape()).data(), output_dims_num_elements, input_dims_num_elements,
        kernels::getTensorData<float>(data.input1_data),
        kernels::getTensorData<float>(data.output_data), offset, input_dims, output_size);
 
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References flatbuffers::data(), circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::MirrorPad(), offset(), luci_interpreter::kernels::TISOKernel::output(), luci_interpreter::kernels::TISOKernel::readData(), and luci::wrap().

execute_kernel_CircleMul()

void luci_interpreter::execute_kernel_CircleMul	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 105 of file Mul.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_MulOptions();
 
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
 
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
  const auto type = Tensor::element_type(kernel.input1());
  switch (type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      auto tiso_func = luci_interpreter_pal::Mul<float>;
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastMul4DSlow<float>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<float>(tiso_func, broadcast_tiso_func, &kernel, options,
                                              std::move(input_shape1), std::move(input_shape2),
                                              std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<float>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                       options, std::move(input_shape1), std::move(input_shape2),
                                       std::move(output_shape));
      }
    }
    break;
#endif // DIS_FLOAT
    case DataType::S64:
    {
      auto tiso_func = luci_interpreter_pal::Mul<int64_t>;
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastMul4DSlow<int64_t>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<int64_t>(tiso_func, broadcast_tiso_func, &kernel, options,
                                                std::move(input_shape1), std::move(input_shape2),
                                                std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<int64_t>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                         options, std::move(input_shape1), std::move(input_shape2),
                                         std::move(output_shape));
      }
    }
    break;
    case DataType::S32:
    {
      auto tiso_func = luci_interpreter_pal::Mul<int32_t>;
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastMul4DSlow<int32_t>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<int32_t>(tiso_func, broadcast_tiso_func, &kernel, options,
                                                std::move(input_shape1), std::move(input_shape2),
                                                std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<int32_t>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                         options, std::move(input_shape1), std::move(input_shape2),
                                         std::move(output_shape));
      }
    }
    break;
#ifndef DIS_QUANT
    case DataType::S8:
    case DataType::S16:
    {
      evalQuantized(kernel.input1(), kernel.input2(), kernel.output(), options, runtime_graph,
                    type);
    }
    break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::kernels::TISOKernel::output(), output_shape, and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleNeg()

void luci_interpreter::execute_kernel_CircleNeg	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 46 of file Neg.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
 
      luci_interpreter_pal::Negate(
        kernels::getTensorShape(input), kernels::getTensorData<float>(input_data),
        kernels::getTensorShape(output), kernels::getTensorData<float>(output_data));
 
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getDataByTensor(), and luci_interpreter::kernels::getTensorShape().

execute_kernel_CircleNotEqual()

void luci_interpreter::execute_kernel_CircleNotEqual	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 34 of file NotEqual.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  switch (Tensor::element_type(kernel.input1()))
  {
    case DataType::S64:
      kernels::evalComparisonGeneric<int64_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::NotEqualFn);
      break;
    case DataType::S32:
      kernels::evalComparisonGeneric<int32_t>(kernel.input1(), kernel.input2(), kernel.output(),
                                              runtime_graph, luci_interpreter_pal::NotEqualFn);
      break;
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      kernels::evalComparisonGeneric<float>(kernel.input1(), kernel.input2(), kernel.output(),
                                            runtime_graph, luci_interpreter_pal::NotEqualFn);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter_pal::NotEqualFn(), and luci_interpreter::kernels::TISOKernel::output().

execute_kernel_CirclePack()

void luci_interpreter::execute_kernel_CirclePack	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 90 of file Pack.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto output_index = cur_op->outputs()->operator[](0);
  assert(output_index != -1);
  assert(input_index != -1);
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  auto output_data = runtime_graph->getDataByTensor(output);
  assert(output_data != nullptr);
 
  switch (Tensor::element_type(output))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      packImpl<float>(input, output, cur_op, runtime_graph, output_data);
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
      packImpl<int8_t>(input, output, cur_op, runtime_graph, output_data);
      break;
    case DataType::U8:
      packImpl<uint8_t>(input, output, cur_op, runtime_graph, output_data);
      break;
#endif // DIS_QUANT
    case DataType::S32:
      packImpl<int32_t>(input, output, cur_op, runtime_graph, output_data);
      break;
    case DataType::S64:
      packImpl<int64_t>(input, output, cur_op, runtime_graph, output_data);
      break;
    default:
      assert(false && "Unsupported types");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and luci_interpreter::RuntimeGraph::getDataByTensor().

execute_kernel_CirclePad()

void luci_interpreter::execute_kernel_CirclePad	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file Pad.cpp.

{
  execute_kernel_CirclePadCommon(cur_op, runtime_graph);
}

References execute_kernel_CirclePadCommon().

execute_kernel_CirclePadCommon()

void luci_interpreter::execute_kernel_CirclePadCommon	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 128 of file PadCommon.cpp.

{
  PadKernel kernel(cur_op, runtime_graph);
 
  const auto input1_tensor = kernel.input1();
  const auto input2_tensor = kernel.input2();
  const auto input3_tensor = kernel.input3();
  const auto output_tensor = kernel.output();
 
  auto pad_params = kernel.getPadParams();
 
  auto *input1_data = runtime_graph->getDataByTensor(input1_tensor);
  if (input1_data == nullptr)
    input1_data = runtime_graph->getConstDataByTensor(input1_tensor);
  assert(input1_data);
 
  auto *input2_data = runtime_graph->getConstDataByTensor(input2_tensor);
  assert(input2_data);
 
  auto *output_data = runtime_graph->getDataByTensor(output_tensor);
  assert(output_data);
 
  switch (Tensor::element_type(input1_tensor))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      float pad_value =
        input3_tensor == nullptr
          ? 0.f
          : *kernels::getTensorData<float>(runtime_graph->getConstDataByTensor(input3_tensor));
      luci_interpreter_pal::Pad(pad_params, kernels::getTensorShape(input1_tensor),
                                kernels::getTensorData<float>(input1_data), &pad_value,
                                kernels::getTensorShape(output_tensor),
                                kernels::getTensorData<float>(output_data));
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), and luci_interpreter_pal::Pad().

Referenced by execute_kernel_CirclePad(), and execute_kernel_CirclePadV2().

execute_kernel_CirclePadV2()

void luci_interpreter::execute_kernel_CirclePadV2	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file PadV2.cpp.

{
  execute_kernel_CirclePadCommon(cur_op, runtime_graph);
}

References execute_kernel_CirclePadCommon().

execute_kernel_CirclePRelu()

void luci_interpreter::execute_kernel_CirclePRelu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 40 of file PRelu.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  kernels::TISOData kernel_data = kernel.readData();
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(kernel_data.input1_data);
      const float *alpha_data_float = kernels::getTensorData<float>(kernel_data.input2_data);
      float *output_data_float = kernels::getTensorData<float>(kernel_data.output_data);
      assert(output_data_float);
      assert(input_data_float);
      assert(alpha_data_float);
 
      luci_interpreter_pal::BroadcastPrelu4DSlowFloat(
        kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph), input_data_float,
        kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph), alpha_data_float,
        kernels::getTensorRuntimeShape(kernel.output(), runtime_graph), output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter_pal::BroadcastPrelu4DSlowFloat(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOData::input1_data, luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOData::input2_data, luci_interpreter::kernels::TISOKernel::output(), luci_interpreter::kernels::TISOData::output_data, and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleQuantize()

void luci_interpreter::execute_kernel_CircleQuantize	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 42 of file Quantize.cpp.

{
#ifndef DIS_QUANT
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
  assert(output_data);
 
  const int flat_size = kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::QuantizationParams params{};
      params.zero_point = Tensor::zero_point(kernel.output());
      params.scale = Tensor::scale(kernel.output());
      switch (Tensor::element_type(kernel.output()))
      {
        case DataType::S8:
          luci_interpreter_pal::Quantize(params, flat_size,
                                         kernels::getTensorData<float>(input_data),
                                         kernels::getTensorData<int8_t>(output_data));
          break;
        case DataType::U8:
          luci_interpreter_pal::Quantize(params, flat_size,
                                         kernels::getTensorData<float>(input_data),
                                         kernels::getTensorData<uint8_t>(output_data));
          break;
        case DataType::S16:
          luci_interpreter_pal::Quantize(params, flat_size,
                                         kernels::getTensorData<float>(input_data),
                                         kernels::getTensorData<int16_t>(output_data));
          break;
        default:
          assert(false && "Unsupported type");
      }
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
#else
  assert(false && "Remove DIS_QUANT flag");
#endif // DIS_QUANT
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::QuantizationParams::zero_point.

execute_kernel_CircleReduceCommon()

void luci_interpreter::execute_kernel_CircleReduceCommon	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 62 of file ReduceCommon.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  kernels::TISOData tiso_data = kernel.readData();
 
  const auto *input = kernel.input1();
  const auto *axis = kernel.input2();
  const auto *output = kernel.output();
 
  const auto *options = cur_op->builtin_options_as_ReducerOptions();
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      reduceProdGeneric<float>(&tiso_data, input, axis, output, options->keep_dims());
      break;
#endif // DIS_FLOAT
    case DataType::S32:
      reduceProdGeneric<int32_t>(&tiso_data, input, axis, output, options->keep_dims());
      break;
    case DataType::S64:
      reduceProdGeneric<int64_t>(&tiso_data, input, axis, output, options->keep_dims());
      break;
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOKernel::output(), and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleReduceMax()

void luci_interpreter::execute_kernel_CircleReduceMax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 66 of file ReduceMax.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  kernels::TISOData tiso_data = kernel.readData();
 
  const auto *input = kernel.input1();
  const auto *axis = kernel.input2();
  const auto *output = kernel.output();
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      reduceMaxGeneric<float>(&tiso_data, input, axis, output);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOKernel::output(), and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleRelu()

void luci_interpreter::execute_kernel_CircleRelu	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Relu.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::ReLUCommon(flat_size, input_data_float, output_data_float, 0.0f, false);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::ReLUCommon().

execute_kernel_CircleRelu6()

void luci_interpreter::execute_kernel_CircleRelu6	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Relu6.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::ReLUCommon(flat_size, input_data_float, output_data_float, 0.0f, true);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::ReLUCommon().

execute_kernel_CircleReshape()

void luci_interpreter::execute_kernel_CircleReshape	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 33 of file Reshape.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto shape_index = cur_op->inputs()->operator[](1);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(shape_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto shape = runtime_graph->getCircleTensorByIndex(shape_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
  if (is_inplace)
  {
    runtime_graph->makeInplaceOperation(input, output);
    return;
  }
 
  const auto input_data = runtime_graph->getDataByTensor(input);
  auto shape_data = runtime_graph->getConstDataByTensor(shape);
  auto output_data = runtime_graph->getDataByTensor(output);
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  int32_t data_size = Tensor::num_elements(output) * getDataTypeSize(Tensor::element_type(output));
 
#ifndef DIS_DYN_SHAPES
  if (shape_data == nullptr)
  {
    shape_data = runtime_graph->getDataByTensor(shape);
    assert(shape_data != nullptr);
 
    assert(Tensor::element_type(shape) == DataType::S32);
 
    const int32_t *shape_data_int = kernels::getTensorData<int32_t>(shape_data);
    const auto num_dims = Tensor::num_dims(output);
 
    luci_interpreter::RuntimeShape dynamic_shape(num_dims);
    data_size = 1;
    for (int i = 0; i < num_dims; ++i)
    {
      dynamic_shape.setDim(i, shape_data_int[i]);
      data_size *= shape_data_int[i];
    }
    data_size *= size(Tensor::element_type(output));
 
    runtime_graph->addDynamicShapeTensor(output, std::move(dynamic_shape));
 
    if (data_size == 0)
    {
      runtime_graph->resetTensorData(nullptr, output);
      return;
    }
 
    auto new_output_data = new uint8_t[data_size];
    output_data = new_output_data;
    runtime_graph->resetTensorData(new_output_data, output);
  }
#else
  assert(shape_data != nullptr);
#endif // DIS_DYN_SHAPES
 
  std::memcpy(output_data, input_data, data_size);
}

References luci_interpreter::RuntimeGraph::addDynamicShapeTensor(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), getDataTypeSize(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::RuntimeGraph::resetTensorData(), luci_interpreter::RuntimeShape::setDim(), and size.

execute_kernel_CircleResizeBilinear()

void luci_interpreter::execute_kernel_CircleResizeBilinear	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 72 of file ResizeBilinear.cpp.

{
  assert(cur_op->inputs()->size() == 2);
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto size_index = cur_op->inputs()->operator[](1);
  const auto output_index = cur_op->outputs()->operator[](0);
 
  assert(input_index != -1);
  assert(size_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto size = runtime_graph->getCircleTensorByIndex(size_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  const uint8_t *size_data = runtime_graph->getConstDataByTensor(size);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  assert(input_data != nullptr);
  assert(size_data != nullptr);
  assert(output_data != nullptr);
 
  // Get parameters
  const auto *op_params = cur_op->builtin_options_as_ResizeBilinearOptions();
 
  switch (Tensor::element_type(output))
  {
    case DataType::FLOAT32:
      luci_interpreter_pal::ResizeBilinear(
        op_params, kernels::getTensorShape(input), kernels::getTensorData<float>(input_data),
        kernels::getTensorShape(size), kernels::getTensorData<int32_t>(size_data),
        kernels::getTensorShape(output), kernels::getTensorData<float>(output_data));
      break;
    case DataType::U8:
      luci_interpreter_pal::ResizeBilinear(
        op_params, kernels::getTensorShape(input), kernels::getTensorData<uint8_t>(input_data),
        kernels::getTensorShape(size), kernels::getTensorData<int32_t>(size_data),
        kernels::getTensorShape(output), kernels::getTensorData<uint8_t>(output_data));
      break;
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), and size.

execute_kernel_CircleResizeNearestNeighbor()

void luci_interpreter::execute_kernel_CircleResizeNearestNeighbor	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 46 of file ResizeNearestNeighbor.cpp.

{
  kernels::TISOKernel tiso_kernel(cur_op, runtime_graph);
  kernels::TISOData tiso_data = tiso_kernel.readData();
 
  // Get parameters
  const auto *op_params = cur_op->builtin_options_as_ResizeNearestNeighborOptions();
 
  luci_interpreter_pal::ResizeNearestNeighborParams params;
  params.align_corners = op_params->align_corners();
  params.half_pixel_centers = false;
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(tiso_kernel.input1());
  const uint8_t *size_data = runtime_graph->getConstDataByTensor(tiso_kernel.input2());
  uint8_t *output_data = runtime_graph->getDataByTensor(tiso_kernel.output());
 
  switch (Tensor::element_type(tiso_kernel.output()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::ResizeNearestNeighbor(
        params, kernels::getTensorRuntimeShape(tiso_kernel.input1(), runtime_graph),
        kernels::getTensorData<float>(input_data),
        kernels::getTensorRuntimeShape(tiso_kernel.input2(), runtime_graph),
        kernels::getTensorData<int32_t>(size_data),
        kernels::getTensorRuntimeShape(tiso_kernel.output(), runtime_graph),
        kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter_pal::ResizeNearestNeighborParams::align_corners, luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter_pal::ResizeNearestNeighborParams::half_pixel_centers, luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOKernel::output(), and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleRound()

void luci_interpreter::execute_kernel_CircleRound	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Round.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Round(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::Round().

execute_kernel_CircleRsqrt()

void luci_interpreter::execute_kernel_CircleRsqrt	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Rsqrt.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Rsqrt(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::Rsqrt().

execute_kernel_CircleSelectV2()

void luci_interpreter::execute_kernel_CircleSelectV2	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 105 of file SelectV2.cpp.

{
  const auto input_cond_index = cur_op->inputs()->operator[](kInputTensorCondition);
  const auto input_x_index = cur_op->inputs()->operator[](kInputTensorX);
  const auto input_y_index = cur_op->inputs()->operator[](kInputTensorY);
  const auto output_index = cur_op->outputs()->operator[](kOutputTensor);
 
  assert(input_cond_index != -1);
  assert(input_x_index != -1);
  assert(input_y_index != -1);
  assert(output_index != -1);
 
  const auto input_cond = runtime_graph->getCircleTensorByIndex(input_cond_index);
  const auto input_x = runtime_graph->getCircleTensorByIndex(input_x_index);
  const auto input_y = runtime_graph->getCircleTensorByIndex(input_y_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input_cond != nullptr);
  assert(input_x != nullptr);
  assert(input_y != nullptr);
 
  bool possible_mixed_scaler =
    Tensor::num_elements(input_cond) == 1 && Tensor::num_elements(input_x) == 1 &&
    Tensor::num_elements(input_y) == 1 && Tensor::num_elements(output) == 1;
 
  bool same_shape = Tensor::num_elements(input_cond) == Tensor::num_elements(input_x) &&
                    Tensor::num_elements(input_x) == Tensor::num_elements(input_y);
  bool is_broadcast = false;
  if (not possible_mixed_scaler and not same_shape)
    is_broadcast = true;
 
  const auto type = Tensor::element_type(input_x);
  switch (type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      CallSelect<float>(input_cond, input_x, input_y, output, is_broadcast, runtime_graph);
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex().

execute_kernel_CircleShape()

void luci_interpreter::execute_kernel_CircleShape	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 29 of file Shape.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const circle::Tensor *input = kernel.input();
  const circle::Tensor *output = kernel.output();
 
  assert(Tensor::element_type(output) == DataType::S32);
  int32_t *output_data = kernels::getTensorData<int32_t>(runtime_graph->getDataByTensor(output));
 
  const int rank = Tensor::num_dims(input);
  for (int i = 0; i < rank; ++i)
  {
    output_data[i] = Tensor::dim(input, i);
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleSin()

void luci_interpreter::execute_kernel_CircleSin	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Sin.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Sin(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::Sin().

execute_kernel_CircleSlice()

void luci_interpreter::execute_kernel_CircleSlice	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 109 of file Slice.cpp.

{
  kernels::MISOKernel kernel(cur_op, runtime_graph);
 
  bool is_dynamic_shapes = false;
 
  const circle::Tensor *input = kernel.input1();
  const circle::Tensor *begin = kernel.input2();
  const circle::Tensor *size_tensor = kernel.input3();
  const circle::Tensor *output = kernel.output();
 
  const auto *input_data = runtime_graph->getDataByTensor(input);
  if (input_data == nullptr)
    input_data = runtime_graph->getConstDataByTensor(input);
  assert(input_data);
 
  const auto *begin_data = runtime_graph->getDataByTensor(begin);
  if (begin_data == nullptr)
  {
    begin_data = runtime_graph->getConstDataByTensor(begin);
    is_dynamic_shapes = true;
  }
  assert(begin_data);
 
  const auto *size_data = runtime_graph->getDataByTensor(size_tensor);
  if (size_data == nullptr)
  {
    size_data = runtime_graph->getConstDataByTensor(size_tensor);
    is_dynamic_shapes = true;
  }
  assert(size_data);
 
  auto *output_data = runtime_graph->getDataByTensor(output);
  assert(output_data);
 
  SliceParams op_params{};
  op_params.begin_count = max_dim;
  op_params.size_count = max_dim;
  for (int i = 0; i < max_dim; i++)
  {
    op_params.begin[i] = 0;
    op_params.size[i] = 1;
  }
  auto num_dim = Tensor::num_dims(input);
 
  if (Tensor::element_type(begin) == DataType::S32)
  {
    getBeginAndSizeVectors<int32_t>(num_dim, begin_data, size_data, op_params.begin,
                                    op_params.size);
  }
  else if (Tensor::element_type(begin) == DataType::S64)
  {
    getBeginAndSizeVectors<int64_t>(num_dim, begin_data, size_data, op_params.begin,
                                    op_params.size);
  }
  else
  {
    assert(false && "Unsupported type");
  }
 
#ifndef DIS_DYN_SHAPES
  if (is_dynamic_shapes)
  {
    int32_t data_size = 1;
    luci_interpreter::RuntimeShape dynamic_shapes(max_dim - num_dim + 1);
    int offset = max_dim - Tensor::num_dims(input);
    for (int i = 0; i <= max_dim - num_dim; ++i)
    {
      if (i + offset > 4)
        return;
      auto cur_size = op_params.size[i + offset] != -1
                        ? op_params.size[i + offset]
                        : Tensor::dim(input, i) - op_params.begin[i + offset];
      data_size *= cur_size;
 
      dynamic_shapes.setDim(i, cur_size);
    }
    data_size *= size(Tensor::element_type(output));
 
    runtime_graph->addDynamicShapeTensor(output, std::move(dynamic_shapes));
 
    if (data_size == 0)
    {
      runtime_graph->resetTensorData(nullptr, output);
      return;
    }
 
    auto new_output_data = new uint8_t[data_size];
    output_data = new_output_data;
    runtime_graph->resetTensorData(new_output_data, output);
  }
#else
  assert(is_dynamic_shapes == false);
#endif // DIS_DYN_SHAPES
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      slice<float>(op_params, kernels::getTensorShape(input),
                   kernels::getTensorData<float>(input_data), kernels::getTensorShape(output),
                   kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::U8:
      slice<uint8_t>(op_params, kernels::getTensorShape(input),
                     kernels::getTensorData<uint8_t>(input_data), kernels::getTensorShape(output),
                     kernels::getTensorData<uint8_t>(output_data));
      break;
    case DataType::S8:
      slice<int8_t>(op_params, kernels::getTensorShape(input),
                    kernels::getTensorData<int8_t>(input_data), kernels::getTensorShape(output),
                    kernels::getTensorData<int8_t>(output_data));
      break;
    case DataType::S16:
      slice<int16_t>(op_params, kernels::getTensorShape(input),
                     kernels::getTensorData<int16_t>(input_data), kernels::getTensorShape(output),
                     kernels::getTensorData<int16_t>(output_data));
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported input type.");
  }
}

References luci_interpreter::RuntimeGraph::addDynamicShapeTensor(), begin, circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), offset(), luci_interpreter::kernels::MISOKernel::output(), luci_interpreter::RuntimeGraph::resetTensorData(), luci_interpreter::RuntimeShape::setDim(), and size.

execute_kernel_CircleSoftmax()

void luci_interpreter::execute_kernel_CircleSoftmax	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 144 of file Softmax.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_SoftmaxOptions();
  const auto input_type = Tensor::element_type(kernel.input());
  switch (input_type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      evalFloat(kernel.input(), kernel.output(), options, runtime_graph);
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
    case DataType::S16:
      evalQuantize(kernel.input(), kernel.output(), options, runtime_graph);
      break;
#endif
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleSpaceToBatchND()

void luci_interpreter::execute_kernel_CircleSpaceToBatchND	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 42 of file SpaceToBatchND.cpp.

{
  kernels::MISOKernel kernel(cur_op, runtime_graph);
  const int32_t pad_value = 0;
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      luci_interpreter_pal::SpaceToBatchND(
        pad_value, kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.input1())),
        kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph),
        kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(kernel.input2())),
        kernels::getTensorRuntimeShape(kernel.input3(), runtime_graph),
        kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(kernel.input3())),
        kernels::getTensorRuntimeShape(kernel.output(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.output())));
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), and luci_interpreter::kernels::MISOKernel::output().

execute_kernel_CircleSpaceToDepth()

void luci_interpreter::execute_kernel_CircleSpaceToDepth	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 52 of file SpaceToDepth.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_SpaceToDepthOptions();
  const int32_t block_size = options->block_size();
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      assert(block_size != 0);
      luci_interpreter_pal::SpaceToDepth(
        block_size, kernels::getTensorRuntimeShape(kernel.input(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.input())),
        kernels::getTensorRuntimeShape(kernel.output(), runtime_graph),
        kernels::getTensorData<float>(runtime_graph->getDataByTensor(kernel.output())));
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleSplit()

void luci_interpreter::execute_kernel_CircleSplit	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 39 of file Split.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](1);
  const auto axis_index = cur_op->inputs()->operator[](0);
 
  assert(input_index != -1);
  assert(axis_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto axis = runtime_graph->getCircleTensorByIndex(axis_index);
 
  assert(input != nullptr);
  assert(axis != nullptr);
 
  const auto *axis_data = runtime_graph->getDataByTensor(axis);
  if (axis_data == nullptr)
    axis_data = runtime_graph->getConstDataByTensor(axis);
 
  assert(axis_data);
 
  int32_t axis_value = (kernels::getTensorData<int32_t>(axis_data))[0];
  if (axis_value < 0)
    axis_value += Tensor::num_dims(input);
 
  assert(axis_value >= 0);
  assert(axis_value < Tensor::num_dims(input));
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      return splitImpl<float>(cur_op, input, axis_value, runtime_graph);
    }
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
    {
      return splitImpl<int8_t>(cur_op, input, axis_value, runtime_graph);
    }
    case DataType::S16:
    {
      return splitImpl<int16_t>(cur_op, input, axis_value, runtime_graph);
    }
#endif // DIS_QUANT
    case DataType::S32:
    {
      return splitImpl<int32_t>(cur_op, input, axis_value, runtime_graph);
    }
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), and luci_interpreter::RuntimeGraph::getDataByTensor().

execute_kernel_CircleSplitV()

void luci_interpreter::execute_kernel_CircleSplitV	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 38 of file SplitV.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  const auto axis_index = cur_op->inputs()->operator[](2);
 
  assert(input_index != -1);
  assert(axis_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto axis = runtime_graph->getCircleTensorByIndex(axis_index);
 
  assert(input != nullptr);
  assert(axis != nullptr);
 
  const auto *axis_data = runtime_graph->getDataByTensor(axis);
  if (axis_data == nullptr)
    axis_data = runtime_graph->getConstDataByTensor(axis);
 
  assert(axis_data);
 
  int32_t axis_value = (kernels::getTensorData<int32_t>(axis_data))[0];
  if (axis_value < 0)
    axis_value += Tensor::num_dims(input);
 
  assert(axis_value >= 0);
  assert(axis_value < Tensor::num_dims(input));
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      return splitImpl<float>(cur_op, input, axis_value, runtime_graph);
    }
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
    {
      return splitImpl<int8_t>(cur_op, input, axis_value, runtime_graph);
    }
    case DataType::S16:
    {
      return splitImpl<int16_t>(cur_op, input, axis_value, runtime_graph);
    }
#endif // DIS_QUANT
    case DataType::S32:
    {
      return splitImpl<int32_t>(cur_op, input, axis_value, runtime_graph);
    }
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), and luci_interpreter::RuntimeGraph::getDataByTensor().

execute_kernel_CircleSqrt()

void luci_interpreter::execute_kernel_CircleSqrt	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 37 of file Sqrt.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Sqrt(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::Sqrt().

execute_kernel_CircleSquare()

void luci_interpreter::execute_kernel_CircleSquare	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 43 of file Square.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Square(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::Square().

execute_kernel_CircleSquaredDifference()

void luci_interpreter::execute_kernel_CircleSquaredDifference	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 43 of file SquaredDifference.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data_1 = runtime_graph->getDataByTensor(kernel.input1());
  const auto *input_data_2 = runtime_graph->getDataByTensor(kernel.input2());
  assert(input_data_1);
  assert(input_data_2);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_1_float = kernels::getTensorData<float>(input_data_1);
      const float *input_data_2_float = kernels::getTensorData<float>(input_data_2);
      float *output_data_float = kernels::getTensorData<float>(output_data);
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph).flatSize();
 
      luci_interpreter_pal::SquaredDifference(flat_size, input_data_1_float, input_data_2_float,
                                              output_data_float);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOKernel::output(), and luci_interpreter_pal::SquaredDifference().

execute_kernel_CircleSqueeze()

void luci_interpreter::execute_kernel_CircleSqueeze	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 78 of file Squeeze.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  assert(cur_op->inputs()->size() == 1);
 
  const circle::Tensor *input = kernel.input();
  const circle::Tensor *output = kernel.output();
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(Tensor::num_elements(input) == Tensor::num_elements(output));
 
  std::memcpy(output_data, input_data,
              getDataTypeSize(Tensor::element_type(input)) * Tensor::num_elements(input));
}

References luci_interpreter::RuntimeGraph::getDataByTensor(), getDataTypeSize(), luci_interpreter::kernels::SISOKernel::input(), and luci_interpreter::kernels::SISOKernel::output().

execute_kernel_CircleStridedSlice()

void luci_interpreter::execute_kernel_CircleStridedSlice	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 75 of file StridedSlice.cpp.

{
  kernels::MISOKernel miso_kernel(cur_op, runtime_graph);
 
  const circle::Tensor *input = miso_kernel.input1();
  const circle::Tensor *begin = miso_kernel.input2();
  const circle::Tensor *end = miso_kernel.input3();
  const circle::Tensor *strides = miso_kernel.input4();
  const circle::Tensor *output = miso_kernel.output();
 
  const int32_t dims = Tensor::num_dims(input);
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  const int32_t *begin_data =
    kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(begin));
  const int32_t *end_data =
    kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(end));
  const int32_t *strides_data =
    kernels::getTensorData<int32_t>(runtime_graph->getConstDataByTensor(strides));
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  LUCI_INTERPRETER_CHECK(input_data != nullptr);
  LUCI_INTERPRETER_CHECK(begin_data != nullptr);
  LUCI_INTERPRETER_CHECK(end_data != nullptr);
  LUCI_INTERPRETER_CHECK(strides_data != nullptr);
  LUCI_INTERPRETER_CHECK(output_data != nullptr);
 
  const auto *options = cur_op->builtin_options_as_StridedSliceOptions();
 
  auto op_params = buildStridedSliceParams(dims, begin_data, end_data, strides_data, options);
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::StridedSlice(op_params, kernels::getTensorShape(input),
                                         kernels::getTensorData<float>(input_data),
                                         kernels::getTensorData<float>(output_data));
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::U8:
      luci_interpreter_pal::StridedSlice(op_params, kernels::getTensorShape(input), input_data,
                                         output_data);
      break;
    case DataType::S8:
      luci_interpreter_pal::StridedSlice(op_params, kernels::getTensorShape(input), input_data,
                                         output_data);
      break;
#endif
    case DataType::S32:
      luci_interpreter_pal::StridedSlice(op_params, kernels::getTensorShape(input),
                                         kernels::getTensorData<int32_t>(input_data),
                                         kernels::getTensorData<int32_t>(output_data));
      break;
    default:
      assert(false && "Unsupported type");
  }
}

References begin, luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::MISOKernel::input1(), luci_interpreter::kernels::MISOKernel::input2(), luci_interpreter::kernels::MISOKernel::input3(), luci_interpreter::kernels::MISOKernel::input4(), LUCI_INTERPRETER_CHECK, luci_interpreter::kernels::MISOKernel::output(), and luci_interpreter_pal::StridedSlice().

execute_kernel_CircleSub()

void luci_interpreter::execute_kernel_CircleSub	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 47 of file Sub.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const auto *options = cur_op->builtin_options_as_SubOptions();
 
  luci_interpreter::RuntimeShape input_shape1 =
    kernels::getTensorRuntimeShape(kernel.input1(), runtime_graph);
  luci_interpreter::RuntimeShape input_shape2 =
    kernels::getTensorRuntimeShape(kernel.input2(), runtime_graph);
 
  luci_interpreter::RuntimeShape output_shape =
    kernels::getTensorRuntimeShape(kernel.output(), runtime_graph);
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      auto tiso_func = luci_interpreter_pal::Sub<float>;
 
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastSub4DSlow<float>;
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<float>(tiso_func, broadcast_tiso_func, &kernel, options,
                                              std::move(input_shape1), std::move(input_shape2),
                                              std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<float>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                       options, std::move(input_shape1), std::move(input_shape2),
                                       std::move(output_shape));
      }
    }
    break;
#endif // DIS_FLOAT
    case DataType::S64:
    {
      auto tiso_func = luci_interpreter_pal::Sub<int64_t>;
 
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastSub4DSlow<int64_t>;
 
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<int64_t>(tiso_func, broadcast_tiso_func, &kernel, options,
                                                std::move(input_shape1), std::move(input_shape2),
                                                std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<int64_t>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                         options, std::move(input_shape1), std::move(input_shape2),
                                         std::move(output_shape));
      }
    }
    break;
    case DataType::S32:
    {
      auto tiso_func = luci_interpreter_pal::Sub<int32_t>;
 
      auto broadcast_tiso_func = luci_interpreter_pal::BroadcastSub4DSlow<int32_t>;
 
      if (is_inplace)
      {
        kernels::evalTISOInplaceKernel<int32_t>(tiso_func, broadcast_tiso_func, &kernel, options,
                                                std::move(input_shape1), std::move(input_shape2),
                                                std::move(output_shape));
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOKernel<int32_t>(tiso_func, broadcast_tiso_func, &kernel, &kernel_data,
                                         options, std::move(input_shape1), std::move(input_shape2),
                                         std::move(output_shape));
      }
    }
    break;
// TODO: fix it
#if 0
#ifndef DIS_QUANT
    case DataType::U8:
    {
      auto tiso_func = [](const tflite::ArithmeticParams &params,
                          const tflite::RuntimeShape &input1_shape, const uint8_t *input1_data,
                          const tflite::RuntimeShape &input2_shape, const uint8_t *input2_data,
                          const tflite::RuntimeShape &output_shape, uint8_t *output_data) {
        tflite::reference_ops::Sub(params, input1_shape, input1_data, input2_shape, input2_data,
                                   output_shape, output_data);
      };
      auto broadcast_tiso_func =
        [](const tflite::ArithmeticParams &params, const tflite::RuntimeShape &input1_shape,
           const uint8_t *input1_data, const tflite::RuntimeShape &input2_shape,
           const uint8_t *input2_data, const tflite::RuntimeShape &output_shape,
           uint8_t *output_data) {
          tflite::reference_ops::BroadcastSubSlow(params, input1_shape, input1_data, input2_shape,
                                                  input2_data, output_shape, output_data);
        };
      if (is_inplace)
      {
        kernels::evalTISOInplaceQuantizedKernel<uint8_t>(tiso_func, broadcast_tiso_func, &kernel,
                                                         options);
      }
      else
      {
        kernels::TISOData kernel_data = kernel.readData();
        kernels::evalTISOQuantizedKernel<uint8_t>(tiso_func, broadcast_tiso_func, &kernel,
                                                  &kernel_data, options);
      }
    }
    break;
#endif // DIS_QUANT
#endif // 0
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::kernels::TISOKernel::output(), output_shape, and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleSum()

void luci_interpreter::execute_kernel_CircleSum	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 64 of file Sum.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
  kernels::TISOData tiso_data = kernel.readData();
 
  const auto *input = kernel.input1();
  const auto *axis = kernel.input2();
  const auto *output = kernel.output();
 
  const auto *options = cur_op->builtin_options_as_ReducerOptions();
 
  switch (Tensor::element_type(kernel.input1()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      sumGeneric<float>(&tiso_data, input, axis, output, options->keep_dims());
      break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOKernel::output(), and luci_interpreter::kernels::TISOKernel::readData().

execute_kernel_CircleSVDF()

void luci_interpreter::execute_kernel_CircleSVDF	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 125 of file SVDF.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](kSvdfInputTensor);
  const auto weights_feature_index = cur_op->inputs()->operator[](kSvdfWeightsFeatureTensor);
  const auto weights_time_index = cur_op->inputs()->operator[](kSvdfWeightsTimeTensor);
  const auto bias_index = cur_op->inputs()->operator[](kSvdfBiasTensor);
  const auto activation_state_index = cur_op->inputs()->operator[](kSvdfInputActivationStateTensor);
  const auto output_index = cur_op->outputs()->operator[](kSvdfOutputTensor);
 
  assert(input_index != -1);
  assert(weights_feature_index != -1);
  assert(weights_time_index != -1);
  assert(activation_state_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto weights_feature = runtime_graph->getCircleTensorByIndex(weights_feature_index);
  const auto weights_time = runtime_graph->getCircleTensorByIndex(weights_time_index);
  const auto bias = runtime_graph->getCircleTensorByIndex(bias_index);
  const auto activation_state = runtime_graph->getCircleTensorByIndex(activation_state_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(weights_feature != nullptr);
  assert(weights_time != nullptr);
  assert(activation_state != nullptr);
  assert(output != nullptr);
 
  const auto *options = cur_op->builtin_options_as_SVDFOptions();
 
  // Define input constants based on input tensor definition above:
  const int rank = options->rank();
  const int input_size = Tensor::dim(input, 1);
  const int batch_size = Tensor::dim(input, 0);
  const int num_filters = Tensor::dim(weights_feature, 0);
  LUCI_INTERPRETER_CHECK(num_filters % rank == 0);
 
  const int num_units = num_filters / rank;
  const int memory_size = Tensor::dim(weights_time, 1);
 
  const uint8_t *input_data = runtime_graph->getDataByTensor(input);
  const uint8_t *weights_feature_data = runtime_graph->getConstDataByTensor(weights_feature);
  const uint8_t *weights_time_data = runtime_graph->getConstDataByTensor(weights_time);
  const uint8_t *bias_data = runtime_graph->getConstDataByTensor(bias);
  uint8_t *output_data = runtime_graph->getDataByTensor(output);
 
  const auto type = Tensor::element_type(input);
  switch (type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      // Create and fill with 0 state tensor
      auto state_data = std::make_unique<float[]>(Tensor::num_elements(activation_state));
      std::fill_n(state_data.get(), Tensor::num_elements(activation_state), 0);
 
      auto scratch_data = std::make_unique<uint8_t[]>(batch_size * num_filters * sizeof(float));
 
      luci_interpreter_pal::SVDF(
        kernels::getTensorData<float>(input_data),
        kernels::getTensorData<float>(weights_feature_data),
        kernels::getTensorData<float>(weights_time_data), kernels::getTensorData<float>(bias_data),
        state_data.get(), kernels::getTensorData<float>(scratch_data.get()),
        kernels::getTensorData<float>(output_data), rank, input_size, batch_size, num_filters,
        num_units, memory_size, options->fused_activation_function());
    }
    break;
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::RuntimeGraph::getDataByTensor(), LUCI_INTERPRETER_CHECK, and luci_interpreter_pal::SVDF().

execute_kernel_CircleTanh()

void luci_interpreter::execute_kernel_CircleTanh	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 156 of file Tanh.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      const float *input_data_float = kernels::getTensorData<float>(input_data);
      float *output_data_float = kernels::getTensorData<float>(output_data);
      if (is_inplace)
      {
        output_data_float = const_cast<float *>(input_data_float);
      }
 
      assert(output_data_float);
 
      const int flat_size =
        kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
      luci_interpreter_pal::Tanh(flat_size, input_data_float, output_data_float);
      break;
    }
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S16:
      // TODO: enable it
#if 0
    case DataType::S8:
#endif
      evalInteger(kernel.input(), kernel.output(), runtime_graph);
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References evalInteger(), luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), luci_interpreter::kernels::SISOKernel::output(), and luci_interpreter_pal::Tanh().

execute_kernel_CircleTranspose()

void luci_interpreter::execute_kernel_CircleTranspose	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 45 of file Transpose.cpp.

{
  kernels::TISOKernel kernel(cur_op, runtime_graph);
 
  const circle::Tensor *input = kernel.input1();
  const circle::Tensor *perm = kernel.input2();
  const circle::Tensor *output = kernel.output();
 
  kernels::TISOData tiso_data = kernel.readData();
  const int32_t *perm_data = kernels::getTensorData<int32_t>(tiso_data.input2_data);
 
  const int32_t size = Tensor::dim(perm, 0);
  luci_interpreter_pal::TransposeParams params;
  params.perm_count = size;
  for (int i = 0; i < size; ++i)
    params.perm[i] = perm_data[i];
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      luci_interpreter_pal::Transpose(params, kernels::getTensorShape(input),
                                      kernels::getTensorData<float>(tiso_data.input1_data),
                                      kernels::getTensorShape(output),
                                      kernels::getTensorData<float>(tiso_data.output_data));
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::U8:
      luci_interpreter_pal::Transpose(params, kernels::getTensorShape(input),
                                      kernels::getTensorData<uint8_t>(tiso_data.input1_data),
                                      kernels::getTensorShape(output),
                                      kernels::getTensorData<uint8_t>(tiso_data.output_data));
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type");
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::kernels::getTensorShape(), luci_interpreter::kernels::TISOKernel::input1(), luci_interpreter::kernels::TISOData::input1_data, luci_interpreter::kernels::TISOKernel::input2(), luci_interpreter::kernels::TISOData::input2_data, luci_interpreter::kernels::TISOKernel::output(), luci_interpreter::kernels::TISOData::output_data, luci_interpreter_pal::TransposeParams::perm, luci_interpreter_pal::TransposeParams::perm_count, luci_interpreter::kernels::TISOKernel::readData(), size, and luci_interpreter_pal::Transpose().

execute_kernel_CircleTransposeConv()

void luci_interpreter::execute_kernel_CircleTransposeConv	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 135 of file TransposeConv.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](kInputTensor);
  const auto weight_index = cur_op->inputs()->operator[](kFilterTensor);
  const auto bias_index =
    cur_op->inputs()->size() == 4 ? cur_op->inputs()->operator[](kBiasTensor) : -1;
  const auto output_index = cur_op->outputs()->operator[](kOutputTensor);
 
  assert(input_index != -1);
  assert(weight_index != -1);
  assert(output_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  const auto weights = runtime_graph->getCircleTensorByIndex(weight_index);
  const auto bias = runtime_graph->getCircleTensorByIndex(bias_index);
  const auto output = runtime_graph->getCircleTensorByIndex(output_index);
 
  assert(input != nullptr);
  assert(weights != nullptr);
  assert(output != nullptr);
 
  const auto *options = cur_op->builtin_options_as_TransposeConvOptions();
 
  const auto type = Tensor::element_type(input);
  switch (type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      if (Tensor::element_type(weights) == DataType::FLOAT32)
      {
        evalFloat(input, weights, bias, output, options, runtime_graph);
        break;
      }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex().

execute_kernel_CircleUnidirectionalSequenceLSTM()

void luci_interpreter::execute_kernel_CircleUnidirectionalSequenceLSTM	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 419 of file UnidirectionalSequenceLSTM.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  assert(input_index != -1);
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
 
  switch (Tensor::element_type(input))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
      evalFloat(cur_op, runtime_graph, is_inplace);
      break;
#endif // DIS_FLOAT
#ifndef DIS_QUANT
    case DataType::S8:
      evalInt8(cur_op, runtime_graph, is_inplace);
      break;
#endif // DIS_QUANT
    default:
      assert(false && "Unsupported type.");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and luci_interpreter::RuntimeGraph::is_inplace_op().

execute_kernel_CircleUnpack()

void luci_interpreter::execute_kernel_CircleUnpack	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 119 of file Unpack.cpp.

{
  const auto input_index = cur_op->inputs()->operator[](0);
  assert(input_index != -1);
 
  const auto input = runtime_graph->getCircleTensorByIndex(input_index);
  assert(input != nullptr);
 
  const auto type = Tensor::element_type(input);
 
  const auto *options = cur_op->builtin_options_as_UnpackOptions();
 
  switch (type)
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      UnpackImpl<float>(cur_op, input, options->num(), options->axis(), runtime_graph);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
}

References luci_interpreter::RuntimeGraph::getCircleTensorByIndex().

execute_kernel_CircleWhile()

void luci_interpreter::execute_kernel_CircleWhile	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 61 of file While.cpp.

{
  auto *main_runtime_graph = runtime_graph;
  auto *runtime_module = runtime_graph->getRuntimeModule();
 
  const auto input_size = cur_op->inputs()->size();
 
  std::vector<uint8_t *> operation_inputs_data(input_size);
  std::vector<uint8_t *> operation_outputs_data;
 
  std::vector<int32_t> input_sizes(input_size);
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  for (int32_t i = 0; i < input_size; ++i)
  {
    const auto op_input_index = cur_op->inputs()->operator[](i);
    const auto op_output_index = cur_op->outputs()->operator[](i);
    assert(op_input_index != -1);
    assert(op_output_index != -1);
    const auto input = main_runtime_graph->getCircleTensorByIndex(op_input_index);
    const auto output = main_runtime_graph->getCircleTensorByIndex(op_output_index);
 
    input_sizes[i] = Tensor::num_elements(input) * size(Tensor::element_type(input));
 
    auto *input_data = main_runtime_graph->getDataByTensor(input);
 
    uint8_t *tensor_data = nullptr;
    if (is_inplace)
    {
      if (input_data == nullptr)
      {
        tensor_data = new uint8_t[input_sizes[i]];
        input_data = main_runtime_graph->getConstDataByTensor(input);
        assert(input_data != nullptr);
        std::memcpy(tensor_data, input_data, input_sizes[i]);
      }
      else
      {
        tensor_data = input_data;
      }
    }
    else
    {
      if (input_data == nullptr)
        input_data = main_runtime_graph->getConstDataByTensor(input);
      assert(input_data != nullptr);
      tensor_data = main_runtime_graph->getDataByTensor(output);
      assert(tensor_data != nullptr);
      std::memcpy(tensor_data, input_data, input_sizes[i]);
    }
    assert(tensor_data != nullptr);
 
    operation_inputs_data[i] = tensor_data;
  }
 
  const auto *options = cur_op->builtin_options_as_WhileOptions();
  const auto body_subgraph_index = options->body_subgraph_index();
  const auto cond_subgraph_index = options->cond_subgraph_index();
 
  auto *cond_runtime_graph = runtime_module->getRuntimeGraphAt(cond_subgraph_index);
  auto *body_runtime_graph = runtime_module->getRuntimeGraphAt(body_subgraph_index);
 
  do
  {
    cond_runtime_graph->selectOwnSubgraph();
 
    for (int32_t i = 0; i < input_size; ++i)
      cond_runtime_graph->configureGraphInput(i, operation_inputs_data[i]);
 
    cond_runtime_graph->execute();
 
    bool cond_value = (cond_runtime_graph->getOutputDataByIndex(0))[0];
    if (!cond_value)
      break;
 
    body_runtime_graph->selectOwnSubgraph();
    for (int32_t i = 0; i < input_size; ++i)
      body_runtime_graph->configureGraphInput(i, operation_inputs_data[i]);
 
    body_runtime_graph->execute();
 
    for (int32_t i = 0; i < input_size; ++i)
    {
      auto cur_output_body_data = body_runtime_graph->getOutputDataByIndex(i);
      if (cur_output_body_data == nullptr)
        continue;
      std::memcpy(operation_inputs_data[i], cur_output_body_data, input_sizes[i]);
    }
  } while (true);
 
  cond_runtime_graph->resetOutputTensorsData();
  cond_runtime_graph->clearTensors();
 
  body_runtime_graph->selectOwnSubgraph();
  body_runtime_graph->resetOutputTensorsData();
  body_runtime_graph->clearTensors();
 
  main_runtime_graph->selectOwnSubgraph();
 
  if (is_inplace)
  {
    for (int32_t i = 0; i < input_size; ++i)
    {
      const auto op_input_index = cur_op->inputs()->operator[](i);
      const auto op_output_index = cur_op->outputs()->operator[](i);
      assert(op_input_index != -1);
      assert(op_output_index != -1);
      const auto input = main_runtime_graph->getCircleTensorByIndex(op_input_index);
      const auto output = main_runtime_graph->getCircleTensorByIndex(op_output_index);
 
      if (main_runtime_graph->getDataByTensor(input))
      {
        main_runtime_graph->makeInplaceOperation(input, output);
      }
      else
      {
        main_runtime_graph->setDataToTensor(output, operation_inputs_data[i]);
      }
    }
  }
}

References luci_interpreter::RuntimeGraph::getRuntimeModule(), luci_interpreter::RuntimeGraph::is_inplace_op(), and size.

execute_kernel_CircleZerosLike()

void luci_interpreter::execute_kernel_CircleZerosLike	(	const circle::Operator *	cur_op,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 46 of file ZerosLike.cpp.

{
  kernels::SISOKernel kernel(cur_op, runtime_graph);
 
  const auto *input_data = runtime_graph->getDataByTensor(kernel.input());
  assert(input_data);
 
  auto *output_data = runtime_graph->getDataByTensor(kernel.output());
 
  bool is_inplace = runtime_graph->is_inplace_op(cur_op);
 
  if (is_inplace)
    output_data = const_cast<uint8_t *>(input_data);
 
  const int flat_size = kernels::getTensorRuntimeShape(kernel.input(), runtime_graph).flatSize();
 
  assert(output_data);
 
  switch (Tensor::element_type(kernel.input()))
  {
#ifndef DIS_FLOAT
    case DataType::FLOAT32:
    {
      resetZeros(kernels::getTensorData<float>(output_data), flat_size);
      break;
    }
#endif // DIS_FLOAT
    default:
      assert(false && "Unsupported type");
  }
 
  if (is_inplace)
    runtime_graph->makeInplaceOperation(kernel.input(), kernel.output());
}

References luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter::kernels::getTensorRuntimeShape(), luci_interpreter::kernels::SISOKernel::input(), luci_interpreter::RuntimeGraph::is_inplace_op(), luci_interpreter::RuntimeGraph::makeInplaceOperation(), and luci_interpreter::kernels::SISOKernel::output().

get_builder_id()

constexpr BuilderID luci_interpreter::get_builder_id ( circle::BuiltinOperator  opcode )

constexpr

Definition at line 43 of file KernelBuilder.h.

{
  switch (opcode)
  {
#define REGISTER_KERNEL(builtin_operator, name)    \
  case circle::BuiltinOperator_##builtin_operator: \
    return BuilderID::BuiltinOperator_##builtin_operator;
 
#if USE_GENERATED_LIST
#include "GeneratedKernelsToBuild.lst"
#else
#include "KernelsToBuild.lst"
#endif
 
#undef REGISTER_KERNEL
    default:
      assert(false && "Unsupported operation");
  }
}

getDataTypeSize()

size_t luci_interpreter::getDataTypeSize ( DataType  data_type )

inline

Definition at line 33 of file DataType.h.

{ return luci::size(data_type); }

References luci::size().

Referenced by luci_interpreter::SimpleMemoryManager::allocate_memory(), luci_interpreter::BuddyMemoryManager::allocate_memory(), luci_interpreter::SimpleMemoryManager::allocate_memory(), luci_interpreter::TestMemoryManager::allocate_memory(), luci_interpreter::kernels::ExpandDims::execute(), luci_interpreter::kernels::If::execute(), luci_interpreter::kernels::Reshape::execute(), luci_interpreter::kernels::Squeeze::execute(), execute_kernel_CircleExpandDims(), execute_kernel_CircleReshape(), execute_kernel_CircleSqueeze(), luci_interpreter::Interpreter::getOutputTensorSize(), luci_interpreter::Tensor::readData(), and luci_interpreter::Tensor::writeData().

luci_actfunc()

FusedActFunc luci_interpreter::luci_actfunc

(

circle::ActivationFunctionType

type

)

Definition at line 55 of file CircleMicroReader.cpp.

{
  switch (type)
  {
    case circle::ActivationFunctionType::ActivationFunctionType_NONE:
      return FusedActFunc::NONE;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU:
      return FusedActFunc::RELU;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU_N1_TO_1:
      return FusedActFunc::RELU_N1_TO_1;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU6:
      return FusedActFunc::RELU6;
    case circle::ActivationFunctionType::ActivationFunctionType_TANH:
      return FusedActFunc::TANH;
    case circle::ActivationFunctionType::ActivationFunctionType_SIGN_BIT:
      return FusedActFunc::SIGN_BIT;
    default:
      break;
  }
  assert(false);
  return FusedActFunc::UNDEFINED;
}

References NONE, RELU, RELU6, RELU_N1_TO_1, SIGN_BIT, TANH, and UNDEFINED.

luci_datatype()

DataType luci_interpreter::luci_datatype

(

circle::TensorType

type

)

Definition at line 26 of file CircleMicroReader.cpp.

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

luci_mirrorpad_mode()

MirrorPadMode luci_interpreter::luci_mirrorpad_mode

(

circle::MirrorPadMode

mode

)

Definition at line 91 of file CircleMicroReader.cpp.

{
  switch (mode)
  {
    case circle::MirrorPadMode::MirrorPadMode_REFLECT:
      return MirrorPadMode::REFLECT;
    case circle::MirrorPadMode::MirrorPadMode_SYMMETRIC:
      return MirrorPadMode::SYMMETRIC;
  }
  assert(false);
  return MirrorPadMode::UNDEFINED;
}

luci_padding()

Padding luci_interpreter::luci_padding

(

circle::Padding

padding

)

Definition at line 78 of file CircleMicroReader.cpp.

{
  switch (padding)
  {
    case circle::Padding::Padding_SAME:
      return Padding::SAME;
    case circle::Padding::Padding_VALID:
      return Padding::VALID;
  }
  assert(false);
  return Padding::UNDEFINED;
}

REGISTER_WRAPPER() [1/8]

luci_interpreter::REGISTER_WRAPPER

(

flatbuffers::Offset< circle::Buffer >

)

REGISTER_WRAPPER() [2/8]

luci_interpreter::REGISTER_WRAPPER

(

flatbuffers::Offset< circle::Metadata >

)

REGISTER_WRAPPER() [3/8]

luci_interpreter::REGISTER_WRAPPER

(

flatbuffers::Offset< circle::Operator >

)

REGISTER_WRAPPER() [4/8]

luci_interpreter::REGISTER_WRAPPER

(

flatbuffers::Offset< circle::OperatorCode >

)

REGISTER_WRAPPER() [5/8]

luci_interpreter::REGISTER_WRAPPER

(

flatbuffers::Offset< circle::SubGraph >

)

REGISTER_WRAPPER() [6/8]

luci_interpreter::REGISTER_WRAPPER

(

flatbuffers::Offset< circle::Tensor >

)

REGISTER_WRAPPER() [7/8]

luci_interpreter::REGISTER_WRAPPER

(

int32_t

)

REGISTER_WRAPPER() [8/8]

luci_interpreter::REGISTER_WRAPPER

(

uint8_t

)

size()

uint32_t luci_interpreter::size ( DataType  data_type )

inline

Returns the size of the data type.

Note

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

Definition at line 141 of file DataType.h.

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

source_without_constant_copying()

std::unique_ptr< luci::GraphBuilderSource > luci_interpreter::source_without_constant_copying

(

)

Creates and returns GraphBuilderSource, which allows to not copy constant buffers from model's file.

Warning

Use this source only in case when model's buffer alive longer than Interpreter.

Definition at line 22 of file GraphBuilderRegistry.cpp.

{
  auto builder = std::make_unique<luci::GraphBuilderRegistry>();
  {
    // redefine NodeBuilder of BUFFER type
    builder->add(std::make_unique<CircleReferencingConstNodeBuilder>());
  }
 
  return builder;
}

Referenced by entry().

splitImpl()

template<typename T >

void luci_interpreter::splitImpl	(	const circle::Operator *	cur_op,
		const circle::Tensor *	input,
		int	axis_value,
		BaseRuntimeGraph *	runtime_graph
	)

Definition at line 27 of file Split.h.

{
  const int output_count = cur_op->outputs()->size();
 
  const auto output0_index = cur_op->outputs()->operator[](0);
  assert(output0_index != -1);
 
  const auto output0 = runtime_graph->getCircleTensorByIndex(output0_index);
  assert(output0 != nullptr);
 
  const int split_dimensions = Tensor::num_dims(input);
 
  assert(axis_value < split_dimensions);
  assert(Tensor::num_dims(output0) == split_dimensions);
 
  int64_t outer_size = 1;
  for (int i = 0; i < axis_value; ++i)
  {
    outer_size *= Tensor::dim(input, i);
  }
 
  int64_t base_inner_size = 1;
  for (int i = axis_value + 1; i < split_dimensions; ++i)
  {
    base_inner_size *= Tensor::dim(input, i);
  }
 
  const T *input_ptr = kernels::getTensorData<T>(runtime_graph->getDataByTensor(input));
  assert(input_ptr != nullptr);
  for (int k = 0; k < outer_size; ++k)
  {
    for (int i = 0; i < output_count; ++i)
    {
      const auto output_index = cur_op->outputs()->operator[](i);
      assert(output_index != -1);
 
      const auto output = runtime_graph->getCircleTensorByIndex(output_index);
      assert(output != nullptr);
 
      T *output_data = kernels::getTensorData<T>(runtime_graph->getDataByTensor(output));
      assert(output_data != nullptr);
      const int copy_size = Tensor::dim(output, axis_value) * base_inner_size;
      T *output_ptr = output_data + k * copy_size;
      assert(output_ptr != nullptr);
      for (int j = 0; j < copy_size; ++j)
        output_ptr[j] = input_ptr[j];
      input_ptr += copy_size;
    }
  }
}

References circle_eval_diff::TensorShape::dim(), luci_interpreter::RuntimeGraph::getCircleTensorByIndex(), and luci_interpreter::RuntimeGraph::getDataByTensor().

wrap()

template<typename T >

VectorWrapper< T > luci_interpreter::wrap

(

const flatbuffers::Vector< T > *

vec

)

Definition at line 146 of file CircleMicroReader.h.

{
  return VectorWrapper<T>(vec);
}

Variable Documentation

kernel_configure

constexpr KernelConfigureRegistry luci_interpreter::kernel_configure

constexpr

Definition at line 199 of file KernelBuilder.h.

Referenced by luci_interpreter::RuntimeGraph::configure().

kernel_executor

constexpr KernelExecuteRegistry luci_interpreter::kernel_executor

constexpr

Definition at line 200 of file KernelBuilder.h.

Referenced by luci_interpreter::RuntimeGraph::execute().