sim_cycle_timer.h

Go to the documentation of this file.

/*
 * sim_cycle_timer.h
 *
 *  Copyright 2021-2024 Clement Savergne <csavergne@yahoo.com>
 
    This file is part of yasim-avr.
 
    yasim-avr is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    yasim-avr is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with yasim-avr.  If not, see <http://www.gnu.org/licenses/>.
 */
 
//=======================================================================================
 
#ifndef __YASIMAVR_CYCLE_TIMER_H__
#define __YASIMAVR_CYCLE_TIMER_H__
 
#include "sim_types.h"
#include <deque>
 
YASIMAVR_BEGIN_NAMESPACE
 
 
//=======================================================================================
 
class CycleManager;
 
class AVR_CORE_PUBLIC_API CycleTimer {
 
public:
 
    CycleTimer();
    CycleTimer(const CycleTimer& other);
    virtual ~CycleTimer();
 
    inline bool scheduled() const { return !!m_manager; }
 
    bool paused() const;
 
    cycle_count_t remaining_delay() const;
 
    virtual cycle_count_t next(cycle_count_t when) = 0;
 
    CycleTimer& operator=(const CycleTimer& other);
 
private:
 
    friend class CycleManager;
 
    CycleManager* m_manager;
 
};
 
 
template<class C>
class BoundFunctionCycleTimer : public CycleTimer {
 
public:
 
    using bound_full_fct_t = cycle_count_t(C::*)(cycle_count_t);
    using bound_noret_fct_t = void(C::*)(cycle_count_t);
    using bound_noarg_fct_t = void(C::*)(void);
 
    constexpr BoundFunctionCycleTimer(C& _c, bound_full_fct_t _f) : CycleTimer(), c(_c), m(Full), f_full(_f) {}
    constexpr BoundFunctionCycleTimer(C& _c, bound_noret_fct_t _f) : CycleTimer(), c(_c), m(NoRet), f_noret(_f) {}
    constexpr BoundFunctionCycleTimer(C& _c, bound_noarg_fct_t _f) : CycleTimer(), c(_c), m(NoArg), f_noarg(_f) {}
 
    virtual cycle_count_t next(cycle_count_t when) override final
    {
        if (m == Full) {
            return (c.*f_full)(when);
        } else if (m == NoRet) {
            (c.*f_noret)(when);
            return 0;
        } else {
            (c.*f_noarg)();
            return 0;
        }
    }
 
private:
 
    enum Mode { Full, NoRet, NoArg };
 
    C& c;
    const Mode m;
 
    union {
        const bound_full_fct_t f_full;
        const bound_noret_fct_t f_noret;
        const bound_noarg_fct_t f_noarg;
    };
 
};
 
 
//=======================================================================================
class AVR_CORE_PUBLIC_API CycleManager {
 
public:
 
    CycleManager();
    ~CycleManager();
 
    cycle_count_t cycle() const;
    void increment_cycle(cycle_count_t count);
 
    void schedule(CycleTimer& timer, cycle_count_t when);
 
    void delay(CycleTimer& timer, cycle_count_t d);
 
    void cancel(CycleTimer& timer);
 
    void pause(CycleTimer& timer);
 
    void resume(CycleTimer& timer);
 
    void process_timers();
 
    cycle_count_t next_when() const;
 
    CycleManager(const CycleManager&) = delete;
    CycleManager& operator=(const CycleManager&) = delete;
 
private:
 
    friend class CycleTimer;
 
    //Structure holding information on a cycle timer when it's in the cycle queue
    struct TimerSlot;
    std::deque<TimerSlot*> m_timer_slots;
    cycle_count_t m_cycle;
 
    //Utility method to add a timer in the cycle queue, conserving the order or 'when'
    //and paused timers last
    void add_to_queue(TimerSlot* slot);
 
    //Utility to remove a timer from the queue.
    TimerSlot* pop_from_queue(CycleTimer& timer);
 
    void copy_slot(const CycleTimer& src, CycleTimer& dst);
 
    TimerSlot* get_slot(const CycleTimer& timer) const;
 
};
 
inline cycle_count_t CycleManager::cycle() const
{
    return m_cycle;
}
 
 
YASIMAVR_END_NAMESPACE
 
#endif //__YASIMAVR_CYCLE_TIMER_H__