WatchdogSupervisor.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
#include "corium/safety/HeartbeatMonitor.hpp"
#include "corium/safety/SafetyEvents.hpp"
#include "corium/timers/ClockPolicies.hpp"
 
namespace corium::safety {
 
template <
    std::size_t MaxServices = 16,
    typename ClockPolicy = ChronoClockPolicy
>
class WatchdogSupervisor {
public:
    using KickCallbackFn = void (*)(void* userData);
 
    WatchdogSupervisor() = default;
 
    void setWatchdogKickCallback(KickCallbackFn kickFn, void* userData = nullptr) noexcept
    {
        _kickFn = kickFn;
        _userData = userData;
    }
 
    [[nodiscard]] HeartbeatMonitor<MaxServices>& heartbeatMonitor() noexcept
    {
        return _monitor;
    }
 
    [[nodiscard]] const HeartbeatMonitor<MaxServices>& heartbeatMonitor() const noexcept
    {
        return _monitor;
    }
 
    bool registerService(uint32_t serviceId, uint64_t timeoutNs) noexcept
    {
        const uint64_t now = nowNs();
        return _monitor.registerService(serviceId, timeoutNs, now);
    }
 
    void beat(uint32_t serviceId) noexcept
    {
        _monitor.beat(serviceId, nowNs());
    }
 
    template <typename EventSinkType>
    bool supervise(const EventSinkType& sink) noexcept
    {
        const uint64_t now = nowNs();
        uint32_t timedOutId = 0;
        uint64_t lastBeat = 0;
        uint64_t budget = 0;
 
        if (_monitor.checkHealth(now, timedOutId, lastBeat, budget)) {
            // System is healthy: feed the watchdog
            if (_kickFn) {
                _kickFn(_userData);
            }
            _kicksCount.fetch_add(1, std::memory_order_relaxed);
            _lastHealthyTimeNs.store(now, std::memory_order_release);
            return true;
        }
 
        // Failure detected: suppress watchdog kick and post emergency event
        _suppressionsCount.fetch_add(1, std::memory_order_relaxed);
        sink.postHighPriority(WatchdogTimeoutEvent{.serviceId = timedOutId, .lastHeartbeatNs = lastBeat, .timeoutBudgetNs = budget});
        return false;
    }
 
    [[nodiscard]] uint64_t totalKicks() const noexcept
    {
        return _kicksCount.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] uint64_t totalSuppressions() const noexcept
    {
        return _suppressionsCount.load(std::memory_order_relaxed);
    }
 
private:
    [[nodiscard]] static uint64_t nowNs() noexcept
    {
        if constexpr (std::is_integral_v<typename ClockPolicy::time_point>) {
            return static_cast<uint64_t>(ClockPolicy::now());
        } else {
            return static_cast<uint64_t>(
                std::chrono::duration_cast<std::chrono::nanoseconds>(
                    ClockPolicy::now().time_since_epoch()
                ).count()
            );
        }
    }
 
    HeartbeatMonitor<MaxServices> _monitor{};
    KickCallbackFn _kickFn{nullptr};
    void* _userData{nullptr};
    std::atomic<uint64_t> _kicksCount{0};
    std::atomic<uint64_t> _suppressionsCount{0};
    std::atomic<uint64_t> _lastHealthyTimeNs{0};
};
 
} // namespace corium::safety