game_loop.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <nlohmann/json_fwd.hpp>
#include <vector>
 
#include "core/cyclic_task.h"
 
struct GameLoopHealth {
  uint64_t periodUs = 0;        
  double targetHz = 0.0;        
  double achievedHz = 0.0;      
  uint64_t executedCycles = 0;  
  uint64_t skippedCycles = 0;   
  uint64_t lastExecNs = 0;      
  uint64_t maxExecNs = 0;       
  uint64_t avgExecNs = 0;       
  bool schedFifo = false;       
  bool memLocked = false;       
  uint64_t timestampUs = 0;     
};
 
void to_json(nlohmann::json& j, const GameLoopHealth& h);
 
class GameLoop {
 public:
  explicit GameLoop(std::chrono::microseconds period);
 
  ~GameLoop() = default;
 
  GameLoop(const GameLoop&) = delete;
  GameLoop& operator=(const GameLoop&) = delete;
 
  void addTask(CyclicTask* task);
 
  void run();
 
  void stop();
 
  void setPeriod(std::chrono::microseconds period);
 
  uint64_t executedCycles() const;
 
  uint64_t skippedCycles() const;
 
  GameLoopHealth health() const;
 
 private:
  // Cycle period; read by the RT loop each iteration, written by setPeriod from another thread.
  // std::chrono::microseconds is an 8-byte trivially-copyable type, so this atomic is lock-free.
  std::atomic<std::chrono::microseconds> period_;
  std::atomic<bool> running_{false};
  std::atomic<uint64_t> executedCycles_{0};
  std::atomic<uint64_t> skippedCycles_{0};
  std::atomic<uint64_t> lastExecNs_{0};   // most recent cycle's task-execution time
  std::atomic<uint64_t> maxExecNs_{0};    // worst task-execution time since run()
  std::atomic<uint64_t> sumExecNs_{0};    // running sum → avg = sum / executedCycles
  std::atomic<uint64_t> startMonoNs_{0};  // steady_clock ns at run() start; 0 until then
  std::atomic<bool> schedFifo_{false};    // SCHED_FIFO acquired in run()
  std::atomic<bool> memLocked_{false};    // mlockall succeeded in run()
  std::vector<CyclicTask*> tasks_;
};