onert_micro::execute::pal Namespace Reference

Data Structures
struct	AddFn
struct	DivFn
struct	FloorDivFn
struct	FloorModFn
struct	MaximumFn
struct	MinimumFn
struct	MulFn
struct	NdArrayDesc
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 >
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 >
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)
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 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	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	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	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 , 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 InputType , typename OutputType >
OMStatus	Mul (const core::ArithmeticQuantParams &params, uint32_t size, const InputType *input1_data, const InputType *input2_data, OutputType *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.

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.

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.

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.

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

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.

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 93 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 224 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.

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.

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.

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 145 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 156 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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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.

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.

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

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

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

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.

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(), and BroadcastArithmeticOp4DSlow().

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

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

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

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.

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.

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

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

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.

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.

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.

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

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.

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

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.

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(), and BroadcastMul6DSlow().

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.

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

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

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

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.

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.

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

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.

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

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.

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

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.

SISOOperation()

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.

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.

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.

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.

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.

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.

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.

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

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.

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