onert::compiler::HEScheduler Class Reference

Class to schedule tasks. More...

#include <HEScheduler.h>

Collaboration diagram for onert::compiler::HEScheduler:

Public Member Functions
	HEScheduler (const std::vector< const backend::Backend * > &backends, const CompilerOptions &options)
	Construct a new Heterogeneous Execution Scheduler object.
std::unique_ptr< compiler::BackendResolver >	schedule (const ir::Graph &graph) final
	Task scheduling.
std::shared_ptr< ir::OperationIndexMap< int64_t > >	getIndexedRanks ()

Detailed Description

Class to schedule tasks.

Definition at line 47 of file HEScheduler.h.

Constructor & Destructor Documentation

HEScheduler()

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

inline

Construct a new Heterogeneous Execution Scheduler object.

Parameters

[in]	model	Graph model
[in]	backend_resolver	backend resolver

Definition at line 55 of file HEScheduler.h.

    : _is_supported{}, _backends_avail_time{}, _ops_eft{},
      _op_to_rank{std::make_shared<ir::OperationIndexMap<int64_t>>()},
      _is_profiling_mode{options.he_profiling_mode}, _is_linear_exec{options.executor == "Linear"},
      _is_parallel_exec{options.executor == "Parallel"}
  {
    for (auto &&entry : backends)
    {
      if (entry->config()->id() == backend::builtin::Config::ID)
        continue;
      _all_backends.push_back(entry);
    }
    _backend_resolver = std::make_unique<compiler::BackendResolver>();
    _exec_time = std::make_unique<exec::ExecTime>(_all_backends);
 
    // Find cpu backend
    auto cpu_backend_it =
      std::find_if(_all_backends.begin(), _all_backends.end(), [](const backend::Backend *backend) {
        return backend->config()->id() == "cpu";
      });
    if (cpu_backend_it == _all_backends.end())
      throw std::runtime_error("HEScheduler could be used only if 'cpu' backend is available");
    _cpu_backend = *cpu_backend_it;
  }

References entry(), and onert::backend::builtin::Config::ID.

Member Function Documentation

getIndexedRanks()

std::shared_ptr< ir::OperationIndexMap< int64_t > > onert::compiler::HEScheduler::getIndexedRanks ( )

inline

Definition at line 88 of file HEScheduler.h.

{ return _op_to_rank; }

schedule()

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

finalvirtual

Task scheduling.

Note

The main idea is taken from HSIP algo: https://www.hindawi.com/journals/sp/2016/3676149/

Implements onert::compiler::IScheduler.

Definition at line 183 of file HEScheduler.cc.

{
  _graph = &graph;
  VERBOSE(HEScheduler::schedule) << "task scheduling started" << std::endl;
  // Make ranks and save in descending order
  makeRank();
 
  for (const auto *backend : _all_backends)
  {
    _backends_avail_time.emplace(backend, std::map<int64_t, int64_t>{{0, 0}});
  }
 
  if (_is_profiling_mode)
  {
    // Check if profiling info about all backend/node pairs already exists
    bool all_nodes_are_profiled = true;
    _graph->operations().iterate([&](const ir::OperationIndex &, const ir::IOperation &op) {
      if (all_nodes_are_profiled)
        all_nodes_are_profiled = isNodeProfiled(op);
    });
 
    // If all nodes are already profiled - schedule backends in such order, so more profiling
    // information about between-backends data transfer could be collected
    if (all_nodes_are_profiled)
    {
      scheduleShufflingBackends();
      VERBOSE(HEScheduler::schedule) << "task scheduling finished" << std::endl;
      return std::move(_backend_resolver);
    }
  }
 
  ir::OperationIndexMap<bool> visited;
  graph.operations().iterate(
    [&](const ir::OperationIndex &index, const ir::IOperation &) { visited[index] = false; });
  // for each task select the backend with the smallest earliest finishing time(eft)
  for (const auto &rank : _rank_to_op)
  {
    scheduleBranch(rank.second, visited);
  }
  VERBOSE(HEScheduler::schedule) << "task scheduling finished" << std::endl;
  return std::move(_backend_resolver);
}

References onert::util::ObjectManager< Index, Object >::iterate(), onert::ir::Graph::operations(), schedule(), and VERBOSE.

Referenced by schedule().

---

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

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