onert::backend::cpu::ops::ElementwiseBinaryLayer Class Reference

#include <ElementwiseBinaryLayer.h>

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

Public Member Functions
	ElementwiseBinaryLayer ()
void	configure (const IPortableTensor *lhs, const IPortableTensor *rhs, IPortableTensor *output, const ElementwiseBinaryType op_type)
void	run () override
Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default
virtual void	prepare ()

Detailed Description

Definition at line 43 of file ElementwiseBinaryLayer.h.

Constructor & Destructor Documentation

ElementwiseBinaryLayer()

onert::backend::cpu::ops::ElementwiseBinaryLayer::ElementwiseBinaryLayer ( )

inline

Definition at line 46 of file ElementwiseBinaryLayer.h.

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

Member Function Documentation

configure()

void onert::backend::cpu::ops::ElementwiseBinaryLayer::configure	(	const IPortableTensor *	lhs,
		const IPortableTensor *	rhs,
		IPortableTensor *	output,
		const ElementwiseBinaryType	op_type
	)

Definition at line 125 of file ElementwiseBinaryLayer.cc.

{
  assert(lhs != nullptr);
  assert(rhs != nullptr);
  assert(output != nullptr);
 
  _lhs = lhs;
  _rhs = rhs;
  _output = output;
 
  switch (op_type)
  {
    case ElementwiseBinaryType::kFloorDiv:
      if (_lhs->data_type() == OperandType::FLOAT32)
      {
        _kernel = FloorDivGeneric<float>;
      }
      else if (_lhs->data_type() == OperandType::INT32)
      {
        _kernel = FloorDivGeneric<int32_t>;
      }
      else
      {
        throw std::runtime_error{"Max: unsupported data type"};
      }
      break;
    case ElementwiseBinaryType::kFloorMod:
      if (_lhs->data_type() == OperandType::FLOAT32)
      {
        _kernel = FloorModGeneric<float>;
      }
      else if (_lhs->data_type() == OperandType::INT64)
      {
        _kernel = FloorModGeneric<int64_t>;
      }
      else
      {
        throw std::runtime_error{"FloorMod: unsupported data type"};
      }
      break;
    case ElementwiseBinaryType::kLogicalAnd:
      if ((_lhs->data_type() == OperandType::BOOL8) && (_rhs->data_type() == OperandType::BOOL8))
      {
        static_assert(sizeof(bool) == 1, "cpu backend supports bool type which is 1 byte");
        _kernel = logicalAndGeneric<bool>;
      }
      else
      {
        throw std::runtime_error{"LogicalOr: Unsupported data type"};
      }
      break;
    case ElementwiseBinaryType::kLogicalOr:
      if ((_lhs->data_type() == OperandType::BOOL8) && (_rhs->data_type() == OperandType::BOOL8))
      {
        static_assert(sizeof(bool) == 1, "cpu backend supports bool type which is 1 byte");
        _kernel = logicalOrGeneric<bool>;
      }
      else
      {
        throw std::runtime_error{"LogicalOr: Unsupported data type"};
      }
      break;
    case ElementwiseBinaryType::kMax:
      if (_lhs->data_type() == OperandType::QUANT_UINT8_ASYMM)
      {
        if (!haveSameQauntInfo(_lhs, _rhs, _output))
        {
          throw std::runtime_error("Max NYI for quantized");
        }
        _kernel = maximumGeneric<uint8_t>;
      }
      else if (_lhs->data_type() == OperandType::FLOAT32)
      {
        _kernel = maximumGeneric<float>;
      }
      else
      {
        throw std::runtime_error{"Max: unsupported data type"};
      }
      break;
    case ElementwiseBinaryType::kMin:
      if (_lhs->data_type() == OperandType::QUANT_UINT8_ASYMM)
      {
        if (!haveSameQauntInfo(_lhs, _rhs, _output))
        {
          throw std::runtime_error("Min NYI for quantized");
        }
        _kernel = minimumGeneric<uint8_t>;
      }
      else if (_lhs->data_type() == OperandType::INT32)
      {
        _kernel = minimumGeneric<int32_t>;
      }
      else if (_lhs->data_type() == OperandType::FLOAT32)
      {
        _kernel = minimumGeneric<float>;
      }
      else
      {
        throw std::runtime_error{"Min: unsupported data type"};
      }
      break;
    default:
      throw std::runtime_error{"ElementwiseBinary: Unsupported ElementwiseBinary type"};
  }
}

References onert::backend::IPortableTensor::data_type(), onert::backend::cpu::ops::kFloorDiv, onert::backend::cpu::ops::kFloorMod, onert::backend::cpu::ops::kLogicalAnd, onert::backend::cpu::ops::kLogicalOr, onert::backend::cpu::ops::kMax, and onert::backend::cpu::ops::kMin.

run()

void onert::backend::cpu::ops::ElementwiseBinaryLayer::run ( )

overridevirtual

Implements onert::exec::IFunction.

Definition at line 233 of file ElementwiseBinaryLayer.cc.

{ _kernel(_lhs, _rhs, _output); }

Referenced by package.infer.session::inference().

---

The documentation for this class was generated from the following files:

• runtime/onert/backend/cpu/ops/ElementwiseBinaryLayer.h
• runtime/onert/backend/cpu/ops/ElementwiseBinaryLayer.cc