luci::GraphBuilderMultiOutput Class Reference

Base of general multiple outputs graph builder(e.g., CircleIfGraphBuilder) More...

#include <GraphBuilderMultiOutput.h>

Collaboration diagram for luci::GraphBuilderMultiOutput:

Data Structures
struct	BuildNodeArgs
struct	BuildOutArgs

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

Detailed Description

Base of general multiple outputs graph builder(e.g., CircleIfGraphBuilder)

Definition at line 31 of file GraphBuilderMultiOutput.h.

Constructor & Destructor Documentation

~GraphBuilderMultiOutput()

virtual luci::GraphBuilderMultiOutput::~GraphBuilderMultiOutput ( )

virtualdefault

Member Function Documentation

build()

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

finalvirtual

Implements luci::GraphBuilderBase.

Definition at line 24 of file GraphBuilderMultiOutput.cpp.

{
  LOGGER(l);
 
  assert(context != nullptr);
 
  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();
  assert(!tensors.null());
 
  std::vector<CircleNode *> input_nodes;
  for (const int32_t input_tensor_index : inputs)
  {
    if (input_tensor_index >= 0)
    {
      auto input = context->nodefinder()->node(input_tensor_index);
      if (input == nullptr)
        INFO(l) << "[luci] Warning: input node is null " << input_tensor_index << std::endl;
      input_nodes.push_back(input);
    }
    else
    {
      // If there is no tensor, insert CircleOutputExclude.
      auto *node = context->graph()->nodes()->create<luci::CircleOutputExclude>();
      input_nodes.push_back(node);
    }
  }
 
  BuildNodeArgs bna(op, context, input_nodes);
  auto *node = build_node(bna);
 
  uint32_t output_count = outputs.size();
  // NOTE CustomOp inherits GraphBuilderMultiOutput and can have 0 output
  if (output_count > 0)
  {
    // Let's use attributes from output 0 for this node
    const auto output_tensor = tensors[outputs[0]];
    assert(output_tensor != nullptr);
    node->name(tensor_name(output_tensor));
    node->dtype(luci_datatype(output_tensor->type()));
 
    // mark operator version
    assert(opcodes[op.opcode_index] != nullptr);
    node->op_version(opcodes[op.opcode_index]->version());
 
    // NOTE We don't set quantization for multiple output nodes but to virtual outputs
  }
 
  // Create virtual outputs of Virtual Output node(s)
  for (uint32_t n = 0; n < output_count; ++n)
  {
    const auto output_tensor = tensors[outputs[n]];
    assert(output_tensor != nullptr);
 
    BuildOutArgs boa(node, n);
    auto *nodeout = build_out(boa);
 
    copy_tensor_attributes(output_tensor, nodeout);
    // NOTE name of CxxxOut nodes may have same name
    // mark shape_status
    if (output_tensor->shape() == nullptr)
      nodeout->shape_status(ShapeStatus::NOSHAPE);
    else
      nodeout->shape_status(ShapeStatus::VALID);
 
    context->nodefinder()->enroll(outputs[n], nodeout);
  }
 
  return node;
}

References luci::copy_tensor_attributes(), loco::NodePool::create(), luci::IndexNodeFinder::enroll(), luci::GraphBuilderContext::graph(), INFO, LOGGER, luci::luci_datatype(), luci::IndexNodeFinder::node(), luci::GraphBuilderContext::nodefinder(), loco::Graph::nodes(), luci::NOSHAPE, luci::CircleReader::opcodes(), luci::GraphBuilderContext::reader(), luci::tensor_name(), luci::CircleReader::tensors(), and luci::VALID.

---

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

• compiler/luci/import/include/luci/Import/GraphBuilderMultiOutput.h
• compiler/luci/import/src/GraphBuilderMultiOutput.cpp