onert::compiler::ManualScheduler Class Reference

#include <ManualScheduler.h>

Collaboration diagram for onert::compiler::ManualScheduler:

Public Member Functions
	ManualScheduler (const std::vector< const backend::Backend * > &backends, const compiler::CompilerOptions &options)
std::unique_ptr< BackendResolver >	schedule (const ir::Graph &graph) override
Public Member Functions inherited from onert::compiler::IScheduler
virtual	~IScheduler ()=default

Detailed Description

Definition at line 26 of file ManualScheduler.h.

Constructor & Destructor Documentation

ManualScheduler()

onert::compiler::ManualScheduler::ManualScheduler	(	const std::vector< const backend::Backend * > &	backends,
		const compiler::CompilerOptions &	options
	)

Definition at line 30 of file ManualScheduler.cc.

  : _backends{backends}, _options{options}
{
}

Member Function Documentation

schedule()

std::unique_ptr< BackendResolver > onert::compiler::ManualScheduler::schedule ( const ir::Graph &  graph )

overridevirtual

Implements onert::compiler::IScheduler.

Definition at line 36 of file ManualScheduler.cc.

{
  const auto &manual_options = _options.manual_scheduler_options;
  auto backend_resolver = std::make_unique<compiler::BackendResolver>();
 
  // This fallback will be used in case that `backend_for_all` is unavailable
  auto fallback = [&]() -> const backend::Backend * {
    for (auto &&backend_id : _options.backend_list)
    {
      auto backend = resolveBackend(backend_id);
      if (backend)
        return backend;
    }
    return nullptr;
  }();
  if (fallback == nullptr)
    throw std::runtime_error{"No loaded backends available."};
 
  // 1. Backend for All operations
  const backend::Backend *backend_all = resolveBackend(manual_options.backend_for_all, fallback);
  VERBOSE(ManualScheduler) << "Default backend for all ops: " << backend_all->config()->id()
                           << std::endl;
 
  graph.operations().iterate([&](const ir::OperationIndex &index, const ir::IOperation &) {
    backend_resolver->setBackend(index, backend_all);
  });
 
  // 2. Backend per operation type
  std::unordered_map<ir::OpCode, backend::Backend *> op_type_map;
  for (const auto &[op_code, backend_name] : manual_options.opcode_to_backend)
  {
    op_type_map.emplace(op_code, BackendManager::get().get(backend_name));
  }
  // By default, Custom uses cpu backend
  op_type_map[ir::OpCode::Custom] = BackendManager::get().get("cpu");
 
  graph.operations().iterate([&](const ir::OperationIndex &index, const ir::IOperation &operation) {
    auto itr = op_type_map.find(operation.opcode());
    if (itr != op_type_map.end())
    {
      backend_resolver->setBackend(index, itr->second);
    }
  });
 
  // 3. Backend per operation
  for (const auto &[key, val] : manual_options.index_to_backend)
  {
    try
    {
      graph.operations().at(key); // Check if exist, or this will throw
      backend_resolver->setBackend(key, BackendManager::get().get(val));
    }
    catch (...)
    {
      VERBOSE(ManualScheduler) << "Invalid value while OperationIndex to Backend mapping : @" << key
                               << " -> \"" << val << "\"" << std::endl;
    }
  }
 
  // Dump final assignment
  WHEN_LOG_ENABLED(backend_resolver->iterate(
    [&](const ir::OperationIndex &index, const backend::Backend &backend) {
      VERBOSE(ManualScheduler) << "backend for " << index << ": " << backend.config()->id()
                               << std::endl;
    }));
 
  return backend_resolver;
}

References onert::compiler::CompilerOptions::backend_list, onert::backend::Backend::config(), onert::compiler::BackendManager::get(), onert::compiler::CompilerOptions::manual_scheduler_options, onert::ir::IOperation::opcode(), VERBOSE, and WHEN_LOG_ENABLED.

---

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

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