#include <BinaryArithmeticLayer.h>

Collaboration diagram for onert::backend::cpu::ops::BinaryArithmeticLayer:

[legend]

Public Member Functions
	BinaryArithmeticLayer ()

void	configure (const IPortableTensor lhs, const IPortableTensor rhs, IPortableTensor *output, const ir::Activation activation, const ArithmeticType arithmetic_type)

void	run () override

Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default

virtual void	prepare ()

Protected Attributes
const IPortableTensor *	_lhs

const IPortableTensor *	_rhs

IPortableTensor *	_output

std::function< void(const IPortableTensor , const IPortableTensor , IPortableTensor *)>	_kernel

Detailed Description

Definition at line 36 of file BinaryArithmeticLayer.h.

Constructor & Destructor Documentation

◆ BinaryArithmeticLayer()

onert::backend::cpu::ops::BinaryArithmeticLayer::BinaryArithmeticLayer ( )

inline

Definition at line 39 of file BinaryArithmeticLayer.h.

                          : _lhs(nullptr), _rhs(nullptr), _output(nullptr)
  {
    // DO NOTHING
  }

Member Function Documentation

◆ configure()

void onert::backend::cpu::ops::BinaryArithmeticLayer::configure	(	const IPortableTensor *	lhs,
		const IPortableTensor *	rhs,
		IPortableTensor *	output,
		const ir::Activation	activation,
		const ArithmeticType	arithmetic_type
	)

Definition at line 228 of file BinaryArithmeticLayer.cc.

{
  assert(lhs != nullptr);
  assert(rhs != nullptr);
  assert(output != nullptr);
 
  _lhs = lhs;
  _rhs = rhs;
  _output = output;
 
  nnfw::cker::BinaryArithmeticOpParam op_params;
  switch (arithmetic_type)
  {
    case ArithmeticType::kAdd:
      if (_lhs->data_type() == OperandType::QUANT_UINT8_ASYMM)
      {
        setAddOrSubQuant8Params(_lhs, _rhs, _output, activation, &op_params);
        _kernel =
          Eval<nnfw::cker::BinaryArithmeticOpType::ADD, uint8_t>(_lhs, _rhs, _output, op_params);
      }
      else if (_lhs->data_type() == OperandType::QUANT_INT8_ASYMM)
      {
        setAddOrSubQuant8Params(_lhs, _rhs, _output, activation, &op_params);
        _kernel =
          Eval<nnfw::cker::BinaryArithmeticOpType::ADD, int8_t>(_lhs, _rhs, _output, op_params);
      }
 
      else
      {
        _kernel = generateKernelGeneric<nnfw::cker::BinaryArithmeticOpType::ADD>(
          _lhs, _rhs, _output, activation, op_params);
      }
      break;
    case ArithmeticType::kSub:
      if (_lhs->data_type() == OperandType::QUANT_UINT8_ASYMM)
      {
        setAddOrSubQuant8Params(_lhs, _rhs, _output, activation, &op_params);
        op_params.input2_multiplier *= -1;
        _kernel =
          Eval<nnfw::cker::BinaryArithmeticOpType::SUB, uint8_t>(_lhs, _rhs, _output, op_params);
      }
      else if (_lhs->data_type() == OperandType::QUANT_INT8_ASYMM)
      {
        setAddOrSubQuant8Params(_lhs, _rhs, _output, activation, &op_params);
        op_params.input2_multiplier *= -1;
        _kernel =
          Eval<nnfw::cker::BinaryArithmeticOpType::SUB, int8_t>(_lhs, _rhs, _output, op_params);
      }
 
      else
      {
        _kernel = generateKernelGeneric<nnfw::cker::BinaryArithmeticOpType::SUB>(
          _lhs, _rhs, _output, activation, op_params);
      }
      break;
    case ArithmeticType::kMul:
      if (_lhs->data_type() == OperandType::QUANT_UINT8_ASYMM)
      {
        nnfw::cker::BinaryArithmeticOpParam op_params;
        setMulQuant8Params(_lhs, _rhs, _output, activation, &op_params);
        _kernel =
          Eval<nnfw::cker::BinaryArithmeticOpType::MUL, uint8_t>(_lhs, _rhs, _output, op_params);
      }
      else if (_lhs->data_type() == OperandType::QUANT_INT8_ASYMM)
      {
        nnfw::cker::BinaryArithmeticOpParam op_params;
        setMulQuant8Params(_lhs, _rhs, _output, activation, &op_params);
        _kernel =
          Eval<nnfw::cker::BinaryArithmeticOpType::MUL, int8_t>(_lhs, _rhs, _output, op_params);
      }
      else
      {
        _kernel = generateKernelGeneric<nnfw::cker::BinaryArithmeticOpType::MUL>(
          _lhs, _rhs, _output, activation, op_params);
      }
      break;
    case ArithmeticType::kDiv:
      if (_lhs->data_type() == OperandType::FLOAT32)
      {
        _kernel = generateKernelGeneric<nnfw::cker::BinaryArithmeticOpType::DIV>(
          _lhs, _rhs, _output, activation, op_params);
      }
      else
      {
        // TODO Support quantized type
        // TODO Support integer type with zero check
        throw std::runtime_error{
          "BinaryArithmetic(Div): Div operation does not support non-float data types yet"};
      }
      break;
    default:
      throw std::runtime_error{"BinaryArithmetic: Unsupported BinaryArithmetic type"};
  }
}