onert::compiler::StaticShapeInferer Class Reference

Class to infer shape before running kernels. It does the following: More...

#include <StaticShapeInferer.h>

Collaboration diagram for onert::compiler::StaticShapeInferer:

Public Member Functions
	StaticShapeInferer (compiler::ILoweredGraph *lowered_subg)
virtual	~StaticShapeInferer ()=default
void	appendSubgInputObserver (const ir::SubgraphIndex &subg_idx, std::unique_ptr< OperandObserver > &&subg_input_observer) noexcept
void	setControlflowOutputObserver (std::unique_ptr< OperandObserver > &&output_observer) noexcept
void	appendChildInferer (const ir::SubgraphIndex &subg_idx, compiler::StaticShapeInferer *inferer)
void	infer (void)
	Infer shape of operands belonging to ops and set the output shape. If output shape cannot be known without running op, mark it so that it can be allocated when running kernel.
void	dump ()
Public Member Functions inherited from onert::ir::OperationVisitor
virtual	~OperationVisitor ()=default

Static Public Member Functions
static std::unordered_map< ir::SubgraphIndex, std::unique_ptr< StaticShapeInferer > >	createStaticShapeInferers (const std::unordered_map< ir::SubgraphIndex, ILoweredGraph * > &lowered_subgs)
	Create a shape inferer map for a lowered model.

Detailed Description

Class to infer shape before running kernels. It does the following:

• re-calculate and set output shape at compile time (before running kernels)
• if calculation cannot be done at compile time, mark the outputs to be dynamic, meaning shapes of outputs will be calculated during running kernels

Definition at line 66 of file StaticShapeInferer.h.

Constructor & Destructor Documentation

StaticShapeInferer()

onert::compiler::StaticShapeInferer::StaticShapeInferer ( compiler::ILoweredGraph *  lowered_subg )

inline

Definition at line 69 of file StaticShapeInferer.h.

    : _lowered_subg{lowered_subg}, _subg_input_observers{}, _controlflow_output_observer{nullptr},
      _child_inferers{}
  {
  }

~StaticShapeInferer()

virtual onert::compiler::StaticShapeInferer::~StaticShapeInferer ( )

virtualdefault

Member Function Documentation

appendChildInferer()

void onert::compiler::StaticShapeInferer::appendChildInferer ( const ir::SubgraphIndex &  subg_idx, compiler::StaticShapeInferer *  inferer  )

inline

Definition at line 88 of file StaticShapeInferer.h.

  {
    _child_inferers[subg_idx] = inferer;
  }

Referenced by createStaticShapeInferers().

appendSubgInputObserver()

void onert::compiler::StaticShapeInferer::appendSubgInputObserver ( const ir::SubgraphIndex &  subg_idx, std::unique_ptr< OperandObserver > &&  subg_input_observer  )

inlinenoexcept

Definition at line 77 of file StaticShapeInferer.h.

  {
    _subg_input_observers[subg_idx] = std::move(subg_input_observer);
  }

createStaticShapeInferers()

std::unordered_map< ir::SubgraphIndex, std::unique_ptr< StaticShapeInferer > > onert::compiler::StaticShapeInferer::createStaticShapeInferers ( const std::unordered_map< ir::SubgraphIndex, ILoweredGraph * > &  lowered_subgs )

static

Create a shape inferer map for a lowered model.

Parameters

[in]

lowered_subgs

lowered model map

Returns

Shape inferer map

Definition at line 204 of file StaticShapeInferer.cc.

{
  // Allocate StaticShapeInferer per each subgraph
  std::unordered_map<ir::SubgraphIndex, std::unique_ptr<StaticShapeInferer>> inferers;
  for (auto &&[subg_index, lowered_subg] : lowered_subgs)
  {
    inferers[subg_index] = std::make_unique<StaticShapeInferer>(lowered_subg);
  }
 
  // Append observers in all StaticShapeInferers
  for (auto &&pair : lowered_subgs)
  {
    const auto &subg_index = pair.first;
    auto &lowered_subg = pair.second;
 
    // TODO: Change this iteration for all to controlflow iteration
    lowered_subg->graph().operations().iterate(
      [&](const ir::OperationIndex &, const ir::IOperation &op) {
        // A Function to append child inferers. These make it possible for a StaticShapeInferer to
        // call StaticShapeInferes of child subgraphs recursively
        auto appendChildInferer = [&](const ir::SubgraphIndex &child_subg_idx) {
          auto *child_inferer = inferers.at(child_subg_idx).get();
          inferers.at(subg_index)->appendChildInferer(child_subg_idx, child_inferer);
        };
 
        // A Function to appaend subg input observers. This makes it possible for a
        // StaticShapeInferer to update inputs of child subgraphs
        auto appendSubgraphInputObserver = [&](const ir::SubgraphIndex &child_subg_idx) {
          std::vector<ir::Operand *> child_subg_inputs;
          auto &child_subg = lowered_subgs.at(child_subg_idx)->graph();
          for (const auto &input_idx : child_subg.getInputs())
          {
            auto operand_ptr = child_subg.operands().getRawPtr(input_idx);
            child_subg_inputs.emplace_back(operand_ptr);
          }
          inferers.at(subg_index)
            ->appendSubgInputObserver(child_subg_idx,
                                      std::make_unique<OperandObserver>(child_subg_inputs));
        };
 
        // A Function to set controlflow output observers. This makes it possible for a
        // StaticShapeInferer to update outputs of parent controlflow opeerations
        auto setControlFlowOutputObserver = [&](const ir::SubgraphIndex &child_subg_idx) {
          std::vector<ir::Operand *> cf_outputs;
          auto &subg = lowered_subg->graph();
          for (const auto &output_idx : op.getOutputs())
          {
            auto operand_ptr = subg.operands().getRawPtr(output_idx);
            cf_outputs.emplace_back(operand_ptr);
          }
          inferers.at(child_subg_idx)
            ->setControlflowOutputObserver(std::make_unique<OperandObserver>(cf_outputs));
        };
 
        // Append Observers in a StaticShapeInferer
        if (op.opcode() == ir::OpCode::If)
        {
          // TODO Remove dynamic_cast
          // An virtual base class cannot be downcasted by static_cast
          try
          {
            const auto &if_op = dynamic_cast<const ir::operation::If &>(op);
 
            appendChildInferer(if_op.param().then_subg_index);
            appendChildInferer(if_op.param().else_subg_index);
 
            appendSubgraphInputObserver(if_op.param().then_subg_index);
            appendSubgraphInputObserver(if_op.param().else_subg_index);
 
            setControlFlowOutputObserver(if_op.param().then_subg_index);
          }
          catch (const std::bad_cast &)
          {
            throw std::runtime_error("StaticShapeInferer: Invalid If operation");
          }
        }
        else if (op.opcode() == ir::OpCode::While)
        {
          // TODO Remove dynamic_cast
          try
          {
            const auto &while_op = dynamic_cast<const ir::operation::While &>(op);
 
            appendChildInferer(while_op.param().cond_subg_index);
            appendChildInferer(while_op.param().body_subg_index);
 
            appendSubgraphInputObserver(while_op.param().cond_subg_index);
            appendSubgraphInputObserver(while_op.param().body_subg_index);
 
            setControlFlowOutputObserver(while_op.param().body_subg_index);
          }
          catch (const std::bad_cast &)
          {
            throw std::runtime_error("StaticShapeInferer: Invalid While operation");
          }
        }
        else if (op.opcode() == ir::OpCode::Call)
        {
          // TODO Remove dynamic_cast
          try
          {
            const auto &call_op = dynamic_cast<const ir::operation::Call &>(op);
 
            appendChildInferer(call_op.param().callee_subg_index);
 
            appendSubgraphInputObserver(call_op.param().callee_subg_index);
            setControlFlowOutputObserver(call_op.param().callee_subg_index);
          }
          catch (const std::bad_cast &)
          {
            throw std::runtime_error("StaticShapeInferer: Invalid Call operation");
          }
        }
      });
  }
 
  return inferers;
}

References appendChildInferer(), onert::ir::IOperation::getOutputs(), and onert::ir::IOperation::opcode().

dump()

void onert::compiler::StaticShapeInferer::dump

(

)

Definition at line 179 of file StaticShapeInferer.cc.

{
  auto get_shape_str = [](const ir::Shape &shape) {
    std::stringstream sstream;
    sstream << "shape : {";
    for (int i = 0; i < shape.rank(); i++)
    {
      if (i == 0)
        sstream << shape.dim(i);
      else
        sstream << " " << shape.dim(i);
    }
    sstream << "}";
    return sstream.str();
  };
 
  _lowered_subg->graph().operands().iterate(
    [&](const ir::OperandIndex &ind, const ir::Operand &operand) {
      VERBOSE(StaticShapeInferer) << "  " << ind << ", "
                                  << (operand.info().isDynamic() ? "Dynamic" : "Static") << ", "
                                  << get_shape_str(operand.info().shape()) << std::endl;
    });
}

References onert::compiler::ILoweredGraph::graph(), onert::ir::Operand::info(), onert::ir::OperandInfo::isDynamic(), onert::util::ObjectManager< Index, Object >::iterate(), onert::ir::Graph::operands(), onert::ir::OperandInfo::shape(), and VERBOSE.

infer()

void onert::compiler::StaticShapeInferer::infer

(

void

)

Infer shape of operands belonging to ops and set the output shape. If output shape cannot be known without running op, mark it so that it can be allocated when running kernel.

Definition at line 56 of file StaticShapeInferer.cc.

{
  for (const auto &op_idx : _lowered_subg->graph().topolSortOperations())
  {
    const auto &op = _lowered_subg->graph().operations().at(op_idx);
 
    // Automatically mark any input with a dynamic dimension (-1)
    // so its shape is computed at execution time.
    for (const auto &idx : op.getUsedInputSet())
    {
      auto &input = _lowered_subg->graph().operands().at(idx);
      const auto &shape = input.info().shape();
      if (shape.hasUnspecifiedDims())
        input.info().setDynamic();
    }
 
    bool has_dynamic_tensor = false;
    const auto opcode = op.opcode();
    // IF: requires shape inference for then, else
    // While: requires shape inference for condition, body
    // Call: requires shape inference for callee
    if (opcode == ir::OpCode::If || opcode == ir::OpCode::While || opcode == ir::OpCode::Call)
    {
      op.accept(*this);
    }
    else
    {
      has_dynamic_tensor = checkDynamicInput(op);
      if (has_dynamic_tensor)
      {
        setDynamicOutput(op);
      }
      else
      {
        op.accept(*this);
      }
    }
    has_dynamic_tensor = has_dynamic_tensor || checkDynamicOutput(op);
    _lowered_subg->setHasDynamicTensor(op_idx, has_dynamic_tensor);
  }
 
  if (_controlflow_output_observer != nullptr)
  {
    // re-sizing output shapes of the controflow operation branching to this subgraph
    std::vector<ir::OperandInfo> outputs_info;
    const auto &graph = _lowered_subg->graph();
    const auto &outputs = graph.getOutputs();
    for (size_t i = 0; i < outputs.size(); ++i)
    {
      const auto &operand_info = graph.operands().at(outputs.at(i)).info();
      outputs_info.emplace_back(operand_info);
    }
    _controlflow_output_observer->updateShapes(outputs_info);
  }
}

References onert::util::ObjectManager< Index, Object >::at(), onert::compiler::ILoweredGraph::graph(), onert::ir::Graph::operands(), onert::ir::Graph::operations(), onert::compiler::ILoweredGraph::setHasDynamicTensor(), and onert::ir::Graph::topolSortOperations().

setControlflowOutputObserver()

void onert::compiler::StaticShapeInferer::setControlflowOutputObserver ( std::unique_ptr< OperandObserver > &&  output_observer )

inlinenoexcept

Definition at line 83 of file StaticShapeInferer.h.

  {
    _controlflow_output_observer = std::move(output_observer);
  }

---

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

• runtime/onert/core/include/compiler/StaticShapeInferer.h
• runtime/onert/core/src/compiler/StaticShapeInferer.cc