TimerScheduler.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <utility>
 
#include "corium/Events.hpp"
#include "corium/internal/StaticMinHeap.hpp"
#include "corium/policies/QueuePolicies.hpp"
#include "corium/timers/ClockPolicies.hpp"
 
namespace corium {
 
using TimerId = uint32_t;
constexpr TimerId INVALID_TIMER_ID = 0;
 
template <
    typename EventVariant = DefaultEvents,
    size_t MaxTimers = 64,
    typename ClockPolicy = ChronoClockPolicy
>
class TimerScheduler {
public:
    using Clock = ClockPolicy;
    using time_point = typename ClockPolicy::time_point;
    using duration = typename ClockPolicy::duration;
 
    struct TimerEntry {
        TimerId id = INVALID_TIMER_ID;
        EventVariant event{};
        time_point expiryTime{};
        duration interval{};
        EventPriority priority = EventPriority::Normal;
        bool isPeriodic = false;
        bool active = false;
    };
 
    struct TimerComparator {
        bool operator()(const TimerEntry& a, const TimerEntry& b) const noexcept {
            return a.expiryTime > b.expiryTime; // Min-heap: earliest expiry at top
        }
    };
 
    TimerScheduler() = default;
 
    template <typename Rep, typename Period>
    TimerId scheduleDelayed(EventVariant event, const std::chrono::duration<Rep, Period>& delay, EventPriority priority = EventPriority::Normal)
    {
        time_point now = ClockPolicy::now();
        time_point expiry = ClockPolicy::add(now, delay);
        duration zeroInterval{};
        return allocateTimer(std::move(event), expiry, zeroInterval, priority, false);
    }
 
    TimerId scheduleDelayed(EventVariant event, duration delay, EventPriority priority = EventPriority::Normal)
        requires (!std::is_same_v<duration, std::chrono::microseconds> && !std::is_same_v<duration, std::chrono::milliseconds>)
    {
        time_point now = ClockPolicy::now();
        time_point expiry = ClockPolicy::add(now, delay);
        duration zeroInterval{};
        return allocateTimer(std::move(event), expiry, zeroInterval, priority, false);
    }
 
    template <typename Rep, typename Period>
    TimerId schedulePeriodic(EventVariant event, const std::chrono::duration<Rep, Period>& interval, EventPriority priority = EventPriority::Normal)
    {
        time_point now = ClockPolicy::now();
        time_point expiry = ClockPolicy::add(now, interval);
        if constexpr (std::is_same_v<duration, std::chrono::microseconds>) {
            return allocateTimer(std::move(event), expiry, std::chrono::duration_cast<std::chrono::microseconds>(interval), priority, true);
        } else if constexpr (std::is_same_v<duration, std::chrono::milliseconds>) {
            return allocateTimer(std::move(event), expiry, std::chrono::duration_cast<std::chrono::milliseconds>(interval), priority, true);
        } else {
            auto nativeInterval = static_cast<duration>(std::chrono::duration_cast<std::chrono::microseconds>(interval).count());
            return allocateTimer(std::move(event), expiry, nativeInterval, priority, true);
        }
    }
 
    TimerId schedulePeriodic(EventVariant event, duration interval, EventPriority priority = EventPriority::Normal)
        requires (!std::is_same_v<duration, std::chrono::microseconds> && !std::is_same_v<duration, std::chrono::milliseconds>)
    {
        time_point now = ClockPolicy::now();
        time_point expiry = ClockPolicy::add(now, interval);
        return allocateTimer(std::move(event), expiry, interval, priority, true);
    }
 
    bool cancelTimer(TimerId id) noexcept
    {
        if (id == INVALID_TIMER_ID || _activeCount == 0) {
            return false;
        }
 
        auto* data = _heap.data();
        const std::size_t n = _heap.size();
        for (std::size_t i = 0; i < n; ++i) {
            if (data[i].active && data[i].id == id) {
                data[i].active = false;
                data[i].id = INVALID_TIMER_ID;
                if (_activeCount > 0) {
                    _activeCount--;
                }
                return true;
            }
        }
        return false;
    }
 
    template <typename EventSink>
    std::size_t processDueTimers(EventSink& sink, time_point now = ClockPolicy::now())
    {
        if (_activeCount == 0 || _heap.empty()) {
            return 0;
        }
 
        std::size_t posted = 0;
 
        while (!_heap.empty()) {
            auto& top = _heap.top();
 
            // Discard cancelled timers at top of heap
            if (!top.active) {
                _heap.pop();
                continue;
            }
 
            // O(1) early exit: if earliest scheduled timer is not due, nothing else is due
            if (!ClockPolicy::isDue(now, top.expiryTime)) {
                break;
            }
 
            TimerEntry entry = std::move(_heap.top());
            _heap.pop();
 
            sink.post(entry.event, entry.priority);
            posted++;
 
            if (entry.isPeriodic) {
                entry.expiryTime = ClockPolicy::add(entry.expiryTime, entry.interval);
                while (ClockPolicy::isDue(now, entry.expiryTime)) {
                    entry.expiryTime = ClockPolicy::add(entry.expiryTime, entry.interval);
                }
                _heap.push(std::move(entry));
            } else {
                if (_activeCount > 0) {
                    _activeCount--;
                }
            }
        }
 
        return posted;
    }
 
    [[nodiscard]] size_t activeCount() const noexcept
    {
        return _activeCount;
    }
 
    [[nodiscard]] constexpr size_t capacity() const noexcept
    {
        return MaxTimers;
    }
 
private:
    TimerId allocateTimer(EventVariant event, time_point expiryTime, duration interval, EventPriority priority, bool isPeriodic)
    {
        if (_activeCount >= MaxTimers || _heap.full()) {
            return INVALID_TIMER_ID;
        }
 
        TimerId id = _nextId++;
        if (_nextId == INVALID_TIMER_ID) {
            _nextId = 1;
        }
 
        TimerEntry entry{
            .id = id,
            .event = std::move(event),
            .expiryTime = expiryTime,
            .interval = interval,
            .priority = priority,
            .isPeriodic = isPeriodic,
            .active = true
        };
 
        if (_heap.push(std::move(entry))) {
            _activeCount++;
            return id;
        }
 
        return INVALID_TIMER_ID;
    }
 
    internal::StaticMinHeap<TimerEntry, MaxTimers, TimerComparator> _heap{};
    size_t _activeCount = 0;
    TimerId _nextId = 1;
};
 
} // namespace corium