onert::backend::cpu::ops Namespace Reference

Data Structures
class	AddNLayer
class	ArgMinMaxLayer
class	AttentionLayer
class	BatchMatMulLayer
class	BatchToSpaceNDLayer
class	BinaryArithmeticLayer
class	BroadcastToLayer
class	CompareLayer
class	ConcatLayer
union	ConstDataPtr
class	ConvolutionLayer
union	DataPtr
class	DepthToSpaceLayer
class	DepthwiseConvolutionLayer
class	DetectionPostProcessLayer
class	DynamicUpdateSliceLayer
class	ElementwiseActivationLayer
class	ElementwiseBinaryLayer
class	ElementwiseUnaryLayer
class	ExpandDimsLayer
class	FillLayer
class	FullyConnectedLayer
class	FusedBatchNormLayer
class	GatherLayer
class	L2NormLayer
class	LogSoftMaxLayer
class	LSTMLayer
class	MeanLayer
class	OneHotLayer
class	PackLayer
class	PadLayer
class	PoolLayer
class	PowLayer
class	QuantizeLayer
class	RangeLayer
class	RankLayer
class	ReduceLayer
class	ReshapeLayer
class	ResizeBilinearLayer
class	ReverseLayer
class	RmsNormLayer
class	RoPELayer
class	SelectLayer
class	ShapeLayer
class	SliceLayer
class	SoftMaxLayer
class	SpaceToBatchNDLayer
class	SpaceToDepthLayer
class	SplitLayer
class	SplitVLayer
class	SqDiffLayer
class	StatelessRandomUniformLayer
class	StridedSliceLayer
class	TileLayer
class	TopKV2Layer
class	TransposeLayer
class	UnpackLayer

Enumerations
enum class	ArithmeticType { kAdd , kSub , kMul , kDiv }
enum class	ElementwiseActivationType {   kElu , kLogistic , kReLU , kTanh ,   kLeakyReLU , kGELU }
enum class	ElementwiseBinaryType {   kFloorDiv , kFloorMod , kLogicalAnd , kLogicalOr ,   kMax , kMin }
enum class	ElementwiseUnaryType {   kAbs , kCast , kCos , kDequantize ,   kErf , kExp , kFloor , kLog ,   kLogicalNot , kNeg , kQuantize , kRound ,   kRSqrt , kSin , kSqrt , kSquare ,   kZerosLike }
enum class	PoolType { kAvg , kL2 , kMax }
enum class	ReduceType {   kSum , kProd , kMax , kMin ,   kAny , kAll , kInvalid }

Functions
int32_t	blockSizeFor (int32_t index, int32_t block_size=32)
template<typename T >
Array< T >	toArray (uint8_t *ptr, std::vector< int32_t > &descr)
template<typename InputT , typename OutputT >
void	affineQuantize (const IPortableTensor *input, IPortableTensor *output)
uint32_t	getNumberOfDimensions (const IPortableTensor *tensor)
uint32_t	getNumberOfElements (const IPortableTensor *tensor)
uint32_t	getSizeOfDimension (const IPortableTensor *tensor, uint32_t dimensionIdx)
void	QuantizeMultiplier (double double_multiplier, int32_t *quantized_multiplier, int *shift)
void	GetQuantizedConvolutionMultiplier (const IPortableTensor *input, const IPortableTensor *filter, const IPortableTensor *bias, const IPortableTensor *output, double *multiplier)
void	GetQuantizedConvolutionMultipliersAndShifts (float input_scale, float output_scale, const float *filter_scales, size_t filter_scales_size, int num_channels, std::vector< int32_t > &per_channel_output_multiplier, std::vector< int > &per_channel_output_shift)
void	QuantizeMultiplierGreaterThanOne (double double_multiplier, int32_t *quantized_multiplier, int *left_shift)
void	CalculateActivationRangeQuantized (ir::Activation activation, const IPortableTensor *output, int32_t *act_min, int32_t *act_max)
bool	HaveSameShapes (const IPortableTensor *input1, const IPortableTensor *input2)
int32_t	CalculateInputRadius (int input_integer_bits, int input_left_shift)
uint32_t	sizeOfData (OperandType type, const std::vector< int32_t > &dimensions)
nnfw::cker::PaddingType	getPaddingType (ir::PaddingType ir_padding_type)
std::vector< int32_t >	getReducerAxes (const IPortableTensor *axes)
nnfw::cker::RoPEMode	getRoPEMode (ir::operation::RoPE::RoPEMode rope_mode)
nnfw::cker::Shape	getExtendedTensorShape (const IPortableTensor *tensor)
nnfw::cker::Shape	getShape (const IPortableTensor *tensor)
nnfw::cker::FusedActivationFunctionType	convertActivationType (const ir::Activation activation)
int32_t	getAxis (uint32_t rank, int32_t axis)
template<typename T >
const T *	getBuffer (const IPortableTensor *tensor)
template<typename T >
T *	getBuffer (IPortableTensor *tensor)
template<>
const bool *	getBuffer (const IPortableTensor *tensor)
template<>
bool *	getBuffer (IPortableTensor *tensor)
template<typename T >
void	GetRawShape (const IPortableTensor *input, T *output_data)

Enumeration Type Documentation

ArithmeticType

enum class onert::backend::cpu::ops::ArithmeticType

strong

Enumerator
kAdd
kSub
kMul
kDiv

Definition at line 28 of file BinaryArithmeticLayer.h.

{
  kAdd,
  kSub,
  kMul,
  kDiv,
};

ElementwiseActivationType

enum class onert::backend::cpu::ops::ElementwiseActivationType

strong

Enumerator
kElu
kLogistic
kReLU
kTanh
kLeakyReLU
kGELU

Definition at line 27 of file ElementwiseActivationLayer.h.

{
  kElu,
  kLogistic,
  kReLU,
  kTanh,
  kLeakyReLU,
  kGELU
};

ElementwiseBinaryType

enum class onert::backend::cpu::ops::ElementwiseBinaryType

strong

Enumerator
kFloorDiv
kFloorMod
kLogicalAnd
kLogicalOr
kMax
kMin

Definition at line 27 of file ElementwiseBinaryLayer.h.

{
  kFloorDiv,
  kFloorMod,
  kLogicalAnd,
  kLogicalOr,
  kMax,
  kMin,
};

ElementwiseUnaryType

enum class onert::backend::cpu::ops::ElementwiseUnaryType

strong

Enumerator
kAbs
kCast
kCos
kDequantize
kErf
kExp
kFloor
kLog
kLogicalNot
kNeg
kQuantize
kRound
kRSqrt
kSin
kSqrt
kSquare
kZerosLike

Definition at line 27 of file ElementwiseUnaryLayer.h.

{
  kAbs,
  kCast,
  kCos,
  kDequantize,
  kErf,
  kExp,
  kFloor,
  kLog,
  kLogicalNot,
  kNeg,
  kQuantize,
  kRound,
  kRSqrt,
  kSin,
  kSqrt,
  kSquare,
  kZerosLike
};

PoolType

enum class onert::backend::cpu::ops::PoolType

strong

Enumerator
kAvg
kL2
kMax

Definition at line 28 of file Pool2DLayer.h.

{
  kAvg,
  kL2,
  kMax,
};

ReduceType

enum class onert::backend::cpu::ops::ReduceType

strong

Enumerator
kSum
kProd
kMax
kMin
kAny
kAll
kInvalid

Definition at line 35 of file ReduceLayer.h.

{
  kSum,
  kProd,
  kMax,
  kMin,
  kAny,
  kAll,
  kInvalid // For debug and initialize
};

Function Documentation

affineQuantize()

template<typename InputT , typename OutputT >

void onert::backend::cpu::ops::affineQuantize	(	const IPortableTensor *	input,
		IPortableTensor *	output
	)

Definition at line 479 of file ElementwiseUnaryLayer.cc.

{
  nnfw::cker::Quantize(getShape(input), getBuffer<InputT>(input), getShape(output),
                       getBuffer<OutputT>(output), output->data_scale(), output->data_zero_point());
}

References getShape(), and nnfw::cker::Quantize().

blockSizeFor()

int32_t onert::backend::cpu::ops::blockSizeFor	(	int32_t	index,
		int32_t	block_size = 32
	)

Calculate the block-aligned size that includes the given index.

Parameters

index	The current token position (0-based index)
block_size	The minimum memory access unit (default: 32)

Returns

The smallest multiple of block_size that can include the given index

This function calculates the minimum block-aligned memory size needed to access data from position 0 up to and including the specified index.

Example with block_size = 32:

• If index = 0 (1st token) -> returns 32 (positions 0-31)
• If index = 31 (32nd token) -> returns 32 (positions 0-31)

This ensures block-aligned memory access for optimal performance.

Definition at line 157 of file AttentionLayer.cc.

{
  // We need to include index, so we calculate for index + 1 elements
  // Then round up to the nearest multiple of block_size
  const int32_t elements_needed = index + 1;
  return ((elements_needed + block_size - 1) / block_size) * block_size;
}

CalculateActivationRangeQuantized()

void onert::backend::cpu::ops::CalculateActivationRangeQuantized	(	ir::Activation	activation,
		const IPortableTensor *	output,
		int32_t *	act_min,
		int32_t *	act_max
	)

Definition at line 138 of file OperationUtils.cc.

{
  int32_t qmin = 0;
  int32_t qmax = 0;
 
  switch (output->data_type())
  {
    case OperandType::QUANT_UINT8_ASYMM:
      qmin = std::numeric_limits<uint8_t>::min();
      qmax = std::numeric_limits<uint8_t>::max();
      break;
    case OperandType::QUANT_INT8_ASYMM:
    case OperandType::QUANT_INT8_SYMM:
      qmin = std::numeric_limits<int8_t>::min();
      qmax = std::numeric_limits<int8_t>::max();
      break;
    default:
      throw std::runtime_error("CalculateActivationRangeQuantized: Not supported operand type.");
  }
 
  const auto scale = output->data_scale();
  const auto zero_point = output->data_zero_point();
  auto quantize = [scale, zero_point](float f) {
    return zero_point + static_cast<int32_t>(std::round(f / scale));
  };
  if (activation == ir::Activation::RELU)
  {
    *act_min = std::max(qmin, quantize(0.0));
    *act_max = qmax;
  }
  else if (activation == ir::Activation::RELU6)
  {
    *act_min = std::max(qmin, quantize(0.0));
    *act_max = std::min(qmax, quantize(6.0));
  }
  else if (activation == ir::Activation::RELU1)
  {
    *act_min = std::max(qmin, quantize(-1.0));
    *act_max = std::min(qmax, quantize(1.0));
  }
  else if (activation == ir::Activation::SIGMOID)
  {
    *act_min = std::max(qmin, quantize(0.0));
    *act_max = std::min(qmax, quantize(1.0));
  }
  else if (activation == ir::Activation::NONE)
  {
    *act_min = qmin;
    *act_max = qmax;
  }
  else
  {
    throw std::runtime_error{"Unsupported fused activation function."};
  }
}

References onert::ir::NONE, onert::ir::RELU, onert::ir::RELU1, onert::ir::RELU6, and onert::ir::SIGMOID.

Referenced by onert::backend::cpu::ops::PoolLayer::configure(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8i(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerChannel(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerTensor(), and onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedQuant8().

CalculateInputRadius()

int32_t onert::backend::cpu::ops::CalculateInputRadius	(	int	input_integer_bits,
		int	input_left_shift
	)

Definition at line 219 of file OperationUtils.cc.

{
  const double max_input_rescaled = 1.0 * ((1 << input_integer_bits) - 1) *
                                    (1ll << (31 - input_integer_bits)) / (1ll << input_left_shift);
  // Tighten bound using floor.  Suppose that we could use the exact value.
  // After scaling the difference, the result would be at the maximum.  Thus we
  // must ensure that our value has lower magnitude.
  return static_cast<int32_t>(std::floor(max_input_rescaled));
}

convertActivationType()

nnfw::cker::FusedActivationFunctionType onert::backend::cpu::ops::convertActivationType ( const ir::Activation  activation )

inline

Definition at line 106 of file OperationUtils.h.

{
  switch (activation)
  {
    case ir::Activation::NONE:
      return nnfw::cker::FusedActivationFunctionType::kNone;
    case ir::Activation::RELU:
      return nnfw::cker::FusedActivationFunctionType::kRelu;
    case ir::Activation::RELU1:
      return nnfw::cker::FusedActivationFunctionType::kRelu1;
    case ir::Activation::RELU6:
      return nnfw::cker::FusedActivationFunctionType::kRelu6;
    case ir::Activation::TANH:
      return nnfw::cker::FusedActivationFunctionType::kTanh;
    case ir::Activation::SIGMOID:
      return nnfw::cker::FusedActivationFunctionType::kSigmoid;
    default:
      throw std::runtime_error{"CPU backend: Cannot convert activation type"};
  }
}

References nnfw::cker::kNone, nnfw::cker::kRelu, nnfw::cker::kRelu1, nnfw::cker::kRelu6, nnfw::cker::kSigmoid, nnfw::cker::kTanh, onert::ir::NONE, onert::ir::RELU, onert::ir::RELU1, onert::ir::RELU6, onert::ir::SIGMOID, and onert::ir::TANH.

Referenced by onert::backend::cpu::ops::FullyConnectedLayer::fullyConnected16x1Float32(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedFloat32(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedHybrid(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedSparseWeight(), and onert::backend::cpu::ops::LSTMLayer::LSTMFloat().

getAxis()

int32_t onert::backend::cpu::ops::getAxis ( uint32_t  rank, int32_t  axis  )

inline

Definition at line 127 of file OperationUtils.h.

{
  auto ret = axis;
 
  if (axis < 0)
  {
    ret += rank;
  }
 
  return ret;
}

getBuffer() [1/4]

template<typename T >

const T * onert::backend::cpu::ops::getBuffer

(

const IPortableTensor *

tensor

)

Definition at line 169 of file OperationUtils.h.

{
  return reinterpret_cast<const T *>(tensor->buffer());
}

References getBuffer().

Referenced by getBuffer(), and getBuffer().

getBuffer() [2/4]

template<>

const bool * onert::backend::cpu::ops::getBuffer ( const IPortableTensor *  tensor )

inline

Definition at line 179 of file OperationUtils.h.

{
  static_assert(sizeof(bool) == 1, "cpu backend supports bool type which is 1 byte");
  return reinterpret_cast<const bool *>(tensor->buffer());
}

References getBuffer().

getBuffer() [3/4]

template<typename T >

T * onert::backend::cpu::ops::getBuffer

(

IPortableTensor *

tensor

)

Definition at line 174 of file OperationUtils.h.

{
  return reinterpret_cast<T *>(tensor->buffer());
}

References getBuffer().

getBuffer() [4/4]

template<>

bool * onert::backend::cpu::ops::getBuffer ( IPortableTensor *  tensor )

inline

Definition at line 185 of file OperationUtils.h.

{
  static_assert(sizeof(bool) == 1, "cpu backend supports bool type which is 1 byte");
  return reinterpret_cast<bool *>(tensor->buffer());
}

References getBuffer().

getExtendedTensorShape()

nnfw::cker::Shape onert::backend::cpu::ops::getExtendedTensorShape ( const IPortableTensor *  tensor )

inline

Definition at line 67 of file OperationUtils.h.

{
  assert(tensor);
  const int32_t extended_rank = 4;
  int32_t raw_shape[extended_rank];
  auto shape = tensor->getShape();
  uint32_t src = extended_rank - shape.rank();
  for (uint32_t i = 0; i < extended_rank; ++i)
  {
    if (i < src)
    {
      raw_shape[i] = 1;
    }
    else
    {
      raw_shape[i] = shape.dim(i - src);
    }
  }
 
  return nnfw::cker::Shape(extended_rank, raw_shape);
}

getNumberOfDimensions()

uint32_t onert::backend::cpu::ops::getNumberOfDimensions

(

const IPortableTensor *

tensor

)

Definition at line 26 of file OperationUtils.cc.

{
  assert(tensor);
  return tensor->getShape().rank();
}

References getNumberOfDimensions().

getNumberOfElements()

uint32_t onert::backend::cpu::ops::getNumberOfElements

(

const IPortableTensor *

tensor

)

Definition at line 32 of file OperationUtils.cc.

{
  assert(tensor);
  uint32_t count = 1;
  auto shape = tensor->getShape();
  for (int i = 0; i < shape.rank(); i++)
  {
    count *= shape.dim(i);
  }
  return count;
}

References getNumberOfElements().

getPaddingType()

nnfw::cker::PaddingType onert::backend::cpu::ops::getPaddingType

(

ir::PaddingType

ir_padding_type

)

Definition at line 262 of file OperationUtils.cc.

{
  switch (ir_padding_type)
  {
    case ir::PaddingType::EXPLICIT:
      return nnfw::cker::PaddingType::kNone;
    case ir::PaddingType::SAME:
      return nnfw::cker::PaddingType::kSame;
    case ir::PaddingType::VALID:
      return nnfw::cker::PaddingType::kValid;
    default:
      throw std::runtime_error("Wrong padding type.");
      break;
  }
}

References onert::ir::EXPLICIT, getPaddingType(), nnfw::cker::kNone, nnfw::cker::kSame, nnfw::cker::kValid, onert::ir::SAME, and onert::ir::VALID.

Referenced by getPaddingType(), and onert::backend::cpu::ops::ConvolutionLayer::prepare().

GetQuantizedConvolutionMultiplier()

void onert::backend::cpu::ops::GetQuantizedConvolutionMultiplier	(	const IPortableTensor *	input,
		const IPortableTensor *	filter,
		const IPortableTensor *	bias,
		const IPortableTensor *	output,
		double *	multiplier
	)

Definition at line 77 of file OperationUtils.cc.

{
  const double input_product_scale = input->data_scale() * filter->data_scale();
  [[maybe_unused]] const double bias_scale =
    (bias != nullptr) ? bias->data_scale() : input_product_scale;
  const double output_scale = output->data_scale();
  // The following conditions must be guaranteed by the training pipeline.
  assert(std::abs(input_product_scale - bias_scale) <=
         1e-6 * std::min(input_product_scale, bias_scale));
  assert(input_product_scale >= 0);
  assert(input_product_scale < output_scale);
  *multiplier = input_product_scale / output_scale;
}

Referenced by onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerTensor(), and onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedQuant8().

GetQuantizedConvolutionMultipliersAndShifts()

void onert::backend::cpu::ops::GetQuantizedConvolutionMultipliersAndShifts	(	float	input_scale,
		float	output_scale,
		const float *	filter_scales,
		size_t	filter_scales_size,
		int	num_channels,
		std::vector< int32_t > &	per_channel_output_multiplier,
		std::vector< int > &	per_channel_output_shift
	)

Definition at line 93 of file OperationUtils.cc.

{
  // Originates from tflite's PopulateConvolutionQuantizationParams()
  per_channel_output_multiplier.resize(num_channels);
  per_channel_output_shift.resize(num_channels);
 
  const bool is_per_channel = filter_scales_size > 1;
  auto per_channel_multiplier = per_channel_output_multiplier.data();
  auto per_channel_shift = per_channel_output_shift.data();
  for (int i = 0; i < num_channels; ++i)
  {
    // If per-tensor quantization parameter is specified, broadcast it along the
    // quantization dimension (channels_out).
    const float scale = is_per_channel ? filter_scales[i] : filter_scales[0];
    const double filter_scale = static_cast<double>(scale);
    const double effective_output_scale =
      static_cast<double>(input_scale) * filter_scale / static_cast<double>(output_scale);
    int32_t significand;
    int channel_shift;
    QuantizeMultiplier(effective_output_scale, &significand, &channel_shift);
    per_channel_multiplier[i] = significand;
    per_channel_shift[i] = channel_shift;
  }
}

References QuantizeMultiplier().

Referenced by onert::backend::cpu::ops::ConvolutionLayer::prepare().

GetRawShape()

template<typename T >

void onert::backend::cpu::ops::GetRawShape	(	const IPortableTensor *	input,
		T *	output_data
	)

Definition at line 53 of file ShapeLayer.cc.

{
  auto shape = input->getShape();
  for (int i = 0; i < shape.rank(); ++i)
  {
    output_data[i] = static_cast<T>(shape.dim(i));
  }
}

Referenced by onert::backend::cpu::ops::ShapeLayer::run().

getReducerAxes()

std::vector< int32_t > onert::backend::cpu::ops::getReducerAxes

(

const IPortableTensor *

axes

)

Definition at line 278 of file OperationUtils.cc.

{
  std::vector<int32_t> ret;
 
  auto axes_vals = (axes->getShape().rank() == 0) ? 1 : axes->getShape().dim(0);
  assert(static_cast<size_t>(axes_vals) == axes->getShape().num_elements());
  switch (axes->data_type())
  {
    case ir::DataType::INT32:
    {
      for (int i = 0; i < axes_vals; ++i)
        ret.emplace_back(*(getBuffer<int32_t>(axes) + i));
      break;
    }
    case ir::DataType::INT64:
    {
      for (int i = 0; i < axes_vals; ++i)
        ret.emplace_back(*(getBuffer<int64_t>(axes) + i));
      break;
    }
    default:
      throw std::runtime_error("getReducerAxes: Not supported data type");
      break;
  }
  return ret;
}

References onert::backend::IPortableTensor::data_type(), and onert::backend::IPortableTensor::getShape().

Referenced by onert::backend::train::ops::MeanLayer::backward(), onert::backend::cpu::ops::MeanLayer::MeanFloat32(), onert::backend::cpu::ops::MeanLayer::MeanQuant8(), and onert::backend::cpu::ops::ReduceLayer::run().

getRoPEMode()

nnfw::cker::RoPEMode onert::backend::cpu::ops::getRoPEMode

(

ir::operation::RoPE::RoPEMode

rope_mode

)

Definition at line 305 of file OperationUtils.cc.

{
  switch (rope_mode)
  {
    case ir::operation::RoPE::RoPEMode::GPT_NEOX:
      return nnfw::cker::RoPEMode::kGptNeox;
    case ir::operation::RoPE::RoPEMode::GPT_J:
      return nnfw::cker::RoPEMode::kGptJ;
    default:
      throw std::runtime_error("Wrong rope mode.");
      break;
  }
}

References onert::ir::operation::RoPE::GPT_J, onert::ir::operation::RoPE::GPT_NEOX, nnfw::cker::kGptJ, and nnfw::cker::kGptNeox.

getShape()

nnfw::cker::Shape onert::backend::cpu::ops::getShape ( const IPortableTensor *  tensor )

inline

Definition at line 89 of file OperationUtils.h.

{
  if (tensor == nullptr)
    return nnfw::cker::Shape();
 
  const ir::Shape &shape = tensor->get_info().shape();
  auto rank = shape.rank();
  nnfw::cker::Shape ret(rank);
  auto data = ret.DimsData();
  for (int i = 0; i < rank; ++i)
  {
    data[i] = shape.dim(i);
  }
  return ret;
}

References nnfw::cker::Shape::DimsData().

Referenced by affineQuantize(), onert::backend::cpu::ops::BatchMatMulLayer::batchMatMulFloat32(), onert::backend::cpu::ops::BatchToSpaceNDLayer::batchToSpaceNDGeneric(), onert::backend::cpu::ops::ConcatLayer::concatenationGeneral(), onert::backend::cpu::ops::ConcatLayer::concatenationQuant8(), onert::backend::cpu::ops::AttentionLayer::configure(), onert::backend::cpu::ops::ElementwiseActivationLayer::configure(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convFloat32(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8i(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8iHybridPerChannel(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerChannel(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerTensor(), onert::backend::cpu::ops::ElementwiseActivationLayer::EvalUsingLookupTable(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnected16x1Float32(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedFloat32(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedHybrid(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedQuant8(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedSparseWeight(), onert::backend::cpu::ops::FusedBatchNormLayer::fusedbatchnormFloat32(), onert::backend::cpu::ops::LogSoftMaxLayer::logsoftmaxFloat32(), onert::backend::cpu::ops::LogSoftMaxLayer::logsoftmaxQuant8(), onert::backend::cpu::ops::MeanLayer::MeanFloat32(), onert::backend::cpu::ops::MeanLayer::MeanQuant8(), onert::backend::cpu::ops::OneHotLayer::oneHotImpl(), onert::backend::cpu::ops::PackLayer::packImpl(), onert::backend::cpu::ops::PadLayer::padImpl(), onert::backend::cpu::ops::PowLayer::powFloat32(), onert::backend::cpu::ops::ConvolutionLayer::prepare(), onert::backend::cpu::ops::FullyConnectedLayer::prepare(), onert::backend::cpu::ops::AddNLayer::run(), onert::backend::cpu::ops::BroadcastToLayer::run(), onert::backend::cpu::ops::DynamicUpdateSliceLayer::run(), onert::backend::cpu::ops::QuantizeLayer::run(), onert::backend::cpu::ops::FillLayer::run(), onert::backend::cpu::ops::L2NormLayer::run(), onert::backend::cpu::ops::ReduceLayer::run(), onert::backend::cpu::ops::ResizeBilinearLayer::run(), onert::backend::cpu::ops::ReverseLayer::run(), onert::backend::cpu::ops::RmsNormLayer::run(), onert::backend::cpu::ops::TopKV2Layer::run(), onert::backend::cpu::ops::SoftMaxLayer::softmaxFloat32(), onert::backend::cpu::ops::SoftMaxLayer::softmaxQuant8(), onert::backend::cpu::ops::SplitLayer::split(), onert::backend::cpu::ops::SplitVLayer::splitV(), onert::backend::cpu::ops::SqDiffLayer::SqDiffFloat32(), onert::backend::cpu::ops::StatelessRandomUniformLayer::StatelessRandomUniformFloat32(), onert::backend::cpu::ops::TileLayer::tileFloat32(), and onert::backend::cpu::ops::TransposeLayer::transpose().

getSizeOfDimension()

uint32_t onert::backend::cpu::ops::getSizeOfDimension	(	const IPortableTensor *	tensor,
		uint32_t	dimensionIdx
	)

Definition at line 44 of file OperationUtils.cc.

{
  assert(tensor);
  auto shape = tensor->getShape();
  if (dimensionIdx >= static_cast<uint32_t>(shape.rank()))
  {
    // TODO, log the error
    return 0;
  }
  return shape.dim(dimensionIdx);
}

References getSizeOfDimension().

HaveSameShapes()

bool onert::backend::cpu::ops::HaveSameShapes	(	const IPortableTensor *	input1,
		const IPortableTensor *	input2
	)

Definition at line 195 of file OperationUtils.cc.

{
  if (input1 == input2)
    return true;
  if (input2 == NULL || input2 == NULL)
    return false;
 
  if (input1 == NULL)
  {
    return (getNumberOfDimensions(input2) == 0);
  }
 
  if (getNumberOfDimensions(input1) != getNumberOfDimensions(input2))
    return false;
 
  auto shape1 = input1->getShape();
  auto shape2 = input2->getShape();
  for (uint32_t i = 0; i < getNumberOfDimensions(input1); i++)
    if (shape1.dim(i) != shape2.dim(i))
      return false;
 
  return true;
}

References getNumberOfDimensions(), and onert::backend::IPortableTensor::getShape().

Referenced by onert::backend::cpu::ops::PowLayer::powFloat32(), and onert::backend::cpu::ops::SelectLayer::run().

QuantizeMultiplier()

void onert::backend::cpu::ops::QuantizeMultiplier	(	double	double_multiplier,
		int32_t *	quantized_multiplier,
		int *	shift
	)

Definition at line 56 of file OperationUtils.cc.

{
  if (double_multiplier == 0.)
  {
    *quantized_multiplier = 0;
    *shift = 0;
    return;
  }
  const double q = std::frexp(double_multiplier, shift);
  auto q_fixed = static_cast<int64_t>(std::round(q * (1ll << 31)));
 
  assert(q_fixed <= (1ll << 31));
  if (q_fixed == (1ll << 31))
  {
    q_fixed /= 2;
    ++*shift;
  }
  assert(q_fixed <= std::numeric_limits<int32_t>::max());
  *quantized_multiplier = static_cast<int32_t>(q_fixed);
}

Referenced by onert::backend::cpu::ops::QuantizeLayer::configure(), onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerTensor(), onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedQuant8(), and GetQuantizedConvolutionMultipliersAndShifts().

QuantizeMultiplierGreaterThanOne()

void onert::backend::cpu::ops::QuantizeMultiplierGreaterThanOne	(	double	double_multiplier,
		int32_t *	quantized_multiplier,
		int *	left_shift
	)

Definition at line 121 of file OperationUtils.cc.

{
  assert(double_multiplier > 1.);
  const double q = std::frexp(double_multiplier, left_shift);
  int64_t q_fixed = static_cast<int64_t>(std::round(q * (1ll << 31)));
  assert(q_fixed <= (1ll << 31));
  if (q_fixed == (1ll << 31))
  {
    q_fixed /= 2;
    ++*left_shift;
  }
  assert(*left_shift >= 0);
  assert(q_fixed <= std::numeric_limits<int32_t>::max());
  *quantized_multiplier = static_cast<int32_t>(q_fixed);
}

sizeOfData()

uint32_t onert::backend::cpu::ops::sizeOfData	(	OperandType	type,
		const std::vector< int32_t > &	dimensions
	)

Definition at line 229 of file OperationUtils.cc.

{
  uint32_t size = 4;
 
  switch (type)
  {
    case OperandType::FLOAT32:
    case OperandType::INT32:
    case OperandType::UINT32:
      size = 4;
      break;
    case OperandType::BOOL8:
    case OperandType::QUANT_UINT8_ASYMM:
    case OperandType::QUANT_INT8_SYMM:
      size = 1;
      break;
    case OperandType::INT64:
      size = 8;
      break;
    default:
      throw std::runtime_error("Not supported operand type.");
      break;
  }
 
  for (auto &&d : dimensions)
  {
    assert(d >= 0);
    size *= static_cast<uint32_t>(d);
  }
 
  return size;
}

References size, and type.

Referenced by onert::backend::cpu::ops::SplitLayer::split(), and onert::backend::cpu::ops::SplitVLayer::splitV().

toArray()

template<typename T >

Array< T > onert::backend::cpu::ops::toArray	(	uint8_t *	ptr,
		std::vector< int32_t > &	descr
	)

Definition at line 313 of file DetectionPostProcessLayer.cc.

{
  ndarray::Shape shape(descr.size());
  for (size_t i = 0; i < descr.size(); ++i)
  {
    shape.dim(i) = descr[i];
  }
 
  return Array<T>{reinterpret_cast<T *>(ptr), shape};
}

References ndarray::Shape::dim().