onert_micro::execute::pal Namespace Reference

Data Structures
struct	AddFn
struct	DivFn
struct	FloorDivFn
struct	FloorModFn
struct	LogicalAndFn
struct	LogicalOrFn
struct	MaximumFn
struct	MinimumFn
struct	MulFn
struct	NdArrayDesc
struct	ReduceProductFn
struct	ReduceProductFn< int8_t >
struct	ReduceSumFn
struct	ReduceSumFn< int8_t >
struct	SquaredDifferenceFn
struct	SubFn
struct	TanhFunctor

Functions
OMStatus	Add (const core::ArithmeticQuantParams &params, const uint32_t flat_size, const int8_t *input1_data, const int8_t *input2_data, int8_t *output_data)
template<typename T1 , typename T2 , typename T3 >
OMStatus	ArgMax (const core::OMRuntimeShape &input1_shape, const T1 *input1_data, const T3 *input2_data, const core::OMRuntimeShape &output_shape, T2 *output_data)
OMStatus	AveragePool (const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const int8_t *input_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)
OMStatus	ConvPerChannel (const core::ConvQuant &params, const core::OMRuntimeShape &input_shape, const int8_t *input_data, const core::OMRuntimeShape &filter_shape, const int8_t *filter_data, const int32_t *bias_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)
OMStatus	DepthwiseConvPerChannel (const core::ConvQuant &params, const core::OMRuntimeShape &input_shape, const int8_t *input_data, const core::OMRuntimeShape &filter_shape, const int8_t *filter_data, const int32_t *bias_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)
template<>
OMStatus	FullyConnected< int8_t > (const core::FullyConnectedParams &params, const int8_t *input_data, const core::OMRuntimeShape &filter_shape, const int8_t *filter_data, const int32_t *bias_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)
template<>
OMStatus	FullyConnected (const core::FullyConnectedParams &params, const int16_t *input_data, const core::OMRuntimeShape &filter_shape, const int8_t *filter_data, const int64_t *bias_data, const core::OMRuntimeShape &output_shape, int16_t *output_data)
OMStatus	MaxPool (const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const int8_t *input_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)
OMStatus	Mul (const core::ArithmeticQuantParams &params, const uint32_t flat_size, const int8_t *input1_data, const int8_t *input2_data, int8_t *output_data)
template<>
OMStatus	ReLUCommon< int8_t > (const int flat_size, const int8_t *input_data, int8_t *output_data, const float alpha, const bool is_relu_6)
template<>
OMStatus	Softmax< int8_t, int8_t > (const core::SoftmaxParams &params, const int8_t *input_data, int8_t *output_data)
OMStatus	SVDF (const core::SVDFQuantParams &params, const int8_t *input_data, const int8_t *weights_feature_data, const int8_t *weights_time_data, const int32_t *bias_data, int8_t *state_data, int8_t *output_data, const core::OMRuntimeShape &input_shape, const core::OMRuntimeShape &weights_feature_shape, const core::OMRuntimeShape &weights_time_shape, const core::OMRuntimeShape &bias_shape, const core::OMRuntimeShape &output_shape)
template<typename T >
OMStatus	Abs (const core::OMRuntimeShape &shape, const T *input_data, T *output_data)
int8_t	AddFunc (int8_t x, int8_t y, const core::ArithmeticQuantParams &params)
template<typename T >
OMStatus	Add (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const T *input1_data, const T *input2_data, T *output_data)
template<typename T >
OMStatus	BroadcastAdd4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
OMStatus	BroadcastAdd4DSlow (const core::ArithmeticQuantParams &params, const core::OMRuntimeShape &input1_shape, const int8_t *input1_data, const core::OMRuntimeShape &input2_shape, const int8_t *input2_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)
template<typename T >
OMStatus	AddN (const size_t flat_size, const size_t num_inputs, const T *const *input_data, T *output_data)
template<typename T1 , typename T2 , typename T3 , typename Cmp >
OMStatus	ArgMinMax (const core::OMRuntimeShape &input1_shape, const T1 *input1_data, const T3 *input2_data, const core::OMRuntimeShape &output_shape, T2 *output_data, const Cmp &cmp)
template<typename T , typename Fn >
OMStatus	ArithmeticOp (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const T *input1_data, const T *input2_data, T *output_data)
template<typename T , typename Fn >
OMStatus	QuantizedArithmeticOp (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const onert_micro::core::QuantizationParams &input1_qparams, const T *input1_data, const onert_micro::core::QuantizationParams &input2_qparams, const T *input2_data, const onert_micro::core::QuantizationParams &output_qparams, T *output_data)
template<typename T >
void	ElementWise (const uint32_t size, const core::ArithmeticQuantParams &params, const T *input1_data, const T *input2_data, T *output_data, T(*binary_func)(T, T, const core::ArithmeticQuantParams &))
template<typename T , typename Fn >
void	ArithmeticOpScalar (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const T *input_data, const T scalar_value, T *output_data)
template<typename T , typename Fn >
OMStatus	BroadcastArithmeticOp4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T , typename Fn >
OMStatus	QuantizedBroadcastArithmeticOp4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const onert_micro::core::QuantizationParams &input1_qparams, const T *input1_data, const core::OMRuntimeShape &input2_shape, const onert_micro::core::QuantizationParams &input2_qparams, const T *input2_data, const core::OMRuntimeShape &output_shape, const onert_micro::core::QuantizationParams &output_qparams, T *output_data)
template<typename T >
void	BroadcastInput1 (int size, const core::ArithmeticQuantParams &params, const T *input1_data, const T *input2_data, T *output_data, T(*binary_func)(T, T, const core::ArithmeticQuantParams &))
template<typename T >
void	BroadcastInput2 (int size, const core::ArithmeticQuantParams &params, const T *input1_data, const T *input2_data, T *output_data, T(*binary_func)(T, T, const core::ArithmeticQuantParams &))
template<typename T >
void	BroadcastRecursiveDimensions (const core::ArithmeticQuantParams &params, int dimension, size_t *input1_offset_p, size_t *input2_offset_p, size_t *output_offset, size_t *compressed_input1_stride, size_t *compressed_input2_stride, size_t *compressed_output_shape, const T *input1_data, const T *input2_data, T *output_data, T(*binary_func)(T, T, const core::ArithmeticQuantParams &))
template<typename T >
void	BroadcastBinaryFunction6DSlow (const core::ArithmeticQuantParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data, T(*binary_func)(T, T, const core::ArithmeticQuantParams &))
OMStatus	AveragePool (const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename T >
OMStatus	BatchToSpaceND (const core::OMRuntimeShape &unextended_input1_shape, const T *input1_data, const core::OMRuntimeShape &unextended_input2_shape, const int32_t *block_shape_data, const core::OMRuntimeShape &unextended_input3_shape, const int32_t *crops_data, const core::OMRuntimeShape &unextended_output_shape, T *output_data)
template<typename T , typename Fn >
OMStatus	BinaryOp (const int flat_size, const T *input1_data, const T *input2_data, T *output_data)
template<typename T , typename Fn >
OMStatus	BroadcastBinaryOp4DSlow (const core::OMRuntimeShape &input1_shape, const float *input1_data, const core::OMRuntimeShape &input2_shape, const float *input2_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename FromT , typename ToT >
OMStatus	Cast (const core::OMRuntimeShape &input_shape, const FromT *input_data, const core::OMRuntimeShape &output_shape, ToT *output_data)
template<typename T >
OMStatus	Ceil (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
bool	LessFn (T lhs, T rhs)
template<typename T >
bool	LessEqualFn (T lhs, T rhs)
template<typename T >
bool	EqualFn (T lhs, T rhs)
template<typename T >
bool	GreaterFn (T lhs, T rhs)
template<typename T >
bool	GreaterEqualFn (T lhs, T rhs)
template<typename T >
bool	NotEqualFn (T lhs, T rhs)
template<typename T >
void	ComparisonNoScaling (const int64_t flat_size, const T *input1_data, const T *input2_data, bool *output_data, bool F(T, T))
template<typename T , typename AccType >
void	BroadcastComparison4DSlowWithScaling (const core::ComparisonParams &op_params, const core::OMRuntimeShape &unextended_input1_shape, const T *input1_data, const core::OMRuntimeShape &unextended_input2_shape, const T *input2_data, const core::OMRuntimeShape &unextended_output_shape, bool *output_data, bool F(AccType, AccType))
template<typename T , typename AccType >
void	ComparisonWithScaling (const core::ComparisonParams &op_params, const int64_t flat_size, const T *input1_data, const T *input2_data, bool *output_data, bool F(AccType, AccType))
template<typename T >
void	BroadcastComparison4DSlowNoScaling (const core::ComparisonParams &op_params, const core::OMRuntimeShape &unextended_input1_shape, const T *input1_data, const core::OMRuntimeShape &unextended_input2_shape, const T *input2_data, const core::OMRuntimeShape &unextended_output_shape, bool *output_data, bool F(T, T))
template<typename Scalar >
OMStatus	Concatenation (core::ConcatenationParams &params, std::vector< uint32_t > &input_shapes, std::vector< const Scalar * > &input_data, const core::OMRuntimeShape &output_shape, Scalar *output_data)
OMStatus	ConvFloat (const core::FloatConv2D *params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &filter_shape, const float *filter_data, const float *bias_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename T >
OMStatus	Cos (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	DepthwiseConv2D (const core::FloatConv2D *params, const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &filter_shape, const T *filter_data, const T *bias_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<>
OMStatus	DepthwiseConv2D< float > (const core::FloatConv2D *params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &filter_shape, const float *filter_data, const float *bias_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename InputT , typename OutputT >
OMStatus	Dequantize (const core::QuantizationParams op_params, const uint32_t flat_size, const InputT *input_data, OutputT *output_data)
template<typename T >
OMStatus	Div (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const T *input1_data, const T *input2_data, T *output_data)
template<typename T >
OMStatus	BroadcastDiv4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
OMStatus	Elu (const int flat_size, const float *input_data, float *output_data)
template<typename T >
OMStatus	Exp (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	Fill (const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	Floor (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
void	FloorDiv (const int flat_size, const float *input1_data, const float *input2_data, float *output_data)
void	BroadcastFloorDiv4DSlow (const core::OMRuntimeShape &input1_shape, const float *input1_data, const core::OMRuntimeShape &input2_shape, const float *input2_data, const core::OMRuntimeShape &output_shape, float *output_data)
void	FloorMod (const int flat_size, const float *input1_data, const float *input2_data, float *output_data)
void	BroadcastFloorMod4DSlow (const core::OMRuntimeShape &input1_shape, const float *input1_data, const core::OMRuntimeShape &input2_shape, const float *input2_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename InputType , typename WeightType , typename OutputType , typename BiasType >
OMStatus	FullyConnected (const core::FullyConnectedParams &params, const InputType *input_data, const core::OMRuntimeShape &filter_shape, const WeightType *filter_data, const BiasType *bias_data, const core::OMRuntimeShape &output_shape, OutputType *output_data)
template<typename WeightType >
OMStatus	FullyConnected (const core::FullyConnectedParams &params, const float *input_data, const core::OMRuntimeShape &filter_shape, const WeightType *filter_data, const float *bias_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename ParamsT , typename IndicesT >
OMStatus	GatherND (core::OMRuntimeShape params_shape, const ParamsT *param_data, core::OMRuntimeShape indices_shape, const IndicesT *index_data, ParamsT *output_data)
OMStatus	GRU (const float *input_data, const float *weight_input_data, const float *weight_hidden_data, const float *bias_input_data, const float *bias_hidden_data, const float *hidden_state_data, float *output_data, float *output_input_data, float *output_hidden_data, const core::OMRuntimeShape &input_shape, const core::OMRuntimeShape &output_shape, const core::OMRuntimeShape &weight_input_shape, const core::OMRuntimeShape &weight_hidden_shape, const size_t intermediate_buffer_size, float *intermediate_buffer)
OMStatus	L2Normalization (const core::L2NormalizationParams &params, const float *input_data, float *output_data)
OMStatus	L2Pool (const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename T >
OMStatus	Log (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<class Fn >
OMStatus	LogicalCommon (const int flat_size, const bool *input1_data, const bool *input2_data, bool *output_data)
OMStatus	LogicalNot (const int flat_size, const bool *input_data, bool *output_data)
OMStatus	Logistic (const int flat_size, const float *input_data, float *output_data)
OMStatus	Logistic (const int flat_size, const int8_t *input_data, float input_scale, int input_zero_point, int8_t *output_data, float output_scale, int output_zero_point)
OMStatus	LogSoftmax (const core::LogSoftmaxParams &params, const float *input_data, float *output_data)
OMStatus	Maximum (const int flat_size, const float *input1_data, const float *input2_data, float *output_data)
OMStatus	BroadcastMaximum4DSlow (const core::OMRuntimeShape &input1_shape, const float *input1_data, const core::OMRuntimeShape &input2_shape, const float *input2_data, const core::OMRuntimeShape &output_shape, float *output_data)
OMStatus	MaxPool (const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)
OMStatus	Minimum (const int flat_size, const float *input1_data, const float *input2_data, float *output_data)
template<typename T >
OMStatus	BroadcastMinimum4DSlow (const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	Mul (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const T *input1_data, const T *input2_data, T *output_data)
template<typename T >
OMStatus	BroadcastMul4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	BroadcastMul6DSlow (const core::ArithmeticQuantParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	Neg (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
OMStatus	Pad (const core::PadParams &op_params, const core::OMRuntimeShape &input_shape, const float *input_data, const float pad_value, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename T >
OMStatus	QuantizedZeroPad (const core::PadParams &op_params, const core::OMRuntimeShape &input_shape, const onert_micro::core::QuantizationParams &input_qparams, const T *input_data, const core::OMRuntimeShape &output_shape, const onert_micro::core::QuantizationParams &output_qparams, T *output_data)
template<typename InputT , typename OutputT >
OMStatus	Quantize (const core::QuantizationParams op_params, const uint32_t flat_size, const InputT *input_data, OutputT *output_data)
template<typename Type >
OMStatus	ReLUCommon (const int flat_size, const Type *input_data, Type *output_data, const float alpha, const bool is_relu_6)
template<typename T >
OMStatus	Round (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<>
OMStatus	Round< float > (const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename T >
OMStatus	Rsqrt (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	QuantizedRsqrt (const core::OMRuntimeShape &input_shape, const onert_micro::core::QuantizationParams &input_qparams, const T *input_data, const core::OMRuntimeShape &output_shape, const onert_micro::core::QuantizationParams &output_qparams, T *output_data)
template<typename T >
OMStatus	Sin (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	SISOOperation (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data, std::function< T(T)> const &func)
template<typename T >
OMStatus	SISOOperation (const core::OMRuntimeShape &input_shape, const onert_micro::core::QuantizationParams &input_qparams, const T *input_data, const core::OMRuntimeShape &output_shape, const onert_micro::core::QuantizationParams &output_qparams, T *output_data, std::function< float(float)> const &func)
template<typename T >
OMStatus	Slice (const core::SliceParams &op_params, const core::OMRuntimeShape &input_shape, const T *input_data, T *output_data)
template<typename T , typename U >
OMStatus	Softmax (const core::SoftmaxParams &params, const T *input_data, U *output_data)
template<>
OMStatus	Softmax< float, float > (const core::SoftmaxParams &params, const float *input_data, float *output_data)
template<typename T >
OMStatus	SpaceToBatchND (const core::OMRuntimeShape &unextended_input1_shape, const T *input1_data, const core::OMRuntimeShape &unextended_input2_shape, const int32_t *block_shape_data, const core::OMRuntimeShape &unextended_input3_shape, const int32_t *paddings_data, const core::OMRuntimeShape &unextended_output_shape, T *output_data)
template<typename T >
OMStatus	SpaceToDepth (const int32_t block_size, const core::OMRuntimeShape &unextended_input_shape, const T *input_data, const core::OMRuntimeShape &unextended_output_shape, T *output_data)
template<typename T >
OMStatus	Split (const core::SplitParams &params, const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, int32_t axis_value)
template<typename T >
OMStatus	Sqrt (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	Square (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	SquaredDifference (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const T *input1_data, const T *input2_data, T *output_data)
template<typename T >
OMStatus	BroadcastSquaredDifference4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	QuantizedBroadcastSquaredDifference4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const onert_micro::core::QuantizationParams &input1_qparams, const T *input1_data, const core::OMRuntimeShape &input2_shape, const onert_micro::core::QuantizationParams &input2_qparams, const T *input2_data, const core::OMRuntimeShape &output_shape, const onert_micro::core::QuantizationParams &output_qparams, T *output_data)
template<typename T >
OMStatus	QuantizedSquaredDifference (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const onert_micro::core::QuantizationParams &input1_qparams, const T *input1_data, const onert_micro::core::QuantizationParams &input2_qparams, const T *input2_data, const onert_micro::core::QuantizationParams &output_qparams, T *output_data)
template<typename T >
OMStatus	StridedSlice (core::StridedSliceParams &op_params, const core::OMRuntimeShape &unextended_input_shape, const T *input_data, T *output_data)
int8_t	SubFunc (int8_t x, int8_t y, const core::ArithmeticQuantParams &params)
template<typename T >
OMStatus	Sub (const core::BinaryArithmeticBroadcastParams &params, const int flat_size, const T *input1_data, const T *input2_data, T *output_data)
template<typename T >
OMStatus	BroadcastSub4DSlow (const core::BinaryArithmeticBroadcastParams &params, const core::OMRuntimeShape &input1_shape, const T *input1_data, const core::OMRuntimeShape &input2_shape, const T *input2_data, const core::OMRuntimeShape &output_shape, T *output_data)
OMStatus	BroadcastSub4DSlow (const core::ArithmeticQuantParams &params, const core::OMRuntimeShape &input1_shape, const int8_t *input1_data, const core::OMRuntimeShape &input2_shape, const int8_t *input2_data, const core::OMRuntimeShape &output_shape, int8_t *output_data)
OMStatus	SVDF (const float *input_data, const float *weights_feature_data, const float *weights_time_data, const float *bias_data, float *state_data, float *scratch_data, float *output_data, const int rank, const int input_size, const int batch_size, const int num_filters, const int num_units, const int memory_size, const circle::ActivationFunctionType activation)
template<typename T >
OMStatus	Tanh (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	QuantizedTanh (const core::OMRuntimeShape &input_shape, const onert_micro::core::QuantizationParams &input_qparams, const T *input_data, const core::OMRuntimeShape &output_shape, const onert_micro::core::QuantizationParams &output_qparams, T *output_data)
template<typename T , int N>
OMStatus	TransposeImpl (const core::TransposeParams &params, const core::OMRuntimeShape &unextended_input_shape, const T *input_data, const core::OMRuntimeShape &unextended_output_shape, T *output_data)
template<typename T , int N = 5>
OMStatus	Transpose (const core::TransposeParams &params, const core::OMRuntimeShape &unextended_input_shape, const T *input_data, const core::OMRuntimeShape &unextended_output_shape, T *output_data)
template<typename T >
OMStatus	TransposeConv (const core::FloatConv2D *params, const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &filter_shape, const T *filter_data, const T *bias_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<>
OMStatus	TransposeConv< float > (const core::FloatConv2D *params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &filter_shape, const float *filter_data, const float *bias_data, const core::OMRuntimeShape &output_shape, float *output_data)
template<typename T , typename Fn >
OMStatus	UnaryOp (const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, T *output_data)
template<typename T >
OMStatus	Unpack (const core::SplitParams &params, const core::OMRuntimeShape &input_shape, const T *input_data, const core::OMRuntimeShape &output_shape, int32_t axis_value)
std::pair< uint32_t, uint32_t >	getUpLowerWeightTensorDepth (core::OpTrainableRankType rank, const uint32_t output_depth)
std::int32_t	saturatingRoundingDoublingHighMul (std::int32_t a, std::int32_t b)
int32_t	roundingDivideByPOT (int32_t x, int32_t exponent)
int32_t	multiplyByQuantizedMultiplier (int32_t x, int32_t quantized_multiplier, int shift)
int32_t	multiplyByQuantizedMultiplierSmallerThanOneExp (int32_t x, int32_t quantized_multiplier, int left_shift)
template<typename P >
void	getActivationParams (const P &params, int32_t *min, int32_t *max)
template<typename P >
void	getActivationParams (const P &params, float *min, float *max)
template<typename P >
void	getActivationParams (const P &params, int64_t *min, int64_t *max)
size_t	reducedOutputOffset (const int32_t num_dims, const int32_t *dims, const int32_t *index, const int32_t num_axis, const int32_t *axis)
bool	nextIndex (const int32_t num_dims, const int32_t *dims, int32_t *current)
int	MatchingDim (const core::OMRuntimeShape &shape1, int index1, const core::OMRuntimeShape &shape2, int index2)
int	flatSizeSkipDim (const int32_t *dims_data, int skip_dim, int num_dims)
int	offset (const int32_t *dims_data, int i0, int i1, int i2, int i3)
int	offset (const int32_t *dims_data, int i0, int i1, int i2, int i3, int i4)
template<typename T >
T	activationFunctionWithMinMax (T x, T output_activation_min, T output_activation_max)
template<int MAX_DIM = 6>
bool	ReduceDimensionsForBroadcast (const core::OMRuntimeShape &input1_shape, const core::OMRuntimeShape &input2_shape, size_t *compressed_input1_stride, size_t *compressed_input2_stride, size_t *compressed_output_shape)
template<int N>
void	copyDimsToDesc (const core::OMRuntimeShape &input_shape, NdArrayDesc< N > *desc_out)
template<int N, int DIM, typename Calc >
std::enable_if< DIM==N-1, void >::type	NDOpsHelperImpl (const NdArrayDesc< N > &output, const Calc &calc, int indexes[N])
template<int N, int DIM, typename Calc >
std::enable_if< DIM!=N-1, void >::type	NDOpsHelperImpl (const NdArrayDesc< N > &output, const Calc &calc, int indexes[N])
template<int N, typename Calc >
void	NDOpsHelper (const NdArrayDesc< N > &output, const Calc &calc)
template<int N>
void	NdArrayDescsForElementwiseBroadcast (const core::OMRuntimeShape &input0_shape, const core::OMRuntimeShape &input1_shape, NdArrayDesc< N > *desc0_out, NdArrayDesc< N > *desc1_out)
int	subscriptToIndex (const NdArrayDesc< 4 > &desc, int i0, int i1, int i2, int i3)
int	subscriptToIndex (const NdArrayDesc< 5 > &desc, int indexes[5])
bool	processBroadcastShapes (const core::OMRuntimeShape &shape0, const core::OMRuntimeShape &shape1, core::BinaryArithmeticBroadcastParams *params)
template<>
OMStatus	AddN< int8_t > (const size_t flat_size, const size_t num_inputs, const int8_t *const *input_data, int8_t *output_data)
template<>
OMStatus	AddN< int16_t > (const size_t flat_size, const size_t num_inputs, const int16_t *const *input_data, int16_t *output_data)
template<typename T1 , typename T2 , typename T3 >
OMStatus	ArgMin (const core::OMRuntimeShape &input1_shape, const T1 *input1_data, const T3 *input2_data, const core::OMRuntimeShape &output_shape, T2 *output_data)
template<typename T , typename AccumT >
OMStatus	BatchMatMul (const OMRuntimeShape &lhs_shape, const T *lhs_data, const OMRuntimeShape &rhs_shape, const T *rhs_data, const OMRuntimeShape &output_shape, T *output_data)
template<typename InputType , typename OutputType >
OMStatus	Mul (const core::ArithmeticQuantParams &params, uint32_t size, const InputType *input1_data, const InputType *input2_data, OutputType *output_data)
bool	resolveAxis (const int num_dims, const int *axis, const int64_t num_axis, int *out_axis, int *out_num_axis)
template<typename T >
bool	ReduceGeneric (const T *input_data, const int *input_dims, const int input_num_dims, T *output_data, const int *axis, const int64_t num_axis_dimensions, T init_value, const int output_flat_size, T reducer(const T, const T))
template<typename T >
bool	reduceSumImpl (const T *input_data, const int *input_dims, const int input_num_dims, T *output_data, const int *axis, const int num_axis, const int num_outputs)
template<typename T >
void	MeanROWH (const OMRuntimeShape &unextended_input_shape, const T *input_data, const OMRuntimeShape &unextended_output_shape, T *output_data)
template<typename T , template< typename > class ReduceFn>
bool	ReduceGeneric (OMReduceDataContext< T > &ctx)
template<typename T , template< typename > class ReduceFn>
bool	Reduce (OMReduceDataContext< T > &ctx, bool mean=false)
template<typename D , typename T >
void	Select (const core::OMRuntimeShape &input_condition_shape, const D *input_condition_data, const core::OMRuntimeShape &input_x_shape, const T *input_x_data, const core::OMRuntimeShape &input_y_shape, const T *input_y_data, const core::OMRuntimeShape &output_shape, T *output_data)
OMStatus	Sub (const core::ArithmeticQuantParams &params, const uint32_t flat_size, const int8_t *input1_data, const int8_t *input2_data, int8_t *output_data)

Variables
constexpr int	MAX_INDICES_ND = 5

Function Documentation

Abs()

template<typename T >

OMStatus onert_micro::execute::pal::Abs ( const core::OMRuntimeShape &  shape, const T *  input_data, T *  output_data  )

inline

Definition at line 33 of file PALAbs.h.

{
  const uint32_t flat_size = shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  for (uint32_t i = 0; i < flat_size; ++i)
  {
    output_data[i] = std::abs(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleAbs().

activationFunctionWithMinMax()

template<typename T >

T onert_micro::execute::pal::activationFunctionWithMinMax ( T  x, T  output_activation_min, T  output_activation_max  )

inline

Definition at line 231 of file PALUtils.h.

{
  using std::max;
  using std::min;
  return min(max(x, output_activation_min), output_activation_max);
}

Referenced by DepthwiseConv2D< float >(), L2Pool(), and TransposeConv< float >().

Add() [1/2]

OMStatus onert_micro::execute::pal::Add	(	const core::ArithmeticQuantParams &	params,
		const uint32_t	flat_size,
		const int8_t *	input1_data,
		const int8_t *	input2_data,
		int8_t *	output_data
	)

Definition at line 33 of file PALAdd.h.

{
  auto status = arm_elementwise_add_s8(
    input1_data, input2_data, params.input1_offset, params.input1_multiplier, params.input1_shift,
    params.input2_offset, params.input2_multiplier, params.input2_shift, params.left_shift,
    output_data, params.output_offset, params.output_multiplier, params.output_shift,
    params.quantized_activation_min, params.quantized_activation_max, flat_size);
 
  assert(status == ARM_CMSIS_NN_SUCCESS);
  if (status != ARM_CMSIS_NN_SUCCESS)
    return UnknownError;
 
  return Ok;
}

References onert_micro::core::ArithmeticQuantParams::input1_multiplier, onert_micro::core::ArithmeticQuantParams::input1_offset, onert_micro::core::ArithmeticQuantParams::input1_shift, onert_micro::core::ArithmeticQuantParams::input2_multiplier, onert_micro::core::ArithmeticQuantParams::input2_offset, onert_micro::core::ArithmeticQuantParams::input2_shift, onert_micro::core::ArithmeticQuantParams::left_shift, onert_micro::Ok, onert_micro::core::ArithmeticQuantParams::output_multiplier, onert_micro::core::ArithmeticQuantParams::output_offset, onert_micro::core::ArithmeticQuantParams::output_shift, onert_micro::core::ArithmeticQuantParams::quantized_activation_max, onert_micro::core::ArithmeticQuantParams::quantized_activation_min, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleAdd().

Add() [2/2]

template<typename T >

OMStatus onert_micro::execute::pal::Add	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data
	)

Definition at line 50 of file PALAddCommon.h.

{
  ArithmeticOp<T, AddFn<T>>(params, flat_size, input1_data, input2_data, output_data);
  return Ok;
}

References onert_micro::Ok.

AddFunc()

int8_t onert_micro::execute::pal::AddFunc	(	int8_t	x,
		int8_t	y,
		const core::ArithmeticQuantParams &	params
	)

Definition at line 30 of file PALAddCommon.h.

{
  const int32_t input1_val = params.input1_offset + x;
  const int32_t input2_val = params.input2_offset + y;
  const int32_t shifted_input1_val = input1_val * (1 << params.left_shift);
  const int32_t shifted_input2_val = input2_val * (1 << params.left_shift);
  const int32_t scaled_input1_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
    shifted_input1_val, params.input1_multiplier, params.input1_shift);
  const int32_t scaled_input2_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
    shifted_input2_val, params.input2_multiplier, params.input2_shift);
  const int32_t raw_sum = scaled_input1_val + scaled_input2_val;
  const int32_t raw_output = multiplyByQuantizedMultiplierSmallerThanOneExp(
                               raw_sum, params.output_multiplier, params.output_shift) +
                             params.output_offset;
  const int32_t clamped_output = std::min(params.quantized_activation_max,
                                          std::max(params.quantized_activation_min, raw_output));
  return static_cast<int8_t>(clamped_output);
}

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

Referenced by BroadcastAdd4DSlow().

AddN()

template<typename T >

OMStatus onert_micro::execute::pal::AddN	(	const size_t	flat_size,
		const size_t	num_inputs,
		const T *const *	input_data,
		T *	output_data
	)

Definition at line 32 of file PALAddNCommon.h.

{
  // All inputs and output should have the same shape, this is checked during
  // Prepare stage.
  for (size_t i = 0; i < flat_size; ++i)
  {
    T x = 0;
    for (size_t j = 0; j < num_inputs; ++j)
    {
      x += input_data[j][i];
    }
    output_data[i] = x;
  }
  return Ok;
}

References onert_micro::Ok.

AddN< int16_t >()

template<>

OMStatus onert_micro::execute::pal::AddN< int16_t >	(	const size_t	flat_size,
		const size_t	num_inputs,
		const int16_t *const *	input_data,
		int16_t *	output_data
	)

Definition at line 38 of file PALAddN.h.

{
  assert(false && "Not IMPL yet");
  return UnsupportedOp;
}

References onert_micro::UnsupportedOp.

AddN< int8_t >()

template<>

OMStatus onert_micro::execute::pal::AddN< int8_t >	(	const size_t	flat_size,
		const size_t	num_inputs,
		const int8_t *const *	input_data,
		int8_t *	output_data
	)

Definition at line 30 of file PALAddN.h.

{
  assert(false && "Not IMPL yet");
  return UnsupportedOp;
}

References onert_micro::UnsupportedOp.

ArgMax()

template<typename T1 , typename T2 , typename T3 >

OMStatus onert_micro::execute::pal::ArgMax	(	const core::OMRuntimeShape &	input1_shape,
		const T1 *	input1_data,
		const T3 *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T2 *	output_data
	)

Definition at line 30 of file PALArgMax.h.

{
  return ArgMinMax(input1_shape, input1_data, input2_data, output_shape, output_data,
                   std::greater<T1>());
}

References ArgMinMax(), and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleArgMax().

ArgMin()

template<typename T1 , typename T2 , typename T3 >

OMStatus onert_micro::execute::pal::ArgMin	(	const core::OMRuntimeShape &	input1_shape,
		const T1 *	input1_data,
		const T3 *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T2 *	output_data
	)

Definition at line 30 of file PALArgMin.h.

{
  return ArgMinMax(input1_shape, input1_data, input2_data, output_shape, output_data,
                   std::less<T1>());
}

References ArgMinMax(), and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleArgMin().

ArgMinMax()

template<typename T1 , typename T2 , typename T3 , typename Cmp >

OMStatus onert_micro::execute::pal::ArgMinMax	(	const core::OMRuntimeShape &	input1_shape,
		const T1 *	input1_data,
		const T3 *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T2 *	output_data,
		const Cmp &	cmp
	)

Definition at line 32 of file PALArgMinMaxCommon.h.

{
  int axis = input2_data[0];
  if (axis < 0)
  {
    axis += input1_shape.dimensionsCount();
  }
  const int axis_size = input1_shape.dims(axis);
 
  int outer_size = 1;
  for (int i = 0; i < axis; ++i)
  {
    outer_size *= input1_shape.dims(i);
  }
 
  int inner_size = 1;
  const int dims_count = input1_shape.dimensionsCount();
  for (int i = axis + 1; i < dims_count; ++i)
  {
    inner_size *= input1_shape.dims(i);
  }
  for (int outer = 0; outer < outer_size; ++outer)
  {
    for (int inner = 0; inner < inner_size; ++inner)
    {
      auto min_max_value = input1_data[outer * axis_size * inner_size + inner];
      T2 min_max_index = 0;
      for (int i = 1; i < axis_size; ++i)
      {
        const auto &curr_value = input1_data[(outer * axis_size + i) * inner_size + inner];
        if (cmp(curr_value, min_max_value))
        {
          min_max_value = curr_value;
          min_max_index = static_cast<T2>(i);
        }
      }
      output_data[outer * inner_size + inner] = min_max_index;
    }
  }
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), and onert_micro::Ok.

Referenced by ArgMax(), and ArgMin().

ArithmeticOp()

template<typename T , typename Fn >

OMStatus onert_micro::execute::pal::ArithmeticOp	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data
	)

Definition at line 54 of file PALArithmeticOpCommon.h.

{
  T activation_min, activation_max;
  getActivationParams(params, &activation_min, &activation_max);
 
  Fn func;
  for (int i = 0; i < flat_size; ++i)
    output_data[i] =
      std::min(std::max(func(input1_data[i], input2_data[i]), activation_min), activation_max);
 
  return Ok;
}

References getActivationParams(), and onert_micro::Ok.

ArithmeticOpScalar()

template<typename T , typename Fn >

void onert_micro::execute::pal::ArithmeticOpScalar ( const core::BinaryArithmeticBroadcastParams &  params, const int  flat_size, const T *  input_data, const T  scalar_value, T *  output_data  )

inline

Definition at line 111 of file PALArithmeticOpCommon.h.

{
  T activation_min, activation_max;
  getActivationParams(params, &activation_min, &activation_max);
 
  for (int i = 0; i < flat_size; ++i)
    output_data[i] =
      std::min(std::max(func(input_data[i], scalar_value), activation_min), activation_max);
}

References getActivationParams().

AveragePool() [1/2]

OMStatus onert_micro::execute::pal::AveragePool	(	const core::Pool2DParams &	params,
		const core::OMRuntimeShape &	input_shape,
		const float *	input_data,
		const core::OMRuntimeShape &	output_shape,
		float *	output_data
	)

Definition at line 33 of file PALAveragePool2DCommon.h.

{
  const int32_t batches = input_shape.dims(0);
  const int32_t depth = output_shape.dims(3);
  const int32_t input_height = input_shape.dims(1);
  const int32_t input_width = input_shape.dims(2);
  const int32_t output_height = output_shape.dims(1);
  const int32_t output_width = output_shape.dims(2);
  const int32_t stride_height = params.stride_h;
  const int32_t stride_width = params.stride_w;
  for (int batch = 0; batch < batches; ++batch)
  {
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        for (int channel = 0; channel < depth; ++channel)
        {
          const int in_x_origin = (out_x * stride_width) - params.pad_w;
          const int in_y_origin = (out_y * stride_height) - params.pad_h;
          // Compute the boundaries of the filter region clamped so as to
          // ensure that the filter window fits in the input array.
          const int filter_x_start = std::max(0, -in_x_origin);
          const int filter_x_end = std::min(static_cast<int32_t>(params.filter_w),
                                            static_cast<int32_t>(input_width - in_x_origin));
          const int filter_y_start = std::max(0, -in_y_origin);
          const int filter_y_end = std::min(static_cast<int32_t>(params.filter_h),
                                            static_cast<int32_t>(input_height - in_y_origin));
 
          float total = 0.f;
          float filter_count = 0;
 
          for (int filter_y = filter_y_start; filter_y < filter_y_end; ++filter_y)
          {
            for (int filter_x = filter_x_start; filter_x < filter_x_end; ++filter_x)
            {
              const int in_x = in_x_origin + filter_x;
              const int in_y = in_y_origin + filter_y;
 
              const int input_data_offset =
                ((batch * input_shape.dims(1) + in_y) * input_shape.dims(2) + in_x) *
                  input_shape.dims(3) +
                channel;
 
              total += input_data[input_data_offset];
              filter_count++;
            }
          }
          const int output_data_offset =
            ((batch * output_shape.dims(1) + out_y) * output_shape.dims(2) + out_x) *
              output_shape.dims(3) +
            channel;
 
          assert(filter_count != 0);
          const float average = total / filter_count;
 
          output_data[output_data_offset] =
            std::min(std::max(average, params.activation_min), params.activation_max);
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::Pool2DParams::activation_max, onert_micro::core::Pool2DParams::activation_min, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::Pool2DParams::filter_h, onert_micro::core::Pool2DParams::filter_w, onert_micro::Ok, output_shape, onert_micro::core::Pool2DParams::pad_h, onert_micro::core::Pool2DParams::pad_w, onert_micro::core::Pool2DParams::stride_h, and onert_micro::core::Pool2DParams::stride_w.

AveragePool() [2/2]

OMStatus onert_micro::execute::pal::AveragePool	(	const core::Pool2DParams &	params,
		const core::OMRuntimeShape &	input_shape,
		const int8_t *	input_data,
		const core::OMRuntimeShape &	output_shape,
		int8_t *	output_data
	)

Definition at line 32 of file PALAveragePool2D.h.

{
  cmsis_nn_dims input_dims;
  cmsis_nn_dims output_dims;
  cmsis_nn_pool_params pool_params;
  cmsis_nn_dims filter_dims;
  cmsis_nn_context ctx;
 
  const int depth = input_shape.dims(3);
  const int output_width = output_shape.dims(2);
 
  input_dims.n = 1;
  input_dims.h = input_shape.dims(1);
  input_dims.w = input_shape.dims(2);
  input_dims.c = depth;
 
  output_dims.n = 1;
  output_dims.h = output_shape.dims(1);
  output_dims.w = output_width;
  output_dims.c = depth;
 
  pool_params.stride.h = params.stride_h;
  pool_params.stride.w = params.stride_w;
  pool_params.padding.h = params.pad_h;
  pool_params.padding.w = params.pad_w;
  pool_params.activation.min = params.quantized_activation_min;
  pool_params.activation.max = params.quantized_activation_max;
 
  filter_dims.n = 1;
  filter_dims.h = params.filter_h;
  filter_dims.w = params.filter_w;
  filter_dims.c = 1;
 
  const int32_t buffer_size = arm_avgpool_s8_get_buffer_size(output_width, depth);
  int8_t *buffer = nullptr;
  if (buffer_size > 0)
  {
    buffer = new int8_t[buffer_size];
  }
 
  ctx.buf = buffer;
  ctx.size = buffer_size;
 
  auto res = arm_avgpool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims, &output_dims,
                            output_data);
 
  if (buffer_size > 0)
    delete[] buffer;
 
  assert(res == ARM_CMSIS_NN_SUCCESS);
  if (res != ARM_CMSIS_NN_SUCCESS)
    return CmsisNNError;
 
  return Ok;
}

References onert_micro::CmsisNNError, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::Pool2DParams::filter_h, onert_micro::core::Pool2DParams::filter_w, onert_micro::Ok, output_shape, onert_micro::core::Pool2DParams::pad_h, onert_micro::core::Pool2DParams::pad_w, onert_micro::core::Pool2DParams::quantized_activation_max, onert_micro::core::Pool2DParams::quantized_activation_min, onert_micro::core::Pool2DParams::stride_h, and onert_micro::core::Pool2DParams::stride_w.

Referenced by onert_micro::execute::execute_kernel_CircleAveragePool2D().

BatchMatMul()

template<typename T , typename AccumT >

OMStatus onert_micro::execute::pal::BatchMatMul ( const OMRuntimeShape &  lhs_shape, const T *  lhs_data, const OMRuntimeShape &  rhs_shape, const T *  rhs_data, const OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 39 of file PALBatchMatMul.h.

{
 
  const OMRuntimeShape extended_lhs_shape = OMRuntimeShape::extendedShape(5, lhs_shape);
  const OMRuntimeShape extended_rhs_shape = OMRuntimeShape::extendedShape(5, rhs_shape);
 
  const int batch_dim0 = extended_lhs_shape.dims(0);
  const int batch_dim1 = extended_lhs_shape.dims(1);
  const int batch_dim2 = extended_lhs_shape.dims(2);
 
  const int lhs_ext0 = extended_lhs_shape.dims(0);
  const int lhs_ext1 = extended_lhs_shape.dims(1);
  const int lhs_ext2 = extended_lhs_shape.dims(2);
  const int rhs_ext0 = extended_rhs_shape.dims(0);
  const int rhs_ext1 = extended_rhs_shape.dims(1);
  const int rhs_ext2 = extended_rhs_shape.dims(2);
 
  // Set params for each matrix multiply.
  const int lhs_rows = extended_lhs_shape.dims(3);
  const int rhs_cols = extended_rhs_shape.dims(4);
  const int accum_depth = extended_lhs_shape.dims(4);
 
  // stride for each batch dim
  const int lhs_stride_b0 =
    extended_lhs_shape.dims(1) * extended_lhs_shape.dims(2) * lhs_rows * accum_depth;
  const int lhs_stride_b1 = extended_lhs_shape.dims(2) * lhs_rows * accum_depth;
  const int lhs_stride_b2 = lhs_rows * accum_depth;
 
  const int rhs_stride_b0 =
    extended_rhs_shape.dims(1) * extended_rhs_shape.dims(2) * accum_depth * rhs_cols;
  const int rhs_stride_b1 = extended_rhs_shape.dims(2) * accum_depth * rhs_cols;
  const int rhs_stride_b2 = accum_depth * rhs_cols;
 
  for (int b0 = 0; b0 < batch_dim0; ++b0)
  {
    const T *lhs_ptr0 = lhs_data + (b0 * lhs_stride_b0);
    const T *rhs_ptr0 = rhs_data + (b0 * rhs_stride_b0);
    for (int b1 = 0; b1 < batch_dim1; ++b1)
    {
      const T *lhs_ptr1 = lhs_ptr0 + b1 * lhs_stride_b1;
      const T *rhs_ptr1 = rhs_ptr0 + b1 * rhs_stride_b1;
      for (int b2 = 0; b2 < batch_dim2; ++b2)
      {
        const T *lhs_ptr2 = lhs_ptr1 + b2 * lhs_stride_b2;
        const T *rhs_ptr2 = rhs_ptr1 + b2 * rhs_stride_b2;
        T *out_ptr = output_data +
                     ((b0 * batch_dim1 * batch_dim2) + b1 * batch_dim2 + b2) * lhs_rows * rhs_cols;
 
        for (int j = 0; j < rhs_cols; ++j)
        {
          for (int i = 0; i < lhs_rows; ++i)
          {
            AccumT total = 0;
            for (int k = 0; k < accum_depth; ++k)
            {
              AccumT lhs_val = lhs_ptr2[accum_depth * i + k];
              AccumT rhs_val = rhs_ptr2[j + k * rhs_cols];
              total += (lhs_val) * (rhs_val);
            }
            const int idx = j + i * rhs_cols;
            out_ptr[idx] = static_cast<T>(total);
          }
        }
      }
    }
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::extendedShape(), and onert_micro::Ok.

BatchToSpaceND()

template<typename T >

OMStatus onert_micro::execute::pal::BatchToSpaceND ( const core::OMRuntimeShape &  unextended_input1_shape, const T *  input1_data, const core::OMRuntimeShape &  unextended_input2_shape, const int32_t *  block_shape_data, const core::OMRuntimeShape &  unextended_input3_shape, const int32_t *  crops_data, const core::OMRuntimeShape &  unextended_output_shape, T *  output_data  )

inline

Definition at line 51 of file PALBatchToSpaceNDCommon.h.

{
  const core::OMRuntimeShape input1_shape = extendShapeBatchToSpace(unextended_input1_shape);
  const core::OMRuntimeShape output_shape = extendShapeBatchToSpace(unextended_output_shape);
 
  const int output_width = output_shape.dims(2);
  const int output_height = output_shape.dims(1);
  const int output_batch_size = output_shape.dims(0);
 
  const int depth = input1_shape.dims(3);
  const int input_width = input1_shape.dims(2);
  const int input_height = input1_shape.dims(1);
  const int input_batch_size = input1_shape.dims(0);
 
  const int block_shape_height = block_shape_data[0];
  const int block_shape_width =
    unextended_input1_shape.dimensionsCount() == 4 ? block_shape_data[1] : 1;
  const int crops_top = crops_data[0];
  const int crops_left = unextended_input1_shape.dimensionsCount() == 4 ? crops_data[2] : 0;
  for (int in_batch = 0; in_batch < input_batch_size; ++in_batch)
  {
    const int out_batch = in_batch % output_batch_size;
    const int spatial_offset = in_batch / output_batch_size;
    for (int in_h = 0; in_h < input_height; ++in_h)
    {
      const int out_h = in_h * block_shape_height + spatial_offset / block_shape_width - crops_top;
      if (out_h < 0 || out_h >= output_height)
      {
        continue;
      }
      for (int in_w = 0; in_w < input_width; ++in_w)
      {
        const int out_w =
          in_w * block_shape_width + spatial_offset % block_shape_width - crops_left;
 
        if (out_w < 0 || out_w >= output_width)
        {
          continue;
        }
        T *out = output_data + offset(output_shape.dimsData(), out_batch, out_h, out_w, 0);
        const T *in = input1_data + offset(input1_shape.dimsData(), in_batch, in_h, in_w, 0);
        memcpy(out, in, depth * sizeof(T));
      }
    }
  }
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::dimsData(), offset(), onert_micro::Ok, and output_shape.

BinaryOp()

template<typename T , typename Fn >

OMStatus onert_micro::execute::pal::BinaryOp ( const int  flat_size, const T *  input1_data, const T *  input2_data, T *  output_data  )

inline

Definition at line 62 of file PALBinaryOpCommon.h.

{
  Fn func;
  for (int i = 0; i < flat_size; ++i)
  {
    output_data[i] = func(input1_data[i], input2_data[i]);
  }
  return Ok;
}

References onert_micro::Ok.

BroadcastAdd4DSlow() [1/2]

OMStatus onert_micro::execute::pal::BroadcastAdd4DSlow	(	const core::ArithmeticQuantParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const int8_t *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const int8_t *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		int8_t *	output_data
	)

Definition at line 68 of file PALAddCommon.h.

{
  BroadcastBinaryFunction6DSlow(params, input1_shape, input1_data, input2_shape, input2_data,
                                output_shape, output_data, AddFunc);
  return Ok;
}

References AddFunc(), BroadcastBinaryFunction6DSlow(), onert_micro::Ok, and output_shape.

BroadcastAdd4DSlow() [2/2]

template<typename T >

OMStatus onert_micro::execute::pal::BroadcastAdd4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 58 of file PALAddCommon.h.

{
  BroadcastArithmeticOp4DSlow<T, AddFn<T>>(params, input1_shape, input1_data, input2_shape,
                                           input2_data, output_shape, output_data);
  return Ok;
}

References onert_micro::Ok, and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleAdd().

BroadcastArithmeticOp4DSlow()

template<typename T , typename Fn >

OMStatus onert_micro::execute::pal::BroadcastArithmeticOp4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 124 of file PALArithmeticOpCommon.h.

{
  NdArrayDesc<4> desc1;
  NdArrayDesc<4> desc2;
  NdArrayDescsForElementwiseBroadcast(input1_shape, input2_shape, &desc1, &desc2);
  const core::OMRuntimeShape extended_output_shape =
    core::OMRuntimeShape::extendedShape(4, output_shape);
 
  T activation_min, activation_max;
  getActivationParams(params, &activation_min, &activation_max);
 
  // In Tensorflow, the dimensions are canonically named (batch_number, row,
  // col, channel), with extents (batches, height, width, depth), with the
  // trailing dimension changing most rapidly (channels has the smallest stride,
  // typically 1 element).
  //
  // In generated C code, we store arrays with the dimensions reversed. The
  // first dimension has smallest stride.
  //
  // We name our variables by their Tensorflow convention, but generate C code
  // nesting loops such that the innermost loop has the smallest stride for the
  // best cache behavior.
  Fn func;
  for (int b = 0; b < extended_output_shape.dims(0); ++b)
  {
    for (int y = 0; y < extended_output_shape.dims(1); ++y)
    {
      for (int x = 0; x < extended_output_shape.dims(2); ++x)
      {
        for (int c = 0; c < extended_output_shape.dims(3); ++c)
        {
          const int output_data_offset =
            ((b * extended_output_shape.dims(1) + y) * extended_output_shape.dims(2) + x) *
              extended_output_shape.dims(3) +
            c;
 
          output_data[output_data_offset] =
            std::min(std::max(func(input1_data[subscriptToIndex(desc1, b, y, x, c)],
                                   input2_data[subscriptToIndex(desc2, b, y, x, c)]),
                              activation_min),
                     activation_max);
        }
      }
    }
  }
  return Ok;
}

References desc1, desc2, onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::extendedShape(), getActivationParams(), NdArrayDescsForElementwiseBroadcast(), onert_micro::Ok, output_shape, and subscriptToIndex().

BroadcastBinaryFunction6DSlow()

template<typename T >

void onert_micro::execute::pal::BroadcastBinaryFunction6DSlow	(	const core::ArithmeticQuantParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data,
		T(*)(T, T, const core::ArithmeticQuantParams &)	binary_func
	)

Definition at line 320 of file PALArithmeticOpCommon.h.

{
  constexpr int kMaxBroadcastDim = 6;
 
  // In Tensorflow, the dimensions are canonically named (batch_number, row,
  // col, channel), with extents (batches, height, width, depth), with the
  // trailing dimension changing most rapidly (channels has the smallest stride,
  // typically 1 element).
  //
  // In generated C code, we store arrays with the dimensions reversed. The
  // first dimension has smallest stride.
  //
  // We name our variables by their Tensorflow convention, but generate C code
  // nesting loops such that the innermost loop has the smallest stride for the
  // best cache behavior.
  size_t compressed_input1_stride[kMaxBroadcastDim];
  size_t compressed_input2_stride[kMaxBroadcastDim];
  size_t compressed_output_shape[kMaxBroadcastDim];
  bool broadcastable_shape = ReduceDimensionsForBroadcast<kMaxBroadcastDim>(
    input1_shape, input2_shape, compressed_input1_stride, compressed_input2_stride,
    compressed_output_shape);
  // Skip broadcasting for degenerate shapes.
  if (!broadcastable_shape)
  {
    return;
  }
 
  size_t input1_offset = 0;
  size_t input2_offset = 0;
  size_t output_offset = 0;
  BroadcastRecursiveDimensions(params, kMaxBroadcastDim - 1, &input1_offset, &input2_offset,
                               &output_offset, compressed_input1_stride, compressed_input2_stride,
                               compressed_output_shape, input1_data, input2_data, output_data,
                               binary_func);
}

References BroadcastRecursiveDimensions().

Referenced by BroadcastAdd4DSlow(), and BroadcastSub4DSlow().

BroadcastBinaryOp4DSlow()

template<typename T , typename Fn >

OMStatus onert_micro::execute::pal::BroadcastBinaryOp4DSlow ( const core::OMRuntimeShape &  input1_shape, const float *  input1_data, const core::OMRuntimeShape &  input2_shape, const float *  input2_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 75 of file PALBinaryOpCommon.h.

{
  NdArrayDesc<4> desc1;
  NdArrayDesc<4> desc2;
  NdArrayDescsForElementwiseBroadcast(input1_shape, input2_shape, &desc1, &desc2);
 
  const core::OMRuntimeShape extended_output_shape =
    core::OMRuntimeShape::extendedShape(4, output_shape);
 
  // In Tensorflow, the dimensions are canonically named (batch_number, row,
  // col, channel), with extents (batches, height, width, depth), with the
  // trailing dimension changing most rapidly (channels has the smallest stride,
  // typically 1 element).
  //
  // In generated C code, we store arrays with the dimensions reversed. The
  // first dimension has smallest stride.
  //
  // We name our variables by their Tensorflow convention, but generate C code
  // nesting loops such that the innermost loop has the smallest stride for the
  // best cache behavior.
 
  Fn func;
  for (int b = 0; b < extended_output_shape.dims(0); ++b)
  {
    for (int y = 0; y < extended_output_shape.dims(1); ++y)
    {
      for (int x = 0; x < extended_output_shape.dims(2); ++x)
      {
        for (int c = 0; c < extended_output_shape.dims(3); ++c)
        {
          const int output_data_offset =
            ((b * extended_output_shape.dims(1) + y) * extended_output_shape.dims(2) + x) *
              extended_output_shape.dims(3) +
            c;
 
          output_data[output_data_offset] = func(input1_data[subscriptToIndex(desc1, b, y, x, c)],
                                                 input2_data[subscriptToIndex(desc2, b, y, x, c)]);
        }
      }
    }
  }
  return Ok;
}

References desc1, desc2, onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::extendedShape(), NdArrayDescsForElementwiseBroadcast(), onert_micro::Ok, output_shape, and subscriptToIndex().

BroadcastComparison4DSlowNoScaling()

template<typename T >

void onert_micro::execute::pal::BroadcastComparison4DSlowNoScaling ( const core::ComparisonParams &  op_params, const core::OMRuntimeShape &  unextended_input1_shape, const T *  input1_data, const core::OMRuntimeShape &  unextended_input2_shape, const T *  input2_data, const core::OMRuntimeShape &  unextended_output_shape, bool *  output_data, bool   FT, T  )

inline

Definition at line 149 of file PALComparisons.h.

{
  const BroadcastComparison4DSlowCommon dims = BroadcastComparison4DSlowPreprocess(
    unextended_input1_shape, unextended_input2_shape, unextended_output_shape);
 
  for (int b = 0; b < dims.output_shape.dims(0); ++b)
  {
    for (int y = 0; y < dims.output_shape.dims(1); ++y)
    {
      for (int x = 0; x < dims.output_shape.dims(2); ++x)
      {
        for (int c = 0; c < dims.output_shape.dims(3); ++c)
        {
          const int output_data_offset =
            ((b * dims.output_shape.dims(1) + y) * dims.output_shape.dims(2) + x) *
              dims.output_shape.dims(3) +
            c;
          output_data[output_data_offset] =
            F(input1_data[subscriptToIndex(dims.desc1, b, y, x, c)],
              input2_data[subscriptToIndex(dims.desc2, b, y, x, c)]);
        }
      }
    }
  }
}

References subscriptToIndex().

BroadcastComparison4DSlowWithScaling()

template<typename T , typename AccType >

void onert_micro::execute::pal::BroadcastComparison4DSlowWithScaling ( const core::ComparisonParams &  op_params, const core::OMRuntimeShape &  unextended_input1_shape, const T *  input1_data, const core::OMRuntimeShape &  unextended_input2_shape, const T *  input2_data, const core::OMRuntimeShape &  unextended_output_shape, bool *  output_data, bool   FAccType, AccType  )

inline

Definition at line 75 of file PALComparisons.h.

{
  const BroadcastComparison4DSlowCommon dims = BroadcastComparison4DSlowPreprocess(
    unextended_input1_shape, unextended_input2_shape, unextended_output_shape);
 
  int left_shift = op_params.left_shift;
  int32_t input1_offset = op_params.input1_offset;
  int32_t input1_multiplier = op_params.input1_multiplier;
  int input1_shift = op_params.input1_shift;
  int32_t input2_offset = op_params.input2_offset;
  int32_t input2_multiplier = op_params.input2_multiplier;
  int input2_shift = op_params.input2_shift;
 
  for (int b = 0; b < dims.output_shape.dims(0); ++b)
  {
    for (int y = 0; y < dims.output_shape.dims(1); ++y)
    {
      for (int x = 0; x < dims.output_shape.dims(2); ++x)
      {
        for (int c = 0; c < dims.output_shape.dims(3); ++c)
        {
          const int32_t input1_val =
            input1_offset + input1_data[subscriptToIndex(dims.desc1, b, y, x, c)];
          const int32_t input2_val =
            input2_offset + input2_data[subscriptToIndex(dims.desc2, b, y, x, c)];
          const int32_t shifted_input1_val = input1_val * (1 << left_shift);
          const int32_t shifted_input2_val = input2_val * (1 << left_shift);
          const int32_t scaled_input1_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
            shifted_input1_val, input1_multiplier, input1_shift);
          const int32_t scaled_input2_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
            shifted_input2_val, input2_multiplier, input2_shift);
 
          const int output_data_offset =
            ((b * dims.output_shape.dims(1) + y) * dims.output_shape.dims(2) + x) *
              dims.output_shape.dims(3) +
            c;
          output_data[output_data_offset] = F(scaled_input1_val, scaled_input2_val);
        }
      }
    }
  }
}

References onert_micro::core::ComparisonParams::input1_multiplier, onert_micro::core::ComparisonParams::input1_offset, onert_micro::core::ComparisonParams::input1_shift, onert_micro::core::ComparisonParams::input2_multiplier, onert_micro::core::ComparisonParams::input2_offset, onert_micro::core::ComparisonParams::input2_shift, onert_micro::core::ComparisonParams::left_shift, multiplyByQuantizedMultiplierSmallerThanOneExp(), and subscriptToIndex().

BroadcastDiv4DSlow()

template<typename T >

OMStatus onert_micro::execute::pal::BroadcastDiv4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 39 of file PALDivCommon.h.

{
  BroadcastArithmeticOp4DSlow<T, DivFn<T>>(params, input1_shape, input1_data, input2_shape,
                                           input2_data, output_shape, output_data);
  return Ok;
}

References onert_micro::Ok, and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleDiv().

BroadcastFloorDiv4DSlow()

void onert_micro::execute::pal::BroadcastFloorDiv4DSlow ( const core::OMRuntimeShape &  input1_shape, const float *  input1_data, const core::OMRuntimeShape &  input2_shape, const float *  input2_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 40 of file PALFloorDivCommon.h.

{
  BroadcastBinaryOp4DSlow<float, FloorDivFn<float>>(input1_shape, input1_data, input2_shape,
                                                    input2_data, output_shape, output_data);
}

References output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleFloorDiv().

BroadcastFloorMod4DSlow()

void onert_micro::execute::pal::BroadcastFloorMod4DSlow ( const core::OMRuntimeShape &  input1_shape, const float *  input1_data, const core::OMRuntimeShape &  input2_shape, const float *  input2_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 40 of file PALFloorModCommon.h.

{
  BroadcastBinaryOp4DSlow<float, FloorModFn<float>>(input1_shape, input1_data, input2_shape,
                                                    input2_data, output_shape, output_data);
}

References output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleFloorMod().

BroadcastInput1()

template<typename T >

void onert_micro::execute::pal::BroadcastInput1	(	int	size,
		const core::ArithmeticQuantParams &	params,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data,
		T(*)(T, T, const core::ArithmeticQuantParams &)	binary_func
	)

Definition at line 241 of file PALArithmeticOpCommon.h.

{
  for (int i = 0; i < size; ++i)
  {
    output_data[i] = binary_func(input1_data[0], input2_data[i], params);
  }
}

References size.

BroadcastInput2()

template<typename T >

void onert_micro::execute::pal::BroadcastInput2	(	int	size,
		const core::ArithmeticQuantParams &	params,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data,
		T(*)(T, T, const core::ArithmeticQuantParams &)	binary_func
	)

Definition at line 252 of file PALArithmeticOpCommon.h.

{
  for (int i = 0; i < size; ++i)
  {
    output_data[i] = binary_func(input1_data[i], input2_data[0], params);
  }
}

References size.

BroadcastMaximum4DSlow()

OMStatus onert_micro::execute::pal::BroadcastMaximum4DSlow ( const core::OMRuntimeShape &  input1_shape, const float *  input1_data, const core::OMRuntimeShape &  input2_shape, const float *  input2_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 38 of file PALMaximumCommon.h.

{
  return BroadcastBinaryOp4DSlow<float, MaximumFn<float>>(input1_shape, input1_data, input2_shape,
                                                          input2_data, output_shape, output_data);
}

References output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleMaximum().

BroadcastMinimum4DSlow()

template<typename T >

OMStatus onert_micro::execute::pal::BroadcastMinimum4DSlow ( const core::OMRuntimeShape &  input1_shape, const T *  input1_data, const core::OMRuntimeShape &  input2_shape, const T *  input2_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 40 of file PALMinimumCommon.h.

{
  return BroadcastBinaryOp4DSlow<float, MinimumFn<float>>(input1_shape, input1_data, input2_shape,
                                                          input2_data, output_shape, output_data);
}

References output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleMinimum().

BroadcastMul4DSlow()

template<typename T >

OMStatus onert_micro::execute::pal::BroadcastMul4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 44 of file PALMulCommon.h.

{
  BroadcastArithmeticOp4DSlow<T, MulFn<T>>(params, input1_shape, input1_data, input2_shape,
                                           input2_data, output_shape, output_data);
  return Ok;
}

References onert_micro::Ok, and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleMul().

BroadcastMul6DSlow()

template<typename T >

OMStatus onert_micro::execute::pal::BroadcastMul6DSlow	(	const core::ArithmeticQuantParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 55 of file PALMulCommon.h.

{
  NdArrayDesc<kMaxMulBroadcastDim> desc1{};
  NdArrayDesc<kMaxMulBroadcastDim> desc2{};
  // The input shapes are extended as part of NdArrayDesc initialization.
  NdArrayDescsForElementwiseBroadcast(input1_shape, input2_shape, &desc1, &desc2);
  const core::OMRuntimeShape extended_output_shape =
    core::OMRuntimeShape::extendedShape(kMaxMulBroadcastDim, output_shape);
  // Cache output shape dimensions.
  int32_t extended_output_shape_dims[kMaxMulBroadcastDim];
  std::memcpy(extended_output_shape_dims, extended_output_shape.dimsData(),
              sizeof(extended_output_shape_dims));
 
  size_t input1_offset_a = 0;
  size_t input2_offset_a = 0;
  size_t output_offset_a = 0;
  for (int a = 0; a < extended_output_shape_dims[0]; ++a)
  {
    size_t input1_offset_d = input1_offset_a;
    size_t input2_offset_d = input2_offset_a;
    size_t output_offset_d = output_offset_a;
    for (int d = 0; d < extended_output_shape_dims[1]; ++d)
    {
      size_t input1_offset_b = input1_offset_d;
      size_t input2_offset_b = input2_offset_d;
      size_t output_offset_b = output_offset_d;
      for (int b = 0; b < extended_output_shape_dims[2]; ++b)
      {
        size_t input1_offset_y = input1_offset_b;
        size_t input2_offset_y = input2_offset_b;
        size_t output_offset_y = output_offset_b;
        for (int y = 0; y < extended_output_shape_dims[3]; ++y)
        {
          size_t input1_offset_x = input1_offset_y;
          size_t input2_offset_x = input2_offset_y;
          size_t output_offset_x = output_offset_y;
          for (int x = 0; x < extended_output_shape_dims[4]; ++x)
          {
            size_t input1_offset_c = input1_offset_x;
            size_t input2_offset_c = input2_offset_x;
            size_t output_offset_c = output_offset_x;
            for (int c = 0; c < extended_output_shape_dims[5]; ++c)
            {
              const int32_t input1_val = params.input1_offset + input1_data[input1_offset_c];
              const int32_t input2_val = params.input2_offset + input2_data[input2_offset_c];
              const int32_t unclamped_result =
                params.output_offset + multiplyByQuantizedMultiplier(input1_val * input2_val,
                                                                     params.output_multiplier,
                                                                     params.output_shift);
              const int32_t clamped_output =
                std::min(params.quantized_activation_max,
                         std::max(params.quantized_activation_min, unclamped_result));
              output_data[output_offset_c] = static_cast<T>(clamped_output);
              input1_offset_c += desc1.strides[5];
              input2_offset_c += desc2.strides[5];
              ++output_offset_c;
            }
            input1_offset_x += desc1.strides[4];
            input2_offset_x += desc2.strides[4];
            output_offset_x += extended_output_shape_dims[5];
          }
          input1_offset_y += desc1.strides[3];
          input2_offset_y += desc2.strides[3];
          output_offset_y += extended_output_shape_dims[4] * extended_output_shape_dims[5];
        }
        input1_offset_b += desc1.strides[2];
        input2_offset_b += desc2.strides[2];
        output_offset_b += extended_output_shape_dims[3] * extended_output_shape_dims[4] *
                           extended_output_shape_dims[5];
      }
      input1_offset_d += desc1.strides[1];
      input2_offset_d += desc2.strides[1];
      output_offset_d += extended_output_shape_dims[2] * extended_output_shape_dims[3] *
                         extended_output_shape_dims[4] * extended_output_shape_dims[5];
    }
    input1_offset_a += desc1.strides[0];
    input2_offset_a += desc2.strides[0];
    output_offset_a += extended_output_shape_dims[1] * extended_output_shape_dims[2] *
                       extended_output_shape_dims[3] * extended_output_shape_dims[4] *
                       extended_output_shape_dims[5];
  }
  return Ok;
}

References desc1, desc2, onert_micro::core::OMRuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::core::ArithmeticQuantParams::input1_offset, onert_micro::core::ArithmeticQuantParams::input2_offset, multiplyByQuantizedMultiplier(), NdArrayDescsForElementwiseBroadcast(), onert_micro::Ok, onert_micro::core::ArithmeticQuantParams::output_multiplier, onert_micro::core::ArithmeticQuantParams::output_offset, output_shape, onert_micro::core::ArithmeticQuantParams::output_shift, onert_micro::core::ArithmeticQuantParams::quantized_activation_max, and onert_micro::core::ArithmeticQuantParams::quantized_activation_min.

Referenced by onert_micro::execute::execute_kernel_CircleMul().

BroadcastRecursiveDimensions()

template<typename T >

void onert_micro::execute::pal::BroadcastRecursiveDimensions	(	const core::ArithmeticQuantParams &	params,
		int	dimension,
		size_t *	input1_offset_p,
		size_t *	input2_offset_p,
		size_t *	output_offset,
		size_t *	compressed_input1_stride,
		size_t *	compressed_input2_stride,
		size_t *	compressed_output_shape,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data,
		T(*)(T, T, const core::ArithmeticQuantParams &)	binary_func
	)

Definition at line 263 of file PALArithmeticOpCommon.h.

{
  if (dimension > 0)
  {
    for (size_t c = 0; c < compressed_output_shape[dimension]; ++c)
    {
      size_t input1_offset_c = *input1_offset_p;
      size_t input2_offset_c = *input2_offset_p;
      BroadcastRecursiveDimensions(params, dimension - 1, &input1_offset_c, &input2_offset_c,
                                   output_offset, compressed_input1_stride,
                                   compressed_input2_stride, compressed_output_shape, input1_data,
                                   input2_data, output_data, binary_func);
      *input1_offset_p += compressed_input1_stride[dimension];
      *input2_offset_p += compressed_input2_stride[dimension];
    }
  }
  else
  {
    assert(dimension == 0);
    bool input1_is_broadcast = compressed_input1_stride[dimension] == 0;
    bool input2_is_broadcast = compressed_input2_stride[dimension] == 0;
    assert(!(input1_is_broadcast && input2_is_broadcast));
    const T *input1_data_ptr = input1_data + *input1_offset_p;
    const T *input2_data_ptr = input2_data + *input2_offset_p;
    T *output_data_ptr = output_data + *output_offset;
    if (input1_is_broadcast)
    {
      // input1 is broadcast.
      BroadcastInput1<T>(compressed_output_shape[dimension], params, input1_data_ptr,
                         input2_data_ptr, output_data_ptr, binary_func);
      *input2_offset_p += compressed_output_shape[dimension];
    }
    else if (input2_is_broadcast)
    {
      // input2 is broadcast.
      BroadcastInput2<T>(compressed_output_shape[dimension], params, input1_data_ptr,
                         input2_data_ptr, output_data_ptr, binary_func);
      *input1_offset_p += compressed_output_shape[dimension];
    }
    else
    {
      // Add element-wise.
      ElementWise<T>(compressed_output_shape[dimension], params, input1_data_ptr, input2_data_ptr,
                     output_data_ptr, binary_func);
      *input1_offset_p += compressed_output_shape[dimension];
      *input2_offset_p += compressed_output_shape[dimension];
    }
    *output_offset += compressed_output_shape[dimension];
  }
}

References BroadcastRecursiveDimensions().

Referenced by BroadcastBinaryFunction6DSlow(), and BroadcastRecursiveDimensions().

BroadcastSquaredDifference4DSlow()

template<typename T >

OMStatus onert_micro::execute::pal::BroadcastSquaredDifference4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 38 of file PALSquaredDifferenceCommon.h.

{
  BroadcastArithmeticOp4DSlow<T, SquaredDifferenceFn<T>>(
    params, input1_shape, input1_data, input2_shape, input2_data, output_shape, output_data);
  return Ok;
}

References onert_micro::Ok, and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleSquaredDifference().

BroadcastSub4DSlow() [1/2]

OMStatus onert_micro::execute::pal::BroadcastSub4DSlow	(	const core::ArithmeticQuantParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const int8_t *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const int8_t *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		int8_t *	output_data
	)

Definition at line 67 of file PALSubCommon.h.

{
  BroadcastBinaryFunction6DSlow(params, input1_shape, input1_data, input2_shape, input2_data,
                                output_shape, output_data, SubFunc);
  return Ok;
}

References BroadcastBinaryFunction6DSlow(), onert_micro::Ok, output_shape, and SubFunc().

BroadcastSub4DSlow() [2/2]

template<typename T >

OMStatus onert_micro::execute::pal::BroadcastSub4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 57 of file PALSubCommon.h.

{
  BroadcastArithmeticOp4DSlow<T, SubFn<T>>(params, input1_shape, input1_data, input2_shape,
                                           input2_data, output_shape, output_data);
  return Ok;
}

References onert_micro::Ok, and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleSub().

Cast()

template<typename FromT , typename ToT >

OMStatus onert_micro::execute::pal::Cast ( const core::OMRuntimeShape &  input_shape, const FromT *  input_data, const core::OMRuntimeShape &  output_shape, ToT *  output_data  )

inline

Definition at line 34 of file PALCast.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = static_cast<ToT>(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleCast().

Ceil()

template<typename T >

OMStatus onert_micro::execute::pal::Ceil ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALCeil.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::ceil(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleCeil().

ComparisonNoScaling()

template<typename T >

void onert_micro::execute::pal::ComparisonNoScaling ( const int64_t  flat_size, const T *  input1_data, const T *  input2_data, bool *  output_data, bool   FT, T  )

inline

Definition at line 65 of file PALComparisons.h.

{
  for (int64_t i = 0; i < flat_size; ++i)
  {
    output_data[i] = F(input1_data[i], input2_data[i]);
  }
}

ComparisonWithScaling()

template<typename T , typename AccType >

void onert_micro::execute::pal::ComparisonWithScaling ( const core::ComparisonParams &  op_params, const int64_t  flat_size, const T *  input1_data, const T *  input2_data, bool *  output_data, bool   FAccType, AccType  )

inline

Definition at line 122 of file PALComparisons.h.

{
  int left_shift = op_params.left_shift;
  int32_t input1_offset = op_params.input1_offset;
  int32_t input1_multiplier = op_params.input1_multiplier;
  int input1_shift = op_params.input1_shift;
  int32_t input2_offset = op_params.input2_offset;
  int32_t input2_multiplier = op_params.input2_multiplier;
  int input2_shift = op_params.input2_shift;
 
  for (int64_t i = 0; i < flat_size; ++i)
  {
    const int32_t input1_val = input1_offset + input1_data[i];
    const int32_t input2_val = input2_offset + input2_data[i];
    const int32_t shifted_input1_val = input1_val * (1 << left_shift);
    const int32_t shifted_input2_val = input2_val * (1 << left_shift);
    const int32_t scaled_input1_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
      shifted_input1_val, input1_multiplier, input1_shift);
    const int32_t scaled_input2_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
      shifted_input2_val, input2_multiplier, input2_shift);
    output_data[i] = F(scaled_input1_val, scaled_input2_val);
  }
}

References onert_micro::core::ComparisonParams::input1_multiplier, onert_micro::core::ComparisonParams::input1_offset, onert_micro::core::ComparisonParams::input1_shift, onert_micro::core::ComparisonParams::input2_multiplier, onert_micro::core::ComparisonParams::input2_offset, onert_micro::core::ComparisonParams::input2_shift, onert_micro::core::ComparisonParams::left_shift, and multiplyByQuantizedMultiplierSmallerThanOneExp().

Concatenation()

template<typename Scalar >

OMStatus onert_micro::execute::pal::Concatenation	(	core::ConcatenationParams &	params,
		std::vector< uint32_t > &	input_shapes,
		std::vector< const Scalar * > &	input_data,
		const core::OMRuntimeShape &	output_shape,
		Scalar *	output_data
	)

Definition at line 30 of file PALConcatenation.h.

{
  int axis = params.axis;
  int inputs_count = params.num_inputs;
  const int concat_dimensions = output_shape.dimensionsCount();
 
  int64_t concat_size = 0;
  for (int i = 0; i < inputs_count; i++)
  {
    concat_size += input_shapes[i];
  }
  int64_t outer_size = 1;
  for (int i = 0; i < axis; ++i)
  {
    outer_size *= output_shape.dims(i);
  }
  // For all input arrays,
  int64_t base_inner_size = 1;
  for (int i = axis + 1; i < concat_dimensions; ++i)
  {
    base_inner_size *= output_shape.dims(i);
  }
 
  Scalar *output_ptr = output_data;
  for (int k = 0; k < outer_size; k++)
  {
    for (int i = 0; i < inputs_count; ++i)
    {
      const int copy_size = input_shapes[i] * base_inner_size;
      const Scalar *input_ptr = input_data[i] + k * copy_size;
      memcpy(output_ptr, input_ptr, copy_size * sizeof(Scalar));
      output_ptr += copy_size;
    }
  }
 
  return Ok;
}

References onert_micro::core::ConcatenationParams::axis, luci_interpreter::RuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::ConcatenationParams::num_inputs, onert_micro::Ok, and output_shape.

ConvFloat()

OMStatus onert_micro::execute::pal::ConvFloat	(	const core::FloatConv2D *	params,
		const core::OMRuntimeShape &	input_shape,
		const float *	input_data,
		const core::OMRuntimeShape &	filter_shape,
		const float *	filter_data,
		const float *	bias_data,
		const core::OMRuntimeShape &	output_shape,
		float *	output_data
	)

Definition at line 31 of file PALConv2DCommon.h.

{
  const int stride_width = params->stride_w;
  const int stride_height = params->stride_h;
  const int dilation_width_factor = params->dilation_width_factor;
  const int dilation_height_factor = params->dilation_height_factor;
  const int pad_width = params->pad_w;
  const int pad_height = params->pad_h;
  const float output_activation_min = params->activation_min;
  const float output_activation_max = params->activation_max;
 
  const auto batches = input_shape.dims(0);
  const int input_height = input_shape.dims(1);
  const int input_width = input_shape.dims(2);
  const int input_depth = input_shape.dims(3);
  const int output_depth = filter_shape.dims(0);
  const int filter_height = filter_shape.dims(1);
  const int filter_width = filter_shape.dims(2);
  const int output_height = output_shape.dims(1);
  const int output_width = output_shape.dims(2);
  for (int batch = 0; batch < batches; ++batch)
  {
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      const int in_y_origin = (out_y * stride_height) - pad_height;
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        const int in_x_origin = (out_x * stride_width) - pad_width;
        for (int out_channel = 0; out_channel < output_depth; ++out_channel)
        {
          float total = 0.f;
          for (int filter_y = 0; filter_y < filter_height; ++filter_y)
          {
            const int in_y = in_y_origin + dilation_height_factor * filter_y;
            for (int filter_x = 0; filter_x < filter_width; ++filter_x)
            {
              const int in_x = in_x_origin + dilation_width_factor * filter_x;
 
              // Zero padding by omitting the areas outside the image.
              const bool is_point_inside_image =
                (in_x >= 0) && (in_x < input_width) && (in_y >= 0) && (in_y < input_height);
 
              if (!is_point_inside_image)
              {
                continue;
              }
 
              for (int in_channel = 0; in_channel < input_depth; ++in_channel)
              {
                const int input_data_offset =
                  ((batch * input_height + in_y) * input_width + in_x) * input_depth + in_channel;
 
                const int filter_data_offset =
                  ((out_channel * filter_height + filter_y) * filter_width + filter_x) *
                    input_depth +
                  in_channel;
 
                const float input_value = input_data[input_data_offset];
                const float filter_value = filter_data[filter_data_offset];
                total += (input_value * filter_value);
              }
            }
          }
          // float bias_value = 0.0f;
          if (bias_data)
          {
            total += bias_data[out_channel];
          }
 
          const int output_data_offset =
            ((batch * output_height + out_y) * output_width + out_x) * output_depth + out_channel;
 
          output_data[output_data_offset] =
            std::min(std::max(total, output_activation_min), output_activation_max);
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::FloatConv2D::activation_max, onert_micro::core::FloatConv2D::activation_min, onert_micro::core::FloatConv2D::dilation_height_factor, onert_micro::core::FloatConv2D::dilation_width_factor, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::Ok, output_shape, onert_micro::core::FloatConv2D::pad_h, onert_micro::core::FloatConv2D::pad_w, onert_micro::core::FloatConv2D::stride_h, and onert_micro::core::FloatConv2D::stride_w.

Referenced by onert_micro::execute::execute_kernel_CircleConv2D().

ConvPerChannel()

OMStatus onert_micro::execute::pal::ConvPerChannel	(	const core::ConvQuant &	params,
		const core::OMRuntimeShape &	input_shape,
		const int8_t *	input_data,
		const core::OMRuntimeShape &	filter_shape,
		const int8_t *	filter_data,
		const int32_t *	bias_data,
		const core::OMRuntimeShape &	output_shape,
		int8_t *	output_data
	)

Definition at line 36 of file PALConv2D.h.

{
  cmsis_nn_conv_params conv_params;
  conv_params.dilation.h = params.dilation_height_factor;
  conv_params.dilation.w = params.dilation_width_factor;
 
  assert(conv_params.dilation.h == 1);
  assert(conv_params.dilation.w == 1);
 
  conv_params.input_offset = params.input_offset;
  conv_params.output_offset = params.output_offset;
  conv_params.stride.h = params.stride_height;
  conv_params.stride.w = params.stride_width;
  conv_params.padding.h = params.pad_h;
  conv_params.padding.w = params.pad_w;
  conv_params.activation.min = params.quantized_activation_min;
  conv_params.activation.max = params.quantized_activation_max;
 
  cmsis_nn_per_channel_quant_params quant_params;
  quant_params.multiplier = const_cast<int32_t *>(params.per_channel_output_multiplier.data());
  quant_params.shift = const_cast<int32_t *>(
    reinterpret_cast<const int32_t *>(params.per_channel_output_shift.data()));
 
  assert(conv_params.activation.min <= conv_params.activation.max);
  const int batch_size = input_shape.dims(0);
  const int input_depth = input_shape.dims(3);
  const int output_depth = filter_shape.dims(0);
 
  cmsis_nn_dims input_dims;
  input_dims.n = batch_size;
  input_dims.h = input_shape.dims(1);
  input_dims.w = input_shape.dims(2);
  input_dims.c = input_depth;
 
  cmsis_nn_dims filter_dims;
  filter_dims.n = output_depth;
  filter_dims.h = filter_shape.dims(1);
  filter_dims.w = filter_shape.dims(2);
  filter_dims.c = input_depth;
 
  cmsis_nn_dims bias_dims;
  bias_dims.n = 1;
  bias_dims.h = 1;
  bias_dims.w = 1;
  bias_dims.c = output_depth;
 
  cmsis_nn_dims output_dims;
  output_dims.n = batch_size;
  output_dims.h = output_shape.dims(1);
  output_dims.w = output_shape.dims(2);
  output_dims.c = output_depth;
 
  auto buf_size =
    arm_convolve_wrapper_s8_get_buffer_size(&conv_params, &input_dims, &filter_dims, &output_dims);
 
  auto buffer = std::make_unique<int8_t[]>(buf_size);
  assert(buffer != nullptr);
 
  cmsis_nn_context ctx;
  ctx.buf = buffer.get();
  ctx.size = buf_size;
 
  auto res = arm_convolve_wrapper_s8(&ctx, &conv_params, &quant_params, &input_dims, input_data,
                                     &filter_dims, filter_data, &bias_dims, bias_data, &output_dims,
                                     output_data);
 
  assert(res == ARM_CMSIS_NN_SUCCESS);
  if (res != ARM_CMSIS_NN_SUCCESS)
    return CmsisNNError;
  return Ok;
}

References onert_micro::CmsisNNError, onert_micro::core::ConvQuant::dilation_height_factor, onert_micro::core::ConvQuant::dilation_width_factor, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::ConvQuant::input_offset, onert_micro::Ok, onert_micro::core::ConvQuant::output_offset, output_shape, onert_micro::core::ConvQuant::pad_h, onert_micro::core::ConvQuant::pad_w, onert_micro::core::ConvQuant::per_channel_output_multiplier, onert_micro::core::ConvQuant::per_channel_output_shift, onert_micro::core::ConvQuant::quantized_activation_max, onert_micro::core::ConvQuant::quantized_activation_min, onert_micro::core::ConvQuant::stride_height, and onert_micro::core::ConvQuant::stride_width.

Referenced by onert_micro::execute::execute_kernel_CircleConv2D().

copyDimsToDesc()

template<int N>

void onert_micro::execute::pal::copyDimsToDesc ( const core::OMRuntimeShape &  input_shape, NdArrayDesc< N > *  desc_out  )

inline

Definition at line 53 of file ProcessBroadcastShapes.h.

{
  int desc_stride = 1;
  for (int i = N - 1; i >= 0; --i)
  {
    desc_out->extents[i] = input_shape.dims(i);
    desc_out->strides[i] = desc_stride;
    desc_stride *= input_shape.dims(i);
  }
}

References onert_micro::core::OMRuntimeShape::dims(), onert_micro::execute::pal::NdArrayDesc< N >::extents, and onert_micro::execute::pal::NdArrayDesc< N >::strides.

Referenced by TransposeImpl().

Cos()

template<typename T >

OMStatus onert_micro::execute::pal::Cos ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALCosCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::cos(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleCos().

DepthwiseConv2D()

template<typename T >

OMStatus onert_micro::execute::pal::DepthwiseConv2D ( const core::FloatConv2D *  params, const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  filter_shape, const T *  filter_data, const T *  bias_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALDepthwiseConv2DCommon.h.

{
  assert(false && "Not IMPL yet");
}

DepthwiseConv2D< float >()

template<>

OMStatus onert_micro::execute::pal::DepthwiseConv2D< float > ( const core::FloatConv2D *  params, const core::OMRuntimeShape &  input_shape, const float *  input_data, const core::OMRuntimeShape &  filter_shape, const float *  filter_data, const float *  bias_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 41 of file PALDepthwiseConv2DCommon.h.

{
  const int stride_width = params->stride_w;
  const int stride_height = params->stride_h;
  const int dilation_width_factor = params->dilation_width_factor;
  const int dilation_height_factor = params->dilation_height_factor;
  const int pad_width = params->pad_w;
  const int pad_height = params->pad_h;
  const int depth_multiplier = params->depth_multiplier;
  const float output_activation_min = params->activation_min;
  const float output_activation_max = params->activation_max;
 
  const auto batches = input_shape.dims(0);
  const int input_height = input_shape.dims(1);
  const int input_width = input_shape.dims(2);
  const int input_depth = input_shape.dims(3);
  const int output_depth = filter_shape.dims(0);
  const int filter_height = filter_shape.dims(1);
  const int filter_width = filter_shape.dims(2);
  const int output_height = output_shape.dims(1);
  const int output_width = output_shape.dims(2);
  for (int b = 0; b < batches; ++b)
  {
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        for (int ic = 0; ic < input_depth; ++ic)
        {
          for (int m = 0; m < depth_multiplier; m++)
          {
            const int oc = m + ic * depth_multiplier;
            const int in_x_origin = (out_x * stride_width) - pad_width;
            const int in_y_origin = (out_y * stride_height) - pad_height;
            float total = 0.f;
            for (int filter_y = 0; filter_y < filter_height; ++filter_y)
            {
              for (int filter_x = 0; filter_x < filter_width; ++filter_x)
              {
                const int in_x = in_x_origin + dilation_width_factor * filter_x;
                const int in_y = in_y_origin + dilation_height_factor * filter_y;
                // If the location is outside the bounds of the input image,
                // use zero as a default value.
                if ((in_x >= 0) && (in_x < input_width) && (in_y >= 0) && (in_y < input_height))
                {
                  float input_value = input_data[offset(input_shape.dimsData(), b, in_y, in_x, ic)];
                  float filter_value =
                    filter_data[offset(filter_shape.dimsData(), 0, filter_y, filter_x, oc)];
                  total += (input_value * filter_value);
                }
              }
            }
            float bias_value = 0.0f;
            if (bias_data)
            {
              bias_value = bias_data[oc];
            }
            output_data[offset(output_shape.dimsData(), b, out_y, out_x, oc)] =
              activationFunctionWithMinMax(total + bias_value, output_activation_min,
                                           output_activation_max);
          }
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::FloatConv2D::activation_max, onert_micro::core::FloatConv2D::activation_min, activationFunctionWithMinMax(), onert_micro::core::FloatConv2D::depth_multiplier, onert_micro::core::FloatConv2D::dilation_height_factor, onert_micro::core::FloatConv2D::dilation_width_factor, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::dimsData(), m, offset(), onert_micro::Ok, output_shape, onert_micro::core::FloatConv2D::pad_h, onert_micro::core::FloatConv2D::pad_w, onert_micro::core::FloatConv2D::stride_h, and onert_micro::core::FloatConv2D::stride_w.

Referenced by onert_micro::execute::execute_kernel_CircleDepthwiseConv2D().

DepthwiseConvPerChannel()

OMStatus onert_micro::execute::pal::DepthwiseConvPerChannel	(	const core::ConvQuant &	params,
		const core::OMRuntimeShape &	input_shape,
		const int8_t *	input_data,
		const core::OMRuntimeShape &	filter_shape,
		const int8_t *	filter_data,
		const int32_t *	bias_data,
		const core::OMRuntimeShape &	output_shape,
		int8_t *	output_data
	)

Definition at line 36 of file PALDepthwiseConv2D.h.

{
  cmsis_nn_dw_conv_params conv_params;
  conv_params.dilation.h = params.dilation_height_factor;
  conv_params.dilation.w = params.dilation_width_factor;
 
  assert(conv_params.dilation.h == 1);
  assert(conv_params.dilation.w == 1);
 
  conv_params.input_offset = params.input_offset;
  conv_params.output_offset = params.output_offset;
  conv_params.stride.h = params.stride_height;
  conv_params.stride.w = params.stride_width;
  conv_params.padding.h = params.pad_h;
  conv_params.padding.w = params.pad_w;
  conv_params.activation.min = params.quantized_activation_min;
  conv_params.activation.max = params.quantized_activation_max;
  conv_params.ch_mult = params.depth_multiplier;
 
  cmsis_nn_per_channel_quant_params quant_params;
  quant_params.multiplier = const_cast<int32_t *>(params.per_channel_output_multiplier.data());
  quant_params.shift = const_cast<int32_t *>(
    reinterpret_cast<const int32_t *>(params.per_channel_output_shift.data()));
 
  assert(conv_params.activation.min <= conv_params.activation.max);
  const int batch_size = input_shape.dims(0);
  const int input_depth = input_shape.dims(3);
  const int output_depth = filter_shape.dims(0);
 
  cmsis_nn_dims input_dims;
  input_dims.n = batch_size;
  input_dims.h = input_shape.dims(1);
  input_dims.w = input_shape.dims(2);
  input_dims.c = input_depth;
 
  cmsis_nn_dims filter_dims;
  filter_dims.n = output_depth;
  filter_dims.h = filter_shape.dims(1);
  filter_dims.w = filter_shape.dims(2);
  filter_dims.c = input_depth;
 
  cmsis_nn_dims bias_dims;
  bias_dims.n = 1;
  bias_dims.h = 1;
  bias_dims.w = 1;
  bias_dims.c = output_depth;
 
  cmsis_nn_dims output_dims;
  output_dims.n = batch_size;
  output_dims.h = output_shape.dims(1);
  output_dims.w = output_shape.dims(2);
  output_dims.c = output_depth;
 
  auto buf_size = arm_depthwise_conv_wrapper_s8_get_buffer_size(&conv_params, &input_dims,
                                                                &filter_dims, &output_dims);
 
  auto buffer = std::make_unique<int8_t[]>(buf_size);
  assert(buffer != nullptr);
 
  cmsis_nn_context ctx;
  ctx.buf = buffer.get();
  ctx.size = buf_size;
 
  auto res = arm_depthwise_conv_wrapper_s8(&ctx, &conv_params, &quant_params, &input_dims,
                                           input_data, &filter_dims, filter_data, &bias_dims,
                                           bias_data, &output_dims, output_data);
 
  assert(res == ARM_CMSIS_NN_SUCCESS);
  if (res != ARM_CMSIS_NN_SUCCESS)
    return CmsisNNError;
  return Ok;
}

References onert_micro::CmsisNNError, onert_micro::core::ConvQuant::depth_multiplier, onert_micro::core::ConvQuant::dilation_height_factor, onert_micro::core::ConvQuant::dilation_width_factor, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::ConvQuant::input_offset, onert_micro::Ok, onert_micro::core::ConvQuant::output_offset, output_shape, onert_micro::core::ConvQuant::pad_h, onert_micro::core::ConvQuant::pad_w, onert_micro::core::ConvQuant::per_channel_output_multiplier, onert_micro::core::ConvQuant::per_channel_output_shift, onert_micro::core::ConvQuant::quantized_activation_max, onert_micro::core::ConvQuant::quantized_activation_min, onert_micro::core::ConvQuant::stride_height, and onert_micro::core::ConvQuant::stride_width.

Referenced by onert_micro::execute::execute_kernel_CircleDepthwiseConv2D().

Dequantize()

template<typename InputT , typename OutputT >

OMStatus onert_micro::execute::pal::Dequantize	(	const core::QuantizationParams	op_params,
		const uint32_t	flat_size,
		const InputT *	input_data,
		OutputT *	output_data
	)

Definition at line 35 of file PALDequantize.h.

{
  const int32_t zero_point = op_params.zero_point;
  const double scale = op_params.scale;
 
  for (uint32_t i = 0; i < flat_size; i++)
  {
    const int32_t val = input_data[i];
    const auto result = static_cast<OutputT>(scale * (val - zero_point));
    output_data[i] = result;
  }
  return Ok;
}

References onert_micro::Ok, onert_micro::core::QuantizationParams::scale, and onert_micro::core::QuantizationParams::zero_point.

Referenced by onert_micro::execute::execute_kernel_CircleDequantize().

Div()

template<typename T >

OMStatus onert_micro::execute::pal::Div	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data
	)

Definition at line 31 of file PALDivCommon.h.

{
  ArithmeticOp<T, DivFn<T>>(params, flat_size, input1_data, input2_data, output_data);
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_kernel_CircleDiv().

ElementWise()

template<typename T >

void onert_micro::execute::pal::ElementWise	(	const uint32_t	size,
		const core::ArithmeticQuantParams &	params,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data,
		T(*)(T, T, const core::ArithmeticQuantParams &)	binary_func
	)

Definition at line 100 of file PALArithmeticOpCommon.h.

{
  for (int i = 0; i < size; ++i)
  {
    output_data[i] = binary_func(input1_data[i], input2_data[i], params);
  }
}

References size.

Referenced by Sub().

Elu()

OMStatus onert_micro::execute::pal::Elu ( const int  flat_size, const float *  input_data, float *  output_data  )

inline

Definition at line 32 of file PALElu.h.

{
  for (int i = 0; i < flat_size; i++)
  {
    float val = input_data[i];
    float result = val < 0.0f ? std::exp(val) - 1 : val;
    output_data[i] = result;
  }
 
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_kernel_CircleElu().

EqualFn()

template<typename T >

bool onert_micro::execute::pal::EqualFn ( T  lhs, T  rhs  )

inline

Definition at line 59 of file PALComparisons.h.

{ return lhs == rhs; }

Referenced by onert_micro::execute::execute_kernel_CircleEqual().

Exp()

template<typename T >

OMStatus onert_micro::execute::pal::Exp ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALExpCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::exp(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleExp().

Fill()

template<typename T >

OMStatus onert_micro::execute::pal::Fill ( const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 32 of file PALFill.h.

{
  const uint32_t flat_size = output_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  for (int i = 0; i < flat_size; ++i)
  {
    output_data[i] = input_data[0];
  }
 
  return Ok;
}

References luci_interpreter::RuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleFill().

flatSizeSkipDim()

int onert_micro::execute::pal::flatSizeSkipDim ( const int32_t *  dims_data, int  skip_dim, int  num_dims  )

inline

Definition at line 210 of file PALUtils.h.

{
  int flat_size = 1;
  for (int i = 0; i < num_dims; ++i)
  {
    flat_size *= (i == skip_dim) ? 1 : dims_data[i];
  }
  return flat_size;
}

Referenced by onert_micro::execute::execute_kernel_CircleL2Normalize(), FullyConnected(), FullyConnected(), FullyConnected(), and FullyConnected< int8_t >().

Floor()

template<typename T >

OMStatus onert_micro::execute::pal::Floor ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 33 of file PALFloorCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  // check that input and output dimensions are equal
  int N = input_shape.dimensionsCount();
  assert(N == output_shape.dimensionsCount());
 
  // check that sizes of all dimensions are equal
  for (int i = 0; i < N; ++i)
  {
    assert(input_shape.dims(i) == output_shape.dims(i));
  }
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::floor(input_data[i]);
  }
 
  return Ok;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleFloor().

FloorDiv()

void onert_micro::execute::pal::FloorDiv ( const int  flat_size, const float *  input1_data, const float *  input2_data, float *  output_data  )

inline

Definition at line 32 of file PALFloorDivCommon.h.

{
  BinaryOp<float, FloorDivFn<float>>(flat_size, input1_data, input2_data, output_data);
}

Referenced by onert_micro::execute::execute_kernel_CircleFloorDiv().

FloorMod()

void onert_micro::execute::pal::FloorMod ( const int  flat_size, const float *  input1_data, const float *  input2_data, float *  output_data  )

inline

Definition at line 32 of file PALFloorModCommon.h.

{
  BinaryOp<float, FloorModFn<float>>(flat_size, input1_data, input2_data, output_data);
}

Referenced by onert_micro::execute::execute_kernel_CircleFloorMod().

FullyConnected() [1/3]

template<typename WeightType >

OMStatus onert_micro::execute::pal::FullyConnected ( const core::FullyConnectedParams &  params, const float *  input_data, const core::OMRuntimeShape &  filter_shape, const WeightType *  filter_data, const float *  bias_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 80 of file PALFullyConnectedCommon.h.

{
  const float output_activation_min = params.float_activation_min;
  const float output_activation_max = params.float_activation_max;
 
  const int batches = flatSizeSkipDim(output_shape.dimsData(), output_shape.dimensionsCount() - 1,
                                      output_shape.dimensionsCount());
  const int output_depth = output_shape.dims(output_shape.dimensionsCount() - 1);
  const int accum_depth = filter_shape.dims(filter_shape.dimensionsCount() - 1);
 
  for (int b = 0; b < batches; ++b)
  {
    const float *weight_scale_ptr = params.weights_scales;
    for (int out_c = 0; out_c < output_depth; ++out_c)
    {
      float total = 0.f;
      for (int d = 0; d < accum_depth; ++d)
      {
        auto input_value = input_data[b * accum_depth + d];
        if (std::is_same<WeightType, float>::value)
        {
          total += input_value * filter_data[out_c * accum_depth + d];
        }
        else
        {
          const float filter_scale = *weight_scale_ptr;
          const float filter_value =
            static_cast<float>(filter_data[out_c * accum_depth + d]) * filter_scale;
          total += input_value * filter_value;
        }
      }
      float bias_value = 0.0f;
      if (bias_data)
      {
        bias_value = bias_data[out_c];
      }
      output_data[out_c + output_depth * b] =
        std::min(std::max(total + bias_value, output_activation_min), output_activation_max);
 
      if (std::is_same<WeightType, int8_t>::value)
      {
        if (params.is_channel_wise_quant)
          weight_scale_ptr++;
      }
    }
  }
  return Ok;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), flatSizeSkipDim(), onert_micro::core::FullyConnectedParams::float_activation_max, onert_micro::core::FullyConnectedParams::float_activation_min, onert_micro::core::FullyConnectedParams::is_channel_wise_quant, onert_micro::Ok, output_shape, and onert_micro::core::FullyConnectedParams::weights_scales.

FullyConnected() [2/3]

template<typename InputType , typename WeightType , typename OutputType , typename BiasType >

OMStatus onert_micro::execute::pal::FullyConnected	(	const core::FullyConnectedParams &	params,
		const InputType *	input_data,
		const core::OMRuntimeShape &	filter_shape,
		const WeightType *	filter_data,
		const BiasType *	bias_data,
		const core::OMRuntimeShape &	output_shape,
		OutputType *	output_data
	)

Definition at line 34 of file PALFullyConnectedCommon.h.

{
  const int32_t input_offset = params.input_offset;
  const int32_t filter_offset = params.weights_offset;
  const int32_t output_offset = params.output_offset;
  const int32_t output_multiplier = params.output_multiplier;
  const int output_shift = params.output_shift;
  const int32_t output_activation_min = params.quantized_activation_min;
  const int32_t output_activation_max = params.quantized_activation_max;
 
  const int filter_dim_count = filter_shape.dimensionsCount();
  const int output_dim_count = output_shape.dimensionsCount();
  const int batches =
    flatSizeSkipDim(output_shape.dimsData(), output_dim_count - 1, output_dim_count);
  const int output_depth = output_shape.dims(output_dim_count - 1);
 
  const int accum_depth = filter_shape.dims(filter_dim_count - 1);
  for (int b = 0; b < batches; ++b)
  {
    for (int out_c = 0; out_c < output_depth; ++out_c)
    {
      BiasType acc = 0;
      for (int d = 0; d < accum_depth; ++d)
      {
        int32_t input_val = input_data[b * accum_depth + d];
        int32_t filter_val = filter_data[out_c * accum_depth + d];
        acc += (filter_val + filter_offset) * (input_val + input_offset);
      }
      if (bias_data)
      {
        acc += bias_data[out_c];
      }
      int32_t acc_scaled = multiplyByQuantizedMultiplier(acc, output_multiplier, output_shift);
      acc_scaled += output_offset;
      acc_scaled = std::max(acc_scaled, output_activation_min);
      acc_scaled = std::min(acc_scaled, output_activation_max);
      output_data[out_c + output_depth * b] = static_cast<OutputType>(acc_scaled);
    }
  }
  return Ok;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), flatSizeSkipDim(), onert_micro::core::FullyConnectedParams::input_offset, multiplyByQuantizedMultiplier(), onert_micro::Ok, onert_micro::core::FullyConnectedParams::output_multiplier, onert_micro::core::FullyConnectedParams::output_offset, output_shape, onert_micro::core::FullyConnectedParams::output_shift, onert_micro::core::FullyConnectedParams::quantized_activation_max, onert_micro::core::FullyConnectedParams::quantized_activation_min, and onert_micro::core::FullyConnectedParams::weights_offset.

FullyConnected() [3/3]

template<>

OMStatus onert_micro::execute::pal::FullyConnected	(	const core::FullyConnectedParams &	params,
		const int16_t *	input_data,
		const core::OMRuntimeShape &	filter_shape,
		const int8_t *	filter_data,
		const int64_t *	bias_data,
		const core::OMRuntimeShape &	output_shape,
		int16_t *	output_data
	)

Definition at line 98 of file PALFullyConnected.h.

{
  const int filter_dim_count = filter_shape.dimensionsCount();
  const int output_dim_count = output_shape.dimensionsCount();
  const int batches =
    flatSizeSkipDim(output_shape.dimsData(), output_dim_count - 1, output_dim_count);
  const int output_depth = output_shape.dims(output_dim_count - 1);
  const int accum_depth = filter_shape.dims(filter_dim_count - 1);
 
  cmsis_nn_fc_params fc_params;
  fc_params.input_offset = params.input_offset;
  fc_params.output_offset = params.output_offset;
  fc_params.filter_offset = params.weights_offset;
  fc_params.activation.min = params.quantized_activation_min;
  fc_params.activation.max = params.quantized_activation_max;
 
  cmsis_nn_per_tensor_quant_params quant_params;
  quant_params.multiplier = params.output_multiplier;
  quant_params.shift = params.output_shift;
 
  cmsis_nn_dims input_dims;
  input_dims.n = batches;
  input_dims.h = 1;
  input_dims.w = 1;
  input_dims.c = accum_depth;
 
  cmsis_nn_dims filter_dims;
  filter_dims.n = accum_depth;
  filter_dims.h = 1;
  filter_dims.w = 1;
  filter_dims.c = output_depth;
 
  cmsis_nn_dims bias_dims;
  bias_dims.n = 1;
  bias_dims.h = 1;
  bias_dims.w = 1;
  bias_dims.c = output_depth;
 
  cmsis_nn_dims output_dims;
  output_dims.n = batches;
  output_dims.h = 1;
  output_dims.w = 1;
  output_dims.c = output_depth;
 
  int32_t buf_size = arm_fully_connected_s16_get_buffer_size(&filter_dims);
  auto buffer = std::make_unique<int8_t[]>(buf_size);
  assert(buffer != nullptr);
 
  cmsis_nn_context ctx;
  ctx.buf = buffer.get();
  ctx.size = buf_size;
 
  auto res =
    arm_fully_connected_s16(&ctx, &fc_params, &quant_params, &input_dims, input_data, &filter_dims,
                            filter_data, &bias_dims, bias_data, &output_dims, output_data);
  assert(res == ARM_CMSIS_NN_SUCCESS);
 
  if (res != ARM_CMSIS_NN_SUCCESS)
    return CmsisNNError;
 
  return Ok;
}

References onert_micro::CmsisNNError, luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), flatSizeSkipDim(), onert_micro::core::FullyConnectedParams::input_offset, onert_micro::Ok, onert_micro::core::FullyConnectedParams::output_multiplier, onert_micro::core::FullyConnectedParams::output_offset, output_shape, onert_micro::core::FullyConnectedParams::output_shift, onert_micro::core::FullyConnectedParams::quantized_activation_max, onert_micro::core::FullyConnectedParams::quantized_activation_min, and onert_micro::core::FullyConnectedParams::weights_offset.

Referenced by onert_micro::execute::execute_kernel_CircleFullyConnected().

FullyConnected< int8_t >()

template<>

OMStatus onert_micro::execute::pal::FullyConnected< int8_t >	(	const core::FullyConnectedParams &	params,
		const int8_t *	input_data,
		const core::OMRuntimeShape &	filter_shape,
		const int8_t *	filter_data,
		const int32_t *	bias_data,
		const core::OMRuntimeShape &	output_shape,
		int8_t *	output_data
	)

Definition at line 32 of file PALFullyConnected.h.

{
  const int filter_dim_count = filter_shape.dimensionsCount();
  const int output_dim_count = output_shape.dimensionsCount();
  const int batches =
    flatSizeSkipDim(output_shape.dimsData(), output_dim_count - 1, output_dim_count);
  const int output_depth = output_shape.dims(output_dim_count - 1);
  const int accum_depth = filter_shape.dims(filter_dim_count - 1);
 
  cmsis_nn_fc_params fc_params;
  fc_params.input_offset = params.input_offset;
  fc_params.output_offset = params.output_offset;
  fc_params.filter_offset = params.weights_offset;
  fc_params.activation.min = params.quantized_activation_min;
  fc_params.activation.max = params.quantized_activation_max;
 
  cmsis_nn_per_tensor_quant_params quant_params;
  quant_params.multiplier = params.output_multiplier;
  quant_params.shift = params.output_shift;
 
  cmsis_nn_dims input_dims;
  input_dims.n = batches;
  input_dims.h = 1;
  input_dims.w = 1;
  input_dims.c = accum_depth;
 
  cmsis_nn_dims filter_dims;
  filter_dims.n = accum_depth;
  filter_dims.h = 1;
  filter_dims.w = 1;
  filter_dims.c = output_depth;
 
  cmsis_nn_dims bias_dims;
  bias_dims.n = 1;
  bias_dims.h = 1;
  bias_dims.w = 1;
  bias_dims.c = output_depth;
 
  cmsis_nn_dims output_dims;
  output_dims.n = batches;
  output_dims.h = 1;
  output_dims.w = 1;
  output_dims.c = output_depth;
 
  int32_t buf_size = arm_fully_connected_s8_get_buffer_size(&filter_dims);
  auto buffer = std::make_unique<int8_t[]>(buf_size);
  assert(buffer != nullptr);
 
  cmsis_nn_context ctx;
  ctx.buf = buffer.get();
  ctx.size = buf_size;
 
  auto res =
    arm_fully_connected_s8(&ctx, &fc_params, &quant_params, &input_dims, input_data, &filter_dims,
                           filter_data, &bias_dims, bias_data, &output_dims, output_data);
  assert(res == ARM_CMSIS_NN_SUCCESS);
  if (res != ARM_CMSIS_NN_SUCCESS)
    return CmsisNNError;
 
  return Ok;
}

References onert_micro::CmsisNNError, luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), flatSizeSkipDim(), onert_micro::core::FullyConnectedParams::input_offset, onert_micro::Ok, onert_micro::core::FullyConnectedParams::output_multiplier, onert_micro::core::FullyConnectedParams::output_offset, output_shape, onert_micro::core::FullyConnectedParams::output_shift, onert_micro::core::FullyConnectedParams::quantized_activation_max, onert_micro::core::FullyConnectedParams::quantized_activation_min, and onert_micro::core::FullyConnectedParams::weights_offset.

GatherND()

template<typename ParamsT , typename IndicesT >

OMStatus onert_micro::execute::pal::GatherND ( core::OMRuntimeShape  params_shape, const ParamsT *  param_data, core::OMRuntimeShape  indices_shape, const IndicesT *  index_data, ParamsT *  output_data  )

inline

Definition at line 35 of file PALGatherND.h.

{
  const int indices_dims = indices_shape.dimensionsCount();
  const int indices_nd = indices_shape.dims(indices_dims - 1);
  const int params_dims = params_shape.dimensionsCount();
 
  int n_slices = 1;
  for (int i = 0; i < indices_dims - 1; ++i)
  {
    n_slices *= indices_shape.dims(i);
  }
 
  // If indices[-1] == params.rank, fetch single elements.
  // If indices[-1] < params.rank, fetch slices.
  int slice_size = 1;
  for (int i = indices_nd; i < params_dims; ++i)
  {
    slice_size *= params_shape.dims(i);
  }
 
  int params_flat_size = params_shape.flatSize();
  int remain_flat_size = params_flat_size;
 
  // Number of elements per dimension
  int dims_to_count[MAX_INDICES_ND];
  for (int i = 0; i < indices_nd; ++i)
  {
    dims_to_count[i] = remain_flat_size / params_shape.dims(i);
    remain_flat_size = dims_to_count[i];
  }
 
  for (int i = 0; i < n_slices; ++i)
  {
    int from_pos = 0;
    for (int j = 0; j < indices_nd; ++j)
    {
      int offset = i * indices_nd + j;
      IndicesT index = index_data[offset];
      from_pos += index * dims_to_count[j];
    }
    if (from_pos < 0 || from_pos + slice_size > params_flat_size)
    {
      assert(false && "GatherND error");
      return UnknownError;
    }
    std::memcpy(output_data + i * slice_size, param_data + from_pos, sizeof(ParamsT) * slice_size);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::flatSize(), MAX_INDICES_ND, offset(), onert_micro::Ok, and onert_micro::UnknownError.

getActivationParams() [1/3]

template<typename P >

void onert_micro::execute::pal::getActivationParams ( const P &  params, float *  min, float *  max  )

inline

Definition at line 126 of file PALUtils.h.

{
  *min = params.float_activation_min;
  *max = params.float_activation_max;
}

getActivationParams() [2/3]

template<typename P >

void onert_micro::execute::pal::getActivationParams ( const P &  params, int32_t *  min, int32_t *  max  )

inline

Definition at line 120 of file PALUtils.h.

{
  *min = params.int32_activation_min;
  *max = params.int32_activation_max;
}

Referenced by ArithmeticOp(), ArithmeticOpScalar(), BroadcastArithmeticOp4DSlow(), QuantizedArithmeticOp(), and QuantizedBroadcastArithmeticOp4DSlow().

getActivationParams() [3/3]

template<typename P >

void onert_micro::execute::pal::getActivationParams ( const P &  params, int64_t *  min, int64_t *  max  )

inline

Definition at line 132 of file PALUtils.h.

{
  *min = params.int64_activation_min;
  *max = params.int64_activation_max;
}

getUpLowerWeightTensorDepth()

std::pair< uint32_t, uint32_t > onert_micro::execute::pal::getUpLowerWeightTensorDepth ( core::OpTrainableRankType  rank, const uint32_t  output_depth  )

inline

Definition at line 30 of file PALUtils.h.

{
  std::pair<uint32_t, uint32_t> result(0u, output_depth);
 
  switch (rank)
  {
    case core::ALL:
      break;
    case core::UP_1_2_PART:
      result.second = static_cast<uint32_t>(static_cast<float>(output_depth) / 2.f);
      break;
    case core::LOWER_1_2_PART:
      result.first = static_cast<uint32_t>(static_cast<float>(output_depth) / 2.f);
      break;
    default:
      assert("Unsupported type");
      break;
  }
 
  return result;
}

References onert_micro::core::ALL, onert_micro::core::LOWER_1_2_PART, and onert_micro::core::UP_1_2_PART.

Referenced by onert_micro::train::pal::Conv2DWeightGrad(), and onert_micro::train::pal::FullyConnectedWeightGrad().

GreaterEqualFn()

template<typename T >

bool onert_micro::execute::pal::GreaterEqualFn ( T  lhs, T  rhs  )

inline

Definition at line 61 of file PALComparisons.h.

{ return lhs >= rhs; }

Referenced by onert_micro::execute::execute_kernel_CircleGreaterEqual().

GreaterFn()

template<typename T >

bool onert_micro::execute::pal::GreaterFn ( T  lhs, T  rhs  )

inline

Definition at line 60 of file PALComparisons.h.

{ return lhs > rhs; }

Referenced by onert_micro::execute::execute_kernel_CircleGreater().

GRU()

OMStatus onert_micro::execute::pal::GRU	(	const float *	input_data,
		const float *	weight_input_data,
		const float *	weight_hidden_data,
		const float *	bias_input_data,
		const float *	bias_hidden_data,
		const float *	hidden_state_data,
		float *	output_data,
		float *	output_input_data,
		float *	output_hidden_data,
		const core::OMRuntimeShape &	input_shape,
		const core::OMRuntimeShape &	output_shape,
		const core::OMRuntimeShape &	weight_input_shape,
		const core::OMRuntimeShape &	weight_hidden_shape,
		const size_t	intermediate_buffer_size,
		float *	intermediate_buffer
	)

Definition at line 183 of file PALGRUCommon.h.

{
  const int32_t time = input_shape.dims(0);
 
  core::OMRuntimeShape output_shape_fc(2);
  output_shape_fc.setDim(0, 1);
  output_shape_fc.setDim(1, weight_hidden_shape.dims(0));
 
  std::memcpy(output_data, hidden_state_data, output_shape.flatSize() * sizeof(float));
 
  for (int i = 0; i < time; ++i)
  {
    calculateGRU(input_data, weight_input_data, weight_hidden_data, bias_input_data,
                 bias_hidden_data, output_data, input_shape, output_shape, weight_input_shape,
                 weight_hidden_shape, output_input_data, output_hidden_data, output_shape_fc,
                 intermediate_buffer);
    input_data += input_shape.dims(2);
    if (intermediate_buffer_size != 0)
    {
      assert(intermediate_buffer != nullptr);
      intermediate_buffer += intermediate_buffer_size;
    }
  }
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::core::OMRuntimeShape::setDim().

Referenced by onert_micro::execute::execute_kernel_CircleGRU().

L2Normalization()

OMStatus onert_micro::execute::pal::L2Normalization ( const core::L2NormalizationParams &  params, const float *  input_data, float *  output_data  )

inline

Definition at line 33 of file PALL2Normalize.h.

{
 
  const int outer_size = params.num_rows;
  const int depth = params.row_size;
  const int epsilon = params.epsilon;
 
  for (int i = 0; i < outer_size; ++i)
  {
    float squared_l2_norm = 0;
    for (int c = 0; c < depth; ++c)
    {
      const float val = input_data[depth * i + c];
      squared_l2_norm += val * val;
    }
    float l2_norm = std::sqrt(squared_l2_norm);
    l2_norm = std::max(l2_norm, static_cast<float>(epsilon));
    for (int c = 0; c < depth; ++c)
    {
      output_data[depth * i + c] = input_data[depth * i + c] / l2_norm;
    }
  }
 
  return Ok;
}

References onert_micro::core::L2NormalizationParams::epsilon, onert_micro::core::L2NormalizationParams::num_rows, onert_micro::Ok, and onert_micro::core::L2NormalizationParams::row_size.

Referenced by onert_micro::execute::execute_kernel_CircleL2Normalize().

L2Pool()

OMStatus onert_micro::execute::pal::L2Pool	(	const core::Pool2DParams &	params,
		const core::OMRuntimeShape &	input_shape,
		const float *	input_data,
		const core::OMRuntimeShape &	output_shape,
		float *	output_data
	)

Definition at line 34 of file PALL2Pool2DCommon.h.

{
  const int32_t batches = input_shape.dims(0);
  const int32_t depth = output_shape.dims(3);
  const int32_t input_height = input_shape.dims(1);
  const int32_t input_width = input_shape.dims(2);
  const int32_t output_height = output_shape.dims(1);
  const int32_t output_width = output_shape.dims(2);
  const int32_t stride_height = params.stride_h;
  const int32_t stride_width = params.stride_w;
  for (int batch = 0; batch < batches; ++batch)
  {
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        for (int channel = 0; channel < depth; ++channel)
        {
          const int in_x_origin = (out_x * stride_width) - params.pad_w;
          const int in_y_origin = (out_y * stride_height) - params.pad_h;
          // Compute the boundaries of the filter region clamped so as to
          // ensure that the filter window fits in the input array.
          const int filter_x_start = std::max(0, -in_x_origin);
          const int filter_x_end = std::min(params.filter_w, input_width - in_x_origin);
          const int filter_y_start = std::max(0, -in_y_origin);
          const int filter_y_end = std::min(params.filter_h, input_height - in_y_origin);
          float sum_squares = 0.f;
          int filter_count = 0;
          for (int filter_y = filter_y_start; filter_y < filter_y_end; ++filter_y)
          {
            for (int filter_x = filter_x_start; filter_x < filter_x_end; ++filter_x)
            {
              const int in_x = in_x_origin + filter_x;
              const int in_y = in_y_origin + filter_y;
              const float val =
                input_data[offset(input_shape.dimsData(), batch, in_y, in_x, channel)];
              sum_squares += val * val;
              filter_count++;
            }
          }
          assert(filter_count != 0);
          if (filter_count == 0)
          {
            std::cerr << "filter_count is zero" << std::endl;
            return FailedCheckCondition;
          }
          const float l2pool_result = std::sqrt(sum_squares / filter_count);
          output_data[offset(output_shape.dimsData(), batch, out_y, out_x, channel)] =
            activationFunctionWithMinMax(l2pool_result, params.activation_min,
                                         params.activation_max);
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::Pool2DParams::activation_max, onert_micro::core::Pool2DParams::activation_min, activationFunctionWithMinMax(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::dimsData(), onert_micro::FailedCheckCondition, onert_micro::core::Pool2DParams::filter_h, onert_micro::core::Pool2DParams::filter_w, offset(), onert_micro::Ok, output_shape, onert_micro::core::Pool2DParams::pad_h, onert_micro::core::Pool2DParams::pad_w, onert_micro::core::Pool2DParams::stride_h, and onert_micro::core::Pool2DParams::stride_w.

Referenced by onert_micro::execute::execute_kernel_CircleL2Pool2D().

LessEqualFn()

template<typename T >

bool onert_micro::execute::pal::LessEqualFn ( T  lhs, T  rhs  )

inline

Definition at line 58 of file PALComparisons.h.

{ return lhs <= rhs; }

Referenced by onert_micro::execute::execute_kernel_CircleLessEqual().

LessFn()

template<typename T >

bool onert_micro::execute::pal::LessFn ( T  lhs, T  rhs  )

inline

Definition at line 57 of file PALComparisons.h.

{ return lhs < rhs; }

Referenced by onert_micro::execute::execute_kernel_CircleLess().

Log()

template<typename T >

OMStatus onert_micro::execute::pal::Log ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALLogCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::log(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleLog().

LogicalCommon()

template<class Fn >

OMStatus onert_micro::execute::pal::LogicalCommon	(	const int	flat_size,
		const bool *	input1_data,
		const bool *	input2_data,
		bool *	output_data
	)

Definition at line 38 of file PALLogicalCommon.h.

{
  Fn func;
 
  for (int i = 0; i < flat_size; ++i)
  {
    output_data[i] = func(input1_data[i], input2_data[i]);
  }
 
  return Ok;
}

References onert_micro::Ok.

LogicalNot()

OMStatus onert_micro::execute::pal::LogicalNot	(	const int	flat_size,
		const bool *	input_data,
		bool *	output_data
	)

Definition at line 25 of file PALLogicalNotCommon.h.

{
  for (int i = 0; i < flat_size; ++i)
  {
    output_data[i] = !(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_kernel_CircleLogicalNot().

Logistic() [1/2]

OMStatus onert_micro::execute::pal::Logistic ( const int  flat_size, const float *  input_data, float *  output_data  )

inline

Definition at line 32 of file PALLogistic.h.

{
  const float cutoff_upper = 16.619047164916992188f;
  const float cutoff_lower = -9.f;
 
  // Rational for using approximation in reference kernel.
  // 0. This approximation gives enough precision for float.
  // 1. This works around an issue on an embedded chipset where exp() does not
  // return correctly as expected - exp(x) should return inf when overflown
  // not 1.701417   IEEE 754 defines representation for inf.
  // 2. This will speed up calculation and is matching the behavior in the
  // optimized kernels. (check the definition of scalar_logistic_op<float>)
 
  for (int i = 0; i < flat_size; i++)
  {
    float val = input_data[i];
    float result;
    if (val > cutoff_upper)
    {
      result = 1.0f;
    }
    else if (val < cutoff_lower)
    {
      result = std::exp(val);
    }
    else
    {
      result = 1.f / (1.f + std::exp(-val));
    }
    output_data[i] = result;
  }
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_kernel_CircleLogistic().

Logistic() [2/2]

OMStatus onert_micro::execute::pal::Logistic ( const int  flat_size, const int8_t *  input_data, float  input_scale, int  input_zero_point, int8_t *  output_data, float  output_scale, int  output_zero_point  )

inline

Definition at line 66 of file PALLogistic.h.

{
  const float cutoff_upper = 16.619047164916992188f;
  const float cutoff_lower = -9.f;
 
  // Rational for using approximation in reference kernel.
  // 0. This approximation gives enough precision for float.
  // 1. This works around an issue on an embedded chipset where exp() does not
  // return correctly as expected - exp(x) should return inf when overflown
  // not 1.701417   IEEE 754 defines representation for inf.
  // 2. This will speed up calculation and is matching the behavior in the
  // optimized kernels. (check the definition of scalar_logistic_op<float>)
 
  for (int i = 0; i < flat_size; i++)
  {
    // Dequantize.
    float val = static_cast<float>((input_data[i] - input_zero_point) * input_scale);
    float result;
    if (val > cutoff_upper)
    {
      result = 1.0f;
    }
    else if (val < cutoff_lower)
    {
      result = std::exp(val);
    }
    else
    {
      result = 1.f / (1.f + std::exp(-val));
    }
    // Requantize
    int8_t output = static_cast<int8_t>(std::round(result / output_scale) + output_zero_point);
    output_data[i] = output;
  }
  return Ok;
}

References onert_micro::Ok.

LogSoftmax()

OMStatus onert_micro::execute::pal::LogSoftmax ( const core::LogSoftmaxParams &  params, const float *  input_data, float *  output_data  )

inline

Definition at line 32 of file PALLogSoftmax.h.

{
  const int outer_size = params.num_rows;
  const int depth = params.row_size;
 
  for (int i = 0; i < outer_size; ++i)
  {
    // Find max element value which we'll use to ensure numerical stability
    // taking advantage of the following equality:
    // log(exp(x[i])/sum(exp(x[i]))) == log(exp(x[i]+C)/sum(exp(x[i]+C)))
    float max = std::numeric_limits<float>::lowest();
    for (int c = 0; c < depth; ++c)
    {
      max = std::max(max, input_data[i * depth + c]);
    }
 
    // Compute sum.
    float sum = 0.f;
    for (int c = 0; c < depth; ++c)
    {
      sum += std::exp(input_data[i * depth + c] - max);
    }
 
    // Compute result.
    const float log_sum = std::log(sum);
    for (int c = 0; c < depth; ++c)
    {
      output_data[i * depth + c] = input_data[i * depth + c] - max - log_sum;
    }
  }
 
  return Ok;
}

References onert_micro::core::LogSoftmaxParams::num_rows, onert_micro::Ok, and onert_micro::core::LogSoftmaxParams::row_size.

Referenced by onert_micro::execute::execute_kernel_CircleLogSoftmax().

MatchingDim()

int onert_micro::execute::pal::MatchingDim ( const core::OMRuntimeShape &  shape1, int  index1, const core::OMRuntimeShape &  shape2, int  index2  )

inline

Definition at line 200 of file PALUtils.h.

{
  assert(shape1.dims(index1) == shape2.dims(index2));
  return shape1.dims(index1);
}

References onert_micro::core::OMRuntimeShape::dims().

Maximum()

OMStatus onert_micro::execute::pal::Maximum ( const int  flat_size, const float *  input1_data, const float *  input2_data, float *  output_data  )

inline

Definition at line 32 of file PALMaximumCommon.h.

{
  return BinaryOp<float, MaximumFn<float>>(flat_size, input1_data, input2_data, output_data);
}

Referenced by onert_micro::execute::execute_kernel_CircleMaximum().

MaxPool() [1/2]

OMStatus onert_micro::execute::pal::MaxPool	(	const core::Pool2DParams &	params,
		const core::OMRuntimeShape &	input_shape,
		const float *	input_data,
		const core::OMRuntimeShape &	output_shape,
		float *	output_data
	)

Definition at line 32 of file PALMaxPool2DCommon.h.

{
  const int32_t batches = input_shape.dims(0);
  const int32_t depth = output_shape.dims(3);
  const int32_t input_height = input_shape.dims(1);
  const int32_t input_width = input_shape.dims(2);
  const int32_t output_height = output_shape.dims(1);
  const int32_t output_width = output_shape.dims(2);
  const int32_t stride_height = params.stride_h;
  const int32_t stride_width = params.stride_w;
  for (int batch = 0; batch < batches; ++batch)
  {
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        for (int channel = 0; channel < depth; ++channel)
        {
          const int in_x_origin = (out_x * stride_width) - params.pad_w;
          const int in_y_origin = (out_y * stride_height) - params.pad_h;
          // Compute the boundaries of the filter region clamped so as to
          // ensure that the filter window fits in the input array.
          const int filter_x_start = std::max(0, -in_x_origin);
          const int filter_x_end = std::min(params.filter_w, input_width - in_x_origin);
          const int filter_y_start = std::max(0, -in_y_origin);
          const int filter_y_end = std::min(params.filter_h, input_height - in_y_origin);
          float max = std::numeric_limits<float>::lowest();
          for (int filter_y = filter_y_start; filter_y < filter_y_end; ++filter_y)
          {
            for (int filter_x = filter_x_start; filter_x < filter_x_end; ++filter_x)
            {
              const int in_x = in_x_origin + filter_x;
              const int in_y = in_y_origin + filter_y;
 
              const int input_data_offset =
                ((batch * input_shape.dims(1) + in_y) * input_shape.dims(2) + in_x) *
                  input_shape.dims(3) +
                channel;
 
              max = std::max(max, input_data[input_data_offset]);
            }
          }
          const int output_data_offset =
            ((batch * output_shape.dims(1) + out_y) * output_shape.dims(2) + out_x) *
              output_shape.dims(3) +
            channel;
 
          output_data[output_data_offset] =
            std::min(std::max(max, params.activation_min), params.activation_max);
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::Pool2DParams::activation_max, onert_micro::core::Pool2DParams::activation_min, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::Pool2DParams::filter_h, onert_micro::core::Pool2DParams::filter_w, onert_micro::Ok, output_shape, onert_micro::core::Pool2DParams::pad_h, onert_micro::core::Pool2DParams::pad_w, onert_micro::core::Pool2DParams::stride_h, and onert_micro::core::Pool2DParams::stride_w.

MaxPool() [2/2]

OMStatus onert_micro::execute::pal::MaxPool	(	const core::Pool2DParams &	params,
		const core::OMRuntimeShape &	input_shape,
		const int8_t *	input_data,
		const core::OMRuntimeShape &	output_shape,
		int8_t *	output_data
	)

Definition at line 32 of file PALMaxPool2D.h.

{
  cmsis_nn_dims input_dims;
  cmsis_nn_dims output_dims;
  cmsis_nn_pool_params pool_params;
  cmsis_nn_dims filter_dims;
  cmsis_nn_context ctx;
 
  const int depth = input_shape.dims(3);
  const int output_width = output_shape.dims(2);
 
  input_dims.n = 1;
  input_dims.h = input_shape.dims(1);
  input_dims.w = input_shape.dims(2);
  input_dims.c = depth;
 
  output_dims.n = 1;
  output_dims.h = output_shape.dims(1);
  output_dims.w = output_width;
  output_dims.c = depth;
 
  pool_params.stride.h = params.stride_h;
  pool_params.stride.w = params.stride_w;
  pool_params.padding.h = params.pad_h;
  pool_params.padding.w = params.pad_w;
  pool_params.activation.min = params.quantized_activation_min;
  pool_params.activation.max = params.quantized_activation_max;
 
  filter_dims.n = 1;
  filter_dims.h = params.filter_h;
  filter_dims.w = params.filter_w;
  filter_dims.c = 1;
 
  auto res = arm_max_pool_s8(&ctx, &pool_params, &input_dims, input_data, &filter_dims,
                             &output_dims, output_data);
 
  assert(res == ARM_CMSIS_NN_SUCCESS);
  if (res != ARM_CMSIS_NN_SUCCESS)
    return CmsisNNError;
 
  return Ok;
}

References onert_micro::CmsisNNError, luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::Pool2DParams::filter_h, onert_micro::core::Pool2DParams::filter_w, onert_micro::Ok, output_shape, onert_micro::core::Pool2DParams::pad_h, onert_micro::core::Pool2DParams::pad_w, onert_micro::core::Pool2DParams::quantized_activation_max, onert_micro::core::Pool2DParams::quantized_activation_min, onert_micro::core::Pool2DParams::stride_h, and onert_micro::core::Pool2DParams::stride_w.

Referenced by onert_micro::execute::execute_kernel_CircleMaxPool2D().

MeanROWH()

template<typename T >

void onert_micro::execute::pal::MeanROWH ( const OMRuntimeShape &  unextended_input_shape, const T *  input_data, const OMRuntimeShape &  unextended_output_shape, T *  output_data  )

inline

Definition at line 194 of file PALReduceCommon.h.

{
  // Current implementation only supports dimension equals 4 and simultaneous
  // reduction over width and height.
  const OMRuntimeShape input_shape = OMRuntimeShape::extendedShape(4, unextended_input_shape);
  const OMRuntimeShape output_shape = OMRuntimeShape::extendedShape(4, unextended_output_shape);
 
  const int output_batch = output_shape.dims(0);
  const int output_depth = output_shape.dims(3);
 
  const int input_height = input_shape.dims(1);
  const int input_width = input_shape.dims(2);
 
  for (int out_b = 0; out_b < output_batch; ++out_b)
  {
    for (int out_d = 0; out_d < output_depth; ++out_d)
    {
      float value = 0;
      for (int in_h = 0; in_h < input_height; ++in_h)
      {
        for (int in_w = 0; in_w < input_width; ++in_w)
        {
          value += static_cast<float>(
            input_data[offset(input_shape.dimsData(), out_b, in_h, in_w, out_d)]);
        }
      }
      float result = value / (input_width * input_height);
      output_data[offset(output_shape.dimsData(), out_b, 0, 0, out_d)] = static_cast<T>(result);
    }
  }
}

References luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::extendedShape(), offset(), and output_shape.

Minimum()

OMStatus onert_micro::execute::pal::Minimum ( const int  flat_size, const float *  input1_data, const float *  input2_data, float *  output_data  )

inline

Definition at line 32 of file PALMinimumCommon.h.

{
  return BinaryOp<float, MinimumFn<float>>(flat_size, input1_data, input2_data, output_data);
}

Referenced by onert_micro::execute::execute_kernel_CircleMinimum().

Mul() [1/3]

OMStatus onert_micro::execute::pal::Mul	(	const core::ArithmeticQuantParams &	params,
		const uint32_t	flat_size,
		const int8_t *	input1_data,
		const int8_t *	input2_data,
		int8_t *	output_data
	)

Definition at line 33 of file PALMul.h.

{
  auto status = arm_elementwise_mul_s8(
    input1_data, input2_data, params.input1_offset, params.input2_offset, output_data,
    params.output_offset, params.output_multiplier, params.output_shift,
    params.quantized_activation_min, params.quantized_activation_max, flat_size);
  assert(status == ARM_CMSIS_NN_SUCCESS);
 
  if (status != ARM_CMSIS_NN_SUCCESS)
    return UnknownError;
 
  return Ok;
}

References onert_micro::core::ArithmeticQuantParams::input1_offset, onert_micro::core::ArithmeticQuantParams::input2_offset, onert_micro::Ok, onert_micro::core::ArithmeticQuantParams::output_multiplier, onert_micro::core::ArithmeticQuantParams::output_offset, onert_micro::core::ArithmeticQuantParams::output_shift, onert_micro::core::ArithmeticQuantParams::quantized_activation_max, onert_micro::core::ArithmeticQuantParams::quantized_activation_min, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleMul().

Mul() [2/3]

template<typename InputType , typename OutputType >

OMStatus onert_micro::execute::pal::Mul	(	const core::ArithmeticQuantParams &	params,
		uint32_t	size,
		const InputType *	input1_data,
		const InputType *	input2_data,
		OutputType *	output_data
	)

Definition at line 31 of file PALMul.h.

{
  for (int i = 0; i < size; ++i)
  {
    const int32_t input1_val = params.input1_offset + input1_data[i];
    const int32_t input2_val = params.input2_offset + input2_data[i];
    const int32_t unclamped_result =
      params.output_offset + multiplyByQuantizedMultiplier(input1_val * input2_val,
                                                           params.output_multiplier,
                                                           params.output_shift);
    const int32_t clamped_output = std::min(
      params.quantized_activation_max, std::max(params.quantized_activation_min, unclamped_result));
    output_data[i] = static_cast<OutputType>(clamped_output);
  }
  return Ok;
}

References onert_micro::core::ArithmeticQuantParams::input1_offset, onert_micro::core::ArithmeticQuantParams::input2_offset, multiplyByQuantizedMultiplier(), onert_micro::Ok, onert_micro::core::ArithmeticQuantParams::output_multiplier, onert_micro::core::ArithmeticQuantParams::output_offset, onert_micro::core::ArithmeticQuantParams::output_shift, onert_micro::core::ArithmeticQuantParams::quantized_activation_max, onert_micro::core::ArithmeticQuantParams::quantized_activation_min, and size.

Mul() [3/3]

template<typename T >

OMStatus onert_micro::execute::pal::Mul	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data
	)

Definition at line 36 of file PALMulCommon.h.

{
  ArithmeticOp<T, MulFn<T>>(params, flat_size, input1_data, input2_data, output_data);
  return Ok;
}

References onert_micro::Ok.

multiplyByQuantizedMultiplier()

int32_t onert_micro::execute::pal::multiplyByQuantizedMultiplier ( int32_t  x, int32_t  quantized_multiplier, int  shift  )

inline

Definition at line 104 of file PALUtils.h.

{
  int left_shift = shift > 0 ? shift : 0;
  int right_shift = shift > 0 ? 0 : -shift;
  return roundingDivideByPOT(
    saturatingRoundingDoublingHighMul(x * (1 << left_shift), quantized_multiplier), right_shift);
}

References roundingDivideByPOT(), and saturatingRoundingDoublingHighMul().

Referenced by BroadcastMul6DSlow(), FullyConnected(), and Mul().

multiplyByQuantizedMultiplierSmallerThanOneExp()

int32_t onert_micro::execute::pal::multiplyByQuantizedMultiplierSmallerThanOneExp ( int32_t  x, int32_t  quantized_multiplier, int  left_shift  )

inline

Definition at line 112 of file PALUtils.h.

{
  return roundingDivideByPOT(saturatingRoundingDoublingHighMul(x, quantized_multiplier),
                             -left_shift);
}

References roundingDivideByPOT(), and saturatingRoundingDoublingHighMul().

Referenced by AddFunc(), BroadcastComparison4DSlowWithScaling(), ComparisonWithScaling(), and SubFunc().

NdArrayDescsForElementwiseBroadcast()

template<int N>

void onert_micro::execute::pal::NdArrayDescsForElementwiseBroadcast ( const core::OMRuntimeShape &  input0_shape, const core::OMRuntimeShape &  input1_shape, NdArrayDesc< N > *  desc0_out, NdArrayDesc< N > *  desc1_out  )

inline

Definition at line 94 of file ProcessBroadcastShapes.h.

{
 
  auto extended_input0_shape = core::OMRuntimeShape::extendedShape(N, input0_shape);
  auto extended_input1_shape = core::OMRuntimeShape::extendedShape(N, input1_shape);
 
  // Copy dims to desc, calculating strides.
  copyDimsToDesc<N>(extended_input0_shape, desc0_out);
  copyDimsToDesc<N>(extended_input1_shape, desc1_out);
 
  // Walk over each dimension. If the extents are equal do nothing.
  // Otherwise, set the desc with extent 1 to have extent equal to the other and
  // stride 0.
  for (int i = 0; i < N; ++i)
  {
    const int extent0 = extended_input0_shape.dims(i);
    const int extent1 = extended_input1_shape.dims(i);
    if (extent0 != extent1)
    {
      if (extent0 == 1)
      {
        desc0_out->strides[i] = 0;
        desc0_out->extents[i] = extent1;
      }
      else
      {
        desc1_out->strides[i] = 0;
        desc1_out->extents[i] = extent0;
      }
    }
  }
}

References onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::execute::pal::NdArrayDesc< N >::extents, and onert_micro::execute::pal::NdArrayDesc< N >::strides.

Referenced by BroadcastArithmeticOp4DSlow(), BroadcastBinaryOp4DSlow(), BroadcastMul6DSlow(), and QuantizedBroadcastArithmeticOp4DSlow().

NDOpsHelper()

template<int N, typename Calc >

void onert_micro::execute::pal::NDOpsHelper ( const NdArrayDesc< N > &  output, const Calc &  calc  )

inline

Definition at line 87 of file ProcessBroadcastShapes.h.

{
  int indexes[N] = {0};
  NDOpsHelperImpl<N, 0, Calc>(output, calc, indexes);
}

NDOpsHelperImpl() [1/2]

template<int N, int DIM, typename Calc >

std::enable_if< DIM==N-1, void >::type onert_micro::execute::pal::NDOpsHelperImpl	(	const NdArrayDesc< N > &	output,
		const Calc &	calc,
		int	indexes[N]
	)

Definition at line 65 of file ProcessBroadcastShapes.h.

{
  for (indexes[DIM] = 0; indexes[DIM] < output.extents[DIM]; ++indexes[DIM])
  {
    calc(indexes);
  }
}

NDOpsHelperImpl() [2/2]

template<int N, int DIM, typename Calc >

std::enable_if< DIM!=N-1, void >::type onert_micro::execute::pal::NDOpsHelperImpl	(	const NdArrayDesc< N > &	output,
		const Calc &	calc,
		int	indexes[N]
	)

Definition at line 75 of file ProcessBroadcastShapes.h.

{
  for (indexes[DIM] = 0; indexes[DIM] < output.extents[DIM]; ++indexes[DIM])
  {
    NDOpsHelperImpl<N, DIM + 1, Calc>(output, calc, indexes);
  }
}

Neg()

template<typename T >

OMStatus onert_micro::execute::pal::Neg ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 30 of file PALNegCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = -(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleNeg().

nextIndex()

bool onert_micro::execute::pal::nextIndex ( const int32_t  num_dims, const int32_t *  dims, int32_t *  current  )

inline

Definition at line 175 of file PALUtils.h.

{
  if (num_dims == 0)
  {
    return false;
  }
  int carry = 1;
  for (int idx = num_dims - 1; idx >= 0; --idx)
  {
    int current_val = current[idx] + carry;
    if (dims[idx] == current_val)
    {
      current[idx] = 0;
    }
    else
    {
      current[idx] = current_val;
      carry = 0;
      break;
    }
  }
  return (carry == 0);
}

Referenced by ReduceGeneric(), and ReduceGeneric().

NotEqualFn()

template<typename T >

bool onert_micro::execute::pal::NotEqualFn ( T  lhs, T  rhs  )

inline

Definition at line 62 of file PALComparisons.h.

{ return lhs != rhs; }

Referenced by onert_micro::execute::execute_kernel_CircleNotEqual().

offset() [1/2]

int onert_micro::execute::pal::offset ( const int32_t *  dims_data, int  i0, int  i1, int  i2, int  i3  )

inline

Definition at line 220 of file PALUtils.h.

{
  return ((i0 * dims_data[1] + i1) * dims_data[2] + i2) * dims_data[3] + i3;
}

Referenced by BatchToSpaceND(), DepthwiseConv2D< float >(), GatherND(), L2Pool(), MeanROWH(), reducedOutputOffset(), SpaceToBatchND(), SpaceToDepth(), and TransposeConv< float >().

offset() [2/2]

int onert_micro::execute::pal::offset ( const int32_t *  dims_data, int  i0, int  i1, int  i2, int  i3, int  i4  )

inline

Definition at line 225 of file PALUtils.h.

{
  return (((i0 * dims_data[1] + i1) * dims_data[2] + i2) * dims_data[3] + i3) * dims_data[4] + i4;
}

Pad()

OMStatus onert_micro::execute::pal::Pad	(	const core::PadParams &	op_params,
		const core::OMRuntimeShape &	input_shape,
		const float *	input_data,
		const float	pad_value,
		const core::OMRuntimeShape &	output_shape,
		float *	output_data
	)

Definition at line 35 of file PALPad.h.

{
  // Runtime calls are currently fixed at 5 dimensions. Copy inputs so we can
  // pad them to 5 dims (yes, we are "padding the padding").
  int left_padding_copy[padKernelMaxDimensionCount];
  for (int &i : left_padding_copy)
  {
    i = 0;
  }
  for (int i = 0; i < op_params.left_padding_count; ++i)
  {
    left_padding_copy[i + padKernelMaxDimensionCount - op_params.left_padding_count] =
      op_params.left_padding[i];
  }
  int right_padding_copy[padKernelMaxDimensionCount];
  for (int &i : right_padding_copy)
  {
    i = 0;
  }
  for (int i = 0; i < op_params.right_padding_count; ++i)
  {
    right_padding_copy[i + padKernelMaxDimensionCount - op_params.right_padding_count] =
      op_params.right_padding[i];
  }
  const auto extended_output =
    core::OMRuntimeShape::extendedShape(padKernelMaxDimensionCount, output_shape);
  const int output_batch = extended_output.dims(0);
  const int output_plane = extended_output.dims(1);
  const int output_height = extended_output.dims(2);
  const int output_width = extended_output.dims(3);
  const int output_depth = extended_output.dims(4);
 
  const int left_b_padding = left_padding_copy[0];
  const int left_p_padding = left_padding_copy[1];
  const int left_h_padding = left_padding_copy[2];
  const int left_w_padding = left_padding_copy[3];
  const int left_d_padding = left_padding_copy[4];
 
  const int right_b_padding = right_padding_copy[0];
  const int right_p_padding = right_padding_copy[1];
  const int right_h_padding = right_padding_copy[2];
  const int right_w_padding = right_padding_copy[3];
  const int right_d_padding = right_padding_copy[4];
 
  const float *in_ptr = input_data;
  float *out_ptr = output_data;
  for (int out_b = 0; out_b < output_batch; ++out_b)
  {
    for (int out_p = 0; out_p < output_plane; ++out_p)
    {
      for (int out_h = 0; out_h < output_height; ++out_h)
      {
        for (int out_w = 0; out_w < output_width; ++out_w)
        {
          for (int out_d = 0; out_d < output_depth; ++out_d)
          {
            if (out_b < left_b_padding || out_b >= output_batch - right_b_padding ||
                out_p < left_p_padding || out_p >= output_plane - right_p_padding ||
                out_h < left_h_padding || out_h >= output_height - right_h_padding ||
                out_w < left_w_padding || out_w >= output_width - right_w_padding ||
                out_d < left_d_padding || out_d >= output_depth - right_d_padding)
            {
              *out_ptr++ = pad_value;
            }
            else
            {
              *out_ptr++ = *in_ptr++;
            }
          }
        }
      }
    }
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::core::PadParams::left_padding, onert_micro::core::PadParams::left_padding_count, onert_micro::Ok, output_shape, onert_micro::core::PadParams::right_padding, and onert_micro::core::PadParams::right_padding_count.

Referenced by onert_micro::execute::execute_kernel_CirclePad().

processBroadcastShapes()

bool onert_micro::execute::pal::processBroadcastShapes ( const core::OMRuntimeShape &  shape0, const core::OMRuntimeShape &  shape1, core::BinaryArithmeticBroadcastParams *  params  )

inline

Definition at line 155 of file ProcessBroadcastShapes.h.

{
  const int dims_count = std::max(shape0.dimensionsCount(), shape1.dimensionsCount());
 
  params->broadcast_category = core::BroadcastableOpCategory::kGenericBroadcast;
 
  auto extended_shape0 = core::OMRuntimeShape::extendedShape(dims_count, shape0);
  auto extended_shape1 = core::OMRuntimeShape::extendedShape(dims_count, shape1);
 
  // Check for "exact" match, implicitly accepting any scalar shapes.
  if (extended_shape0 == extended_shape1)
  {
    params->broadcast_category = core::BroadcastableOpCategory::kNonBroadcast;
    return false;
  }
 
  if (shape0.flatSize() == 1)
  {
    params->broadcast_category = core::BroadcastableOpCategory::kScalarFirstBroadcast;
    return true;
  }
  else if (shape1.flatSize() == 1)
  {
    params->broadcast_category = core::BroadcastableOpCategory::kScalarSecondBroadcast;
    return true;
  }
 
  for (int i = dims_count - 1; i >= 0; --i)
  {
    if (extended_shape0.dims(i) == extended_shape1.dims(i))
    {
      continue;
    }
    else if (extended_shape0.dims(i) == 1)
    {
      params->broadcast_category = core::BroadcastableOpCategory::kFirstInputBroadcastsFast;
      return true;
    }
    else if (extended_shape1.dims(i) == 1)
    {
      params->broadcast_category = core::BroadcastableOpCategory::kSecondInputBroadcastsFast;
      return true;
    }
    else
    {
      // This case is erroneous: there is a dimension that does not match and
      // is not a broadcast from one shape to the other.
      params->broadcast_category = core::BroadcastableOpCategory::kGenericBroadcast;
      return true;
    }
  }
 
  return false;
}

References onert_micro::core::BinaryArithmeticBroadcastParams::broadcast_category, onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::core::kFirstInputBroadcastsFast, onert_micro::core::kGenericBroadcast, onert_micro::core::kNonBroadcast, onert_micro::core::kScalarFirstBroadcast, onert_micro::core::kScalarSecondBroadcast, and onert_micro::core::kSecondInputBroadcastsFast.

Referenced by onert_micro::execute::execute_kernel_CircleAdd(), onert_micro::execute::execute_kernel_CircleDiv(), onert_micro::execute::execute_kernel_CircleMul(), onert_micro::execute::execute_kernel_CircleSquaredDifference(), and onert_micro::execute::execute_kernel_CircleSub().

Quantize()

template<typename InputT , typename OutputT >

OMStatus onert_micro::execute::pal::Quantize	(	const core::QuantizationParams	op_params,
		const uint32_t	flat_size,
		const InputT *	input_data,
		OutputT *	output_data
	)

Definition at line 35 of file PALQuantize.h.

{
  const int32_t zero_point = op_params.zero_point;
  const double scale = op_params.scale;
  static constexpr int32_t min_val = std::numeric_limits<OutputT>::min();
  static constexpr int32_t max_val = std::numeric_limits<OutputT>::max();
 
  for (int i = 0; i < flat_size; i++)
  {
    const InputT val = input_data[i];
    int32_t unclamped =
      static_cast<int32_t>(std::round(val / static_cast<float>(scale))) + zero_point;
    int32_t clamped = std::min(std::max(unclamped, min_val), max_val);
    output_data[i] = clamped;
  }
 
  return Ok;
}

References onert_micro::Ok, onert_micro::core::QuantizationParams::scale, and onert_micro::core::QuantizationParams::zero_point.

Referenced by onert_micro::execute::execute_kernel_CircleQuantize().

QuantizedArithmeticOp()

template<typename T , typename Fn >

OMStatus onert_micro::execute::pal::QuantizedArithmeticOp	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const onert_micro::core::QuantizationParams &	input1_qparams,
		const T *	input1_data,
		const onert_micro::core::QuantizationParams &	input2_qparams,
		const T *	input2_data,
		const onert_micro::core::QuantizationParams &	output_qparams,
		T *	output_data
	)

Definition at line 69 of file PALArithmeticOpCommon.h.

{
  float activation_min, activation_max;
  getActivationParams(params, &activation_min, &activation_max);
 
  Fn func;
  for (int i = 0; i < flat_size; ++i)
  {
    // Dequantize input1
    float input1 = static_cast<float>((input1_data[i] - static_cast<T>(input1_qparams.zero_point)) *
                                      input1_qparams.scale);
    // Dequantize input2
    float input2 = static_cast<float>((input2_data[i] - static_cast<T>(input2_qparams.zero_point)) *
                                      input2_qparams.scale);
    float result = std::min(std::max(func(input1, input2), activation_min), activation_max);
 
    // Quantize result
    result = result / output_qparams.scale + output_qparams.zero_point;
    result = std::max<float>(std::numeric_limits<T>::min(), result);
    result = std::min<float>(std::numeric_limits<T>::max(), result);
    output_data[i] = static_cast<T>(result);
  }
 
  return Ok;
}

References getActivationParams(), onert_micro::Ok, onert_micro::core::QuantizationParams::scale, and onert_micro::core::QuantizationParams::zero_point.

QuantizedBroadcastArithmeticOp4DSlow()

template<typename T , typename Fn >

OMStatus onert_micro::execute::pal::QuantizedBroadcastArithmeticOp4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const onert_micro::core::QuantizationParams &	input1_qparams,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const onert_micro::core::QuantizationParams &	input2_qparams,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		const onert_micro::core::QuantizationParams &	output_qparams,
		T *	output_data
	)

Definition at line 176 of file PALArithmeticOpCommon.h.

{
  NdArrayDesc<4> desc1;
  NdArrayDesc<4> desc2;
  NdArrayDescsForElementwiseBroadcast(input1_shape, input2_shape, &desc1, &desc2);
  const core::OMRuntimeShape extended_output_shape =
    core::OMRuntimeShape::extendedShape(4, output_shape);
 
  float activation_min, activation_max;
  getActivationParams(params, &activation_min, &activation_max);
 
  // In Tensorflow, the dimensions are canonically named (batch_number, row,
  // col, channel), with extents (batches, height, width, depth), with the
  // trailing dimension changing most rapidly (channels has the smallest stride,
  // typically 1 element).
  //
  // In generated C code, we store arrays with the dimensions reversed. The
  // first dimension has smallest stride.
  //
  // We name our variables by their Tensorflow convention, but generate C code
  // nesting loops such that the innermost loop has the smallest stride for the
  // best cache behavior.
  Fn func;
  for (int b = 0; b < extended_output_shape.dims(0); ++b)
  {
    for (int y = 0; y < extended_output_shape.dims(1); ++y)
    {
      for (int x = 0; x < extended_output_shape.dims(2); ++x)
      {
        for (int c = 0; c < extended_output_shape.dims(3); ++c)
        {
          // Dequantize input1
          float input1 = static_cast<float>((input1_data[subscriptToIndex(desc1, b, y, x, c)] -
                                             static_cast<T>(input1_qparams.zero_point)) *
                                            input1_qparams.scale);
          // Dequantize input2
          float input2 = static_cast<float>((input2_data[subscriptToIndex(desc2, b, y, x, c)] -
                                             static_cast<T>(input2_qparams.zero_point)) *
                                            input2_qparams.scale);
 
          float result = std::min(std::max(func(input1, input2), activation_min), activation_max);
 
          // Quantize result
          result = result / output_qparams.scale + output_qparams.zero_point;
          result = std::max<float>(std::numeric_limits<T>::min(), result);
          result = std::min<float>(std::numeric_limits<T>::max(), result);
          const int output_data_offset =
            ((b * extended_output_shape.dims(1) + y) * extended_output_shape.dims(2) + x) *
              extended_output_shape.dims(3) +
            c;
          output_data[output_data_offset] = static_cast<T>(result);
        }
      }
    }
  }
  return Ok;
}

References desc1, desc2, onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::extendedShape(), getActivationParams(), NdArrayDescsForElementwiseBroadcast(), onert_micro::Ok, output_shape, onert_micro::core::QuantizationParams::scale, subscriptToIndex(), and onert_micro::core::QuantizationParams::zero_point.

QuantizedBroadcastSquaredDifference4DSlow()

template<typename T >

OMStatus onert_micro::execute::pal::QuantizedBroadcastSquaredDifference4DSlow	(	const core::BinaryArithmeticBroadcastParams &	params,
		const core::OMRuntimeShape &	input1_shape,
		const onert_micro::core::QuantizationParams &	input1_qparams,
		const T *	input1_data,
		const core::OMRuntimeShape &	input2_shape,
		const onert_micro::core::QuantizationParams &	input2_qparams,
		const T *	input2_data,
		const core::OMRuntimeShape &	output_shape,
		const onert_micro::core::QuantizationParams &	output_qparams,
		T *	output_data
	)

Definition at line 49 of file PALSquaredDifferenceCommon.h.

{
  QuantizedBroadcastArithmeticOp4DSlow<T, SquaredDifferenceFn<float>>(
    params, input1_shape, input1_qparams, input1_data, input2_shape, input2_qparams, input2_data,
    output_shape, output_qparams, output_data);
  return Ok;
}

References onert_micro::Ok, and output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleSquaredDifference().

QuantizedRsqrt()

template<typename T >

OMStatus onert_micro::execute::pal::QuantizedRsqrt ( const core::OMRuntimeShape &  input_shape, const onert_micro::core::QuantizationParams &  input_qparams, const T *  input_data, const core::OMRuntimeShape &  output_shape, const onert_micro::core::QuantizationParams &  output_qparams, T *  output_data  )

inline

Definition at line 42 of file PALRsqrtCommon.h.

{
  return SISOOperation<T>(input_shape, input_qparams, input_data, output_shape, output_qparams,
                          output_data, [](float arg) -> float { return 1.f / std::sqrt(arg); });
}

References output_shape.

QuantizedSquaredDifference()

template<typename T >

OMStatus onert_micro::execute::pal::QuantizedSquaredDifference	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const onert_micro::core::QuantizationParams &	input1_qparams,
		const T *	input1_data,
		const onert_micro::core::QuantizationParams &	input2_qparams,
		const T *	input2_data,
		const onert_micro::core::QuantizationParams &	output_qparams,
		T *	output_data
	)

Definition at line 64 of file PALSquaredDifferenceCommon.h.

{
 
  QuantizedArithmeticOp<T, SquaredDifferenceFn<float>>(params, flat_size, input1_qparams,
                                                       input1_data, input2_qparams, input2_data,
                                                       output_qparams, output_data);
 
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_kernel_CircleSquaredDifference().

QuantizedTanh()

template<typename T >

OMStatus onert_micro::execute::pal::QuantizedTanh ( const core::OMRuntimeShape &  input_shape, const onert_micro::core::QuantizationParams &  input_qparams, const T *  input_data, const core::OMRuntimeShape &  output_shape, const onert_micro::core::QuantizationParams &  output_qparams, T *  output_data  )

inline

Definition at line 53 of file PALTanhCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
  for (int i = 0; i < flat_size; i++)
  {
    // Dequantize.
    float val = static_cast<float>((input_data[i] - static_cast<T>(input_qparams.zero_point)) *
                                   input_qparams.scale);
    // float result
    float result = std::tanh(val);
 
    // Quantize float to output type
    result = result / output_qparams.scale + output_qparams.zero_point;
    result = std::max<float>(std::numeric_limits<T>::min(), result);
    result = std::min<float>(std::numeric_limits<T>::max(), result);
 
    output_data[i] = static_cast<T>(result);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, onert_micro::core::QuantizationParams::scale, and onert_micro::core::QuantizationParams::zero_point.

QuantizedZeroPad()

template<typename T >

OMStatus onert_micro::execute::pal::QuantizedZeroPad	(	const core::PadParams &	op_params,
		const core::OMRuntimeShape &	input_shape,
		const onert_micro::core::QuantizationParams &	input_qparams,
		const T *	input_data,
		const core::OMRuntimeShape &	output_shape,
		const onert_micro::core::QuantizationParams &	output_qparams,
		T *	output_data
	)

Definition at line 115 of file PALPad.h.

{
  // TODO reduce code duplication with Pad
 
  // Runtime calls are currently fixed at 5 dimensions. Copy inputs so we can
  // pad them to 5 dims (yes, we are "padding the padding").
  int left_padding_copy[padKernelMaxDimensionCount];
  for (int &i : left_padding_copy)
  {
    i = 0;
  }
  for (int i = 0; i < op_params.left_padding_count; ++i)
  {
    left_padding_copy[i + padKernelMaxDimensionCount - op_params.left_padding_count] =
      op_params.left_padding[i];
  }
  int right_padding_copy[padKernelMaxDimensionCount];
  for (int &i : right_padding_copy)
  {
    i = 0;
  }
  for (int i = 0; i < op_params.right_padding_count; ++i)
  {
    right_padding_copy[i + padKernelMaxDimensionCount - op_params.right_padding_count] =
      op_params.right_padding[i];
  }
  const auto extended_output =
    core::OMRuntimeShape::extendedShape(padKernelMaxDimensionCount, output_shape);
  const int output_batch = extended_output.dims(0);
  const int output_plane = extended_output.dims(1);
  const int output_height = extended_output.dims(2);
  const int output_width = extended_output.dims(3);
  const int output_depth = extended_output.dims(4);
 
  const int left_b_padding = left_padding_copy[0];
  const int left_p_padding = left_padding_copy[1];
  const int left_h_padding = left_padding_copy[2];
  const int left_w_padding = left_padding_copy[3];
  const int left_d_padding = left_padding_copy[4];
 
  const int right_b_padding = right_padding_copy[0];
  const int right_p_padding = right_padding_copy[1];
  const int right_h_padding = right_padding_copy[2];
  const int right_w_padding = right_padding_copy[3];
  const int right_d_padding = right_padding_copy[4];
 
  const T *in_ptr = input_data;
  T *out_ptr = output_data;
  T pad_value = output_qparams.zero_point;
  for (int out_b = 0; out_b < output_batch; ++out_b)
  {
    for (int out_p = 0; out_p < output_plane; ++out_p)
    {
      for (int out_h = 0; out_h < output_height; ++out_h)
      {
        for (int out_w = 0; out_w < output_width; ++out_w)
        {
          for (int out_d = 0; out_d < output_depth; ++out_d)
          {
            if (out_b < left_b_padding || out_b >= output_batch - right_b_padding ||
                out_p < left_p_padding || out_p >= output_plane - right_p_padding ||
                out_h < left_h_padding || out_h >= output_height - right_h_padding ||
                out_w < left_w_padding || out_w >= output_width - right_w_padding ||
                out_d < left_d_padding || out_d >= output_depth - right_d_padding)
            {
              *out_ptr++ = pad_value;
            }
            else
            {
              float result = static_cast<float>(
                (*in_ptr - static_cast<T>(input_qparams.zero_point)) * input_qparams.scale);
 
              // Quantize result
              result = result / output_qparams.scale + output_qparams.zero_point;
              result = std::max<float>(std::numeric_limits<T>::min(), result);
              result = std::min<float>(std::numeric_limits<T>::max(), result);
 
              *out_ptr++ = static_cast<T>(result);
              in_ptr++;
            }
          }
        }
      }
    }
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::core::PadParams::left_padding, onert_micro::core::PadParams::left_padding_count, onert_micro::Ok, output_shape, onert_micro::core::PadParams::right_padding, onert_micro::core::PadParams::right_padding_count, onert_micro::core::QuantizationParams::scale, and onert_micro::core::QuantizationParams::zero_point.

Referenced by onert_micro::execute::execute_kernel_CirclePad().

Reduce()

template<typename T , template< typename > class ReduceFn>

bool onert_micro::execute::pal::Reduce	(	OMReduceDataContext< T > &	ctx,
		bool	mean = false
	)

Definition at line 291 of file PALReduceCommon.h.

{
  // Special case mean implementation exists for 4D mean across axes 1
  // and 2
  const int *axis_value = ctx.Axis().Data().Get();
  bool special_case_4d_axes_1_and_2 =
    ctx.Input().DimsCount() == 4 && ctx.Axis().ShapeFlatSize() == 2 &&
    ((axis_value[0] == 1 && axis_value[1] == 2) || (axis_value[0] == 2 && axis_value[1] == 1));
  if (special_case_4d_axes_1_and_2)
  {
    OMRuntimeShape input_shape(ctx.Input().Shape());
    OMRuntimeShape output_shape(ctx.Output().Shape());
    MeanROWH<T>(input_shape, ctx.Input().Data().Get(), output_shape, ctx.Output().Data().Get());
    return true;
  }
 
  constexpr static T kInitValue = T(0);
 
  if (!ReduceGeneric<T, ReduceFn>(ctx))
  {
    return false;
  }
 
  auto &input = ctx.Input();
  auto input_dims = input.Dims();
  auto input_num_dims = input.DimsCount();
 
  auto &output = ctx.Output();
  auto &output_data = output.Data();
  auto num_outputs = output.ShapeFlatSize();
 
  auto &axis = ctx.Axis().Data();
  auto num_axis_dimensions = ctx.Axis().DimsCount();
 
  // Resolve axis again for computing mean
  int num_resolved_axis = 0;
  int resolved_axis[2];
 
  if (!resolveAxis(input_num_dims, axis.Get(), num_axis_dimensions, resolved_axis,
                   &num_resolved_axis))
  {
    return false;
  }
 
  // clang-format off
 
  auto fnReduceOutput = [&](size_t divide_by = 1)
  {
      for (size_t idx = 0; idx < num_outputs; ++idx)
      {
        auto value = output_data.ValueAt(idx);
        value /= static_cast<T>(divide_by);
        output_data.SetAt(idx, value);
      }
  };
 
  // clang-format on
 
  if (!mean)
  {
    fnReduceOutput();
    return true;
  }
 
  // Calculate mean by dividing output_data by num of aggregated element.
  size_t num_elements_in_axis = 1;
  for (int idx = 0; idx < num_resolved_axis; ++idx)
  {
    size_t current = static_cast<size_t>(input_dims[resolved_axis[idx]]);
    // Overflow prevention.
    if (current > (std::numeric_limits<size_t>::max() / num_elements_in_axis))
    {
      return false;
    }
    num_elements_in_axis *= current;
  }
 
  if (num_elements_in_axis > 0)
  {
    fnReduceOutput(num_elements_in_axis);
  }
 
  return true;
}

References onert_micro::core::OMDataContext< T, Mixins >::Input(), onert_micro::core::OMDataContext< T, Mixins >::Output(), output_shape, and resolveAxis().

ReduceDimensionsForBroadcast()

template<int MAX_DIM = 6>

bool onert_micro::execute::pal::ReduceDimensionsForBroadcast	(	const core::OMRuntimeShape &	input1_shape,
		const core::OMRuntimeShape &	input2_shape,
		size_t *	compressed_input1_stride,
		size_t *	compressed_input2_stride,
		size_t *	compressed_output_shape
	)

Definition at line 242 of file PALUtils.h.

{
  size_t num_compressed_dims = 0;
  size_t compressed_input1_shape[MAX_DIM];
  size_t compressed_input2_shape[MAX_DIM];
  std::fill(compressed_input1_shape, compressed_input1_shape + MAX_DIM, 1);
  std::fill(compressed_input2_shape, compressed_input2_shape + MAX_DIM, 1);
  std::fill(compressed_output_shape, compressed_output_shape + MAX_DIM, 1);
  bool broadcast_input1 = false;
  bool broadcast_input2 = false;
  bool first_nonunit = true;
 
  if (input1_shape.dimensionsCount() < 0 || input2_shape.dimensionsCount() < 0)
  {
    return false;
  }
  const size_t num_input1_dims = input1_shape.dimensionsCount();
  const size_t num_input2_dims = input2_shape.dimensionsCount();
  const int32_t *input1_dims = input1_shape.dimsData();
  const int32_t *input2_dims = input2_shape.dimsData();
  const size_t num_common_dims = std::min(num_input1_dims, num_input2_dims);
  for (size_t i = 1; i <= num_common_dims; i++)
  {
    if (input1_dims[num_input1_dims - i] < 0 || input2_dims[num_input2_dims - i] < 0)
    {
      return false;
    }
    const size_t input1_dim = input1_dims[num_input1_dims - i];
    const size_t input2_dim = input2_dims[num_input2_dims - i];
    if (input1_dim == 0 || input2_dim == 0)
    {
      return false;
    }
    if (input1_dim == 1 && input2_dim == 1)
    {
      continue;
    }
    assert(!broadcast_input1 || !broadcast_input2);
 
    if (input1_dim == 1)
    {
      if (!broadcast_input1)
      {
        broadcast_input1 = true;
        broadcast_input2 = false;
        num_compressed_dims++;
      }
      compressed_input2_shape[num_compressed_dims - 1] *= input2_dim;
      compressed_output_shape[num_compressed_dims - 1] *= input2_dim;
    }
    else if (input2_dim == 1)
    {
      if (!broadcast_input2)
      {
        broadcast_input1 = false;
        broadcast_input2 = true;
        num_compressed_dims++;
      }
      compressed_input1_shape[num_compressed_dims - 1] *= input1_dim;
      compressed_output_shape[num_compressed_dims - 1] *= input1_dim;
    }
    else
    {
      assert(input1_dim == input2_dim);
      if (broadcast_input1 || broadcast_input2 || first_nonunit)
      {
        broadcast_input1 = false;
        broadcast_input2 = false;
        num_compressed_dims++;
      }
      compressed_input1_shape[num_compressed_dims - 1] *= input1_dim;
      compressed_input2_shape[num_compressed_dims - 1] *= input1_dim;
      compressed_output_shape[num_compressed_dims - 1] *= input1_dim;
    }
    first_nonunit = false;
  }
  if (num_input1_dims > num_input2_dims)
  {
    if (!broadcast_input2)
    {
      num_compressed_dims++;
    }
    for (size_t i = 0; i < num_input1_dims - num_input2_dims; i++)
    {
      if (input1_dims[i] < 0)
        return false;
      const size_t input1_dim = input1_dims[i];
      if (input1_dim == 0)
      {
        return false;
      }
      compressed_input1_shape[num_compressed_dims - 1] *= input1_dim;
      compressed_output_shape[num_compressed_dims - 1] *= input1_dim;
    }
  }
  else if (num_input2_dims > num_input1_dims)
  {
    if (!broadcast_input1)
    {
      num_compressed_dims++;
    }
    for (size_t i = 0; i < num_input2_dims - num_input1_dims; i++)
    {
      if (input2_dims[i] < 0)
        return false;
      const size_t input2_dim = input2_dims[i];
      if (input2_dim == 0)
      {
        return false;
      }
      compressed_input2_shape[num_compressed_dims - 1] *= input2_dim;
      compressed_output_shape[num_compressed_dims - 1] *= input2_dim;
    }
  }
  num_compressed_dims = (num_compressed_dims > 1) ? num_compressed_dims : 1;
 
  int input1_stride = 1;
  int input2_stride = 1;
  for (int i = 0; i < MAX_DIM; ++i)
  {
    compressed_input1_stride[i] = input1_stride;
    input1_stride *= compressed_input1_shape[i];
    compressed_input2_stride[i] = input2_stride;
    input2_stride *= compressed_input2_shape[i];
  }
  for (int i = 0; i < MAX_DIM; ++i)
  {
    if (compressed_input1_shape[i] != compressed_input2_shape[i])
    {
      if (compressed_input1_shape[i] == 1)
      {
        compressed_input1_stride[i] = 0;
      }
      else
      {
        assert(compressed_input2_shape[i] == 1);
        compressed_input2_stride[i] = 0;
      }
    }
  }
  return true;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), and onert_micro::core::OMRuntimeShape::dimsData().

reducedOutputOffset()

size_t onert_micro::execute::pal::reducedOutputOffset ( const int32_t  num_dims, const int32_t *  dims, const int32_t *  index, const int32_t  num_axis, const int32_t *  axis  )

inline

Definition at line 143 of file PALUtils.h.

{
  if (num_dims == 0)
  {
    return 0;
  }
  size_t offset = 0;
  for (int idx = 0; idx < num_dims; ++idx)
  {
    // if we need to skip this axis
    bool is_axis = false;
    if (axis != nullptr)
    {
      for (int axis_idx = 0; axis_idx < num_axis; ++axis_idx)
      {
        if (idx == axis[axis_idx])
        {
          is_axis = true;
          break;
        }
      }
    }
    if (!is_axis)
    {
      offset = offset * static_cast<size_t>(dims[idx]) + static_cast<size_t>(index[idx]);
    }
  }
  return offset;
}

References offset().

Referenced by ReduceGeneric(), and ReduceGeneric().

ReduceGeneric() [1/2]

template<typename T >

bool onert_micro::execute::pal::ReduceGeneric ( const T *  input_data, const int *  input_dims, const int  input_num_dims, T *  output_data, const int *  axis, const int64_t  num_axis_dimensions, T  init_value, const int  output_flat_size, T   reducerconst T, const T  )

inline

Definition at line 138 of file PALReduceCommon.h.

{
  // Return early when input shape has zero dim.
  for (int i = 0; i < input_num_dims; ++i)
  {
    if (input_dims[i] == 0)
      return false;
  }
 
  for (size_t idx = 0; idx < output_flat_size; ++idx)
  {
    output_data[idx] = init_value;
  }
 
  // Resolve axis.
  int num_resolved_axis = 0;
  int resolved_axis[2];
 
  if (!resolveAxis(input_num_dims, axis, num_axis_dimensions, resolved_axis, &num_resolved_axis))
  {
    return false;
  }
 
  int temp_index[5];
  // Reset input iterator.
  for (int idx = 0; idx < input_num_dims; ++idx)
  {
    temp_index[idx] = 0;
  }
  // Iterate through input_data.
  do
  {
    size_t input_offset = reducedOutputOffset(input_num_dims, input_dims, temp_index, 0, nullptr);
    size_t output_offset =
      reducedOutputOffset(input_num_dims, input_dims, temp_index, num_resolved_axis, axis);
    output_data[output_offset] = reducer(output_data[output_offset], input_data[input_offset]);
  } while (nextIndex(input_num_dims, input_dims, temp_index));
 
  return true;
}

References nextIndex(), reducedOutputOffset(), and resolveAxis().

ReduceGeneric() [2/2]

template<typename T , template< typename > class ReduceFn>

bool onert_micro::execute::pal::ReduceGeneric

(

OMReduceDataContext< T > &

ctx

)

Definition at line 228 of file PALReduceCommon.h.

{
  auto &input = ctx.Input();
  auto &input_data = input.Data();
  auto input_dims = input.Dims();
  auto input_num_dims = input.DimsCount();
 
  auto &output = ctx.Output();
  auto &output_data = output.Data();
  auto output_flat_size = output.ShapeFlatSize();
 
  auto &axis_ctx = ctx.Axis();
  auto &axis = axis_ctx.Data();
  auto num_axis_dimensions = axis_ctx.DimsCount();
 
  // Return early when input shape has zero dim.
  for (size_t i = 0; i < input_num_dims; ++i)
  {
    if (input_dims[i] == 0)
      return false;
  }
 
  for (size_t idx = 0; idx < output_flat_size; ++idx)
  {
    output_data.SetValueAt(idx, ReduceFn<T>::InitValue);
  }
 
  // Resolve axis.
  int num_resolved_axis = 0;
  int resolved_axis[2];
 
  if (!resolveAxis(input_num_dims, axis.Get(), num_axis_dimensions, resolved_axis,
                   &num_resolved_axis))
  {
    return false;
  }
 
  int temp_index[5];
  // Reset input iterator.
  for (size_t idx = 0; idx < input_num_dims; ++idx)
  {
    temp_index[idx] = 0;
  }
 
  // Iterate through input_data.
  do
  {
    size_t input_offset = reducedOutputOffset(input_num_dims, input_dims, temp_index, 0, nullptr);
    size_t output_offset =
      reducedOutputOffset(input_num_dims, input_dims, temp_index, num_resolved_axis, axis.Get());
 
    ReduceFn<T> reducer;
    auto value = reducer(output_data.ValueAt(output_offset), input_data.ValueAt(input_offset));
    output_data.SetValueAt(output_offset, value);
 
  } while (nextIndex(input_num_dims, input_dims, temp_index));
 
  return true;
}

References onert_micro::core::OMDataContext< T, Mixins >::Input(), nextIndex(), onert_micro::core::OMDataContext< T, Mixins >::Output(), reducedOutputOffset(), and resolveAxis().

reduceSumImpl()

template<typename T >

bool onert_micro::execute::pal::reduceSumImpl ( const T *  input_data, const int *  input_dims, const int  input_num_dims, T *  output_data, const int *  axis, const int  num_axis, const int  num_outputs  )

inline

Definition at line 183 of file PALReduceCommon.h.

{
  return ReduceGeneric<T>(input_data, input_dims, input_num_dims, output_data, axis, num_axis,
                          static_cast<T>(0), num_outputs,
                          [](const T current, const T in) -> T { return in + current; });
}

ReLUCommon()

template<typename Type >

OMStatus onert_micro::execute::pal::ReLUCommon	(	const int	flat_size,
		const Type *	input_data,
		Type *	output_data,
		const float	alpha,
		const bool	is_relu_6
	)

Definition at line 33 of file PALReluCommon.h.

{
  const Type relu_6_value = 6.0f;
  for (int i = 0; i < flat_size; i++)
  {
    const Type val = input_data[i];
    Type result = val > 0 ? val : val * alpha;
    result = is_relu_6 ? (result > relu_6_value ? relu_6_value : result) : result;
    output_data[i] = result;
  }
 
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_relu_common().

ReLUCommon< int8_t >()

template<>

OMStatus onert_micro::execute::pal::ReLUCommon< int8_t >	(	const int	flat_size,
		const int8_t *	input_data,
		int8_t *	output_data,
		const float	alpha,
		const bool	is_relu_6
	)

Definition at line 33 of file PALRelu.h.

{
  // 1. Relu
  if (is_relu_6 == false && alpha == 0)
  {
    memcpy(output_data, input_data, flat_size);
    arm_relu_q7(output_data, flat_size);
  }
  // 2. Relu6
  else if (is_relu_6 && alpha == 0)
  {
    memcpy(output_data, input_data, flat_size);
    arm_relu6_s8(output_data, flat_size);
  }
  // 3. Leaky_Relu not supported by cmsis_nn
  else if (alpha != 0)
  {
    for (int i = 0; i < flat_size; i++)
    {
      const int8_t val = input_data[i];
      int8_t result = val > 0 ? val : val * alpha;
      output_data[i] = result;
    }
  }
 
  return Ok;
}

References onert_micro::Ok.

resolveAxis()

bool onert_micro::execute::pal::resolveAxis ( const int  num_dims, const int *  axis, const int64_t  num_axis, int *  out_axis, int *  out_num_axis  )

inline

Definition at line 90 of file PALReduceCommon.h.

{
  *out_num_axis = 0; // Just in case.
  // Short-circuit axis resolution for scalars; the axis will go unused.
  if (num_dims == 0)
  {
    return true;
  }
  // o(n^2) is fine since out_num_axis should be really small, mostly <= 4
  for (int64_t idx = 0; idx < num_axis; ++idx)
  {
    // Handle negative index. A positive index 'p_idx' can be represented as a
    // negative index 'n_idx' as: n_idx = p_idx-num_dims
    // eg: For num_dims=3, [0, 1, 2] is the same as [-3, -2, -1]  */
    int current = axis[idx] < 0 ? (axis[idx] + num_dims) : axis[idx];
    if (current < 0 || current >= num_dims)
    {
      return false;
    }
    bool is_dup = false;
    for (int j = 0; j < *out_num_axis; ++j)
    {
      if (out_axis[j] == current)
      {
        is_dup = true;
        break;
      }
    }
    if (!is_dup)
    {
      if (*out_num_axis > 1)
      {
        return false;
      }
      out_axis[*out_num_axis] = current;
      *out_num_axis += 1;
    }
  }
  return true;
}

Referenced by Reduce(), ReduceGeneric(), and ReduceGeneric().

Round()

template<typename T >

OMStatus onert_micro::execute::pal::Round ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Referenced by onert_micro::execute::execute_kernel_CircleRound().

Round< float >()

template<>

OMStatus onert_micro::execute::pal::Round< float > ( const core::OMRuntimeShape &  input_shape, const float *  input_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 38 of file PALRoundCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    // Note that this implementation matches that of tensorFlow tf.round
    // and corresponds to the bankers rounding method.
    auto floor_val = std::floor(input_data[i]);
    auto diff = input_data[i] - floor_val;
    if ((diff < 0.5f) || ((diff == 0.5f) && (static_cast<int>(floor_val) % 2 == 0)))
    {
      output_data[i] = floor_val;
    }
    else
    {
      output_data[i] = floor_val + 1.0f;
    }
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

roundingDivideByPOT()

int32_t onert_micro::execute::pal::roundingDivideByPOT ( int32_t  x, int32_t  exponent  )

inline

Definition at line 92 of file PALUtils.h.

{
  assert(exponent >= 0);
  assert(exponent <= 31);
  const int32_t mask = int32_t((1ll << exponent) - 1);
  const int32_t zero = int32_t(0);
  const int32_t one = int32_t(1);
  const int32_t remainder = x & mask;
  const int32_t threshold = (mask >> 1) + ((x < zero ? one : zero) & one);
  return (x >> exponent) + ((remainder > threshold ? one : zero) & one);
}

Referenced by multiplyByQuantizedMultiplier(), and multiplyByQuantizedMultiplierSmallerThanOneExp().

Rsqrt()

template<typename T >

OMStatus onert_micro::execute::pal::Rsqrt ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALRsqrtCommon.h.

{
  return SISOOperation<T>(input_shape, input_data, output_shape, output_data,
                          [](T arg) -> T { return 1.f / std::sqrt(arg); });
}

References output_shape.

Referenced by onert_micro::execute::execute_kernel_CircleRsqrt().

saturatingRoundingDoublingHighMul()

std::int32_t onert_micro::execute::pal::saturatingRoundingDoublingHighMul ( std::int32_t  a, std::int32_t  b  )

inline

Definition at line 79 of file PALUtils.h.

{
  bool overflow = a == b && a == std::numeric_limits<std::int32_t>::min();
  std::int64_t a_64(a);
  std::int64_t b_64(b);
  std::int64_t ab_64 = a_64 * b_64;
  std::int32_t nudge = ab_64 >= 0 ? (1 << 30) : (1 - (1 << 30));
  std::int32_t ab_x2_high32 = static_cast<std::int32_t>((ab_64 + nudge) / (1ll << 31));
  return overflow ? std::numeric_limits<std::int32_t>::max() : ab_x2_high32;
}

Referenced by multiplyByQuantizedMultiplier(), and multiplyByQuantizedMultiplierSmallerThanOneExp().

Select()

template<typename D , typename T >

void onert_micro::execute::pal::Select	(	const core::OMRuntimeShape &	input_condition_shape,
		const D *	input_condition_data,
		const core::OMRuntimeShape &	input_x_shape,
		const T *	input_x_data,
		const core::OMRuntimeShape &	input_y_shape,
		const T *	input_y_data,
		const core::OMRuntimeShape &	output_shape,
		T *	output_data
	)

Definition at line 33 of file PALSelectV2.h.

{
  int64_t flatsize;
  // Allow select operator executions on mixed scalar tensors and one element
  // tensors.
  if (input_condition_shape.flatSize() == 1 && input_x_shape.flatSize() == 1 &&
      input_y_shape.flatSize() == 1 && output_shape.flatSize() == 1)
  {
    flatsize = 1;
  }
  else
  {
    flatsize = input_condition_shape.flatSize();
  }
  for (int64_t i = 0; i < flatsize; ++i)
  {
    output_data[i] = input_condition_data[i] ? input_x_data[i] : input_y_data[i];
  }
}

References luci_interpreter::RuntimeShape::flatSize(), onert_micro::core::OMRuntimeShape::flatSize(), and output_shape.

Sin()

template<typename T >

OMStatus onert_micro::execute::pal::Sin ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 35 of file PALSinCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::sin(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleSin().

SISOOperation() [1/2]

template<typename T >

OMStatus onert_micro::execute::pal::SISOOperation ( const core::OMRuntimeShape &  input_shape, const onert_micro::core::QuantizationParams &  input_qparams, const T *  input_data, const core::OMRuntimeShape &  output_shape, const onert_micro::core::QuantizationParams &  output_qparams, T *  output_data, std::function< float(float)> const &  func  )

inline

Definition at line 54 of file PALSISOOperation.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    // Dequantize input
    float result = static_cast<float>((input_data[i] - static_cast<T>(input_qparams.zero_point)) *
                                      input_qparams.scale);
    // float result
    result = func(result);
 
    // Quantize result to output type
    result = result / output_qparams.scale + output_qparams.zero_point;
    result = std::max<float>(std::numeric_limits<T>::min(), result);
    result = std::min<float>(std::numeric_limits<T>::max(), result);
 
    output_data[i] = static_cast<T>(result);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, onert_micro::core::QuantizationParams::scale, onert_micro::UnknownError, and onert_micro::core::QuantizationParams::zero_point.

SISOOperation() [2/2]

template<typename T >

OMStatus onert_micro::execute::pal::SISOOperation ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data, std::function< T(T)> const &  func  )

inline

Definition at line 31 of file PALSISOOperation.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = func(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Slice()

template<typename T >

OMStatus onert_micro::execute::pal::Slice	(	const core::SliceParams &	op_params,
		const core::OMRuntimeShape &	input_shape,
		const T *	input_data,
		T *	output_data
	)

Definition at line 29 of file PALSlice.h.

{
  const core::OMRuntimeShape ext_shape = core::OMRuntimeShape::extendedShape(5, input_shape);
  const int begin_count = op_params.begin_count;
  const int size_count = op_params.size_count;
  // We front-pad the begin and size vectors.
  int start[5];
  int stop[5];
  for (int i = 0; i < 5; ++i)
  {
    int padded_i = 5 - i;
    start[i] = begin_count < padded_i ? 0 : op_params.begin[begin_count - padded_i];
    stop[i] = (size_count < padded_i || op_params.size[size_count - padded_i] == -1)
                ? ext_shape.dims(i)
                : start[i] + op_params.size[size_count - padded_i];
  }
 
  for (int i0 = start[0]; i0 < stop[0]; ++i0)
  {
    for (int i1 = start[1]; i1 < stop[1]; ++i1)
    {
      for (int i2 = start[2]; i2 < stop[2]; ++i2)
      {
        for (int i3 = start[3]; i3 < stop[3]; ++i3)
        {
          for (int i4 = start[4]; i4 < stop[4]; ++i4)
          {
            auto position =
              (((i0 * ext_shape.dims(1) + i1) * ext_shape.dims(2) + i2) * ext_shape.dims(3) + i3) *
                ext_shape.dims(4) +
              i4;
            *output_data++ = input_data[position];
          }
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::SliceParams::begin, begin_count, onert_micro::core::SliceParams::begin_count, onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::Ok, onert_micro::core::SliceParams::size, size_count, and onert_micro::core::SliceParams::size_count.

Referenced by onert_micro::execute::execute_kernel_CircleSlice().

Softmax()

template<typename T , typename U >

OMStatus onert_micro::execute::pal::Softmax	(	const core::SoftmaxParams &	params,
		const T *	input_data,
		U *	output_data
	)

Definition at line 33 of file PALSoftmaxCommon.h.

{
  const int outer_size = params.num_rows;
  const int depth = params.row_size;
  const double beta = params.beta;
 
  const float input_scale = params.input_scale;
  const float output_scale = params.output_scale;
 
  const int input_zp = params.input_zp;
  const int output_zp = params.output_zp;
 
  for (int i = 0; i < outer_size; ++i)
  {
    // Find max element value which we'll use to ensure numerical stability
    // taking advantage of the following equality:
    // exp(x[i])/sum(exp(x[i])) == exp(x[i]+C)/sum(exp(x[i]+C))
    float max = std::numeric_limits<float>::lowest();
    for (int c = 0; c < depth; ++c)
    {
      auto t = input_data[i * depth + c] - input_zp;
      auto t_f = static_cast<float>(input_data[i * depth + c] - input_zp);
      float cur_val = static_cast<float>(input_data[i * depth + c] - input_zp) * input_scale;
      max = std::max(max, cur_val);
    }
 
    static constexpr int32_t min_val = std::numeric_limits<U>::min();
    static constexpr int32_t max_val = std::numeric_limits<U>::max();
    // Compute sum.
    float sum = 0.f;
    for (int c = 0; c < depth; ++c)
    {
      float cur_val = static_cast<float>(input_data[i * depth + c] - input_zp) * input_scale;
      const auto exp_c = static_cast<float>(std::exp((cur_val - max) * beta));
      sum += exp_c;
    }
 
    // Compute result.
    for (int c = 0; c < depth; ++c)
    {
      float cur_val = static_cast<float>(input_data[i * depth + c] - input_zp) * input_scale;
      const auto exp_c = static_cast<float>(std::exp((cur_val - max) * beta));
      float softmax_val = exp_c / sum;
      auto unclamped = static_cast<int32_t>(std::round(softmax_val / output_scale) +
                                            static_cast<float>(output_zp));
      int32_t clamped = std::min(std::max(unclamped, min_val), max_val);
      output_data[i * depth + c] = static_cast<U>(clamped);
    }
  }
  return Ok;
}

References onert_micro::core::SoftmaxParams::beta, onert_micro::core::SoftmaxParams::input_scale, onert_micro::core::SoftmaxParams::input_zp, onert_micro::core::SoftmaxParams::num_rows, onert_micro::Ok, onert_micro::core::SoftmaxParams::output_scale, onert_micro::core::SoftmaxParams::output_zp, and onert_micro::core::SoftmaxParams::row_size.

Referenced by onert_micro::execute::execute_kernel_CircleSoftmax().

Softmax< float, float >()

template<>

OMStatus onert_micro::execute::pal::Softmax< float, float >	(	const core::SoftmaxParams &	params,
		const float *	input_data,
		float *	output_data
	)

Definition at line 86 of file PALSoftmaxCommon.h.

{
  const int outer_size = params.num_rows;
  const int depth = params.row_size;
  const double beta = params.beta;
 
  for (int i = 0; i < outer_size; ++i)
  {
    // Find max element value which we'll use to ensure numerical stability
    // taking advantage of the following equality:
    // exp(x[i])/sum(exp(x[i])) == exp(x[i]+C)/sum(exp(x[i]+C))
    float max = std::numeric_limits<float>::lowest();
    for (int c = 0; c < depth; ++c)
    {
      max = std::max(max, input_data[i * depth + c]);
    }
 
    // Compute sum.
    float sum = 0.f;
    for (int c = 0; c < depth; ++c)
    {
      const float exp_c = std::exp((input_data[i * depth + c] - max) * static_cast<float>(beta));
      output_data[i * depth + c] = exp_c;
      sum += exp_c;
    }
 
    assert(sum != 0);
 
    if (sum == 0)
      return UnknownError;
 
    // Compute result.
    for (int c = 0; c < depth; ++c)
    {
      output_data[i * depth + c] = output_data[i * depth + c] / sum;
    }
  }
  return Ok;
}

References onert_micro::core::SoftmaxParams::beta, onert_micro::core::SoftmaxParams::num_rows, onert_micro::Ok, onert_micro::core::SoftmaxParams::row_size, and onert_micro::UnknownError.

Softmax< int8_t, int8_t >()

template<>

OMStatus onert_micro::execute::pal::Softmax< int8_t, int8_t >	(	const core::SoftmaxParams &	params,
		const int8_t *	input_data,
		int8_t *	output_data
	)

Definition at line 33 of file PALSoftmax.h.

{
  arm_softmax_s8(input_data, params.num_rows, params.row_size, params.input_multiplier,
                 params.input_left_shift, params.diff_min, output_data);
 
  return Ok;
}

References onert_micro::core::SoftmaxParams::diff_min, onert_micro::core::SoftmaxParams::input_left_shift, onert_micro::core::SoftmaxParams::input_multiplier, onert_micro::core::SoftmaxParams::num_rows, onert_micro::Ok, and onert_micro::core::SoftmaxParams::row_size.

SpaceToBatchND()

template<typename T >

OMStatus onert_micro::execute::pal::SpaceToBatchND ( const core::OMRuntimeShape &  unextended_input1_shape, const T *  input1_data, const core::OMRuntimeShape &  unextended_input2_shape, const int32_t *  block_shape_data, const core::OMRuntimeShape &  unextended_input3_shape, const int32_t *  paddings_data, const core::OMRuntimeShape &  unextended_output_shape, T *  output_data  )

inline

Definition at line 51 of file PALSpaceToBatchNDCommon.h.

{
  // Extends the input/output shape from 3D to 4D if needed, NHC -> NH1C.
  const core::OMRuntimeShape input1_shape = extendShapeSpaceToBatch(unextended_input1_shape);
  const core::OMRuntimeShape output_shape = extendShapeSpaceToBatch(unextended_output_shape);
 
  const int depth = input1_shape.dims(3);
  const int input_width = input1_shape.dims(2);
  const int input_height = input1_shape.dims(1);
  const int input_batch_size = input1_shape.dims(0);
 
  const int output_width = output_shape.dims(2);
  const int output_height = output_shape.dims(1);
  const int output_batch_size = output_shape.dims(0);
 
  const int block_shape_height = block_shape_data[0];
  const int block_shape_width =
    unextended_input1_shape.dimensionsCount() == 4 ? block_shape_data[1] : 1;
  const int padding_top = paddings_data[0];
  const int padding_left = unextended_input1_shape.dimensionsCount() == 4 ? paddings_data[2] : 0;
 
  const int32_t pad_value = 0;
 
  for (int out_b = 0; out_b < output_batch_size; ++out_b)
  {
    int input_batch = out_b % input_batch_size;
    int shift_w = (out_b / input_batch_size) % block_shape_width;
    int shift_h = (out_b / input_batch_size) / block_shape_width;
    for (int out_h = 0; out_h < output_height; ++out_h)
    {
      for (int out_w = 0; out_w < output_width; ++out_w)
      {
        T *out = output_data + offset(output_shape.dimsData(), out_b, out_h, out_w, 0);
        if (out_h * block_shape_height + shift_h < padding_top ||
            out_h * block_shape_height + shift_h >= padding_top + input_height ||
            out_w * block_shape_width + shift_w < padding_left ||
            out_w * block_shape_width + shift_w >= padding_left + input_width)
        {
          // This may not execute correctly when pad_value != 0 and T != uint8.
          memset(out, pad_value, depth * sizeof(T));
        }
        else
        {
          const T *in =
            input1_data + offset(input1_shape.dimsData(), input_batch,
                                 (out_h * block_shape_height + shift_h) - padding_top,
                                 (out_w * block_shape_width + shift_w) - padding_left, 0);
          memcpy(out, in, depth * sizeof(T));
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::dimsData(), offset(), onert_micro::Ok, and output_shape.

SpaceToDepth()

template<typename T >

OMStatus onert_micro::execute::pal::SpaceToDepth ( const int32_t  block_size, const core::OMRuntimeShape &  unextended_input_shape, const T *  input_data, const core::OMRuntimeShape &  unextended_output_shape, T *  output_data  )

inline

Definition at line 32 of file PALSpaceToDepthCommon.h.

{
  if (block_size == 0)
  {
    return FailedCheckCondition;
  }
 
  const core::OMRuntimeShape input_shape =
    core::OMRuntimeShape::extendedShape(4, unextended_input_shape);
  const core::OMRuntimeShape output_shape =
    core::OMRuntimeShape::extendedShape(4, unextended_output_shape);
 
  const int input_depth = input_shape.dims(3);
  const int input_width = input_shape.dims(2);
  const int input_height = input_shape.dims(1);
  const int input_batch = input_shape.dims(0);
 
  for (int in_b = 0; in_b < input_batch; ++in_b)
  {
    for (int in_h = 0; in_h < input_height; ++in_h)
    {
      for (int in_w = 0; in_w < input_width; ++in_w)
      {
        for (int in_d = 0; in_d < input_depth; ++in_d)
        {
          const int out_d =
            in_d + ((in_h % block_size) * block_size + in_w % block_size) * input_depth;
          const int out_w = in_w / block_size;
          const int out_h = in_h / block_size;
          const int out_b = in_b;
 
          const int input_index = offset(input_shape.dimsData(), in_b, in_h, in_w, in_d);
          const int output_index = offset(output_shape.dimsData(), out_b, out_h, out_w, out_d);
 
          output_data[output_index] = input_data[input_index];
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::FailedCheckCondition, offset(), onert_micro::Ok, and output_shape.

Split()

template<typename T >

OMStatus onert_micro::execute::pal::Split	(	const core::SplitParams &	params,
		const core::OMRuntimeShape &	input_shape,
		const T *	input_data,
		const core::OMRuntimeShape &	output_shape,
		int32_t	axis_value
	)

Definition at line 36 of file PALSplit.h.

{
  const auto output_count = params.num_outputs;
 
  const auto split_dimensions = input_shape.dimensionsCount();
 
  assert(axis_value < split_dimensions);
  assert(output_shape.dimensionsCount() == split_dimensions);
 
  int64_t outer_size = 1;
  for (uint32_t i = 0; i < axis_value; ++i)
  {
    outer_size *= input_shape.dims(i);
  }
 
  int64_t base_inner_size = 1;
  for (uint32_t i = axis_value + 1; i < split_dimensions; ++i)
  {
    base_inner_size *= input_shape.dims(i);
  }
 
  assert(input_data != nullptr);
  for (int64_t k = 0; k < outer_size; ++k)
  {
    for (uint32_t i = 0; i < output_count; ++i)
    {
      T *output_data = core::utils::castOutputData<T>(params.output_data[i]);
      assert(output_data != nullptr);
      const auto copy_size = output_shape.dims(axis_value) * base_inner_size;
      T *output_ptr = output_data + k * copy_size;
      assert(output_ptr != nullptr);
      for (int64_t j = 0; j < copy_size; ++j)
        output_ptr[j] = input_data[j];
      input_data += copy_size;
    }
  }
  return Ok;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::SplitParams::num_outputs, onert_micro::Ok, onert_micro::core::SplitParams::output_data, and output_shape.

Sqrt()

template<typename T >

OMStatus onert_micro::execute::pal::Sqrt ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALSqrtCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::sqrt(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleSqrt().

Square()

template<typename T >

OMStatus onert_micro::execute::pal::Square ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 34 of file PALSquareCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = (input_data[i]) * (input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Referenced by onert_micro::execute::execute_kernel_CircleSquare().

SquaredDifference()

template<typename T >

OMStatus onert_micro::execute::pal::SquaredDifference	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data
	)

Definition at line 29 of file PALSquaredDifferenceCommon.h.

{
  ArithmeticOp<T, SquaredDifferenceFn<T>>(params, flat_size, input1_data, input2_data, output_data);
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_kernel_CircleSquaredDifference().

StridedSlice()

template<typename T >

OMStatus onert_micro::execute::pal::StridedSlice	(	core::StridedSliceParams &	op_params,
		const core::OMRuntimeShape &	unextended_input_shape,
		const T *	input_data,
		T *	output_data
	)

Definition at line 206 of file PALStridedSlice.h.

{
  const core::OMRuntimeShape input_shape =
    core::OMRuntimeShape::extendedShape(5, unextended_input_shape);
 
  // Reverse and pad to 5 dimensions because that is what the runtime code
  // requires (ie. all shapes must be 5D and are given backwards).
  stridedSlicePadIndices(&op_params, 5);
 
  const int start_0 = startForAxis(op_params, input_shape, 0);
  const int stop_0 = stopForAxis(op_params, input_shape, 0, start_0);
  const int start_1 = startForAxis(op_params, input_shape, 1);
  const int stop_1 = stopForAxis(op_params, input_shape, 1, start_1);
  const int start_2 = startForAxis(op_params, input_shape, 2);
  const int stop_2 = stopForAxis(op_params, input_shape, 2, start_2);
  const int start_3 = startForAxis(op_params, input_shape, 3);
  const int stop_3 = stopForAxis(op_params, input_shape, 3, start_3);
  const int start_4 = startForAxis(op_params, input_shape, 4);
  const int stop_4 = stopForAxis(op_params, input_shape, 4, start_4);
 
  for (int offset_0 = start_0 * input_shape.dims(1), end_0 = stop_0 * input_shape.dims(1),
           step_0 = op_params.strides[0] * input_shape.dims(1);
       !loopCondition(offset_0, end_0, op_params.strides[0]); offset_0 += step_0)
  {
    for (int offset_1 = (offset_0 + start_1) * input_shape.dims(2),
             end_1 = (offset_0 + stop_1) * input_shape.dims(2),
             step_1 = op_params.strides[1] * input_shape.dims(2);
         !loopCondition(offset_1, end_1, op_params.strides[1]); offset_1 += step_1)
    {
      for (int offset_2 = (offset_1 + start_2) * input_shape.dims(3),
               end_2 = (offset_1 + stop_2) * input_shape.dims(3),
               step_2 = op_params.strides[2] * input_shape.dims(3);
           !loopCondition(offset_2, end_2, op_params.strides[2]); offset_2 += step_2)
      {
        for (int offset_3 = (offset_2 + start_3) * input_shape.dims(4),
                 end_3 = (offset_2 + stop_3) * input_shape.dims(4),
                 step_3 = op_params.strides[3] * input_shape.dims(4);
             !loopCondition(offset_3, end_3, op_params.strides[3]); offset_3 += step_3)
        {
          for (int offset_4 = offset_3 + start_4, end_4 = offset_3 + stop_4;
               !loopCondition(offset_4, end_4, op_params.strides[4]);
               offset_4 += op_params.strides[4])
          {
            *output_data++ = input_data[offset_4];
          }
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::Ok, and onert_micro::core::StridedSliceParams::strides.

Referenced by onert_micro::execute::execute_kernel_CircleStridedSlice().

Sub() [1/2]

OMStatus onert_micro::execute::pal::Sub	(	const core::ArithmeticQuantParams &	params,
		const uint32_t	flat_size,
		const int8_t *	input1_data,
		const int8_t *	input2_data,
		int8_t *	output_data
	)

Definition at line 31 of file PALSub.h.

{
  ElementWise(flat_size, params, input1_data, input2_data, output_data, SubFunc);
  return Ok;
}

References ElementWise(), onert_micro::Ok, and SubFunc().

Sub() [2/2]

template<typename T >

OMStatus onert_micro::execute::pal::Sub	(	const core::BinaryArithmeticBroadcastParams &	params,
		const int	flat_size,
		const T *	input1_data,
		const T *	input2_data,
		T *	output_data
	)

Definition at line 49 of file PALSubCommon.h.

{
  ArithmeticOp<T, SubFn<T>>(params, flat_size, input1_data, input2_data, output_data);
  return Ok;
}

References onert_micro::Ok.

Referenced by onert_micro::execute::execute_kernel_CircleSub().

SubFunc()

int8_t onert_micro::execute::pal::SubFunc	(	int8_t	x,
		int8_t	y,
		const core::ArithmeticQuantParams &	params
	)

Definition at line 29 of file PALSubCommon.h.

{
  const int32_t input1_val = params.input1_offset + x;
  const int32_t input2_val = params.input2_offset + y;
  const int32_t shifted_input1_val = input1_val * (1 << params.left_shift);
  const int32_t shifted_input2_val = input2_val * (1 << params.left_shift);
  const int32_t scaled_input1_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
    shifted_input1_val, params.input1_multiplier, params.input1_shift);
  const int32_t scaled_input2_val = multiplyByQuantizedMultiplierSmallerThanOneExp(
    shifted_input2_val, params.input2_multiplier, params.input2_shift);
  const int32_t raw_sum = scaled_input1_val - scaled_input2_val;
  const int32_t raw_output = multiplyByQuantizedMultiplierSmallerThanOneExp(
                               raw_sum, params.output_multiplier, params.output_shift) +
                             params.output_offset;
  const int32_t clamped_output = std::min(params.quantized_activation_max,
                                          std::max(params.quantized_activation_min, raw_output));
  return static_cast<int8_t>(clamped_output);
}

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

Referenced by BroadcastSub4DSlow(), and Sub().

subscriptToIndex() [1/2]

int onert_micro::execute::pal::subscriptToIndex ( const NdArrayDesc< 4 > &  desc, int  i0, int  i1, int  i2, int  i3  )

inline

Definition at line 130 of file ProcessBroadcastShapes.h.

{
  return i0 * desc.strides[0] + i1 * desc.strides[1] + i2 * desc.strides[2] + i3 * desc.strides[3];
}

References onert_micro::execute::pal::NdArrayDesc< N >::strides.

Referenced by BroadcastArithmeticOp4DSlow(), BroadcastBinaryOp4DSlow(), BroadcastComparison4DSlowNoScaling(), BroadcastComparison4DSlowWithScaling(), QuantizedBroadcastArithmeticOp4DSlow(), and TransposeImpl().

subscriptToIndex() [2/2]

int onert_micro::execute::pal::subscriptToIndex ( const NdArrayDesc< 5 > &  desc, int  indexes[5]  )

inline

Definition at line 135 of file ProcessBroadcastShapes.h.

{
  return indexes[0] * desc.strides[0] + indexes[1] * desc.strides[1] +
         indexes[2] * desc.strides[2] + indexes[3] * desc.strides[3] + indexes[4] * desc.strides[4];
}

References onert_micro::execute::pal::NdArrayDesc< N >::strides.

SVDF() [1/2]

OMStatus onert_micro::execute::pal::SVDF	(	const core::SVDFQuantParams &	params,
		const int8_t *	input_data,
		const int8_t *	weights_feature_data,
		const int8_t *	weights_time_data,
		const int32_t *	bias_data,
		int8_t *	state_data,
		int8_t *	output_data,
		const core::OMRuntimeShape &	input_shape,
		const core::OMRuntimeShape &	weights_feature_shape,
		const core::OMRuntimeShape &	weights_time_shape,
		const core::OMRuntimeShape &	bias_shape,
		const core::OMRuntimeShape &	output_shape
	)

Definition at line 35 of file PALSVDF.h.

{
  cmsis_nn_dims input_dims;
  input_dims.n = input_shape.dims(0);
  input_dims.h = input_shape.dims(1);
 
  cmsis_nn_dims weights_feature_dims;
  weights_feature_dims.n = weights_feature_shape.dims(0);
  weights_feature_dims.h = weights_feature_shape.dims(1);
 
  cmsis_nn_dims weights_time_dims;
  weights_time_dims.n = weights_time_shape.dims(0);
  weights_time_dims.h = weights_time_shape.dims(1);
 
  cmsis_nn_dims bias_dims;
  bias_dims.n = bias_shape.dims(0);
 
  cmsis_nn_dims state_dims;
  state_dims.n = bias_shape.dims(0);
  state_dims.h = bias_shape.dims(1);
 
  cmsis_nn_dims output_dims;
  output_dims.n = output_shape.dims(0);
  output_dims.h = output_shape.dims(1);
 
  cmsis_nn_svdf_params svdf_params;
  svdf_params.rank = params.rank;
  svdf_params.input_offset = params.input_zero_point;
  svdf_params.output_offset = params.output_zero_point;
 
  svdf_params.input_activation.min = INT16_MIN;
  svdf_params.input_activation.max = INT16_MAX;
 
  svdf_params.output_activation.min = INT8_MIN;
  svdf_params.output_activation.max = INT8_MAX;
 
  cmsis_nn_per_tensor_quant_params in_quant_params;
  in_quant_params.multiplier = params.effective_scale_1_a;
  in_quant_params.shift = params.effective_scale_1_b;
 
  cmsis_nn_per_tensor_quant_params out_quant_params;
  out_quant_params.multiplier = params.effective_scale_2_a;
  out_quant_params.shift = params.effective_scale_2_b;
 
  const int batch_size = input_shape.dims(0);
  const int input_size = input_shape.dims(1);
  const int num_filters = weights_feature_shape.dims(0);
  const int num_units = num_filters / params.rank;
 
  uint8_t *scratch_tensor_data;
  OMStatus status = core::memory::OMMemoryManager::allocateMemory(
    batch_size * num_filters * sizeof(int32_t), &scratch_tensor_data);
  assert(status == Ok);
  if (status != Ok)
    return status;
 
  uint8_t *scratch_output_tensor_data;
  status = core::memory::OMMemoryManager::allocateMemory(batch_size * num_units * sizeof(int32_t),
                                                         &scratch_output_tensor_data);
  assert(status == Ok);
  if (status != Ok)
    return status;
 
  cmsis_nn_context scratch_ctx;
  scratch_ctx.buf = reinterpret_cast<int32_t *>(scratch_tensor_data);
 
  cmsis_nn_context scratch_output_ctx;
  scratch_output_ctx.buf = reinterpret_cast<int32_t *>(scratch_output_tensor_data);
 
  arm_svdf_s8(&scratch_ctx, &scratch_output_ctx, &svdf_params, &in_quant_params, &out_quant_params,
              &input_dims, input_data, &state_dims, state_data, &weights_feature_dims,
              weights_feature_data, &weights_time_dims, weights_time_data, &bias_dims, bias_data,
              &output_dims, output_data);
 
  core::memory::OMMemoryManager::deallocateMemory(scratch_tensor_data);
  core::memory::OMMemoryManager::deallocateMemory(scratch_output_tensor_data);
 
  return Ok;
}

References onert_micro::core::memory::OMMemoryManager::allocateMemory(), onert_micro::core::memory::OMMemoryManager::deallocateMemory(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::SVDFQuantParams::effective_scale_1_a, onert_micro::core::SVDFQuantParams::effective_scale_1_b, onert_micro::core::SVDFQuantParams::effective_scale_2_a, onert_micro::core::SVDFQuantParams::effective_scale_2_b, onert_micro::core::SVDFQuantParams::input_zero_point, onert_micro::Ok, output_shape, onert_micro::core::SVDFQuantParams::output_zero_point, and onert_micro::core::SVDFQuantParams::rank.

Referenced by onert_micro::execute::execute_kernel_CircleSVDF().

SVDF() [2/2]

OMStatus onert_micro::execute::pal::SVDF	(	const float *	input_data,
		const float *	weights_feature_data,
		const float *	weights_time_data,
		const float *	bias_data,
		float *	state_data,
		float *	scratch_data,
		float *	output_data,
		const int	rank,
		const int	input_size,
		const int	batch_size,
		const int	num_filters,
		const int	num_units,
		const int	memory_size,
		const circle::ActivationFunctionType	activation
	)

Definition at line 138 of file PALSVDFCommon.h.

{
  // Left shift the activation_state.
  {
    float *new_state_start = state_data;
    const float *old_state_start = state_data + 1;
    const float *old_state_end = state_data + batch_size * num_filters * memory_size;
    while (old_state_start != old_state_end)
    {
      *new_state_start++ = *old_state_start++;
    }
  }
 
  // Note: no need to clear the latest activation, matmul is not accumulative.
 
  // Compute conv1d(inputs, weights_feature).
  // The activation_state's rightmost column is used to save current cycle
  // activation. This is achieved by starting at state_ptr[memory_size - 1] and
  // having the stride equal to memory_size.
 
  // Perform batched matrix vector multiply operation:
  {
    const float *matrix = weights_feature_data;
    const float *vector = input_data;
    float *result = &state_data[memory_size - 1];
    float *result_in_batch = result;
    for (int i = 0; i < batch_size; ++i)
    {
      const float *matrix_ptr = matrix;
      for (int j = 0; j < num_filters; ++j)
      {
        float dot_prod = 0.0f;
        const float *vector_in_batch = vector + i * input_size;
        for (int k = 0; k < input_size; ++k)
        {
          dot_prod += *matrix_ptr++ * *vector_in_batch++;
        }
        *result_in_batch = dot_prod;
        result_in_batch += memory_size;
      }
    }
  }
 
  applyTimeWeightsBiasAndActivation(batch_size, memory_size, num_filters, num_units, rank,
                                    weights_time_data, bias_data, activation, state_data,
                                    scratch_data, output_data);
  return Ok;
}

References onert_micro::Ok.

Tanh()

template<typename T >

OMStatus onert_micro::execute::pal::Tanh ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 31 of file PALTanhCommon.h.

{
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
 
  for (int i = 0; i < flat_size; i++)
  {
    output_data[i] = std::tanh(input_data[i]);
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Transpose()

template<typename T , int N = 5>

OMStatus onert_micro::execute::pal::Transpose ( const core::TransposeParams &  params, const core::OMRuntimeShape &  unextended_input_shape, const T *  input_data, const core::OMRuntimeShape &  unextended_output_shape, T *  output_data  )

inline

Definition at line 78 of file PALTransposeCommon.h.

{
  // Transpose kernel only does rearranging values not numeric evaluations on
  // each cell. It's safe to implement per size of scalar type and this trick
  // keeps the total code size in a reasonable range.
  OMStatus status;
  switch (sizeof(T))
  {
    case 1:
      status = TransposeImpl<int8_t, N>(
        params, unextended_input_shape, reinterpret_cast<const int8_t *>(input_data),
        unextended_output_shape, reinterpret_cast<int8_t *>(output_data));
      break;
    case 2:
      status = TransposeImpl<int16_t, N>(
        params, unextended_input_shape, reinterpret_cast<const int16_t *>(input_data),
        unextended_output_shape, reinterpret_cast<int16_t *>(output_data));
      break;
 
    case 4:
      status = TransposeImpl<int32_t, N>(
        params, unextended_input_shape, reinterpret_cast<const int32_t *>(input_data),
        unextended_output_shape, reinterpret_cast<int32_t *>(output_data));
      break;
    case 8:
      status = TransposeImpl<int64_t, N>(
        params, unextended_input_shape, reinterpret_cast<const int64_t *>(input_data),
        unextended_output_shape, reinterpret_cast<int64_t *>(output_data));
      break;
    default:
      status = UnknownError;
      break;
  }
  return status;
}

References onert_micro::UnknownError.

TransposeConv()

template<typename T >

OMStatus onert_micro::execute::pal::TransposeConv ( const core::FloatConv2D *  params, const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  filter_shape, const T *  filter_data, const T *  bias_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 35 of file PALTransposeConvCommon.h.

{
  assert(false && "Not IMPL yet");
}

TransposeConv< float >()

template<>

OMStatus onert_micro::execute::pal::TransposeConv< float > ( const core::FloatConv2D *  params, const core::OMRuntimeShape &  input_shape, const float *  input_data, const core::OMRuntimeShape &  filter_shape, const float *  filter_data, const float *  bias_data, const core::OMRuntimeShape &  output_shape, float *  output_data  )

inline

Definition at line 42 of file PALTransposeConvCommon.h.

{
  const int stride_width = params->stride_w;
  const int stride_height = params->stride_h;
  const int pad_width = params->pad_w;
  const int pad_height = params->pad_h;
 
  const int batches = input_shape.dims(0);
  const int input_depth = input_shape.dims(3);
  const int output_depth = filter_shape.dims(0);
  const int input_height = input_shape.dims(1);
  const int input_width = input_shape.dims(2);
  const int filter_height = filter_shape.dims(1);
  const int filter_width = filter_shape.dims(2);
  const int output_height = output_shape.dims(1);
  const int output_width = output_shape.dims(2);
  const float output_activation_min = params->activation_min;
  const float output_activation_max = params->activation_max;
 
  // Although transpose convolution simplifies to convolution with transposed
  // weights for strides of 1, non-unitary striding complicates matters. To
  // keep this reference implementation as clear as possible, we use a
  // "scatter" access pattern, where we loop through all the input elements,
  // computing their influence on the output, rather than looping through the
  // output elements in the typical "gather" access pattern of a conv. We
  // therefore must initialize the output array to zero.
  const int num_elements = output_shape.flatSize();
  for (int i = 0; i < num_elements; i++)
  {
    output_data[i] = 0.0f;
  }
 
  // Loop through input elements one at a time.
  for (int batch = 0; batch < batches; ++batch)
  {
    for (int in_y = 0; in_y < input_height; ++in_y)
    {
      for (int in_x = 0; in_x < input_width; ++in_x)
      {
        for (int in_channel = 0; in_channel < input_depth; ++in_channel)
        {
          // Loop through the output elements it will influence
          const int out_x_origin = (in_x * stride_width) - pad_width;
          const int out_y_origin = (in_y * stride_height) - pad_height;
          for (int filter_y = 0; filter_y < filter_height; ++filter_y)
          {
            for (int filter_x = 0; filter_x < filter_width; ++filter_x)
            {
              for (int out_channel = 0; out_channel < output_depth; ++out_channel)
              {
                // Compute output element location
                const int out_x = out_x_origin + filter_x;
                const int out_y = out_y_origin + filter_y;
                // We cannot accumulate out of bounds
                if ((out_x >= 0) && (out_x < output_width) && (out_y >= 0) &&
                    (out_y < output_height))
                {
                  float input_value =
                    input_data[offset(input_shape.dimsData(), batch, in_y, in_x, in_channel)];
                  float filter_value = filter_data[offset(filter_shape.dimsData(), out_channel,
                                                          filter_y, filter_x, in_channel)];
                  output_data[offset(output_shape.dimsData(), batch, out_y, out_x, out_channel)] +=
                    input_value * filter_value;
                }
              }
            }
          }
        }
      }
    }
  }
 
  for (int batch = 0; batch < batches; ++batch)
  {
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        for (int out_channel = 0; out_channel < output_depth; ++out_channel)
        {
          float acc =
            output_data[offset(output_shape.dimsData(), batch, out_y, out_x, out_channel)];
          if (bias_data)
            acc += bias_data[out_channel];
 
          output_data[offset(output_shape.dimsData(), batch, out_y, out_x, out_channel)] =
            activationFunctionWithMinMax(acc, output_activation_min, output_activation_max);
        }
      }
    }
  }
  return Ok;
}

References onert_micro::core::FloatConv2D::activation_max, onert_micro::core::FloatConv2D::activation_min, activationFunctionWithMinMax(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::dimsData(), onert_micro::core::OMRuntimeShape::dimsData(), luci_interpreter::RuntimeShape::flatSize(), offset(), onert_micro::Ok, output_shape, onert_micro::core::FloatConv2D::pad_h, onert_micro::core::FloatConv2D::pad_w, onert_micro::core::FloatConv2D::stride_h, and onert_micro::core::FloatConv2D::stride_w.

Referenced by onert_micro::execute::execute_kernel_CircleTransposeConv().

TransposeImpl()

template<typename T , int N>

OMStatus onert_micro::execute::pal::TransposeImpl ( const core::TransposeParams &  params, const core::OMRuntimeShape &  unextended_input_shape, const T *  input_data, const core::OMRuntimeShape &  unextended_output_shape, T *  output_data  )

inline

Definition at line 36 of file PALTransposeCommon.h.

{
  const int unextended_input_size = unextended_input_shape.dimensionsCount();
  const int unextended_output_size = unextended_output_shape.dimensionsCount();
 
  const int input_ext_size = N - unextended_input_size;
  const int output_ext_size = N - unextended_output_size;
  NdArrayDesc<N> input_desc;
  NdArrayDesc<N> output_desc;
  copyDimsToDesc(core::OMRuntimeShape::extendedShape(N, unextended_input_shape), &input_desc);
  copyDimsToDesc(core::OMRuntimeShape::extendedShape(N, unextended_output_shape), &output_desc);
 
  // The perm data is extended to match the output, each index incremented by
  // the amount of front padding of the input shape.
  int extended_perm[N];
  for (int i = 0; i < N; ++i)
  {
    extended_perm[i] = i < output_ext_size ? i : params.perm[i - output_ext_size] + input_ext_size;
  }
 
  // Permutes the input shape so we don't need to permute the indexes inside
  // the loop. Check to make sure output_dims is matching input_dims.
  NdArrayDesc<N> perm_input_desc;
  for (int k = 0; k < N; ++k)
  {
    perm_input_desc.extents[k] = input_desc.extents[extended_perm[k]];
    perm_input_desc.strides[k] = input_desc.strides[extended_perm[k]];
  }
 
  // Naive transpose loop (iterate on output index and compute input index).
  auto tranpose_func = [&](int indexes[N]) {
    output_data[subscriptToIndex(output_desc, indexes)] =
      input_data[subscriptToIndex(perm_input_desc, indexes)];
  };
  NDOpsHelper<N>(output_desc, tranpose_func);
  return Ok;
}

References copyDimsToDesc(), onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::extendedShape(), onert_micro::execute::pal::NdArrayDesc< N >::extents, onert_micro::Ok, onert_micro::core::TransposeParams::perm, onert_micro::execute::pal::NdArrayDesc< N >::strides, and subscriptToIndex().

UnaryOp()

template<typename T , typename Fn >

OMStatus onert_micro::execute::pal::UnaryOp ( const core::OMRuntimeShape &  input_shape, const T *  input_data, const core::OMRuntimeShape &  output_shape, T *  output_data  )

inline

Definition at line 40 of file PALUnaryOpCommon.h.

{
  Fn func;
  const uint32_t flat_size = input_shape.flatSize();
 
  if (flat_size == -1)
    return UnknownError;
 
  assert(input_data != nullptr);
  assert(output_data != nullptr);
 
  assert(input_shape == output_shape);
  for (int i = 0; i < flat_size; ++i)
  {
    output_data[i] = func(input_data[i]);
  }
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::Ok, output_shape, and onert_micro::UnknownError.

Unpack()

template<typename T >

OMStatus onert_micro::execute::pal::Unpack	(	const core::SplitParams &	params,
		const core::OMRuntimeShape &	input_shape,
		const T *	input_data,
		const core::OMRuntimeShape &	output_shape,
		int32_t	axis_value
	)

Definition at line 31 of file PALUnpack.h.

{
  const auto dimensions = input_shape.dimensionsCount();
 
  if (axis_value < 0)
  {
    axis_value += dimensions;
  }
 
  int outer_size = 1;
  for (int i = 0; i < axis_value; ++i)
  {
    outer_size *= input_shape.dims(i);
  }
  int copy_size = 1;
  for (int i = axis_value + 1; i < dimensions; ++i)
  {
    copy_size *= input_shape.dims(i);
  }
  int output_size = 1;
  for (int i = 0; i < output_shape.dimensionsCount(); ++i)
  {
    output_size *= output_shape.dims(i);
  }
 
  for (int i = 0; i < params.num_outputs; ++i)
  {
    T *output_data = core::utils::castOutputData<T>(params.output_data[i]);
    assert(output_data != nullptr);
    for (int k = 0; k < outer_size; ++k)
    {
      T *output_ptr = output_data + copy_size * k;
      int loc = k * params.num_outputs * copy_size + i * copy_size;
      const T *input_ptr = input_data + loc;
      for (int j = 0; j < copy_size; ++j)
        output_ptr[j] = input_ptr[j];
    }
  }
  return Ok;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::SplitParams::num_outputs, onert_micro::Ok, onert_micro::core::SplitParams::output_data, and output_shape.

Variable Documentation

MAX_INDICES_ND

constexpr int onert_micro::execute::pal::MAX_INDICES_ND = 5

constexpr

Definition at line 32 of file PALGatherND.h.

Referenced by onert_micro::import::configure_kernel_CircleGatherND(), and GatherND().