helios::app::details::ScheduleExecutor Class Reference

Manages system scheduling and execution for a single schedule. More...

#include <scheduler.hpp>

Public Member Functions
	ScheduleExecutor ()=default
	ScheduleExecutor (ScheduleId schedule_id)
	ScheduleExecutor (const ScheduleExecutor &)=delete
	ScheduleExecutor (ScheduleExecutor &&) noexcept=default
	~ScheduleExecutor ()=default
ScheduleExecutor &	operator= (const ScheduleExecutor &)=delete
ScheduleExecutor &	operator= (ScheduleExecutor &&) noexcept=default
void	Clear ()
	Clears all systems and resets the schedule.
void	AddSystem (size_t system_storage_index)
	Adds a system to this schedule.
void	RegisterOrdering (ecs::SystemTypeId system_id, SystemOrdering ordering)
	Registers ordering constraints for a system.
void	BuildExecutionGraph (ecs::World &world, std::span< SystemStorage > system_storage, const std::unordered_map< SystemSetId, SystemSetInfo > &system_sets)
	Builds the execution graph based on system access policies.
void	Execute (ecs::World &world, async::Executor &executor, std::span< SystemStorage > system_storage)
	Executes all systems in this schedule.
auto	FindSystemIndexByType (ecs::SystemTypeId system_id, std::span< const SystemStorage > system_storage) const noexcept -> std::optional< size_t >
	Finds the storage index of a system by type ID within this schedule.
bool	IsMainStage () const noexcept
	Checks if this schedule is the Main stage.
bool	Contains (size_t system_storage_index) const noexcept
	Checks if a system is in this schedule by storage index.
bool	ContainsSystemOfType (ecs::SystemTypeId system_id, std::span< const SystemStorage > system_storage) const noexcept
	Checks if a system of given type is in this schedule.
bool	Empty () const noexcept
	Checks if this schedule has any systems.
ScheduleId	GetScheduleId () const noexcept
	Gets the schedule ID.
size_t	SystemCount () const noexcept
	Gets the number of systems in this schedule.
const std::vector< size_t > &	SystemIndices () const noexcept
	Gets const reference to system indices in this schedule.

Detailed Description

Manages system scheduling and execution for a single schedule.

Builds a dependency graph based on AccessPolicy conflicts and executes systems concurrently when possible using TaskGraph.

Note

Not thread-safe.

Definition at line 71 of file scheduler.hpp.

Constructor & Destructor Documentation

ScheduleExecutor() [1/4]

helios::app::details::ScheduleExecutor::ScheduleExecutor ( )

default

ScheduleExecutor() [2/4]

helios::app::details::ScheduleExecutor::ScheduleExecutor ( ScheduleId  schedule_id )

inlineexplicit

Definition at line 74 of file scheduler.hpp.

: schedule_id_(schedule_id) {}

ScheduleExecutor() [3/4]

helios::app::details::ScheduleExecutor::ScheduleExecutor ( const ScheduleExecutor &  )

delete

ScheduleExecutor() [4/4]

helios::app::details::ScheduleExecutor::ScheduleExecutor ( ScheduleExecutor &&  )

defaultnoexcept

~ScheduleExecutor()

helios::app::details::ScheduleExecutor::~ScheduleExecutor ( )

default

Member Function Documentation

AddSystem()

void helios::app::details::ScheduleExecutor::AddSystem ( size_t  system_storage_index )

inline

Adds a system to this schedule.

Parameters

system_storage_index

Index in the global system storage

Definition at line 234 of file scheduler.hpp.

                                                                   {
  system_indices_.push_back(system_storage_index);
  graph_built_ = false;
}

BuildExecutionGraph()

void helios::app::details::ScheduleExecutor::BuildExecutionGraph	(	ecs::World &	world,
		std::span< SystemStorage >	system_storage,
		const std::unordered_map< SystemSetId, SystemSetInfo > &	system_sets
	)

Builds the execution graph based on system access policies.

Analyzes conflicts and creates dependency chains.

Parameters

world	World to execute systems on
system_storage	Reference to global system storage

Definition at line 162 of file scheduler.cpp.

                                                                                                            {
  if (system_indices_.empty()) {
    graph_built_ = true;
    return;
  }
 
  execution_graph_.Clear();
 
  auto [tasks, system_id_to_task_index] = CreateSystemTasks(system_storage, world);
  ApplyExplicitOrdering(tasks, system_id_to_task_index, system_storage);
  ApplySetOrdering(tasks, system_id_to_task_index, system_sets);
  ApplyAccessPolicyOrdering(tasks, system_storage);
 
  graph_built_ = true;
}

Clear()

void helios::app::details::ScheduleExecutor::Clear ( )

inline

Clears all systems and resets the schedule.

Definition at line 227 of file scheduler.hpp.

                                    {
  system_indices_.clear();
  system_orderings_.clear();
  execution_graph_.Clear();
  graph_built_ = false;
}

Contains()

bool helios::app::details::ScheduleExecutor::Contains ( size_t  system_storage_index ) const

inlinenoexcept

Checks if a system is in this schedule by storage index.

Parameters

system_storage_index

Index in the global system storage

Returns

True if system is present, false otherwise

Definition at line 141 of file scheduler.hpp.

                                                                          {
    return std::ranges::find(system_indices_, system_storage_index) != system_indices_.end();
  }

ContainsSystemOfType()

bool helios::app::details::ScheduleExecutor::ContainsSystemOfType ( ecs::SystemTypeId  system_id, std::span< const SystemStorage >  system_storage  ) const

inlinenoexcept

Checks if a system of given type is in this schedule.

Parameters

system_id	System type ID to check
system_storage	Reference to global system storage

Returns

True if system of this type is present, false otherwise

Definition at line 151 of file scheduler.hpp.

                                                                                                      {
    return std::ranges::any_of(system_indices_, [system_storage, system_id](size_t index) {
      return index < system_storage.size() && system_storage[index].info.type_id == system_id;
    });
  }

Empty()

bool helios::app::details::ScheduleExecutor::Empty ( ) const

inlinenoexcept

Checks if this schedule has any systems.

Returns

True if empty, false otherwise

Definition at line 162 of file scheduler.hpp.

{ return system_indices_.empty(); }

Execute()

void helios::app::details::ScheduleExecutor::Execute	(	ecs::World &	world,
		async::Executor &	executor,
		std::span< SystemStorage >	system_storage
	)

Executes all systems in this schedule.

Warning

Triggers assertion if execution graph has not been built.

Parameters

world	World to execute systems on
executor	Async executor for parallel execution (ignored if use_async_ is false)
system_storage	Reference to global system storage

Definition at line 27 of file scheduler.cpp.

                                                                                                              {
  HELIOS_ASSERT(graph_built_, "Failed to execute: Execution graph must be built before executing schedule!");
 
  if (IsMainStage()) {
    // Main stage: Execute systems sequentially on the main thread
    // Systems run in dependency order for immediate visibility
    for (const size_t index : system_indices_) {
      auto& storage = system_storage[index];
      app::SystemContext ctx(world, storage.info, executor, storage.local_storage);
      storage.system->Update(ctx);
      ++storage.info.execution_count;
 
      // Merge events after each system in main schedule for immediate visibility
      if (!storage.local_storage.GetEventQueue().Empty()) {
        world.MergeEventQueue(storage.local_storage.GetEventQueue());
        storage.local_storage.GetEventQueue().Clear();
      }
    }
  } else {
    // All other stages: Execute the graph asynchronously via executor
    executor.Run(execution_graph_).Wait();
 
    // After async execution, merge all local event queues into world's main queue
    for (const size_t index : system_indices_) {
      auto& storage = system_storage[index];
      if (!storage.local_storage.GetEventQueue().Empty()) {
        world.MergeEventQueue(storage.local_storage.GetEventQueue());
        storage.local_storage.GetEventQueue().Clear();
      }
    }
  }
}

FindSystemIndexByType()

auto helios::app::details::ScheduleExecutor::FindSystemIndexByType ( ecs::SystemTypeId  system_id, std::span< const SystemStorage >  system_storage  ) const -> std::optional<size_t>

inlinenoexcept

Finds the storage index of a system by type ID within this schedule.

Parameters

system_id	System type ID to find
system_storage	Reference to global system storage

Returns

Index in system storage if found, std::nullopt otherwise

Definition at line 244 of file scheduler.hpp.

                           {
  std::optional<size_t> result;
  const auto it = std::ranges::find_if(system_indices_, [system_storage, system_id](size_t index) {
    return index < system_storage.size() && system_storage[index].info.type_id == system_id;
  });
 
  if (it != system_indices_.end()) {
    result = *it;
  }
  return result;
}

GetScheduleId()

ScheduleId helios::app::details::ScheduleExecutor::GetScheduleId ( ) const

inlinenoexcept

Gets the schedule ID.

Returns

Schedule ID

Definition at line 168 of file scheduler.hpp.

{ return schedule_id_; }

IsMainStage()

bool helios::app::details::ScheduleExecutor::IsMainStage ( ) const

inlinenoexcept

Checks if this schedule is the Main stage.

Main stage executes synchronously on the main thread. All other stages execute asynchronously via the executor.

Returns

True if this is the Main stage, false otherwise

Definition at line 134 of file scheduler.hpp.

{ return schedule_id_ == ScheduleIdOf<Main>(); }

operator=() [1/2]

ScheduleExecutor & helios::app::details::ScheduleExecutor::operator= ( const ScheduleExecutor &  )

delete

operator=() [2/2]

ScheduleExecutor & helios::app::details::ScheduleExecutor::operator= ( ScheduleExecutor &&  )

defaultnoexcept

RegisterOrdering()

void helios::app::details::ScheduleExecutor::RegisterOrdering ( ecs::SystemTypeId  system_id, SystemOrdering  ordering  )

inline

Registers ordering constraints for a system.

Parameters

system_id	System type ID
ordering	Ordering constraints (before/after)

Definition at line 239 of file scheduler.hpp.

                                                                                                 {
  system_orderings_[system_id] = std::move(ordering);
  graph_built_ = false;
}

SystemCount()

size_t helios::app::details::ScheduleExecutor::SystemCount ( ) const

inlinenoexcept

Gets the number of systems in this schedule.

Returns

Number of systems

Definition at line 174 of file scheduler.hpp.

{ return system_indices_.size(); }

SystemIndices()

const std::vector< size_t > & helios::app::details::ScheduleExecutor::SystemIndices ( ) const

inlinenoexcept

Gets const reference to system indices in this schedule.

Returns

Const reference to vector of system storage indices

Definition at line 180 of file scheduler.hpp.

{ return system_indices_; }