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 order will be used in case that manual backend mapping is unavailable
  std::vector<const backend::Backend *> backend_order;
  for (auto &&backend_id : _options.backend_list)
  {
    auto backend = resolveBackend(backend_id);
    if (backend)
      backend_order.push_back(backend);
  }
  if (backend_order.size() == 0)
    throw std::runtime_error{"No loaded backends available."};
 
  // 1. 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));
  }
 
  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);
    }
  });
 
  // 2. Backend per operation index
  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;
    }
  }
 
  // 3. Fallback - backend priority order
  std::unordered_map<const backend::Backend *, std::unique_ptr<backend::ValidatorBase>> validators;
  for (auto &&backend : backend_order)
  {
    // Skip train backend because it's not supporting validator
    // TODO: Remove this condition when train backend supports validator
    if (backend->config()->id() == "train")
      continue;
 
    validators.emplace(backend, backend->validator(graph));
  }
 
  graph.operations().iterate([&](const ir::OperationIndex &index, const ir::IOperation &op) {
    if (!backend_resolver->hasBackend(index))
    {
      for (auto backend : backend_order)
      {
        // Use train backend if existed
        // On training mode, we should use train backend only for all operations
        // TODO: Remove this condition when train backend supports validator
        if (backend->config()->id() == "train")
        {
          backend_resolver->setBackend(index, backend);
          break;
        }
 
        if (validators[backend]->supported(op))
        {
          backend_resolver->setBackend(index, backend);
          break;
        }
      }
      if (!backend_resolver->hasBackend(index))
        throw std::runtime_error{"No backend found for operation @" +
                                 std::to_string(index.value())};
    }
  });
 
  // 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::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