onert::compiler::Compiler Class Reference

Class to compile NN package. More...

#include <Compiler.h>

Collaboration diagram for onert::compiler::Compiler:

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

Constructor & Destructor Documentation

Compiler() [1/2]

onert::compiler::Compiler::Compiler	(	const std::shared_ptr< ir::Model > &	model,
		CompilerOptions *	copts
	)

Construct a new Compiler object for single model.

Parameters

[in]	model	model to compile
[in]	copts	Compiler Options

Definition at line 39 of file Compiler.cc.

  : _model{model}, _options{copts}
{
  // DO NOTHING
}

Compiler() [2/2]

onert::compiler::Compiler::Compiler	(	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 45 of file Compiler.cc.

  : _model{nnpkg->primary_model()}, _options{copts}
{
  // Use for single model only
  assert(nnpkg->model_count() == 1);
}

~Compiler()

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

default

Destroy the Compiler object.

Member Function Documentation

compile()

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

virtual

Do compilation with the options.

Returns

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

Implements onert::compiler::ICompiler.

Definition at line 52 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");
  }
 
  if (!_model->hasOnly<ir::Graph>())
  {
    throw std::runtime_error("Compiler can only compile models for inference.");
  }
 
  _options->forceInternalOptions();
  _options->verboseOptions();
 
  auto custom_kernel_builder = _model->getKernelBuilder();
 
  _model->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
  auto tracing_ctx = std::make_unique<util::TracingCtx>();
 
  // Lower: Assign backend
  std::unordered_map<ir::SubgraphIndex, std::unique_ptr<compiler::LoweredGraph>> lowered_subgs;
  {
    _model->iterate([&](const ir::SubgraphIndex &subg_index, ir::IGraph &graph) {
      auto &subg = nnfw::misc::polymorphic_downcast<ir::Graph &>(graph);
 
      // Lower: Assign backend
      lowered_subgs[subg_index] = std::make_unique<compiler::LoweredGraph>(subg, *_options);
      // Set tracing_ctx for copied graph
      tracing_ctx->setSubgraphIndex(&(lowered_subgs[subg_index]->graph()), subg_index.value());
    });
  }
 
  _model.reset();
 
  for (const auto &[subg_index, lowered_subg] : lowered_subgs)
  {
    dot_dumper.dump(*lowered_subg, nnfw::misc::str("after_lower_subg-", subg_index.value()));
  }
 
  // Shape inference.
  {
    // Run the StaticShapeInfer of primary subg. All child StaticShapeInferers are called
    // recursively
    std::unordered_map<ir::SubgraphIndex, std::unique_ptr<StaticShapeInferer>> inferers =
      createStaticShapeInferers(lowered_subgs);
 
    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)
  {
    auto &lowered_subg = pair.second;
    compiler::ShapeValidator{lowered_subg->graph()}();
  }
 
  /*************************************************************
   *  Backend independent analysis & optimization phase finished
   *************************************************************/
  auto executors = std::make_shared<exec::SingleModelExecutors>();
  for (auto &&[subg_index, lowered_subg] : lowered_subgs)
  {
    auto const model_index = ir::ModelIndex{0};
    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_builder;
    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::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::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/include/compiler/Compiler.h
• runtime/onert/core/src/compiler/Compiler.cc