#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 54 of file ElementwiseUnaryLayer.h.

Constructor & Destructor Documentation

◆ ElementwiseUnaryLayer()

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

inline

Definition at line 57 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 210 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"};
  }
}

◆ run()

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

overridevirtual

Implements onert::exec::IFunction.

Definition at line 397 of file ElementwiseUnaryLayer.cc.

397{ _kernel(_input, _output); }

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

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