#include <ModuleLoader.h>

Public Member Functions
	ModuleLoader (const luci::Module module, RuntimeModule runtime_module, RuntimeToIR &runtime_to_ir, std::unordered_map< const loco::Node , Tensor > &node_to_tensor, IMemoryManager *memory_manager)

void	load ()

Static Public Member Functions
static void	load (RuntimeModule runtime_module, MemoryManager memory_manager, const char *model_data_raw, bool dealloc_input)

Detailed Description

Definition at line 31 of file ModuleLoader.h.

Constructor & Destructor Documentation

◆ ModuleLoader()

luci_interpreter::ModuleLoader::ModuleLoader	(	const luci::Module *	module,
		RuntimeModule *	runtime_module,
		RuntimeToIR &	runtime_to_ir,
		std::unordered_map< const loco::Node , Tensor > &	node_to_tensor,
		IMemoryManager *	memory_manager
	)

Definition at line 24 of file ModuleLoader.cpp.

  : _module(module), _runtime_module(runtime_module), _runtime_to_ir(runtime_to_ir),
    _node_to_tensor(node_to_tensor), _memory_manager(memory_manager)
{
}

Member Function Documentation

◆ load() [1/2]

void luci_interpreter::ModuleLoader::load ( )

Definition at line 33 of file ModuleLoader.cpp.

{
  // Runtime graphs have to be created in advance, because they will be needed during the loading
  // process for control flow nodes.
  for (size_t i = 0; i < _module->size(); ++i)
  {
    _graph_to_runtime_graph.emplace(_module->graph(i), _runtime_module->addGraph(_memory_manager));
  }
  for (size_t i = 0; i < _module->size(); ++i)
  {
    const loco::Graph *graph = _module->graph(i);
    RuntimeGraph *runtime_graph = _graph_to_runtime_graph.at(graph);
    GraphLoader loader(graph, runtime_graph, _runtime_to_ir, _graph_to_runtime_graph,
                       _node_to_tensor, _memory_manager);
    loader.loadTensors();
    loader.initInputOutputTensors();
    loader.loadOperators();
  }
}

References luci_interpreter::RuntimeModule::addGraph(), luci::Module::graph(), luci_interpreter::GraphLoader::initInputOutputTensors(), luci_interpreter::GraphLoader::loadOperators(), luci_interpreter::GraphLoader::loadTensors(), and luci::Module::size().

Referenced by luci_interpreter::Interpreter::Interpreter(), luci_interpreter::Interpreter::Interpreter(), and luci_interpreter::Interpreter::Interpreter().

◆ load() [2/2]

void luci_interpreter::ModuleLoader::load	(	RuntimeModule *	runtime_module,
		MemoryManager *	memory_manager,
		const char *	model_data_raw,
		bool	dealloc_input
	)

static

Definition at line 24 of file ModuleLoader.cpp.

{
  const circle::Model *model = circle::GetModel(model_data_raw);
 
  CircleReader &reader = runtime_module->getCircleReader();
  if (!reader.parse(model))
    assert(false && "Error during parse");
 
  for (size_t i = 0; i < reader.num_subgraph(); ++i)
  {
    if (!reader.select_subgraph(i))
      assert(false && "Error during select subgraph");
    runtime_module->addGraph(memory_manager);
 
#ifndef USE_STATIC_ALLOC
    auto *runtime_graph = runtime_module->getRuntimeGraphAt(i);
    // For Dynamic memory manager we can use inplace optimization
    GraphLoader::checkInplaceOps(&reader, runtime_graph);
#endif // USE_STATIC_ALLOC
  }
 
  // For Dynamic Memory manager we build memory allocate/deallocate plan and then configure kernels.
  // For Static Memory manager we only configure kernels.
  for (size_t i = 0; i < reader.num_subgraph(); ++i)
  {
    auto *runtime_graph = runtime_module->getRuntimeGraphAt(i);
#ifdef USE_STATIC_ALLOC
    runtime_graph->configure_kernels();
#else
    runtime_graph->configure(dealloc_input);
#endif // USE_STATIC_ALLOC
  }
 
  // Select main subgraph
  reader.select_subgraph(0);
}

References luci_interpreter::RuntimeModule::addGraph(), luci_interpreter::GraphLoader::checkInplaceOps(), luci_interpreter::RuntimeGraph::configure(), luci_interpreter::RuntimeModule::getCircleReader(), luci_interpreter::RuntimeModule::getRuntimeGraphAt(), luci::CircleReader::num_subgraph(), luci::CircleReader::parse(), and luci::CircleReader::select_subgraph().

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

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