onert::loader::BaseLoader< LoaderDomain > Class Template Reference

#include <BaseLoader.h>

Collaboration diagram for onert::loader::BaseLoader< LoaderDomain >:

Public Member Functions
	BaseLoader ()
	Construct a new Loader object.
std::unique_ptr< ir::Model >	loadFromFile (const std::string &file_path)
	Load a model from file.
std::unique_ptr< ir::Model >	loadFromBuffer (uint8_t *buffer, size_t size)
	Load a model from a buffer.

Protected Types
using	Verifier = typename LoaderDomain::Verifier
using	ActivationFunctionType = typename LoaderDomain::ActivationFunctionType
using	Buffer = typename LoaderDomain::Buffer
using	BuiltinOperator = typename LoaderDomain::BuiltinOperator
using	CustomOptionsFormat = typename LoaderDomain::CustomOptionsFormat
using	Metadata = typename LoaderDomain::Metadata
using	Model = typename LoaderDomain::Model
using	Operator = typename LoaderDomain::Operator
using	Padding = typename LoaderDomain::Padding
using	Pool2DOptions = typename LoaderDomain::Pool2DOptions
using	SubGraph = typename LoaderDomain::SubGraph
using	Tensor = typename LoaderDomain::Tensor
using	TensorType = typename LoaderDomain::TensorType
using	DimensionType = typename LoaderDomain::DimensionType
using	SparseIndexVector = typename LoaderDomain::SparseIndexVector

Protected Member Functions
bool	isOptionalInputTensor (std::int32_t idx)
virtual bool	allowOptionalInputTensor (BuiltinOperator)=0
	~BaseLoader ()=default
std::unique_ptr< ir::Model >	loadModel ()
ir::Activation	convertActivation (ActivationFunctionType type)
virtual ir::DataType	tensorTypeToDataType (const TensorType type)
ir::OperandIndex	tensorIdxToOperandIdx (int32_t tensorIdx)
flexbuffers::Map	getCustomOpAttrMap (const Operator *op)
ir::OperandIndex	loadOperand (const Tensor *tensor, ir::Graph &subg)
void	loadQuantization (const Tensor *tensor, ir::TypeInfo &typeInfo)
void	loadSparsity (const Tensor *tensor, ir::TypeInfo &typeInfo)
void	loadOperationIO (const Operator *op, ir::OperandIndexSequence &inputs, ir::OperandIndexSequence &outputs)
template<typename OpIR , typename... Args>
const OpIR *	loadOperationTo (const Operator *op, ir::Graph &subg, Args &&...args)
void	loadOperation (const Operator *op, ir::Graph &subg)
template<typename Param , typename OptionsType >
void	loadStridesAndPaddings (Param &param, const OptionsType *options)
template<typename Param >
void	loadPool2DOptions (Param &param, const Pool2DOptions *options)
BuiltinOperator	getBuiltinOperator (const Operator *op)
void	verifySubgraphIndex (int subg_index)

Protected Attributes
uint8_t *	_base
int32_t	_pagesize
int	_fd
std::string	_file_path
const Model *	_domain_model
std::vector< ir::OperandIndex >	_tensor_to_operand
std::unordered_map< ir::OperandIndex, std::string >	_tensor_names
std::unique_ptr< Verifier >	_verifier
bool	_use_mmaped_data = false
std::unordered_map< uint32_t, std::shared_ptr< ir::Data > >	_buf_to_data

Detailed Description

template<typename LoaderDomain>
class onert::loader::BaseLoader< LoaderDomain >

Definition at line 40 of file BaseLoader.h.

Member Typedef Documentation

ActivationFunctionType

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::ActivationFunctionType = typename LoaderDomain::ActivationFunctionType

protected

Definition at line 44 of file BaseLoader.h.

Buffer

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Buffer = typename LoaderDomain::Buffer

protected

Definition at line 45 of file BaseLoader.h.

BuiltinOperator

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::BuiltinOperator = typename LoaderDomain::BuiltinOperator

protected

Definition at line 46 of file BaseLoader.h.

CustomOptionsFormat

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::CustomOptionsFormat = typename LoaderDomain::CustomOptionsFormat

protected

Definition at line 47 of file BaseLoader.h.

DimensionType

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::DimensionType = typename LoaderDomain::DimensionType

protected

Definition at line 56 of file BaseLoader.h.

Metadata

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Metadata = typename LoaderDomain::Metadata

protected

Definition at line 48 of file BaseLoader.h.

Model

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Model = typename LoaderDomain::Model

protected

Definition at line 49 of file BaseLoader.h.

Operator

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Operator = typename LoaderDomain::Operator

protected

Definition at line 50 of file BaseLoader.h.

Padding

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Padding = typename LoaderDomain::Padding

protected

Definition at line 51 of file BaseLoader.h.

Pool2DOptions

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Pool2DOptions = typename LoaderDomain::Pool2DOptions

protected

Definition at line 52 of file BaseLoader.h.

SparseIndexVector

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::SparseIndexVector = typename LoaderDomain::SparseIndexVector

protected

Definition at line 57 of file BaseLoader.h.

SubGraph

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::SubGraph = typename LoaderDomain::SubGraph

protected

Definition at line 53 of file BaseLoader.h.

Tensor

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Tensor = typename LoaderDomain::Tensor

protected

Definition at line 54 of file BaseLoader.h.

TensorType

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::TensorType = typename LoaderDomain::TensorType

protected

Definition at line 55 of file BaseLoader.h.

Verifier

template<typename LoaderDomain >

using onert::loader::BaseLoader< LoaderDomain >::Verifier = typename LoaderDomain::Verifier

protected

Definition at line 43 of file BaseLoader.h.

Constructor & Destructor Documentation

BaseLoader()

template<typename LoaderDomain >

onert::loader::BaseLoader< LoaderDomain >::BaseLoader ( )

inlineexplicit

Construct a new Loader object.

Definition at line 67 of file BaseLoader.h.

                        : _base{nullptr}, _pagesize(getpagesize()), _fd(-1), _domain_model{nullptr}
  {
    _use_mmaped_data = util::getConfigBool(util::config::USE_MMAPED_DATA);
  }

References onert::loader::BaseLoader< LoaderDomain >::_use_mmaped_data, and onert::util::getConfigBool().

~BaseLoader()

template<typename LoaderDomain >

onert::loader::BaseLoader< LoaderDomain >::~BaseLoader ( )

protecteddefault

Member Function Documentation

allowOptionalInputTensor()

template<typename LoaderDomain >

virtual bool onert::loader::BaseLoader< LoaderDomain >::allowOptionalInputTensor ( BuiltinOperator  )

protectedpure virtual

convertActivation()

template<typename LoaderDomain >

ir::Activation onert::loader::BaseLoader< LoaderDomain >::convertActivation ( ActivationFunctionType  type )

protected

getBuiltinOperator()

template<typename LoaderDomain >

BuiltinOperator onert::loader::BaseLoader< LoaderDomain >::getBuiltinOperator ( const Operator *  op )

inlineprotected

Definition at line 114 of file BaseLoader.h.

  {
    // Enforce explicit bounds validation for opcode_index before every operator-code lookup
    if (op->opcode_index() < 0 ||
        static_cast<size_t>(op->opcode_index()) >= _domain_model->operator_codes()->size())
    {
      throw std::runtime_error("Invalid opcode_index: " + std::to_string(op->opcode_index()));
    }
 
    auto const builtin_opcode = _domain_model->operator_codes()->Get(op->opcode_index());
    auto builtin_op = builtin_opcode->builtin_code();
    if (builtin_op < BuiltinOperator::BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES)
      builtin_op = static_cast<BuiltinOperator>(builtin_opcode->deprecated_builtin_code());
 
    return builtin_op;
  }

References onert::loader::BaseLoader< LoaderDomain >::_domain_model.

getCustomOpAttrMap()

template<typename LoaderDomain >

flexbuffers::Map onert::loader::BaseLoader< LoaderDomain >::getCustomOpAttrMap ( const Operator *  op )

protected

isOptionalInputTensor()

template<typename LoaderDomain >

bool onert::loader::BaseLoader< LoaderDomain >::isOptionalInputTensor ( std::int32_t  idx )

inlineprotected

Definition at line 60 of file BaseLoader.h.

{ return idx == -1; }

loadFromBuffer()

template<typename LoaderDomain >

std::unique_ptr< ir::Model > onert::loader::BaseLoader< LoaderDomain >::loadFromBuffer	(	uint8_t *	buffer,
		size_t	size
	)

Load a model from a buffer.

Parameters

[in]	buffer	buffer pointer
[in]	size	buffer size

Returns

Loaded model object

loadFromFile()

template<typename LoaderDomain >

std::unique_ptr< ir::Model > onert::loader::BaseLoader< LoaderDomain >::loadFromFile

(

const std::string &

file_path

)

Load a model from file.

Parameters

[in]

file_path

model file path

Returns

Loaded model object

loadModel()

template<typename LoaderDomain >

std::unique_ptr< ir::Model > onert::loader::BaseLoader< LoaderDomain >::loadModel ( )

protected

Definition at line 1702 of file BaseLoader.h.

{
  LoaderDomain::VerifyModelBuffer(*_verifier.get());
  _domain_model = LoaderDomain::GetModel(_base);
 
  auto model = std::make_unique<ir::Model>();
  // Version unused
  // const auto version = _model->version();
  // Description unused
 
  // Load Metadata
  auto const metadata_list = _domain_model->metadata();
  if (metadata_list != nullptr)
  {
    for (uint32_t i = 0; i < metadata_list->size(); ++i)
    {
      const auto metadata = metadata_list->Get(i);
      if (metadata->name() == nullptr)
        continue; // metadata should have name
 
      std::unique_ptr<const ir::Data> data = loadMetadata(metadata->buffer());
      model->add_metadata(metadata->name()->str(), std::move(data));
    }
  }
 
  // Load signature map
  auto const signature_table = _domain_model->signature_defs();
  if (signature_table != nullptr)
  {
    for (uint32_t i = 0; i < signature_table->size(); ++i)
    {
      const auto signature = signature_table->Get(i);
      if (signature == nullptr)
        continue;
      const auto signature_key = signature->signature_key();
      if (signature_key == nullptr)
        continue; // signature should have key
      const auto subgraph_index = static_cast<uint16_t>(signature->subgraph_index());
 
      model->addSignatureMap(ir::SubgraphIndex{subgraph_index}, signature_key->str());
    }
  }
 
  // const auto *description = _model->description();
  // Load subgraphs and map operations on subgraph
  const auto subgraphs = _domain_model->subgraphs();
  if (subgraphs->size() - 1 > ir::SubgraphIndex::max())
    throw std::runtime_error{"The number of subgraphs cannot exceed " +
                             std::to_string(ir::SubgraphIndex::max() + 1)};
  for (uint16_t subgraph_index = 0; subgraph_index < subgraphs->size(); ++subgraph_index)
  {
    auto subg = loadSubgraph((*_domain_model->subgraphs())[subgraph_index]);
    // NOTE: Used () instead of {}, which does not check narrowing.
    // It is okay since overflow is checked the above if-statement.
    model->push(ir::SubgraphIndex(subgraph_index), std::move(subg));
  }
  return model;
}

References onert::util::Index< uint16_t, SubgraphIndexTag >::max().

loadOperand()

template<typename LoaderDomain >

ir::OperandIndex onert::loader::BaseLoader< LoaderDomain >::loadOperand ( const Tensor *  tensor, ir::Graph &  subg  )

protected

Definition at line 369 of file BaseLoader.h.

{
  ir::Shape shape;
  // Shape
  const auto *tensor_shape =
    tensor->shape_signature() ? tensor->shape_signature() : tensor->shape();
  if (tensor_shape != nullptr)
  {
    for (const auto &dim : *tensor_shape)
    {
      shape.append(dim);
    }
  }
 
  // Note for tensor->shape_signature()
  // We don't handle shape signature
  //    How we handle:
  //       If shape_signature[k] == -1, we will use tensor->shape()[k] == 1
  //       If app wants to change the input shape, call nnfw_apply_input_tensorinfo() can
  //       be used.
 
  // TypeInfo
  ir::TypeInfo type_info(tensorTypeToDataType(tensor->type()));
  // Ignore quantize param if datatype does not requires
  if (ir::requireQuantParam(type_info.type()))
    loadQuantization(tensor, type_info);
  loadSparsity(tensor, type_info);
 
  // Create operand
  const auto operand_index = subg.addOperand(shape, type_info);
 
  // Constant tensors are indicated by non-empty data.
  const auto *data = _domain_model->buffers()->Get(tensor->buffer())->data();
  if (data != nullptr)
  {
    using std::ptrdiff_t;
    std::shared_ptr<ir::Data> data_obj;
 
    if (_fd == -1) // Model is from memory
    {
      data_obj = std::make_shared<ir::ExternalData>(data->data(), data->size());
    }
    else // Model is loaded(mmap'd) from a file
    {
      size_t data_size = data->size();
      ptrdiff_t unaligned_offset_start = data->data() - _base;
      ptrdiff_t offset_end = unaligned_offset_start + data_size;
 
      // Calculated aligned offset from base address of mapped region
      // munmap accepts memory address which is a multiple of the pagesize
      ptrdiff_t aligned_offset_start = (unaligned_offset_start / _pagesize) * _pagesize;
      size_t mmap_size = offset_end - aligned_offset_start;
 
      uint32_t buf_idx = tensor->buffer();
      auto buffer_found = _buf_to_data.find(buf_idx);
 
      if (buffer_found != _buf_to_data.end())
      {
        // Another tensor points this buffer and its matching Data(either CachedData or MMapedData)
        // was already created. Let's reuse the Data
        data_obj = buffer_found->second;
      }
      else if (_use_mmaped_data)
      {
        data_obj = std::make_shared<ir::MMapedData>(_fd, aligned_offset_start, mmap_size,
                                                    unaligned_offset_start, data_size);
        _buf_to_data[buf_idx] = data_obj;
      }
      else
      {
        size_t offset = unaligned_offset_start - aligned_offset_start;
        uint8_t *mmap_base = static_cast<uint8_t *>(
          mmap(NULL, mmap_size, PROT_READ, MAP_PRIVATE, _fd, aligned_offset_start));
 
        data_obj = std::make_shared<ir::CachedData>(mmap_base + offset, data_size);
        _buf_to_data[buf_idx] = data_obj;
 
        munmap(mmap_base, mmap_size);
      }
    }
    subg.setOperandValue(operand_index, std::move(data_obj));
  }
 
  _tensor_names.emplace(operand_index, tensor->name()->str());
 
  // Variable
  if (tensor->is_variable())
  {
    if (data != nullptr)
      throw std::runtime_error("Variable tensor with buffer is not supported!");
 
    subg.operands().at(operand_index).info().setAsVariable();
  }
 
  return operand_index;
}

References onert::ir::Graph::addOperand(), onert::util::ObjectManager< Index, Object >::at(), offset(), onert::ir::Graph::operands(), onert::ir::requireQuantParam(), onert::ir::Graph::setOperandValue(), and onert::ir::TypeInfo::type().

loadOperation()

template<typename LoaderDomain >

void onert::loader::BaseLoader< LoaderDomain >::loadOperation ( const Operator *  op, ir::Graph &  subg  )

protected

Definition at line 1395 of file BaseLoader.h.

{
  auto const builtin_op = getBuiltinOperator(op);
 
  switch (builtin_op)
  {
    case BuiltinOperator::BuiltinOperator_ADD_N:
      loadOperationTo<ir::operation::AddN>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_CONV_2D:
      loadConv2D(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_AVERAGE_POOL_2D:
      loadPool2D(op, subg, ir::operation::Pool2D::PoolType::AVG);
      return;
    case BuiltinOperator::BuiltinOperator_DEPTHWISE_CONV_2D:
      loadDepthwiseConv2D(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_TRANSPOSE_CONV:
      loadTransposeConv(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_RESHAPE:
      loadReshape(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SOFTMAX:
      loadSoftmax(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_MAX_POOL_2D:
      loadPool2D(op, subg, ir::operation::Pool2D::PoolType::MAX);
      return;
    case BuiltinOperator::BuiltinOperator_CONCATENATION:
      loadConcatenation(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_FLOOR:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::FLOOR);
      return;
    case BuiltinOperator::BuiltinOperator_FULLY_CONNECTED:
      loadFC(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_ADD:
      loadBinaryArithmetic(op, subg, ir::operation::BinaryArithmetic::ArithmeticType::ADD);
      return;
    case BuiltinOperator::BuiltinOperator_SUB:
      loadBinaryArithmetic(op, subg, ir::operation::BinaryArithmetic::ArithmeticType::SUB);
      return;
    case BuiltinOperator::BuiltinOperator_MUL:
      loadBinaryArithmetic(op, subg, ir::operation::BinaryArithmetic::ArithmeticType::MUL);
      return;
    case BuiltinOperator::BuiltinOperator_DIV:
      loadBinaryArithmetic(op, subg, ir::operation::BinaryArithmetic::ArithmeticType::DIV);
      return;
    case BuiltinOperator::BuiltinOperator_PACK:
      loadPack(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_ELU:
      loadElementwiseActivation(op, subg, ir::operation::ElementwiseActivation::Type::ELU);
      return;
    case BuiltinOperator::BuiltinOperator_RELU:
      loadElementwiseActivation(op, subg, ir::operation::ElementwiseActivation::Type::RELU,
                                ir::operation::ElementwiseActivation::infinity, 0.f);
      return;
    case BuiltinOperator::BuiltinOperator_RELU_N1_TO_1:
      loadElementwiseActivation(op, subg, ir::operation::ElementwiseActivation::Type::RELU, 1.f,
                                -1.f);
      return;
    case BuiltinOperator::BuiltinOperator_RELU6:
      loadElementwiseActivation(op, subg, ir::operation::ElementwiseActivation::Type::RELU, 6.f,
                                0.f);
      return;
    case BuiltinOperator::BuiltinOperator_RESIZE_BILINEAR:
      loadResizeBilinear(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_RESIZE_NEAREST_NEIGHBOR:
      loadResizeNearestNeighbor(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_RSQRT:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::RSQRT);
      return;
    case BuiltinOperator::BuiltinOperator_SELECT:
    case BuiltinOperator::BuiltinOperator_SELECT_V2:
      loadOperationTo<ir::operation::Select>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SQRT:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::SQRT);
      return;
    case BuiltinOperator::BuiltinOperator_SQUARE:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::SQUARE);
      return;
    case BuiltinOperator::BuiltinOperator_SQUARED_DIFFERENCE:
      loadOperationTo<ir::operation::SquaredDifference>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_TANH:
      loadElementwiseActivation(op, subg, ir::operation::ElementwiseActivation::Type::TANH, 1.f,
                                1.f);
      return;
    case BuiltinOperator::BuiltinOperator_TRANSPOSE:
      loadOperationTo<ir::operation::Transpose>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_MEAN:
      loadReduce(op, subg, ir::operation::Reduce::ReduceType::MEAN);
      return;
    case BuiltinOperator::BuiltinOperator_REDUCE_ANY:
      loadReduce(op, subg, ir::operation::Reduce::ReduceType::ANY);
      return;
    case BuiltinOperator::BuiltinOperator_REDUCE_MAX:
      loadReduce(op, subg, ir::operation::Reduce::ReduceType::MAX);
      return;
    case BuiltinOperator::BuiltinOperator_REDUCE_ALL:
      loadReduce(op, subg, ir::operation::Reduce::ReduceType::ALL);
      return;
    case BuiltinOperator::BuiltinOperator_REVERSE_V2:
      loadOperationTo<ir::operation::Reverse>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_PAD:
    case BuiltinOperator::BuiltinOperator_PADV2:
      loadOperationTo<ir::operation::Pad>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_LOGISTIC:
      loadElementwiseActivation(op, subg, ir::operation::ElementwiseActivation::Type::LOGISTIC);
      return;
    case BuiltinOperator::BuiltinOperator_EXP:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::EXP);
      return;
    case BuiltinOperator::BuiltinOperator_EXPAND_DIMS:
      loadOperationTo<ir::operation::ExpandDims>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_GATHER:
      loadGather(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_GELU:
      loadGELU(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SPACE_TO_BATCH_ND:
      loadOperationTo<ir::operation::SpaceToBatchND>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_BATCH_TO_SPACE_ND:
      loadOperationTo<ir::operation::BatchToSpaceND>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SUM:
      loadReduce(op, subg, ir::operation::Reduce::ReduceType::SUM);
      return;
    case BuiltinOperator::BuiltinOperator_CUSTOM:
      loadCustom(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SQUEEZE:
      loadSqueeze(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_PRELU:
      loadOperationTo<ir::operation::PReLU>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SPLIT:
      loadSplit(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SPLIT_V:
      loadSplitV(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_SLICE:
      loadOperationTo<ir::operation::Slice>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_STRIDED_SLICE:
      loadStridedSlice(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_UNPACK:
      loadUnpack(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_FLOOR_DIV:
      loadElementwiseBinary(op, subg,
                            ir::operation::ElementwiseBinary::ElementwiseBinaryType::FLOOR_DIV);
      return;
    case BuiltinOperator::BuiltinOperator_FLOOR_MOD:
      loadElementwiseBinary(op, subg,
                            ir::operation::ElementwiseBinary::ElementwiseBinaryType::FLOOR_MOD);
      return;
    case BuiltinOperator::BuiltinOperator_MINIMUM:
      loadElementwiseBinary(op, subg, ir::operation::ElementwiseBinary::ElementwiseBinaryType::MIN);
      return;
    case BuiltinOperator::BuiltinOperator_MAXIMUM:
      loadElementwiseBinary(op, subg, ir::operation::ElementwiseBinary::ElementwiseBinaryType::MAX);
      return;
    case BuiltinOperator::BuiltinOperator_CAST:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::CAST);
      return;
    case BuiltinOperator::BuiltinOperator_EQUAL:
    case BuiltinOperator::BuiltinOperator_NOT_EQUAL:
    case BuiltinOperator::BuiltinOperator_GREATER_EQUAL:
    case BuiltinOperator::BuiltinOperator_GREATER:
    case BuiltinOperator::BuiltinOperator_LESS_EQUAL:
    case BuiltinOperator::BuiltinOperator_LESS:
      loadComparison(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_ONE_HOT:
      loadOneHot(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_ABS:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::ABS);
      return;
    case BuiltinOperator::BuiltinOperator_COS:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::COS);
      return;
    case BuiltinOperator::BuiltinOperator_SIN:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::SIN);
      return;
    case BuiltinOperator::BuiltinOperator_SHAPE:
      loadOperationTo<ir::operation::Shape>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_REDUCE_PROD:
      loadReduce(op, subg, ir::operation::Reduce::ReduceType::PROD);
      return;
    case BuiltinOperator::BuiltinOperator_IF:
      loadIf(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_WHILE:
      loadWhile(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_NEG:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::NEG);
      return;
    case BuiltinOperator::BuiltinOperator_ARG_MAX:
      loadArgMinMax(op, subg, true);
      return;
    case BuiltinOperator::BuiltinOperator_ARG_MIN:
      loadArgMinMax(op, subg, false);
      return;
    case BuiltinOperator::BuiltinOperator_LOG:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::LOG);
      return;
    case BuiltinOperator::BuiltinOperator_ROUND:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::ROUND);
      return;
    case BuiltinOperator::BuiltinOperator_POW:
      loadOperationTo<ir::operation::Pow>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_LOGICAL_NOT:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::LOGICAL_NOT);
      return;
    case BuiltinOperator::BuiltinOperator_LOGICAL_AND:
      loadElementwiseBinary(op, subg,
                            ir::operation::ElementwiseBinary::ElementwiseBinaryType::LOGICAL_AND);
      return;
    case BuiltinOperator::BuiltinOperator_LOGICAL_OR:
      loadElementwiseBinary(op, subg,
                            ir::operation::ElementwiseBinary::ElementwiseBinaryType::LOGICAL_OR);
      return;
    case BuiltinOperator::BuiltinOperator_FILL:
      loadOperationTo<ir::operation::Fill>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_ZEROS_LIKE:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::ZEROS_LIKE);
      return;
    case BuiltinOperator::BuiltinOperator_TILE:
      loadOperationTo<ir::operation::Tile>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_RANGE:
      loadOperationTo<ir::operation::Range>(op, subg);
      return;
    // case BuiltinOperator::BuiltinOperator_BATCH_MATMUL:
    //   Handled on each loader: different option name
    //     Circle: adjoint_lhs, adjoint_rhs
    //     TFLite: adj_x, adj_y
    case BuiltinOperator::BuiltinOperator_BROADCAST_TO:
      loadOperationTo<ir::operation::BroadcastTo>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_LOG_SOFTMAX:
      loadLogSoftmax(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_QUANTIZE:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::QUANTIZE);
      return;
    case BuiltinOperator::BuiltinOperator_DEQUANTIZE:
      loadElementwiseUnary(op, subg, ir::operation::ElementwiseUnary::Type::DEQUANTIZE);
      return;
    case BuiltinOperator::BuiltinOperator_SPACE_TO_DEPTH:
      loadSpaceToDepth(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_L2_NORMALIZATION:
      loadOperationTo<ir::operation::L2Normalization>(op, subg);
      break;
    case BuiltinOperator::BuiltinOperator_LEAKY_RELU:
      loadLeakyRelu(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_RANK:
      loadOperationTo<ir::operation::Rank>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM:
      loadUnidirectionalSequenceLSTM(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_DEPTH_TO_SPACE:
      loadDepthToSpace(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_EMBEDDING_LOOKUP:
      loadOperationTo<ir::operation::EmbeddingLookup>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_HASHTABLE_LOOKUP:
      loadOperationTo<ir::operation::HashtableLookup>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_DYNAMIC_UPDATE_SLICE:
      loadOperationTo<ir::operation::DynamicUpdateSlice>(op, subg);
      return;
    case BuiltinOperator::BuiltinOperator_TOPK_V2:
      loadTopKV2(op, subg);
      return;
    default:
      throw std::runtime_error(
        std::string("Unsupported operation: ").append(EnumNameBuiltinOperator(builtin_op)));
  }
}

References onert::ir::operation::ElementwiseUnary::ABS, onert::ir::operation::BinaryArithmetic::ADD, onert::ir::operation::Reduce::ALL, onert::ir::operation::Reduce::ANY, onert::ir::operation::Pool2D::AVG, onert::ir::operation::ElementwiseUnary::CAST, onert::ir::operation::ElementwiseUnary::COS, onert::ir::operation::ElementwiseUnary::DEQUANTIZE, onert::ir::operation::BinaryArithmetic::DIV, onert::ir::operation::ElementwiseActivation::ELU, onert::ir::operation::ElementwiseUnary::EXP, onert::ir::operation::ElementwiseUnary::FLOOR, onert::ir::operation::ElementwiseBinary::FLOOR_DIV, onert::ir::operation::ElementwiseBinary::FLOOR_MOD, onert::ir::operation::ElementwiseActivation::infinity, onert::ir::operation::ElementwiseUnary::LOG, onert::ir::operation::ElementwiseBinary::LOGICAL_AND, onert::ir::operation::ElementwiseUnary::LOGICAL_NOT, onert::ir::operation::ElementwiseBinary::LOGICAL_OR, onert::ir::operation::ElementwiseActivation::LOGISTIC, onert::ir::operation::ElementwiseBinary::MAX, onert::ir::operation::Pool2D::MAX, onert::ir::operation::Reduce::MAX, onert::ir::operation::Reduce::MEAN, onert::ir::operation::ElementwiseBinary::MIN, onert::ir::operation::BinaryArithmetic::MUL, onert::ir::operation::ElementwiseUnary::NEG, onert::ir::operation::Reduce::PROD, onert::ir::operation::ElementwiseUnary::QUANTIZE, onert::ir::operation::ElementwiseActivation::RELU, onert::ir::operation::ElementwiseUnary::ROUND, onert::ir::operation::ElementwiseUnary::RSQRT, onert::ir::operation::ElementwiseUnary::SIN, onert::ir::operation::ElementwiseUnary::SQRT, onert::ir::operation::ElementwiseUnary::SQUARE, onert::ir::operation::BinaryArithmetic::SUB, onert::ir::operation::Reduce::SUM, onert::ir::operation::ElementwiseActivation::TANH, and onert::ir::operation::ElementwiseUnary::ZEROS_LIKE.

loadOperationIO()

template<typename LoaderDomain >

void onert::loader::BaseLoader< LoaderDomain >::loadOperationIO ( const Operator *  op, ir::OperandIndexSequence &  inputs, ir::OperandIndexSequence &  outputs  )

protected

Definition at line 619 of file BaseLoader.h.

{
  for (const std::int32_t idx : *op->inputs())
  {
    // Optional tensors are not supported yet except for FULLY_CONNECTED and BCQ_FULLY_CONNECTED
    auto check_optional_input = [&]() {
      auto builtin_code = getBuiltinOperator(op);
      if (isOptionalInputTensor(idx) && !allowOptionalInputTensor(builtin_code))
        throw std::runtime_error(
          std::string("loader doesn't support optional input tensor yet for ")
            .append(EnumNameBuiltinOperator(builtin_code)));
    };
    check_optional_input();
    inputs.append(tensorIdxToOperandIdx(idx));
  }
 
  for (const std::int32_t idx : *op->outputs())
  {
    outputs.append(tensorIdxToOperandIdx(idx));
  }
}

References onert::ir::OperandIndexSequence::append().

loadOperationTo()

template<typename LoaderDomain >

template<typename OpIR , typename... Args>

const OpIR * onert::loader::BaseLoader< LoaderDomain >::loadOperationTo ( const Operator *  op, ir::Graph &  subg, Args &&...  args  )

protected

Definition at line 684 of file BaseLoader.h.

{
  static_assert(sizeof...(args) <= 1, "You can't have more than 1 arguments!");
  ir::OperandIndexSequence inputs;
  ir::OperandIndexSequence outputs;
 
  loadOperationIO(op, inputs, outputs);
 
  std::unique_ptr<OpIR> new_op(new OpIR(inputs, outputs, std::forward<Args>(args)...));
  auto ret = new_op.get();
  subg.addOperation(std::move(new_op));
 
  return ret;
}

References onert::ir::Graph::addOperation().

loadPool2DOptions()

template<typename LoaderDomain >

template<typename Param >

void onert::loader::BaseLoader< LoaderDomain >::loadPool2DOptions ( Param &  param, const Pool2DOptions *  options  )

protected

Definition at line 666 of file BaseLoader.h.

{
  // Strides and Paddings
  if (options->stride_h() <= 0 || options->stride_w() <= 0)
    throw std::runtime_error{"Invalid stride vertical or horizontal - both must be bigger than 0"};
  loadStridesAndPaddings(param, options);
  // Filter width and height
  // Strides
  if (options->filter_width() <= 0 || options->filter_height() <= 0)
    throw std::runtime_error{"Invalid filter width or height - both must be bigger than 0"};
  param.kw = options->filter_width();
  param.kh = options->filter_height();
  // Activation
  param.activation = convertActivation(options->fused_activation_function());
}

loadQuantization()

template<typename LoaderDomain >

void onert::loader::BaseLoader< LoaderDomain >::loadQuantization ( const Tensor *  tensor, ir::TypeInfo &  typeInfo  )

protected

Definition at line 467 of file BaseLoader.h.

{
  auto q_params = tensor->quantization();
 
  // Type validation
  // INT16 should be symmetric quantized
  if (tensor->type() == TensorType::TensorType_INT16)
  {
    if (q_params->zero_point() != nullptr && q_params->zero_point()->size() != 0)
    {
      auto zero_points = q_params->zero_point();
      for (uint32_t i = 0; i < zero_points->size(); i++)
      {
        if (zero_points->Get(i) != 0)
          throw std::runtime_error(
            "Quantization param: int16 should be symmetric, but zero_point is not zero.");
      }
    }
  }
 
  if (q_params == nullptr || q_params->scale() == nullptr || q_params->scale()->size() == 0)
  {
    typeInfo.quantization(0., 0);
    return;
  }
  if (q_params->zero_point() == nullptr)
  {
    throw std::runtime_error("Quantization params: scale is not null, but zero_point is null.");
  }
  const size_t num_scales = q_params->scale()->size();
  if (num_scales != q_params->zero_point()->size())
  {
    throw std::runtime_error("Quantization params: scale size != zero_point size");
  }
  std::vector<float> scales;
  std::vector<int32_t> zero_points;
  scales.resize(num_scales);
  zero_points.resize(num_scales);
  for (size_t i = 0; i < num_scales; ++i)
  {
    scales[i] = q_params->scale()->Get(i);
    // zero_point is defined as long (i64) in schema while TypeInfo's zero_point is int32_t.
    // int64_t is used instead of long because long is 4 byte in most 32bit architecture.
    int64_t zero_point = q_params->zero_point()->Get(i);
    if (zero_point < std::numeric_limits<int32_t>::min() ||
        zero_point > std::numeric_limits<int32_t>::max())
      throw std::runtime_error("Zero_point is out of int32 range.");
    zero_points[i] = static_cast<int32_t>(zero_point);
  }
  auto details = q_params->details_as_CustomQuantization();
  if (details != nullptr)
    throw std::runtime_error("Custom Quantization is not supported");
  typeInfo.quantization(std::move(scales), std::move(zero_points));
}

References onert::ir::TypeInfo::quantization().

loadSparsity()

template<typename LoaderDomain >

void onert::loader::BaseLoader< LoaderDomain >::loadSparsity ( const Tensor *  tensor, ir::TypeInfo &  typeInfo  )

protected

Definition at line 523 of file BaseLoader.h.

{
  auto src_sparsity = tensor->sparsity();
  if (src_sparsity != nullptr)
  {
    std::vector<uint16_t> w1_segments;
    std::vector<uint16_t> w1_indices;
    // check traversal_order
    if (src_sparsity->traversal_order())
    {
      const int traversal_order_size = src_sparsity->traversal_order()->size();
      for (int i = 0; i < traversal_order_size; ++i)
      {
        if (i != src_sparsity->traversal_order()->Get(i))
          throw std::runtime_error("traversal_order [0, 1, ..., n-1] is only supported.");
      }
    }
    // check block_map
    int block_rank = 0;
    if (src_sparsity->block_map())
    {
      block_rank = src_sparsity->block_map()->size();
      for (int i = 0; i < block_rank; ++i)
      {
        if (i != src_sparsity->block_map()->Get(i))
          throw std::runtime_error("block_map [0, 1, ..., n-1] is only supported.");
      }
    }
    // load metadata
    const auto dim_metadata_size = src_sparsity->dim_metadata()->size();
    const auto dense_rank = tensor->shape() ? tensor->shape()->size() : 0;
    if (dense_rank + block_rank != dim_metadata_size)
      throw std::runtime_error("sparsity dim_metadata length is wrong.");
    bool random_sparsity = dim_metadata_size == 2 && block_rank == 0;
    bool block2D_sparsity = dim_metadata_size == 4 && block_rank == 2;
    if (dim_metadata_size != !random_sparsity && !block2D_sparsity)
      throw std::runtime_error(
        "sparsity is supported only for 2D tensor with random or 16x1 block sparsity.");
 
    const auto *src_metadata = src_sparsity->dim_metadata()->Get(0);
    if (src_metadata->format() != DimensionType::DimensionType_DENSE)
      throw std::runtime_error("sparse tensor dim[0] is not DENSE");
    src_metadata = src_sparsity->dim_metadata()->Get(1);
    if (src_metadata->format() != DimensionType::DimensionType_SPARSE_CSR)
      throw std::runtime_error("sparse tensor dim[0] is not SPARSE_CSR");
    auto ParseSparseIndexVector = [src_metadata, &w1_segments, &w1_indices]() {
      if (src_metadata->array_segments() == nullptr || src_metadata->array_indices() == nullptr)
        return false;
      bool status = true;
      /* `onert` inernally uses uint16 type regardless of the value of
         the array_segments_type and array_indices_type */
      switch (src_metadata->array_segments_type())
      {
        case SparseIndexVector::SparseIndexVector_Int32Vector:
          throw std::runtime_error("sparse tensor with int32 segment type is not supported");
        case SparseIndexVector::SparseIndexVector_Uint16Vector:
          status = Copy(src_metadata->array_segments_as_Uint16Vector(), w1_segments);
          break;
        case SparseIndexVector::SparseIndexVector_Uint8Vector:
          status = Copy(src_metadata->array_segments_as_Uint8Vector(), w1_segments);
          break;
        default:
          return false;
      }
      if (status != true)
        return false;
      switch (src_metadata->array_indices_type())
      {
        case SparseIndexVector::SparseIndexVector_Int32Vector:
          throw std::runtime_error("sparse tensor with int32 indices type is not supported");
        case SparseIndexVector::SparseIndexVector_Uint16Vector:
          return Copy(src_metadata->array_indices_as_Uint16Vector(), w1_indices);
        case SparseIndexVector::SparseIndexVector_Uint8Vector:
          return Copy(src_metadata->array_indices_as_Uint8Vector(), w1_indices);
        default:
          break;
      }
      return false;
    };
    if (ParseSparseIndexVector() == false)
      throw std::runtime_error("Error during parsing sparsity index information");
    // Get block size
    std::vector<int32_t> block_size;
    for (int i = 0; i < block_rank; ++i)
    {
      auto block_metadata = src_sparsity->dim_metadata()->Get(dense_rank + i);
      if (block_metadata->format() != DimensionType::DimensionType_DENSE)
        throw std::runtime_error("block dimension must be DENSE.");
      block_size.push_back(block_metadata->dense_size());
    }
    typeInfo.sparsity(std::make_shared<ir::Sparsity>(std::move(w1_segments), std::move(w1_indices),
                                                     std::move(block_size)));
  }
}

References onert::loader::Copy(), and onert::ir::TypeInfo::sparsity().

loadStridesAndPaddings()

template<typename LoaderDomain >

template<typename Param , typename OptionsType >

void onert::loader::BaseLoader< LoaderDomain >::loadStridesAndPaddings ( Param &  param, const OptionsType *  options  )

protected

Definition at line 644 of file BaseLoader.h.

{
  // Strides
  param.stride.vertical = options->stride_h();
  param.stride.horizontal = options->stride_w();
  // Paddings
  switch (options->padding())
  {
    case Padding::Padding_SAME:
      param.padding.type = ir::PaddingType::SAME;
      break;
    case Padding::Padding_VALID:
      param.padding.type = ir::PaddingType::VALID;
      break;
    default:
      throw std::runtime_error{"Invalid padding type"};
  }
  // param paddings indexes unused
}

References onert::ir::SAME, and onert::ir::VALID.

tensorIdxToOperandIdx()

template<typename LoaderDomain >

ir::OperandIndex onert::loader::BaseLoader< LoaderDomain >::tensorIdxToOperandIdx ( int32_t  tensorIdx )

protected

tensorTypeToDataType()

template<typename LoaderDomain >

virtual ir::DataType onert::loader::BaseLoader< LoaderDomain >::tensorTypeToDataType ( const TensorType  type )

protectedvirtual

verifySubgraphIndex()

template<typename LoaderDomain >

void onert::loader::BaseLoader< LoaderDomain >::verifySubgraphIndex ( int  subg_index )

inlineprotected

Definition at line 131 of file BaseLoader.h.

  {
    const auto num_subgraphs = _domain_model->subgraphs()->size();
    if (subg_index < 0 || subg_index >= static_cast<int32_t>(num_subgraphs))
      throw std::runtime_error{std::string{"Invalid subgraph index - "} +
                               std::to_string(subg_index)};
  }

References onert::loader::BaseLoader< LoaderDomain >::_domain_model.

Field Documentation

_base

template<typename LoaderDomain >

uint8_t* onert::loader::BaseLoader< LoaderDomain >::_base

protected

Definition at line 190 of file BaseLoader.h.

_buf_to_data

template<typename LoaderDomain >

std::unordered_map<uint32_t , std::shared_ptr<ir::Data> > onert::loader::BaseLoader< LoaderDomain >::_buf_to_data

protected

Definition at line 206 of file BaseLoader.h.

_domain_model

template<typename LoaderDomain >

const Model* onert::loader::BaseLoader< LoaderDomain >::_domain_model

protected

Definition at line 196 of file BaseLoader.h.

Referenced by onert::loader::BaseLoader< LoaderDomain >::getBuiltinOperator(), and onert::loader::BaseLoader< LoaderDomain >::verifySubgraphIndex().

_fd

template<typename LoaderDomain >

int onert::loader::BaseLoader< LoaderDomain >::_fd

protected

Definition at line 194 of file BaseLoader.h.

_file_path

template<typename LoaderDomain >

std::string onert::loader::BaseLoader< LoaderDomain >::_file_path

protected

Definition at line 195 of file BaseLoader.h.

_pagesize

template<typename LoaderDomain >

int32_t onert::loader::BaseLoader< LoaderDomain >::_pagesize

protected

Definition at line 192 of file BaseLoader.h.

_tensor_names

template<typename LoaderDomain >

std::unordered_map<ir::OperandIndex, std::string> onert::loader::BaseLoader< LoaderDomain >::_tensor_names

protected

Definition at line 199 of file BaseLoader.h.

_tensor_to_operand

template<typename LoaderDomain >

std::vector<ir::OperandIndex> onert::loader::BaseLoader< LoaderDomain >::_tensor_to_operand

protected

Definition at line 198 of file BaseLoader.h.

_use_mmaped_data

template<typename LoaderDomain >

bool onert::loader::BaseLoader< LoaderDomain >::_use_mmaped_data = false

protected

Definition at line 203 of file BaseLoader.h.

Referenced by onert::loader::BaseLoader< LoaderDomain >::BaseLoader().

_verifier

template<typename LoaderDomain >

std::unique_ptr<Verifier> onert::loader::BaseLoader< LoaderDomain >::_verifier

protected

Definition at line 201 of file BaseLoader.h.

---

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

• runtime/onert/core/src/loader/BaseLoader.h