onert::backend::cpu::ops::ElementwiseUnaryLayer Class Reference

#include <ElementwiseUnaryLayer.h>

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

Public Member Functions
	ElementwiseUnaryLayer ()
void	configure (const IPortableTensor *input, IPortableTensor *output, const ElementwiseUnaryType op_type)
void	run () override
Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default
virtual void	prepare ()

Detailed Description

Definition at line 48 of file ElementwiseUnaryLayer.h.

Constructor & Destructor Documentation

ElementwiseUnaryLayer()

onert::backend::cpu::ops::ElementwiseUnaryLayer::ElementwiseUnaryLayer ( )

inline

Definition at line 51 of file ElementwiseUnaryLayer.h.

                          : _input(nullptr), _output(nullptr), _kernel()
  {
    // DO NOTHING
  }

Member Function Documentation

configure()

void onert::backend::cpu::ops::ElementwiseUnaryLayer::configure	(	const IPortableTensor *	input,
		IPortableTensor *	output,
		const ElementwiseUnaryType	op_type
	)

Definition at line 204 of file ElementwiseUnaryLayer.cc.

{
  assert(input != nullptr);
  assert(output != nullptr);
 
  _input = input;
  _output = output;
 
  switch (op_type)
  {
    case ElementwiseUnaryType::kAbs:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = absFloat32;
      }
      else
      {
        throw std::runtime_error{"Abs: Unsupported data type"};
      }
      break;
    case ElementwiseUnaryType::kCast:
      _kernel = cast;
      break;
    case ElementwiseUnaryType::kCos:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = cosFloat32;
      }
      else
      {
        throw std::runtime_error{"Cos: Unsupported data type"};
      }
      break;
    case ElementwiseUnaryType::kDequantize:
      if ((input->data_type() == OperandType::QUANT_UINT8_ASYMM))
      {
        _kernel = dequantizeUint8;
      }
      else if ((input->data_type() == OperandType::QUANT_INT8_ASYMM) ||
               (input->data_type() == OperandType::QUANT_INT8_SYMM))
      {
        _kernel = dequantizeInt8;
      }
      else
      {
        throw std::runtime_error{"Dequantize: Unsupported data type"};
      }
      break;
    case ElementwiseUnaryType::kExp:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = expFloat32;
      }
      else
      {
        throw std::runtime_error{"Exp: Unsupported data type"};
      }
      break;
    case ElementwiseUnaryType::kErf:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = erfFloat32;
      }
      else
      {
        throw std::runtime_error{"Exp: Unsupported data type"};
      }
      break;
    case ElementwiseUnaryType::kFloor:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = floorFloat32;
      }
      else
      {
        throw std::runtime_error{"Floor: Unsupported data type"};
      }
      break;
    case ElementwiseUnaryType::kLog:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = logFloat32;
      }
      else
      {
        throw std::runtime_error{"Log: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kLogicalNot:
      if ((input->data_type() == OperandType::BOOL8))
      {
        static_assert(sizeof(bool) == 1, "cpu backend supports bool type which is 1 byte");
        _kernel = logicalNot;
      }
      else
      {
        throw std::runtime_error{"LogicalNot: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kNeg:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = neg<float>;
      }
      else if ((input->data_type() == OperandType::INT64))
      {
        _kernel = neg<int64_t>;
      }
      else if ((input->data_type() == OperandType::INT32))
      {
        _kernel = neg<int32_t>;
      }
      else
      {
        throw std::runtime_error{"Neg: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kRound:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = roundFloat32;
      }
      else
      {
        throw std::runtime_error{"Round: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kRSqrt:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = rsqrtFloat32;
      }
      else
      {
        throw std::runtime_error{"RSqrt: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kSin:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = sinFloat32;
      }
      else
      {
        throw std::runtime_error{"Sin: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kSqrt:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = sqrtFloat32;
      }
      else
      {
        throw std::runtime_error{"Sqrt: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kSquare:
      if ((input->data_type() == OperandType::FLOAT32))
      {
        _kernel = squareFloat32;
      }
      else
      {
        throw std::runtime_error{"Square: Unsupported  data type"};
      }
      break;
    case ElementwiseUnaryType::kZerosLike:
      if (input->data_type() == OperandType::FLOAT32)
      {
        _kernel = zerosLikeFloat32<float>;
      }
      else if (input->data_type() == OperandType::INT32)
      {
        _kernel = zerosLikeFloat32<int32_t>;
      }
      else
      {
        throw std::runtime_error{"ZerosLike: Unsupported data type"};
      }
      break;
    default:
      throw std::runtime_error{"ElementwiseUnary: Unsupported ElementwiseUnary type"};
  }
}

References onert::backend::cpu::ops::kAbs, onert::backend::cpu::ops::kCast, onert::backend::cpu::ops::kCos, onert::backend::cpu::ops::kDequantize, onert::backend::cpu::ops::kErf, onert::backend::cpu::ops::kExp, onert::backend::cpu::ops::kFloor, onert::backend::cpu::ops::kLog, onert::backend::cpu::ops::kLogicalNot, onert::backend::cpu::ops::kNeg, onert::backend::cpu::ops::kRound, onert::backend::cpu::ops::kRSqrt, onert::backend::cpu::ops::kSin, onert::backend::cpu::ops::kSqrt, onert::backend::cpu::ops::kSquare, and onert::backend::cpu::ops::kZerosLike.

run()

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

overridevirtual

Implements onert::exec::IFunction.

Definition at line 391 of file ElementwiseUnaryLayer.cc.

{ _kernel(_input, _output); }

---

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

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