Scheduler.hh

Go to the documentation of this file.

#ifndef SCHEDULER_HH
#define SCHEDULER_HH
 
#include "EmuTime.hh"
#include "SchedulerQueue.hh"
#include <vector>
 
namespace openmsx {
 
class Schedulable;
class MSXCPU;
 
class SynchronizationPoint
{
public:
        SynchronizationPoint() = default;
        SynchronizationPoint(EmuTime::param time, Schedulable* dev)
                : timeStamp(time), device(dev) {}
        [[nodiscard]] EmuTime::param getTime() const { return timeStamp; }
        void setTime(EmuTime::param time) { timeStamp = time; }
        [[nodiscard]] Schedulable* getDevice() const { return device; }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        EmuTime timeStamp = EmuTime::zero();
        Schedulable* device = nullptr;
};
 
 
class Scheduler
{
public:
        using SyncPoints = std::vector<SynchronizationPoint>;
 
        Scheduler() = default;
        ~Scheduler();
 
        void setCPU(MSXCPU* cpu_)
        {
                cpu = cpu_;
        }
 
        [[nodiscard]] EmuTime::param getCurrentTime() const;
 
        [[nodiscard]] inline EmuTime::param getNext() const
        {
                return queue.front().getTime();
        }
 
        inline void schedule(EmuTime::param limit)
        {
                if (EmuTime next = getNext(); limit >= next) [[unlikely]] {
                        scheduleHelper(limit, next); // slow path not inlined
                }
                scheduleTime = limit;
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private: // -> intended for Schedulable
        friend class Schedulable;
 
        void setSyncPoint(EmuTime::param timestamp, Schedulable& device);
 
        [[nodiscard]] SyncPoints getSyncPoints(const Schedulable& device) const;
 
        bool removeSyncPoint(const Schedulable& device);
 
        void removeSyncPoints(const Schedulable& device);
 
        [[nodiscard]] bool pendingSyncPoint(const Schedulable& device, EmuTime& result) const;
 
private:
        void scheduleHelper(EmuTime::param limit, EmuTime next);
 
private:
        SchedulerQueue<SynchronizationPoint> queue;
        EmuTime scheduleTime = EmuTime::zero();
        MSXCPU* cpu = nullptr;
        bool scheduleInProgress = false;
};
 
} // namespace openmsx
 
#endif