onert::compiler::pass::ConstantInsertionPass Class Reference

#include <ConstantInsertionPass.h>

Collaboration diagram for onert::compiler::pass::ConstantInsertionPass:

Public Member Functions
std::string	id () final
	Returns string id for this pass. Same with class name.
void	callback (const ir::OperationIndex &index, ir::IOperation &node) final
	Be called for all nodes of graph.
	LoweredOperationPass (ILoweredGraph &lowered_graph)
Public Member Functions inherited from onert::compiler::pass::LoweredOperationPass
	LoweredOperationPass (ILoweredGraph &lowered_graph)
virtual	~LoweredOperationPass ()=default
Public Member Functions inherited from onert::compiler::pass::OperationPass
virtual	~OperationPass ()=default
void	run () final
	Run the pass.
	Pass (ir::Graph &graph)
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::LoweredOperationPass
ILoweredGraph &	_lowered_graph
Protected Attributes inherited from onert::compiler::pass::Pass
ir::Graph &	_graph

Detailed Description

Definition at line 29 of file ConstantInsertionPass.h.

Member Function Documentation

callback()

void onert::compiler::pass::ConstantInsertionPass::callback ( const ir::OperationIndex &  index, ir::IOperation &  node  )

finalvirtual

Be called for all nodes of graph.

Parameters

index	is the index of a node in graph
node	is the node in graph

Implements onert::compiler::pass::LoweredOperationPass.

Definition at line 25 of file ConstantInsertionPass.cc.

{
  const auto backend = _lowered_graph.lower_info().operation.at(node_index);
 
  for (const auto &input : node.getInputs() | ir::Remove::DUPLICATED | ir::Remove::UNDEFINED)
  {
    auto &object = _graph.operands().at(input);
 
    // Skip if the operand is not constant or not shared constant
    if (!object.isConstant() || object.getUses().size() < 2)
      continue;
 
    // 1st use of shared constant operand. Keep using original operand without insertion of new one
    // Register original operand into keep_operand map for later reuse on same backend
    if (_keep_operands_map.find(input) == _keep_operands_map.end())
    {
      _keep_operands_map.emplace(input, backend);
      continue;
    }
 
    // Same PermuteFactor with original operand usage. Keep using original operand
    if (_keep_operands_map.at(input) == backend)
      continue;
 
    // Different backend with original operand
 
    // Check operand is already created for current input's PermuteFactor
    // If not, create new operand and register to _replace_operands_map
    if (_replace_operands_map.count(backend) == 0)
    {
      ir::Operand new_object(object);
      new_object.clearDefUse();
      const auto new_index = _graph.operands().emplace(new_object);
      _replace_operands_map[backend] = new_index;
    }
 
    const auto replaced_input = _replace_operands_map[backend];
 
    // Update the same inputs of a node at once because inputs of an operation have the same
    // backend
    node.replaceInputs(input, replaced_input);
 
    // Update operand
    auto &replaced_object = _graph.operands().at(replaced_input);
    replaced_object.insertUse(node_index);
 
    VERBOSE(ConstInsertPass) << "New operand " << replaced_input << " added(copy of " << input
                             << ") for " << backend->config()->id() << std::endl;
    // Remove this node from uses of origin operand
    // Constant operand has no def.
    assert(!object.getDef().valid());
    object.removeUse(node_index);
 
    // Remain uses by _keep_operands_map
    assert(object.getUses().size() != 0);
  }
 
  // Now this runtime does not support the node making output as constant
  for ([[maybe_unused]] const auto &output :
       node.getOutputs() | ir::Remove::DUPLICATED | ir::Remove::UNDEFINED)
  {
    assert(!_graph.operands().at(output).isConstant());
  }
}

References onert::compiler::pass::Pass::_graph, onert::compiler::pass::LoweredOperationPass::_lowered_graph, onert::util::ObjectManager< Index, Object >::at(), onert::ir::Operand::clearDefUse(), onert::ir::DUPLICATED, onert::util::ObjectManager< Index, Object >::emplace(), onert::ir::IOperation::getInputs(), onert::ir::IOperation::getOutputs(), onert::compiler::ILoweredGraph::lower_info(), onert::ir::Graph::operands(), onert::compiler::GraphLowerInfo::operation, onert::ir::IOperation::replaceInputs(), size, onert::ir::UNDEFINED, and VERBOSE.

id()

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

inlinefinalvirtual

Returns string id for this pass. Same with class name.

Returns

string id

Implements onert::compiler::pass::LoweredOperationPass.

Definition at line 35 of file ConstantInsertionPass.h.

{ return "ConstantInsertionPass"; }

LoweredOperationPass()

onert::compiler::pass::LoweredOperationPass::LoweredOperationPass ( ILoweredGraph &  lowered_graph )

inline

Definition at line 29 of file LoweredOperationPass.h.

    : OperationPass{lowered_graph.graph()}, _lowered_graph{lowered_graph}
  {
    // DO NOTHING
  }

---

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

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