Clock.hh

Go to the documentation of this file.

#ifndef CLOCK_HH
#define CLOCK_HH
 
#include "EmuDuration.hh"
#include "EmuTime.hh"
#include "DivModByConst.hh"
#include "serialize.hh"
#include <cassert>
 
namespace openmsx {
 
template<unsigned FREQ_NUM, unsigned FREQ_DENOM = 1>
class Clock
{
private:
        // stuff below calculates:
        //   MASTER_TICKS = MAIN_FREQ / (FREQ_NUM / FREQ_DENOM) + 0.5
        static_assert(MAIN_FREQ < (1ULL << 32), "must fit in 32 bit");
        static constexpr uint64_t P = MAIN_FREQ * FREQ_DENOM + (FREQ_NUM / 2);
        static constexpr uint64_t MASTER_TICKS = P / FREQ_NUM;
        static_assert(MASTER_TICKS < (1ULL << 32), "must fit in 32 bit");
        static constexpr unsigned MASTER_TICKS32 = MASTER_TICKS;
 
public:
        // Note: default copy constructor and assignment operator are ok.
 
        [[nodiscard]] static constexpr EmuDuration duration(unsigned ticks) {
                return EmuDuration(ticks * MASTER_TICKS);
        }
 
        constexpr explicit Clock(EmuTime::param e)
                : lastTick(e) { }
 
        [[nodiscard]] constexpr EmuTime::param getTime() const { return lastTick; }
 
        [[nodiscard]] constexpr bool before(EmuTime::param e) const {
                return lastTick.time < e.time;
        }
 
        [[nodiscard]] constexpr unsigned getTicksTill(EmuTime::param e) const {
                assert(e.time >= lastTick.time);
                uint64_t result = (e.time - lastTick.time) / MASTER_TICKS;
#ifdef DEBUG
                // we don't even want this overhead in devel builds
                assert(result == unsigned(result));
#endif
                return unsigned(result);
        }
        [[nodiscard]] constexpr unsigned getTicksTill_fast(EmuTime::param e) const {
                assert(e.time >= lastTick.time);
                DivModByConst<MASTER_TICKS32> dm;
                return dm.div(e.time - lastTick.time);
        }
        [[nodiscard]] constexpr uint64_t getTicksTillUp(EmuTime::param e) const {
                assert(e.time >= lastTick.time);
                return (e.time - lastTick.time + MASTER_TICKS - 1) / MASTER_TICKS;
        }
 
        [[nodiscard]] constexpr EmuTime operator+(uint64_t n) const {
                return EmuTime(lastTick.time + n * MASTER_TICKS);
        }
 
        [[nodiscard]] constexpr EmuTime getFastAdd(unsigned n) const {
                #ifdef DEBUG
                assert((uint64_t(n) * MASTER_TICKS) < (1ULL << 32));
                #endif
                return EmuTime(lastTick.time + n * MASTER_TICKS);
        }
 
        constexpr void reset(EmuTime::param e) {
                lastTick.time = e.time;
        }
 
        constexpr void advance(EmuTime::param e) {
                assert(lastTick.time <= e.time);
                lastTick.time = e.time - ((e.time - lastTick.time) % MASTER_TICKS);
        }
        constexpr void advance_fast(EmuTime::param e) {
                assert(lastTick.time <= e.time);
                DivModByConst<MASTER_TICKS32> dm;
                lastTick.time = e.time - dm.mod(e.time - lastTick.time);
        }
 
        constexpr void operator+=(unsigned n) {
                lastTick.time += n * MASTER_TICKS;
        }
 
        constexpr void fastAdd(unsigned n) {
                #ifdef DEBUG
                // we don't even want this overhead in development versions
                assert((n * MASTER_TICKS) < (1ULL << 32));
                #endif
                lastTick.time += n * MASTER_TICKS32;
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned /*version*/)
        {
                ar.serialize("lastTick", lastTick);
        }
 
private:
        EmuTime lastTick;
};
 
template<unsigned FREQ_NUM, unsigned FREQ_DENOM>
struct SerializeAsMemcpy<Clock<FREQ_NUM, FREQ_DENOM>> : std::true_type {};
 
} // namespace openmsx
 
#endif