onert::compiler::pass::PermutationIOPass Class Reference

Pass to insert permutation operations for input and output for layout and/or data type conversions. More...

#include <PermutationIOPass.h>

Collaboration diagram for onert::compiler::pass::PermutationIOPass:

Public Member Functions
	PermutationIOPass (ir::Graph &graph, const CompilerOptions &options)
std::string	id () override
void	run () override
Public Member Functions inherited from onert::compiler::pass::Pass
	Pass (ir::Graph &graph)
virtual	~Pass ()=default
Public Member Functions inherited from onert::compiler::pass::IPass
virtual	~IPass ()=default

Additional Inherited Members
Protected Attributes inherited from onert::compiler::pass::Pass
ir::Graph &	_graph

Detailed Description

Pass to insert permutation operations for input and output for layout and/or data type conversions.

If actual layout or data type of input/output by user request is different with model's layout or data type, this pass will insert permutation operations for input/output nodes.

If actual layout and data type of input/output by user request is same with model's layout and data type, this pass does nothing.

Definition at line 42 of file PermutationIOPass.h.

Constructor & Destructor Documentation

PermutationIOPass()

onert::compiler::pass::PermutationIOPass::PermutationIOPass ( ir::Graph &  graph, const CompilerOptions &  options  )

inline

Definition at line 46 of file PermutationIOPass.h.

    : Pass(graph), _options(options)
  {
  }

Member Function Documentation

id()

std::string onert::compiler::pass::PermutationIOPass::id ( )

inlineoverridevirtual

Implements onert::compiler::pass::Pass.

Definition at line 52 of file PermutationIOPass.h.

{ return "PermutationIOPass"; }

run()

void onert::compiler::pass::PermutationIOPass::run ( )

overridevirtual

Implements onert::compiler::pass::Pass.

Definition at line 29 of file PermutationIOPass.cc.

{
  if (_options.input_layout.size() == 0 && _options.output_layout.size() == 0 &&
      _options.input_type.size() == 0 && _options.output_type.size() == 0)
    return;
 
  for (auto i = ir::IOIndex{0}; i < ir::IOIndex{_graph.getInputs().size()}; i++)
  {
    if (_options.input_layout.count(i) == 0 && _options.input_type.count(i) == 0)
      continue;
 
    const auto index = _graph.getInputs().at(i);
    const auto &type = _options.input_type.count(i) > 0 ? _options.input_type.at(i)
                                                        : _graph.operands().at(index).typeInfo();
    const auto layout =
      _options.input_layout.count(i) > 0 ? _options.input_layout.at(i) : ir::Layout::NHWC;
 
    insertInputPermute(index, type, layout);
  }
 
  for (auto i = ir::IOIndex{0}; i < ir::IOIndex{_graph.getOutputs().size()}; i++)
  {
    if (_options.output_layout.count(i) == 0 && _options.output_type.count(i) == 0)
      continue;
 
    const auto index = _graph.getOutputs().at(i);
    const auto &type = _options.output_type.count(i) > 0 ? _options.output_type.at(i)
                                                         : _graph.operands().at(index).typeInfo();
    const auto layout =
      _options.output_layout.count(i) > 0 ? _options.output_layout.at(i) : ir::Layout::NHWC;
 
    insertOutputPermute(index, type, layout);
  }
}

References onert::compiler::pass::Pass::_graph, onert::util::ObjectManager< Index, Object >::at(), onert::ir::OperandIndexSequence::at(), onert::ir::Graph::getInputs(), onert::ir::Graph::getOutputs(), onert::compiler::CompilerOptions::input_layout, onert::compiler::CompilerOptions::input_type, onert::ir::NHWC, onert::ir::Graph::operands(), onert::compiler::CompilerOptions::output_layout, onert::compiler::CompilerOptions::output_type, and size.

---

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

• runtime/onert/core/src/compiler/pass/PermutationIOPass.h
• runtime/onert/core/src/compiler/pass/PermutationIOPass.cc