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"
#include "node/device_manager.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;       
  int cpuAffinity = -1;         
  bool cpuPinned = false;       
  uint64_t timestampUs = 0;     
};
 
void to_json(nlohmann::json& j, const GameLoopHealth& h);
 
class GameLoop {
 public:
  GameLoop(mm::node::DeviceManager& deviceManager, std::chrono::microseconds period,
           int cpuAffinity = -1);
 
  ~GameLoop() = default;
 
  GameLoop(const GameLoop&) = delete;
  GameLoop& operator=(const GameLoop&) = delete;
 
  void addTask(mm::core::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::atomic<bool> cpuPinned_{false};    // affinity applied in run()
  const int cpuAffinity_;                 // core to pin to; < 0 = leave unpinned
  // The cycle the loop enters before calling any task. Held for the whole task list, so a task's
  // device and parameter lookups stay valid without the task naming the guard at all.
  mm::node::DeviceManager& deviceManager_;
  std::vector<mm::core::CyclicTask*> tasks_;
};