Scheduler.hh

Go to the documentation of this file.

#ifndef SCHEDULER_HH
#define SCHEDULER_HH

#include "EmuTime.hh"
#include "SchedulerQueue.hh"
#include "likely.hh"
#include <vector>

namespace openmsx {

class Schedulable;
class MSXCPU;

class SynchronizationPoint
{
public:
        SynchronizationPoint() = default;
        SynchronizationPoint(EmuTime::param time, Schedulable* dev)
                : timeStamp(time), device(dev) {}
        EmuTime::param getTime() const { return timeStamp; }
        void setTime(EmuTime::param time) { timeStamp = time; }
        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_;
        }

        EmuTime::param getCurrentTime() const;

        inline EmuTime::param getNext() const
        {
                return queue.front().getTime();
        }

        inline void schedule(EmuTime::param limit)
        {
                EmuTime next = getNext();
                if (unlikely(limit >= next)) {
                        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);

        SyncPoints getSyncPoints(const Schedulable& device) const;

        bool removeSyncPoint(Schedulable& device);

        void removeSyncPoints(Schedulable& device);

        bool pendingSyncPoint(const Schedulable& device, EmuTime& result) const;

private:
        void scheduleHelper(EmuTime::param limit, EmuTime next);

        SchedulerQueue<SynchronizationPoint> queue;
        EmuTime scheduleTime = EmuTime::zero;
        MSXCPU* cpu = nullptr;
        bool scheduleInProgress = false;
};

} // namespace openmsx

#endif