luci::CircleWhileGraphBuilder Class Reference

#include <CircleWhile.h>

Collaboration diagram for luci::CircleWhileGraphBuilder:

Public Member Functions
bool	validate (const ValidateArgs &args) const final
CircleNode *	build (const circle::OperatorT &op, GraphBuilderContext *context) const final
	While Node builder.
Public Member Functions inherited from luci::GraphBuilderBase
virtual	~GraphBuilderBase ()=default

Detailed Description

Definition at line 25 of file CircleWhile.h.

Member Function Documentation

build()

CircleNode * luci::CircleWhileGraphBuilder::build ( const circle::OperatorT &  op, GraphBuilderContext *  context  ) const

finalvirtual

While Node builder.

Note

Current loco does not provide multiple outputs We will create multiple CircleWhileOut nodes to emulate this For two outputs that may look like this

— CircleWhile — Node — - Node —

will be created like this

— CircleWhile — CircleWhileOut — Node — - CircleWhileOut — Node —

Implements luci::GraphBuilderBase.

Definition at line 61 of file CircleWhile.cpp.

{
  assert(context != nullptr);
 
  auto graph = context->graph();
 
  const std::vector<int32_t> &inputs = op.inputs;
  const std::vector<int32_t> &outputs = op.outputs;
  const auto tensors = context->reader()->tensors();
  const auto opcodes = context->reader()->opcodes();
 
  std::vector<CircleNode *> input_nodes;
  for (const int32_t input_tensor_index : inputs)
  {
    auto input_node = context->nodefinder()->node(input_tensor_index);
    assert(input_node != nullptr);
    input_nodes.push_back(input_node);
  }
 
  uint32_t input_count = inputs.size();
  uint32_t output_count = outputs.size();
 
  // Create CircleWhile
  CircleWhile *node = graph->nodes()->create<CircleWhile>(input_count, output_count);
 
  for (uint32_t idx = 0; idx < input_count; ++idx)
  {
    node->input(idx, input_nodes[idx]);
  }
 
  const auto *options = op.builtin_options.AsWhileOptions();
  node->cond_branch(options->cond_subgraph_index);
  node->body_branch(options->body_subgraph_index);
 
  assert(outputs.size() > 0);
  {
    // Lets use name of output 0 as While name
    const auto output_tensor = tensors[outputs[0]];
    assert(output_tensor != nullptr);
    node->name(tensor_name(output_tensor));
    assert(opcodes[op.opcode_index] != nullptr);
    node->op_version(opcodes[op.opcode_index]->version());
 
    // NOTE We don't set quantization for While itself but to virtual outputs
  }
 
  // Create virtual outputs of While
  for (uint32_t n = 0; n < output_count; ++n)
  {
    const auto output_tensor = tensors[outputs[n]];
    assert(output_tensor != nullptr);
 
    auto *nodeout = graph->nodes()->create<CircleWhileOut>();
 
    nodeout->input(node);
    nodeout->index(n);
 
    copy_tensor_attributes(output_tensor, nodeout);
 
    // Note: leave shape_status to UNKNOWN to run shape inference
 
    context->nodefinder()->enroll(outputs[n], nodeout);
  }
 
  return node;
}

References luci::CircleWhile::body_branch(), luci::CircleWhile::cond_branch(), luci::copy_tensor_attributes(), luci::IndexNodeFinder::enroll(), luci::GraphBuilderContext::graph(), luci::CircleWhile::input(), luci::CircleWhileOut::input(), luci::input_node(), luci::CircleNode::name(), luci::IndexNodeFinder::node(), luci::GraphBuilderContext::nodefinder(), luci::CircleNode::op_version(), luci::CircleReader::opcodes(), luci::GraphBuilderContext::reader(), luci::tensor_name(), and luci::CircleReader::tensors().

validate()

bool luci::CircleWhileGraphBuilder::validate ( const ValidateArgs &  args ) const

finalvirtual

Implements luci::GraphBuilderBase.

Definition at line 28 of file CircleWhile.cpp.

{
  const auto &inputs = args.op.inputs;
  const auto *options = args.op.builtin_options.AsWhileOptions();
 
  if (inputs.size() != args.op.outputs.size())
    return false;
 
  auto num_graphs = static_cast<int32_t>(args.reader.num_subgraph());
  if (options->cond_subgraph_index >= num_graphs)
    return false;
  if (options->body_subgraph_index >= num_graphs)
    return false;
 
  return true;
}

---

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

• compiler/luci/import/include/luci/Import/Nodes/CircleWhile.h
• compiler/luci/import/src/Nodes/CircleWhile.cpp