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

Data Structures
class	AddNLayer
class	ArgMinMaxLayer
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	EinsumLayer
class	ElementwiseActivationLayer
class	ElementwiseBinaryLayer
class	ElementwiseUnaryLayer
class	ExpandDimsLayer
class	FillLayer
class	FullyConnectedLayer
class	FusedBatchNormLayer
class	GatherLayer
class	L2NormLayer
class	LogSoftMaxLayer
class	LSTMLayer
class	MatrixBandPartLayer
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	TransposeLayer
class	UnpackLayer

Enumerations
enum class	ArithmeticType { kAdd , kSub , kMul , kDiv }
enum class	ElementwiseActivationType {   kElu , kLogistic , kReLU , kTanh ,   kLeakyReLU }
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
template<typename T >
Array< T >	toArray (uint8_t *ptr, std::vector< int32_t > &descr)
ggml_type	getGGMLType (ir::DataType type)
struct ggml_tensor	getGGMLTensor (const IPortableTensor *tensor)
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 InputT , typename OutputT >
void	affineQuantize (const IPortableTensor *input, IPortableTensor *output)
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

Definition at line 27 of file ElementwiseActivationLayer.h.

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

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 PoolLayer.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 30 of file QuantizeLayer.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().

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

getGGMLTensor()

struct ggml_tensor onert::backend::cpu::ops::getGGMLTensor

(

const IPortableTensor *

tensor

)

Definition at line 41 of file GGMLHelper.cc.

{
  struct ggml_tensor res;
 
  res.type = getGGMLType(tensor->data_type());
  const auto rank = tensor->getShape().rank();
  for (int i = 0; i < GGML_MAX_DIMS; ++i)
  {
    if (i >= rank)
      res.ne[i] = 1;
    else
      res.ne[i] = tensor->getShape().dim(rank - i - 1);
  }
 
  res.nb[0] = ggml_type_size(res.type);
  res.nb[1] = res.nb[0] * (res.ne[0] / ggml_blck_size(res.type));
  for (int i = 2; i < GGML_MAX_DIMS; ++i)
    res.nb[i] = res.nb[i - 1] * res.ne[i - 1];
 
  res.op = GGML_OP_NONE;
  res.grad = nullptr;
  res.data = (void *)(tensor->buffer());
 
  return res;
}

References getGGMLType().

Referenced by onert::backend::cpu::ops::FullyConnectedLayer::fullyConnectedGGMLWeight().

getGGMLType()

ggml_type onert::backend::cpu::ops::getGGMLType

(

ir::DataType

type

)

Definition at line 22 of file GGMLHelper.cc.

{
  switch (type)
  {
    case ir::DataType::FLOAT32:
      return GGML_TYPE_F32;
    case ir::DataType::QUANT_GGML_Q4_0:
      return GGML_TYPE_Q4_0;
    case ir::DataType::QUANT_GGML_Q8_0:
      return GGML_TYPE_Q8_0;
    case ir::DataType::INT32:
      return GGML_TYPE_I32;
    case ir::DataType::INT64:
      return GGML_TYPE_I64;
    default:
      throw std::runtime_error("Unsupported data type");
  }
}

Referenced by getGGMLTensor().

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 29 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::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::EinsumLayer::einsumFloat32(), 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::MatrixBandPartLayer::matrixBandPartFloat32(), 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::FillLayer::run(), onert::backend::cpu::ops::L2NormLayer::run(), onert::backend::cpu::ops::QuantizeLayer::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::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.

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