onert::compiler::MultiModelCompiler Class Reference

Class to compile NN package. More...

#include <MultiModelCompiler.h>

Collaboration diagram for onert::compiler::MultiModelCompiler:

Public Member Functions
	MultiModelCompiler (const std::shared_ptr< ir::NNPkg > &nnpkg, CompilerOptions *copts)
	Construct a new Compiler object for NN package.
	~MultiModelCompiler ()=default
	Destroy the MultiModelCompiler object.
std::shared_ptr< CompilerArtifact >	compile (void)
	Do compilation with the options.
Public Member Functions inherited from onert::compiler::ICompiler
virtual	~ICompiler ()=default
	Virtual ICompiler destructor.

Detailed Description

Class to compile NN package.

Definition at line 37 of file MultiModelCompiler.h.

Constructor & Destructor Documentation

MultiModelCompiler()

onert::compiler::MultiModelCompiler::MultiModelCompiler	(	const std::shared_ptr< ir::NNPkg > &	nnpkg,
		CompilerOptions *	copts
	)

Construct a new Compiler object for NN package.

Parameters

[in]	nnpkg	NN package to compile
[in]	copts	Compiler option for package

Definition at line 41 of file MultiModelCompiler.cc.

  : _nnpkg{nnpkg}, _options{copts}
{
  // DO NOTHING
}

~MultiModelCompiler()

onert::compiler::MultiModelCompiler::~MultiModelCompiler ( )

default

Destroy the MultiModelCompiler object.

Member Function Documentation

compile()

std::shared_ptr< CompilerArtifact > onert::compiler::MultiModelCompiler::compile ( void  )

virtual

Do compilation with the options.

Returns

std::shared_ptr<CompilerArtifact> MultiModelExecutors as a result of compilation

Implements onert::compiler::ICompiler.

Definition at line 48 of file MultiModelCompiler.cc.

{
  /***************************************************
   * Prepare compilation phase
   ***************************************************/
  {
    if (!_options)
      throw std::runtime_error{"Empty compile option"};
 
    // Mode check
    // TODO handle option for each model
    if (_options->he_profiling_mode)
      throw std::runtime_error("NYI: Profiling mode for multiple model is not supported yet");
 
    _options->forceInternalOptions();
    _options->verboseOptions();
  }
 
  // NYI: allow one model compilation
  auto const model_count = _nnpkg->model_count();
  for (uint16_t i = 0; i < model_count; i++)
  {
    if (!_nnpkg->model(ir::ModelIndex{i})->hasOnly<ir::Graph>())
      throw std::runtime_error("MultiModelCompiler can only compile models for inference.");
  }
 
  for (uint16_t i = 0; i < model_count; i++)
  {
    _nnpkg->model(ir::ModelIndex{i})->iterate([&](const ir::SubgraphIndex &, ir::IGraph &graph) {
      auto &subg = nnfw::misc::polymorphic_downcast<ir::Graph &>(graph);
 
      // Mandatory passes
      pass::PassRunner{}
        .append(std::make_unique<pass::ConstantOutputPass>(subg))
        .append(std::make_unique<pass::OddOutputPass>(subg))
        .run();
 
      // Optimizations
      pass::PassRunner{}.append(std::make_unique<pass::UnusedOperandEliminationPass>(subg)).run();
    });
  }
 
  /***************************************************
   * Backend independent analysis & optimization phase
   ***************************************************/
  // TODO Handle dump level for each model
  auto dump_level = static_cast<dumper::dot::DotDumper::Level>(_options->graph_dump_level);
  onert::dumper::dot::DotDumper dot_dumper(dump_level);
 
  // Tracing context
  // TODO Support tracing_ctx for multiple model
  std::unique_ptr<util::TracingCtx> tracing_ctx = nullptr;
 
  // Model edge context: copy model edge context
  auto model_edges = std::make_unique<ir::ModelEdges>(_nnpkg->model_edges());
 
  // Custom kernels
  std::unordered_map<ir::ModelIndex, std::shared_ptr<backend::custom::IKernelBuilder>>
    custom_kernel_builders;
  for (uint16_t i = 0; i < model_count; i++)
  {
    auto const model_index = ir::ModelIndex{i};
    custom_kernel_builders[model_index] = _nnpkg->model(model_index)->getKernelBuilder();
  }
 
  // Lower: Assign backend
  std::unordered_map<ir::ModelIndex,
                     std::unordered_map<ir::SubgraphIndex, std::unique_ptr<compiler::LoweredGraph>>>
    lowered_subgs;
 
  for (uint16_t i = 0; i < model_count; i++)
  {
    auto const model_index = ir::ModelIndex{i};
    auto model = _nnpkg->model(model_index);
 
    model->iterate([&](const ir::SubgraphIndex &subg_index, ir::IGraph &graph) {
      auto &subg = nnfw::misc::polymorphic_downcast<ir::Graph &>(graph);
 
      dot_dumper.dump(subg,
                      nnfw::misc::str("before_lower_model-", i, "-subg-", subg_index.value()));
      // Lower: Assign backend
      lowered_subgs[model_index][subg_index] =
        std::make_unique<compiler::LoweredGraph>(subg, *_options);
      // Set tracing_ctx for copied graph
      if (tracing_ctx != nullptr)
        tracing_ctx->setSubgraphIndex(&(lowered_subgs[model_index][subg_index]->graph()),
                                      subg_index.value());
    });
  }
 
  _nnpkg.reset();
 
  for (const auto &pair : lowered_subgs)
  {
    const auto &model_index = pair.first;
    const auto &model_lsubg = pair.second;
 
    for (const auto &pair_inner : model_lsubg)
    {
      const auto &subg_index = pair_inner.first;
      const auto &lowered_subg = pair_inner.second;
      dot_dumper.dump(*lowered_subg, nnfw::misc::str("after_lower_model-", model_index.value(),
                                                     "-subg-", subg_index.value()));
    }
  }
 
  // Shape inference.
  for (auto &&pair : lowered_subgs)
  {
    auto &model_lsubgs = pair.second;
    // Run the StaticShapeInfer of primary subg. All child StaticShapeInferers are called
    // recursively
    std::unordered_map<ir::SubgraphIndex, std::unique_ptr<StaticShapeInferer>> inferers =
      createStaticShapeInferers(model_lsubgs);
 
    const auto primary_subg_idx = ir::SubgraphIndex{0};
    inferers.at(primary_subg_idx)->infer();
 
    for (const auto &pair_inferer : inferers)
    {
      const auto inferer = pair_inferer.second.get();
      inferer->dump();
    }
  }
 
  // Shape validation
  // TODO Move shape independent feature check from ShapeValidator to OperationValidator
  // TODO Move ShapeValidator into shape inference
  //      - Check input tensor shape validation
  //      - Check parameter value validation which valid value is depend on input tensor shape
  //      - Output tensor shape validation check is needless because
  //        static/dynamic shape inferer will make valid output shape
  for (const auto &pair : lowered_subgs)
  {
    const auto &model_lsubgs = pair.second;
 
    for (const auto &pair_inner : model_lsubgs)
    {
      const auto &lowered_subg = pair_inner.second;
      compiler::ShapeValidator{lowered_subg->graph()}();
    }
  }
 
  /*************************************************************
   *  Backend independent analysis & optimization phase finished
   *************************************************************/
  auto executors = std::make_shared<exec::MultiModelExecutors>(std::move(model_edges));
  for (auto &&pair : lowered_subgs)
  {
    auto const &model_index = pair.first;
    auto &model_lsubgs = pair.second;
 
    for (auto &&pair_inner : model_lsubgs)
    {
      auto const subg_index = pair_inner.first;
      auto &lowered_subg = pair_inner.second;
      auto const indexed_ranks = lowered_subg->indexed_ranks();
 
      ir::OperationDumper dumper("Executor generation of Subgraph " +
                                 std::to_string(subg_index.value()));
      lowered_subg->graph().operations().iterate(
        [&](const ir::OperationIndex &, const ir::IOperation &op) { op.accept(dumper); });
 
      ExecutorFactoryArgs args;
      args.tracing_ctx = tracing_ctx.get();
      args.options = _options;
      args.model_index = model_index;
      args.custom_kernel_builder = custom_kernel_builders[model_index];
      auto executor = std::unique_ptr<exec::IExecutor>{
        ExecutorFactory::get().create(std::move(lowered_subg), executors, args)};
      executor->setIndexedRanks(indexed_ranks);
      executors->emplace(model_index, subg_index, std::move(executor));
    }
  }
 
  /********************************
   * Code generation phase finished
   ********************************/
  return std::make_shared<CompilerArtifact>(executors, std::move(tracing_ctx));
}

References onert::ir::IOperation::accept(), onert::compiler::pass::PassRunner::append(), onert::compiler::ExecutorFactory::create(), onert::dumper::dot::DotDumper::dump(), onert::compiler::CompilerOptions::forceInternalOptions(), onert::compiler::ExecutorFactory::get(), onert::compiler::CompilerOptions::graph_dump_level, onert::compiler::CompilerOptions::he_profiling_mode, onert::compiler::pass::PassRunner::run(), onert::exec::IExecutor::setIndexedRanks(), nnfw::misc::str(), onert::util::Index< T, DummyTag >::value(), and onert::compiler::CompilerOptions::verboseOptions().

---

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

• runtime/onert/core/src/compiler/MultiModelCompiler.h
• runtime/onert/core/src/compiler/MultiModelCompiler.cc