tick_scheduler.hpp

Go to the documentation of this file.

 
#pragma once
#include "box.hpp"
#include "node.hpp"
#include "wave_executor.hpp"
 
#include <mutex>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace toast {
 
namespace _detail {
struct NodeCluster {
  explicit NodeCluster(std::vector<Box<Node>>& nodes) : nodes(std::move(nodes)) { }
 
  std::vector<Box<Node>> nodes;
 
  void earlyTick();
  void tick();
  void physicsTick();
  void postPhysics();
  void lateTick();
 
  auto hasEarlyTick() -> bool;
  auto hasTick() -> bool;
  auto hasPhysicsTick() -> bool;
  auto hasPostPhysics() -> bool;
  auto hasLateTick() -> bool;
};
 
struct TickSchedule {
  using Wave = std::vector<std::variant<Box<Node>, NodeCluster>>;
  std::vector<Wave> early_tick;
  std::vector<Wave> tick;
  std::vector<Wave> physics_tick;
  std::vector<Wave> post_physics;
  std::vector<Wave> late_tick;
};

using Interactions = std::unordered_map<Box<Node>, std::vector<Box<Node>>>;

TOAST_API auto planWave(const TickSchedule::Wave& wave, TickFunctionList func, const Interactions* interactions = nullptr)
    -> std::vector<WaveJob>;
}
 
class TickScheduler {
public:
  struct DependencyGraph {
    std::unordered_map<Box<Node>, std::vector<Box<Node>>> connections;            
    std::unordered_map<Box<Node>, std::vector<Box<Node>>> inverse_connections;    
  };
 
  // clang-format off
  auto registerDependency(Node& from, Node& to) -> bool;
  auto unregisterDependency(Node& from, Node& to) -> bool;
  // clang-format on

  auto registerInteraction(Node& first, Node& second) -> bool;

  void compute(const std::vector<Box<Node>>& all_nodes);

  void run() const;

  void runLifecycle(Node& root, TickFunctionList stage) const;

  void runPhaseSerial(const std::vector<_detail::TickSchedule::Wave>& phase, TickFunctionList func, std::string_view name) const;

  void runPhase(const std::vector<_detail::TickSchedule::Wave>& phase, TickFunctionList func, std::string_view name) const;

  mutable std::mutex graph_mutex;
  DependencyGraph graph;
  _detail::TickSchedule schedule;

  _detail::Interactions interactions;
 
private:
  static void tickItem(const _detail::TickSchedule::Wave::value_type& item, TickFunctionList func);

  static void runWave(
      const _detail::TickSchedule::Wave& wave, const std::vector<_detail::WaveJob>& jobs, TickFunctionList func, int number
  );
 
  struct CachedPlan {
    TickFunctionList func = TickFunctionList::none;
    std::vector<_detail::WaveJob> jobs;
  };
 
  auto planFor(const _detail::TickSchedule::Wave& wave, TickFunctionList func) const -> const std::vector<_detail::WaveJob>&;
 
  mutable std::unordered_map<const _detail::TickSchedule::Wave*, CachedPlan> m_plans;

  auto subgraphSeparation(const std::vector<Box<Node>>& all_nodes) -> std::vector<std::vector<Box<Node>>>;

  auto tarjanAlgorithm(const std::vector<std::vector<Box<Node>>>& input_subgraphs) -> std::vector<_detail::TickSchedule::Wave>;

  auto assignWaves(const std::vector<_detail::TickSchedule::Wave>& subgraphs) -> std::vector<_detail::TickSchedule::Wave>;

  auto optimizeWaves(const std::vector<_detail::TickSchedule::Wave>& waves) -> _detail::TickSchedule;
};
 
}