luci_interpreter::GraphLoader Class Reference

#include <GraphLoader.h>

Public Member Functions
	GraphLoader (const loco::Graph *graph, RuntimeGraph *runtime_graph, RuntimeToIR &runtime_to_ir, const std::unordered_map< const loco::Graph *, RuntimeGraph * > &graph_to_runtime_graph, std::unordered_map< const loco::Node *, Tensor * > &node_to_tensor, IMemoryManager *memory_manager)
void	loadTensors ()
void	initInputOutputTensors () const
void	loadOperators ()

Static Public Member Functions
static void	checkInplaceOps (CircleReader *reader, RuntimeGraph *runtime_graph)

Detailed Description

Definition at line 31 of file GraphLoader.h.

Constructor & Destructor Documentation

GraphLoader()

luci_interpreter::GraphLoader::GraphLoader	(	const loco::Graph *	graph,
		RuntimeGraph *	runtime_graph,
		RuntimeToIR &	runtime_to_ir,
		const std::unordered_map< const loco::Graph *, RuntimeGraph * > &	graph_to_runtime_graph,
		std::unordered_map< const loco::Node *, Tensor * > &	node_to_tensor,
		IMemoryManager *	memory_manager
	)

Definition at line 177 of file GraphLoader.cpp.

  : _graph(graph), _runtime_graph(runtime_graph), _runtime_to_ir(runtime_to_ir),
    _graph_to_runtime_graph(graph_to_runtime_graph), _node_to_tensor(node_to_tensor),
    _memory_manager(memory_manager)
{
}

Member Function Documentation

checkInplaceOps()

void luci_interpreter::GraphLoader::checkInplaceOps ( CircleReader *  reader, RuntimeGraph *  runtime_graph  )

static

Definition at line 89 of file GraphLoader.cpp.

{
  const auto operators = reader->operators();
  const auto graph_outputs = reader->outputs();
  for (uint32_t i = 0; i < operators.size(); ++i)
  {
    const auto *op = operators.at(i);
    assert(op != nullptr);
 
    // Check inplace optimization for operation with single input and single output
    if (isInplaceOperation(reader->builtin_code(op)))
    {
      const auto *op_inputs = op->inputs();
      const auto *op_outputs = op->outputs();
 
      bool is_inplace = true;
      auto non_const_input_it = op_inputs->begin();
      while (true)
      {
        non_const_input_it =
          std::find_if(non_const_input_it, op_inputs->end(), [&reader](const auto input_idx) {
            if (input_idx == -1)
              return false;
 
            return not Tensor::is_constant_tensor(reader, reader->tensors()[input_idx]);
          });
 
        if (non_const_input_it == op_inputs->end())
          break;
 
        auto dist = std::distance(op_inputs->begin(), non_const_input_it);
 
        const auto non_const_input_idx = *non_const_input_it;
 
        // Check single usage of input tensor
        if (not isSingleUsageOfTensor(reader, non_const_input_idx))
        {
          is_inplace = false;
          break;
        }
 
        // Let's check single usage of output tensor
        if (dist >= op_outputs->size() and op_outputs->size() == 1)
          dist = 0;
        assert(dist < op_outputs->size());
        const auto output_index = op_outputs->operator[](dist);
        if (not isSingleUsageOfTensor(reader, output_index))
        {
          is_inplace = false;
          break;
        }
 
        // Check that num elements are equal
        {
          const auto *input_non_const_tensor = reader->tensors().at(non_const_input_idx);
          const auto *output_tensor = reader->tensors().at(output_index);
          if (Tensor::num_elements(input_non_const_tensor) != Tensor::num_elements(output_tensor))
          {
            is_inplace = false;
            break;
          }
        }
 
        // Let's check that output is not a graph output tensor
        // TODO: check this statement
        {
          if (std::find(graph_outputs.begin(), graph_outputs.end(), output_index) !=
              graph_outputs.end())
          {
            is_inplace = false;
            break;
          }
        }
 
        non_const_input_it++;
      }
 
      if (is_inplace)
        runtime_graph->addInplaceOpIndex(op);
    }
  }
}

References luci_interpreter::RuntimeGraph::addInplaceOpIndex(), luci::VectorWrapper< T >::at(), luci::CircleReader::builtin_code(), luci::CircleReader::operators(), luci::CircleReader::outputs(), size, and luci::CircleReader::tensors().

Referenced by luci_interpreter::ModuleLoader::load().

initInputOutputTensors()

void luci_interpreter::GraphLoader::initInputOutputTensors

(

)

const

Definition at line 274 of file GraphLoader.cpp.

{
  auto input_nodes = loco::input_nodes(_graph);
  std::vector<Tensor *> input_tensors(input_nodes.size());
  for (size_t i = 0; i < input_nodes.size(); ++i)
  {
    input_tensors[i] = _node_to_tensor.at(input_nodes[i]);
    _memory_manager->allocate_memory(*input_tensors[i]);
  }
  _runtime_graph->setInputTensors(input_tensors);
 
  auto output_nodes = loco::output_nodes(const_cast<loco::Graph *>(_graph));
  std::vector<Tensor *> output_tensors(output_nodes.size());
  for (size_t i = 0; i < output_nodes.size(); ++i)
  {
    const auto *node = loco::must_cast<const luci::CircleOutput *>(output_nodes[i]);
    output_tensors[i] = _node_to_tensor.at(node->from());
  }
  _runtime_graph->setOutputTensors(output_tensors);
}

References luci_interpreter::IMemoryManager::allocate_memory(), loco::input_nodes(), loco::output_nodes(), luci_interpreter::RuntimeGraph::setInputTensors(), and luci_interpreter::RuntimeGraph::setOutputTensors().

Referenced by luci_interpreter::ModuleLoader::load().

loadOperators()

void luci_interpreter::GraphLoader::loadOperators

(

)

Definition at line 295 of file GraphLoader.cpp.

{
  KernelBuilder kernel_builder(_graph_to_runtime_graph, _node_to_tensor);
 
  // Create kernels for executable nodes. This has to be done in execution order.
  auto graph = const_cast<loco::Graph *>(_graph);
 
  auto const graph_nodes = loco::all_nodes(graph);
 
  // Checking for execution plan in node annotations.
  bool has_execution_annotation = true;
  auto const checking_exec_plan = [&has_execution_annotation](auto const node) {
    const auto *circle_node = loco::must_cast<const luci::CircleNode *>(node);
    if (!luci::has_execution_plan(circle_node))
      has_execution_annotation = false;
  };
  std::for_each(begin(graph_nodes), end(graph_nodes), checking_exec_plan);
 
  if (has_execution_annotation)
  {
    // Build ordered_nodes vector that stores the order of execution of graph nodes.
    std::vector<const luci::CircleNode *> ordered_nodes(graph_nodes.size());
 
    auto const filler = [&ordered_nodes](auto const node) {
      const auto *circle_node = loco::must_cast<const luci::CircleNode *>(node);
      auto const position = luci::get_execution_plan(circle_node).order_in_plan();
      ordered_nodes.at(position) = circle_node;
    };
    std::for_each(begin(graph_nodes), end(graph_nodes), filler);
 
    for (auto node : ordered_nodes)
    {
      if (isExecutableNode(node))
      {
        std::unique_ptr<Kernel> kernel = kernel_builder.build(node);
        _runtime_to_ir.kernel_to_node.emplace(kernel.get(), node);
        _runtime_graph->addKernel(std::move(kernel));
      }
    }
  }
  else
  {
    // If it is impossible to build the execution order plan,
    // then we use the default postorder_traversal approach.
    for (const loco::Node *loco_node : loco::postorder_traversal(loco::output_nodes(graph)))
    {
      const auto *node = loco::must_cast<const luci::CircleNode *>(loco_node);
      if (isExecutableNode(node))
      {
        std::unique_ptr<Kernel> kernel = kernel_builder.build(node);
        _runtime_to_ir.kernel_to_node.emplace(kernel.get(), node);
        _runtime_graph->addKernel(std::move(kernel));
      }
    }
  }
}

References luci_interpreter::RuntimeGraph::addKernel(), loco::all_nodes(), begin, luci_interpreter::KernelBuilder::build(), luci::get_execution_plan(), luci::has_execution_plan(), luci_interpreter::RuntimeToIR::kernel_to_node, luci::CircleNodeExecutionPlan::order_in_plan(), loco::output_nodes(), and loco::postorder_traversal().

Referenced by luci_interpreter::ModuleLoader::load().

loadTensors()

void luci_interpreter::GraphLoader::loadTensors

(

)

Definition at line 187 of file GraphLoader.cpp.

{
  for (uint32_t i = 0; i < _graph->nodes()->size(); ++i)
  {
    const auto *node = loco::must_cast<const luci::CircleNode *>(_graph->nodes()->at(i));
 
    if (node->opcode() == luci::CircleOpcode::CUSTOM && !isSupportedCustomNode(node))
    {
      const auto *cnode = loco::must_cast<const luci::CircleCustom *>(node);
      throw std::runtime_error("Unsupported Custom operator. " + cnode->custom_code() + " in " +
                               node->name());
    }
 
    if (!isTensorProducingNode(node))
      continue;
 
    // Only Input, Const, Custom and Variable nodes have shapes. Shapes of intermediate tensors will
    // be inferred.
    Shape shape{};
    switch (node->opcode())
    {
      case luci::CircleOpcode::CIRCLECONST:
      case luci::CircleOpcode::CIRCLECUSTOMOUT:
      case luci::CircleOpcode::CIRCLEINPUT:
      case luci::CircleOpcode::CIRCLEVARIABLE:
        shape = getNodeShape(node);
        break;
      default:
        break;
    }
 
    AffineQuantization quantization;
    if (node->quantparam() != nullptr)
    {
      const luci::CircleQuantParam *params = node->quantparam();
      assert(params->scale.size() == params->zerop.size());
      quantization.scale.assign(params->scale.cbegin(), params->scale.cend());
      quantization.zero_point.assign(params->zerop.cbegin(), params->zerop.cend());
      quantization.quantized_dimension = params->quantized_dimension;
    }
 
    auto tensor = std::make_unique<Tensor>(node->dtype(), std::move(shape), std::move(quantization),
                                           node->name());
 
    // If node has execution plan then read memory offsets for nodes
    // from the beginning of shared memory buffer. Used in Static Memory Manager.
    if (luci::has_execution_plan(node))
    {
      auto execution_plan = luci::get_execution_plan(node);
      assert(!execution_plan.offsets().empty());
      tensor->set_offset(execution_plan.offsets().front());
    }
 
    if (const auto *const_node = dynamic_cast<const luci::CircleConst *>(node))
    {
      size_t data_size{};
      const void *const_data = getNodeData(const_node, &data_size);
      if (const_data != nullptr)
      {
        _memory_manager->allocate_memory(*tensor);
        tensor->writeData(const_data, data_size);
      }
    }
    else if (const auto *custom_out_node = dynamic_cast<const luci::CircleCustomOut *>(node))
    {
      const auto *custom_node =
        loco::must_cast<const luci::CircleCustom *>(custom_out_node->input());
 
      if (custom_node->custom_code() == "CircleReferencingConst")
      {
        size_t data_size{};
        const void *const_data = getNodeData(custom_node, &data_size);
        if (const_data != nullptr)
        {
          _memory_manager->allocate_memory(*tensor);
          tensor->writeData(const_data, data_size);
        }
      }
    }
 
    _node_to_tensor.emplace(node, tensor.get());
    _runtime_to_ir.tensor_to_node.emplace(tensor.get(), node);
 
    _runtime_graph->addTensor(std::move(tensor));
  }
}

References luci_interpreter::RuntimeGraph::addTensor(), luci_interpreter::IMemoryManager::allocate_memory(), loco::ObjectPool< T >::at(), luci::get_execution_plan(), luci::has_execution_plan(), luci::CircleNode::name(), loco::Graph::nodes(), luci::CircleNode::opcode(), luci_interpreter::AffineQuantization::quantized_dimension, luci::CircleQuantParam::quantized_dimension, luci::CircleNode::quantparam(), luci_interpreter::AffineQuantization::scale, luci::CircleQuantParam::scale, size, luci_interpreter::RuntimeToIR::tensor_to_node, luci_interpreter::AffineQuantization::zero_point, and luci::CircleQuantParam::zerop.

Referenced by luci_interpreter::ModuleLoader::load().

---

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

• compiler/luci-interpreter/src/loader/GraphLoader.h
• onert-micro/luci-interpreter/src/loader/GraphLoader.h
• compiler/luci-interpreter/src/loader/GraphLoader.cpp
• onert-micro/luci-interpreter/src/loader/GraphLoader.cpp