onert::compiler::Compiler Class Reference

Class to compile NN package. More...

#include <Compiler.h>

Collaboration diagram for onert::compiler::Compiler:

Public Member Functions
	Compiler (std::unique_ptr< ir::NNPkg > nnpkg, CompilerOptions *copts)
	Construct a new Compiler object for NN package.
	~Compiler ()=default
	Destroy the Compiler object.
std::unique_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 35 of file Compiler.h.

Constructor & Destructor Documentation

Compiler()

onert::compiler::Compiler::Compiler	(	std::unique_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 Compiler.cc.

  : _nnpkg{std::move(nnpkg)}, _options{copts}
{
  // DO NOTHING
}

~Compiler()

onert::compiler::Compiler::~Compiler ( )

default

Destroy the Compiler object.

Member Function Documentation

compile()

std::unique_ptr< CompilerArtifact > onert::compiler::Compiler::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 66 of file Compiler.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)
    {
      if (!_options->he_scheduler)
        throw std::runtime_error("Heterogeneous scheduler must be enabled during profiling.");
 
      if (_options->executor != "Dataflow")
        throw std::runtime_error("Profiling mode works only with 'Dataflow' executor");
    }
 
    _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("Compiler can only compile models for inference.");
  }
 
  if (model_count > 1)
    updateOptionForMultiModel();
 
  for (uint16_t i = 0; i < model_count; i++)
  {
    auto model_index = ir::ModelIndex{i};
    _nnpkg->model(ir::ModelIndex{i})
      ->iterate([&](const ir::SubgraphIndex &subg_index, 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))
          .append(
            std::make_unique<pass::PermutationIOPass>(subg, *_options, model_index, subg_index))
          .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
  auto tracing_ctx = std::make_unique<util::TracingCtx>();
 
  // 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
      tracing_ctx->setSubgraphIndex(&(lowered_subgs[model_index][subg_index]->graph()),
                                    {model_index, subg_index});
    });
  }
 
  _nnpkg.reset();
 
  for (const auto &[model_index, model_lsubg] : lowered_subgs)
  {
    for (const auto &[subg_index, lowered_subg] : model_lsubg)
    {
      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
   *************************************************************/
  std::shared_ptr<exec::IExecutors> executors = nullptr;
  const auto &pkg_outputs = model_edges->pkg_outputs;
  if (model_count == 1)
    executors = std::make_shared<exec::SingleModelExecutors>();
  else
    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];
      if (_options->internal_output_alloc)
      {
        for (const auto &desc : pkg_outputs)
        {
          // Only outputs of this entry
          if (const auto &[m, s, io] = desc; m == model_index && s == subg_index)
          {
            // Map IOIndex to OperandIndex
            auto idx = lowered_subg->graph().getOutputs().at(io);
            args.internal_io_indexes.add(idx);
          }
        }
      }
      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_unique<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::executor, onert::compiler::CompilerOptions::forceInternalOptions(), onert::compiler::ExecutorFactory::get(), onert::compiler::CompilerOptions::graph_dump_level, onert::compiler::CompilerOptions::he_profiling_mode, onert::compiler::CompilerOptions::he_scheduler, onert::compiler::CompilerOptions::internal_output_alloc, m, 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/Compiler.h
• runtime/onert/core/src/compiler/Compiler.cc