Data Structures
struct	AbsImpl

struct	AbsImpl< uint8_t >

struct	AddImpl

struct	AddImpl< uint8_t >

class	AvgPool2DImpl

struct	AvgPool2DImpl< uint8_t >

struct	CappedReLUImpl

struct	CappedReLUImpl< uint8_t >

struct	ConcatImpl

struct	ConcatImpl< uint8_t >

struct	Conv2DImpl

struct	Conv2DImpl< uint8_t >

struct	DeConv2DImpl

struct	DepthwiseConv2DImpl

struct	DepthwiseConv2DImpl< uint8_t >

struct	DivImpl

struct	DivImpl< uint8_t >

struct	ELUImpl

struct	EqualImpl

struct	FillImpl

struct	FullyConnectedImpl

struct	FullyConnectedImpl< uint8_t >

struct	GatherByT

struct	GatherImpl

struct	GreaterImpl

struct	HardSwishImpl

struct	HardSwishImpl< uint8_t >

struct	LeakyReLUImpl

struct	LessImpl

struct	MaxImpl

struct	MaxImpl< uint8_t >

struct	MaxPool2DImpl

struct	MaxPool2DImpl< uint8_t >

class	MIRInterpreter

struct	MulImpl

struct	MulImpl< uint8_t >

struct	PadImpl

struct	ReduceMeanImpl

struct	ReLUImpl

struct	ReLUImpl< uint8_t >

struct	SigmoidImpl

struct	SigmoidImpl< uint8_t >

struct	SliceImpl

struct	SoftmaxImpl

struct	SoftmaxImpl< uint8_t >

struct	SqrtImpl

struct	SqrtImpl< uint8_t >

struct	SubImpl

struct	SubImpl< uint8_t >

struct	TanhImpl

struct	TanhImpl< uint8_t >

struct	TransposeImpl

Functions
void	Abs (const mir::TensorVariant &arg, mir::TensorVariant &result)

void	Add (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

void	AvgPool2D (const mir::ops::AvgPool2DOp &op, const mir::TensorVariant &input, mir::TensorVariant &output)

void	CappedReLU (const mir::TensorVariant &arg, float cap, mir::TensorVariant &result)

Index	shift (const Index &in_index, const Shape &shift_from)

template<template< typename > class F, typename... Args>
void	dispatch (mir::DataType dt, Args &&...args)

template<typename T >
void	erase (mir::TensorVariant &tv)

void	Concat (const std::vector< std::reference_wrapper< const mir::TensorVariant > > &inputs, int axis, mir::TensorVariant &output)

void	Conv2D (const mir::TensorVariant &input, const mir::TensorVariant &kernel, const mir::Conv2DOpAttributes &attributes, mir::TensorVariant &result, const mir::TensorVariant *fused_bias)

void	DeConv2D (const mir::TensorVariant &input, const mir::TensorVariant &kernel, const mir::Deconv2DOpAttributes &attributes, mir::TensorVariant &output)
	Transposed convolution (or Deconvolution)

void	DepthwiseConv2D (const mir::ops::DepthwiseConv2DOp &op, const mir::TensorVariant &input, const mir::TensorVariant &kernel, mir::TensorVariant &output, const mir::TensorVariant *bias)

void	Div (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

void	ELU (const mir::TensorVariant &arg, float alpha, mir::TensorVariant &result)

void	Equal (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

template<typename F >
void	Fill (mir::TensorVariant &t, F f)

void	FullyConnected (const mir::TensorVariant &input, const mir::TensorVariant &weights, const mir::ops::FullyConnectedOp &op, mir::TensorVariant &res, const mir::TensorVariant *bias)

void	Gather (const TensorVariant &data, const TensorVariant &indices, const ops::GatherOp &op, TensorVariant &res)

void	Greater (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

void	HardSwish (const mir::TensorVariant &input, mir::TensorVariant &result)

void	LeakyReLU (const mir::TensorVariant &arg, float alpha, mir::TensorVariant &result)

void	Less (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

void	Max (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

void	MaxPool2D (const mir::TensorVariant &input, const mir::ops::MaxPool2DOp &op, mir::TensorVariant &result)

void	Mul (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

void	Pad (const mir::TensorVariant &input, const mir::ops::PadOp &op, mir::TensorVariant &result)
	Implements PadOp for interpreter backend.

void	Dequantize (const TensorVariant &input, TensorVariant &output)

void	Quantize (const TensorVariant &input, TensorVariant &output)

void	QuantizeMultiplier (double double_multiplier, int32_t quantized_multiplier, int shift)

void	QuantizeMultiplierSmallerThanOneExp (double double_multiplier, int32_t quantized_multiplier, int left_shift)

int32_t	MaskIfNonZero (int32_t a)

int32_t	MaskIfZero (int32_t a)

int32_t	MaskIfLessThan (int32_t a, int32_t b)

int32_t	MaskIfGreaterThan (int32_t a, int32_t b)

int32_t	RoundingDivideByPOT (int32_t x, int exponent)

std::int32_t	SaturatingRoundingDoublingHighMul (std::int32_t a, std::int32_t b)

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)

void	ReduceMean (const mir::TensorVariant &input, const mir::ops::ReduceMeanOp &op, mir::TensorVariant &output)

void	ReLU (const mir::TensorVariant &arg, mir::TensorVariant &result)

void	Reshape (const mir::TensorVariant &input, mir::TensorVariant &output)

void	Sigmoid (const mir::TensorVariant &arg, mir::TensorVariant &result)

void	Slice (const mir::TensorVariant &arg, const mir::Shape &starts, mir::TensorVariant &res)

void	Softmax (const mir::TensorVariant &arg, int axis, mir::TensorVariant &result)

void	Sqrt (const mir::TensorVariant &arg, mir::TensorVariant &result)

void	Sub (const TensorVariant &lhs, const TensorVariant &rhs, TensorVariant &res)

void	Tanh (const mir::TensorVariant &arg, mir::TensorVariant &result)

void	Transpose (const mir::TensorVariant &input, const mir::ops::TransposeOp &op, mir::TensorVariant &output)

Function Documentation

◆ Abs()

void mir_interpreter::Abs	(	const mir::TensorVariant &	arg,
		mir::TensorVariant &	result
	)

Definition at line 50 of file Abs.cpp.

{
  dispatch<AbsImpl>(arg.getElementType(), arg, result);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Add()

void mir_interpreter::Add	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 121 of file Add.cpp.

{
  if (lhs.getElementType() != rhs.getElementType())
  {
    throw std::runtime_error{"Add with different input types is unsupported"};
  }
  dispatch<AddImpl>(res.getElementType(), lhs, rhs, res);
}

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ AvgPool2D()

void mir_interpreter::AvgPool2D	(	const mir::ops::AvgPool2DOp &	op,
		const mir::TensorVariant &	input,
		mir::TensorVariant &	output
	)

Definition at line 167 of file AvgPool2D.cpp.

{
  dispatch<AvgPool2DImpl>(output.getElementType(), op, input, output);
}

◆ CappedReLU()

void mir_interpreter::CappedReLU	(	const mir::TensorVariant &	arg,
		float	cap,
		mir::TensorVariant &	result
	)

Definition at line 77 of file CappedReLU.cpp.

{
  dispatch<CappedReLUImpl>(arg.getElementType(), arg, cap, result);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Concat()

void mir_interpreter::Concat	(	const std::vector< std::reference_wrapper< const mir::TensorVariant > > &	inputs,
		int	axis,
		mir::TensorVariant &	output
	)

Definition at line 166 of file Concat.cpp.

{
  dispatch<ConcatImpl>(inputs[0].get().getElementType(), inputs, axis, output);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Conv2D()

void mir_interpreter::Conv2D	(	const mir::TensorVariant &	input,
		const mir::TensorVariant &	kernel,
		const mir::Conv2DOpAttributes &	attributes,
		mir::TensorVariant &	result,
		const mir::TensorVariant *	fused_bias
	)

Definition at line 254 of file Conv2D.cpp.

{
  dispatch<Conv2DImpl>(result.getElementType(), input, kernel, attributes, result, fused_bias);
}

References Conv2D().

Referenced by Conv2D(), and mir_interpreter::MIRInterpreter::visit().

◆ DeConv2D()

void mir_interpreter::DeConv2D	(	const mir::TensorVariant &	input,
		const mir::TensorVariant &	kernel,
		const mir::Deconv2DOpAttributes &	attributes,
		mir::TensorVariant &	output
	)

Transposed convolution (or Deconvolution)

Parameters

input	The Input tensor
op	The DeConvolution operation object

This is basically the backward pass for the convolution operation, hence all the indexing can be deducted by expressing the input index of Conv in terms of it's output index.

Definition at line 116 of file DeConv2D.cpp.

{
  dispatch<DeConv2DImpl>(output.getElementType(), input, kernel, attributes, output);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ DepthwiseConv2D()

void mir_interpreter::DepthwiseConv2D	(	const mir::ops::DepthwiseConv2DOp &	op,
		const mir::TensorVariant &	input,
		const mir::TensorVariant &	kernel,
		mir::TensorVariant &	output,
		const mir::TensorVariant *	bias
	)

Definition at line 218 of file DepthwiseConv2D.cpp.

{
  dispatch<DepthwiseConv2DImpl>(output.getElementType(), op, input, kernel, bias, output);
}

◆ Dequantize()

void mir_interpreter::Dequantize	(	const TensorVariant &	input,
		TensorVariant &	output
	)

Definition at line 28 of file Quantization.cpp.

{
  const TensorType &input_type = input.getType();
  assert(input_type.isQuantized());
  assert(input_type.getElementType() == DataType::UINT8);
 
  const float scale = input_type.getQuantization().getScale();
  const int32_t zero_point = input_type.getQuantization().getZeroPoint();
 
  Tensor<uint8_t> input_accessor(input);
  Tensor<float> res_accessor(output);
 
  for (const auto &index : ShapeRange(output.getShape()))
  {
    const int32_t value = input_accessor.at(index);
    res_accessor.at(index) = scale * static_cast<float>(value - zero_point);
  }
}

References mir::Tensor< T >::at(), mir::TensorType::getElementType(), mir::TensorType::getQuantization(), mir::AffineQuantization::getScale(), mir::AffineQuantization::getZeroPoint(), and mir::TensorType::isQuantized().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ dispatch()

template<template< typename > class F, typename... Args>

void mir_interpreter::dispatch	(	mir::DataType	dt,
		Args &&...	args
	)

Definition at line 30 of file Common.h.

{
  switch (dt)
  {
    case mir::DataType::FLOAT32:
      return F<float>::run(std::forward<Args>(args)...);
    case mir::DataType::FLOAT64:
      return F<double>::run(std::forward<Args>(args)...);
    case mir::DataType::INT32:
      return F<int32_t>::run(std::forward<Args>(args)...);
    case mir::DataType::INT64:
      return F<int64_t>::run(std::forward<Args>(args)...);
    case mir::DataType::UINT8:
      return F<uint8_t>::run(std::forward<Args>(args)...);
    case mir::DataType::UNKNOWN:
      throw std::runtime_error{"Unknown datatype met during operation execution"};
    default:
      throw std::runtime_error{"mir::DataType enum mismatch"};
  }
}

◆ Div()

void mir_interpreter::Div	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 57 of file Div.cpp.

{
  dispatch<DivImpl>(res.getElementType(), lhs, rhs, res);
}

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ ELU()

void mir_interpreter::ELU	(	const mir::TensorVariant &	arg,
		float	alpha,
		mir::TensorVariant &	result
	)

Definition at line 46 of file ELU.cpp.

{
  dispatch<ELUImpl>(result.getElementType(), arg, alpha, result);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Equal()

void mir_interpreter::Equal	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 48 of file Equal.cpp.

{
  if (lhs.getElementType() != rhs.getElementType())
  {
    throw std::runtime_error{"Equal with different input types is unsupported"};
  }
 
  dispatch<EqualImpl>(lhs.getElementType(), lhs, rhs, res);
}

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ erase()

template<typename T >

void mir_interpreter::erase ( mir::TensorVariant & tv )

Definition at line 51 of file Common.h.

{
  size_t element_count = tv.getShape().numElements();
  for (size_t i = 0; i < element_count; ++i)
  {
    auto ptr = tv.atOffset(i);
    *reinterpret_cast<T *>(ptr) = 0;
  }
}

References mir::TensorVariant::atOffset(), mir::TensorVariant::getShape(), and mir::Shape::numElements().

◆ Fill()

template<typename F >

void mir_interpreter::Fill	(	mir::TensorVariant &	t,
		F	f
	)

Definition at line 41 of file Fill.h.

{
  dispatch<FillImpl>(t.getElementType(), t, f);
}

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ FullyConnected()

void mir_interpreter::FullyConnected	(	const mir::TensorVariant &	input,
		const mir::TensorVariant &	weights,
		const mir::ops::FullyConnectedOp &	op,
		mir::TensorVariant &	res,
		const mir::TensorVariant *	bias
	)

Definition at line 208 of file FullyConnected.cpp.

{
  dispatch<FullyConnectedImpl>(res.getElementType(), input, weights, op, res, bias);
}

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Gather()

void mir_interpreter::Gather	(	const TensorVariant &	data,
		const TensorVariant &	indices,
		const ops::GatherOp &	op,
		TensorVariant &	res
	)

Definition at line 86 of file Gather.cpp.

{
  dispatch<GatherByT>(data.getElementType(), data, indices, op, res);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Greater()

void mir_interpreter::Greater	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 48 of file Greater.cpp.

{
  if (lhs.getElementType() != rhs.getElementType())
  {
    throw std::runtime_error{"Greater with different input types is unsupported"};
  }
  dispatch<GreaterImpl>(lhs.getElementType(), lhs, rhs, res);
}

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ HardSwish()

void mir_interpreter::HardSwish	(	const mir::TensorVariant &	input,
		mir::TensorVariant &	result
	)

Definition at line 49 of file HardSwish.cpp.

{
  dispatch<HardSwishImpl>(input.getElementType(), input, result);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ LeakyReLU()

void mir_interpreter::LeakyReLU	(	const mir::TensorVariant &	arg,
		float	alpha,
		mir::TensorVariant &	result
	)

Definition at line 44 of file LeakyReLU.cpp.

{
  dispatch<LeakyReLUImpl>(result.getElementType(), arg, alpha, result);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Less()

void mir_interpreter::Less	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 48 of file Less.cpp.

{
  if (lhs.getElementType() != rhs.getElementType())
  {
    throw std::runtime_error{"Less with different input types is unsupported"};
  }
  dispatch<LessImpl>(lhs.getElementType(), lhs, rhs, res);
}

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ MaskIfGreaterThan()

int32_t mir_interpreter::MaskIfGreaterThan	(	int32_t	a,
		int32_t	b
	)

inline

Definition at line 85 of file QuantizationHelpers.h.

85{ return MaskIfNonZero(a > b); }

mir_interpreter::MaskIfNonZero

int32_t MaskIfNonZero(int32_t a)

Definition QuantizationHelpers.h:75

References MaskIfNonZero().

Referenced by RoundingDivideByPOT().

◆ MaskIfLessThan()

int32_t mir_interpreter::MaskIfLessThan	(	int32_t	a,
		int32_t	b
	)

inline

Definition at line 83 of file QuantizationHelpers.h.

83{ return MaskIfNonZero(a < b); }

References MaskIfNonZero().

Referenced by RoundingDivideByPOT().

◆ MaskIfNonZero()

int32_t mir_interpreter::MaskIfNonZero ( int32_t a )

inline

Definition at line 75 of file QuantizationHelpers.h.

{
  static const int32_t zero = 0;
  return a ? ~zero : zero;
}

Referenced by MaskIfGreaterThan(), MaskIfLessThan(), and MaskIfZero().

◆ MaskIfZero()

int32_t mir_interpreter::MaskIfZero ( int32_t a )

inline

Definition at line 81 of file QuantizationHelpers.h.

81{ return MaskIfNonZero(!a); }

References MaskIfNonZero().

◆ Max()

void mir_interpreter::Max	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 57 of file Max.cpp.

{
  if (lhs.getElementType() != rhs.getElementType())
  {
    throw std::runtime_error{"Max with different input types is unsupported"};
  }
  dispatch<MaxImpl>(lhs.getElementType(), lhs, rhs, res);
}

References mir::TensorVariant::getElementType().

◆ MaxPool2D()

void mir_interpreter::MaxPool2D	(	const mir::TensorVariant &	input,
		const mir::ops::MaxPool2DOp &	op,
		mir::TensorVariant &	result
	)

Definition at line 151 of file MaxPool2D.cpp.

{
  dispatch<MaxPool2DImpl>(input.getElementType(), input, op, result);
};

◆ Mul()

void mir_interpreter::Mul	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 56 of file Mul.cpp.

{
  dispatch<MulImpl>(lhs.getElementType(), lhs, rhs, res);
};

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ MultiplyByQuantizedMultiplier()

int32_t mir_interpreter::MultiplyByQuantizedMultiplier	(	int32_t	x,
		int32_t	quantized_multiplier,
		int	shift
	)

inline

Definition at line 108 of file QuantizationHelpers.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(), SaturatingRoundingDoublingHighMul(), and shift().

Referenced by mir_interpreter::DepthwiseConv2DImpl< uint8_t >::run(), mir_interpreter::FullyConnectedImpl< uint8_t >::run(), and mir_interpreter::Conv2DImpl< uint8_t >::run().

◆ MultiplyByQuantizedMultiplierSmallerThanOneExp()

int32_t mir_interpreter::MultiplyByQuantizedMultiplierSmallerThanOneExp	(	int32_t	x,
		int32_t	quantized_multiplier,
		int	left_shift
	)

inline

Definition at line 116 of file QuantizationHelpers.h.

{
  return RoundingDivideByPOT(SaturatingRoundingDoublingHighMul(x, quantized_multiplier),
                             -left_shift);
}

References RoundingDivideByPOT(), and SaturatingRoundingDoublingHighMul().

Referenced by mir_interpreter::AddImpl< uint8_t >::run().

◆ Pad()

void mir_interpreter::Pad	(	const mir::TensorVariant &	input,
		const mir::ops::PadOp &	op,
		mir::TensorVariant &	result
	)

Implements PadOp for interpreter backend.

This operation pads a tensor according to the paddings you specify. For each dimension of input add values before and after of contents.

Definition at line 79 of file Pad.cpp.

{
  dispatch<PadImpl>(input.getElementType(), input, op, result);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Quantize()

void mir_interpreter::Quantize	(	const TensorVariant &	input,
		TensorVariant &	output
	)

Definition at line 47 of file Quantization.cpp.

{
  const TensorType &output_type = output.getType();
  assert(output_type.isQuantized());
  assert(input.getElementType() == DataType::FLOAT32);
 
  const float scale = output_type.getQuantization().getScale();
  const int32_t zero_point = output_type.getQuantization().getZeroPoint();
 
  const int32_t min_val = std::numeric_limits<uint8_t>::min();
  const int32_t max_val = std::numeric_limits<uint8_t>::max();
 
  Tensor<float> input_accessor(input);
  Tensor<uint8_t> res_accessor(output);
 
  for (const auto &index : ShapeRange(output.getShape()))
  {
    const float value = input_accessor.at(index);
    int32_t unclamped = static_cast<int32_t>(std::round(value / scale)) + zero_point;
    int32_t clamped = std::min(std::max(unclamped, min_val), max_val);
    res_accessor.at(index) = static_cast<uint8_t>(clamped);
  }
}

References mir::Tensor< T >::at().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ QuantizeMultiplier()

void mir_interpreter::QuantizeMultiplier	(	double	double_multiplier,
		int32_t *	quantized_multiplier,
		int *	shift
	)

inline

Definition at line 27 of file QuantizationHelpers.h.

{
  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>(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());
  // A shift amount smaller than -31 would cause all bits to be shifted out
  // and thus all results would be zero. We implement that instead with
  // q_fixed==0, so as to avoid hitting issues with right-shift
  // operations with shift amounts greater than 31. Note that this happens
  // roughly when abs(double_multiplier) < 2^-31 and the present handling means
  // that we're effectively flushing tiny double_multiplier's to zero.
  // We could conceivably handle values in the range (roughly) [32, 63]
  // as 'denormals' i.e. (shift==0, q_fixed < 2^30). In that point of view
  // the present handling is just doing 'flush denormals to zero'. We could
  // reconsider and actually generate nonzero denormals if a need arises.
  if (*shift < -31)
  {
    *shift = 0;
    q_fixed = 0;
  }
  *quantized_multiplier = static_cast<int32_t>(q_fixed);
}

References shift().

Referenced by QuantizeMultiplierSmallerThanOneExp(), mir_interpreter::DepthwiseConv2DImpl< uint8_t >::run(), mir_interpreter::FullyConnectedImpl< uint8_t >::run(), and mir_interpreter::Conv2DImpl< uint8_t >::run().

◆ QuantizeMultiplierSmallerThanOneExp()

void mir_interpreter::QuantizeMultiplierSmallerThanOneExp	(	double	double_multiplier,
		int32_t *	quantized_multiplier,
		int *	left_shift
	)

inline

Definition at line 64 of file QuantizationHelpers.h.

{
  assert(double_multiplier < 1.0);
  assert(double_multiplier > 0.0);
  int shift;
  QuantizeMultiplier(double_multiplier, quantized_multiplier, &shift);
  assert(shift <= 0);
  *left_shift = shift;
}

References QuantizeMultiplier(), and shift().

Referenced by mir_interpreter::AddImpl< uint8_t >::run().

◆ ReduceMean()

void mir_interpreter::ReduceMean	(	const mir::TensorVariant &	input,
		const mir::ops::ReduceMeanOp &	op,
		mir::TensorVariant &	output
	)

Definition at line 90 of file ReduceMean.cpp.

{
  dispatch<ReduceMeanImpl>(input.getElementType(), input, op, output);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ ReLU()

void mir_interpreter::ReLU	(	const mir::TensorVariant &	arg,
		mir::TensorVariant &	result
	)

Definition at line 53 of file ReLU.cpp.

{
  dispatch<ReLUImpl>(arg.getElementType(), arg, result);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Reshape()

void mir_interpreter::Reshape	(	const mir::TensorVariant &	input,
		mir::TensorVariant &	output
	)

Definition at line 26 of file Reshape.cpp.

{
  assert(input.getShape().numElements() == output.getShape().numElements());
 
  mir::ShapeRange input_range(input.getShape());
  auto in_iter = input_range.begin();
  const size_t elem_size = input.getElementSize();
 
  for (const auto &out_index : mir::ShapeRange(output.getShape()))
    std::memcpy(output.at(out_index), input.at(*in_iter++), elem_size);
}

References mir::ShapeRange::begin().

Referenced by mir_interpreter::MIRInterpreter::visit(), and mir_interpreter::MIRInterpreter::visit().

◆ RoundingDivideByPOT()

int32_t mir_interpreter::RoundingDivideByPOT	(	int32_t	x,
		int	exponent
	)

inline

Definition at line 87 of file QuantizationHelpers.h.

{
  assert(exponent >= 0);
  assert(exponent <= 31);
  const int32_t mask = (1ll << exponent) - 1;
  const int32_t remainder = x & mask;
  const int32_t threshold = (mask >> 1) + (MaskIfLessThan(x, 0) & 1);
  return (x >> exponent) + (MaskIfGreaterThan(remainder, threshold) & 1);
}

References MaskIfGreaterThan(), and MaskIfLessThan().

Referenced by MultiplyByQuantizedMultiplier(), and MultiplyByQuantizedMultiplierSmallerThanOneExp().

◆ SaturatingRoundingDoublingHighMul()

std::int32_t mir_interpreter::SaturatingRoundingDoublingHighMul	(	std::int32_t	a,
		std::int32_t	b
	)

inline

Definition at line 97 of file QuantizationHelpers.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().

◆ shift()

mir::Index mir_interpreter::shift	(	const Index &	in_index,
		const Shape &	shift_from
	)

Definition at line 26 of file Common.cpp.

{
  Index index = in_index;
  assert(index.rank() == shift_from.rank());
  for (int32_t d = 0; d < in_index.rank(); ++d)
  {
    index.at(d) = index.at(d) + shift_from.dim(d);
  }
  return index;
}

References mir::Shape::dim(), mir::Index::rank(), and mir::Shape::rank().

Referenced by MultiplyByQuantizedMultiplier(), QuantizeMultiplier(), QuantizeMultiplierSmallerThanOneExp(), and mir_interpreter::SliceImpl< T >::run().

◆ Sigmoid()

void mir_interpreter::Sigmoid	(	const mir::TensorVariant &	arg,
		mir::TensorVariant &	result
	)

Definition at line 53 of file Sigmoid.cpp.

{
  dispatch<SigmoidImpl>(arg.getElementType(), arg, result);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Slice()

void mir_interpreter::Slice	(	const mir::TensorVariant &	arg,
		const mir::Shape &	starts,
		mir::TensorVariant &	res
	)

Definition at line 47 of file Slice.cpp.

{
  dispatch<SliceImpl>(arg.getElementType(), arg, starts, res);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Softmax()

void mir_interpreter::Softmax	(	const mir::TensorVariant &	arg,
		int	axis,
		mir::TensorVariant &	result
	)

Definition at line 150 of file Softmax.cpp.

{
  dispatch<SoftmaxImpl>(arg.getElementType(), arg, axis, result);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Sqrt()

void mir_interpreter::Sqrt	(	const mir::TensorVariant &	arg,
		mir::TensorVariant &	result
	)

Definition at line 53 of file Sqrt.cpp.

{
  dispatch<SqrtImpl>(arg.getElementType(), arg, result);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Sub()

void mir_interpreter::Sub	(	const TensorVariant &	lhs,
		const TensorVariant &	rhs,
		TensorVariant &	res
	)

Definition at line 56 of file Sub.cpp.

{
  dispatch<SubImpl>(lhs.getElementType(), lhs, rhs, res);
};

References mir::TensorVariant::getElementType().

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Tanh()

void mir_interpreter::Tanh	(	const mir::TensorVariant &	arg,
		mir::TensorVariant &	result
	)

Definition at line 53 of file Tanh.cpp.

{
  dispatch<TanhImpl>(arg.getElementType(), arg, result);
};

Referenced by mir_interpreter::MIRInterpreter::visit().

◆ Transpose()

void mir_interpreter::Transpose	(	const mir::TensorVariant &	input,
		const mir::ops::TransposeOp &	op,
		mir::TensorVariant &	output
	)

Definition at line 58 of file Transpose.cpp.

{
  dispatch<TransposeImpl>(input.getElementType(), input, op, output);
}

Referenced by mir_interpreter::MIRInterpreter::visit().

Data Structures

Functions

Function Documentation

◆ Abs()

◆ Add()

◆ AvgPool2D()

◆ CappedReLU()

◆ Concat()

◆ Conv2D()

◆ DeConv2D()

◆ DepthwiseConv2D()

◆ Dequantize()

◆ dispatch()

◆ Div()

◆ ELU()

◆ Equal()

◆ erase()

◆ Fill()

◆ FullyConnected()

◆ Gather()

◆ Greater()

◆ HardSwish()

◆ LeakyReLU()

◆ Less()

◆ MaskIfGreaterThan()

◆ MaskIfLessThan()

◆ MaskIfNonZero()

◆ MaskIfZero()

◆ Max()

◆ MaxPool2D()

◆ Mul()

◆ MultiplyByQuantizedMultiplier()

◆ MultiplyByQuantizedMultiplierSmallerThanOneExp()

◆ Pad()

◆ Quantize()

◆ QuantizeMultiplier()

◆ QuantizeMultiplierSmallerThanOneExp()

◆ ReduceMean()

◆ ReLU()

◆ Reshape()

◆ RoundingDivideByPOT()

◆ SaturatingRoundingDoublingHighMul()

◆ shift()

◆ Sigmoid()

◆ Slice()

◆ Softmax()

◆ Sqrt()

◆ Sub()

◆ Tanh()

◆ Transpose()