HeartbeatMonitor.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <atomic>
#include <cstddef>
#include <cstdint>
 
namespace corium::safety {
 
template <std::size_t MaxServices = 16>
class HeartbeatMonitor {
public:
    struct alignas(32) ServiceEntry {
        uint32_t serviceId{0};
        uint64_t timeoutNs{0};
        std::atomic<uint64_t> lastHeartbeatNs{0};
        std::atomic<bool> active{false};
    };
 
    HeartbeatMonitor() = default;
 
    bool registerService(uint32_t serviceId, uint64_t timeoutNs, uint64_t initialTimestampNs = 0) noexcept
    {
        for (std::size_t i = 0; i < MaxServices; ++i) {
            bool expected = false;
            if (_services[i].active.compare_exchange_strong(expected, true, std::memory_order_relaxed)) {
                _services[i].serviceId = serviceId;
                _services[i].timeoutNs = timeoutNs;
                _services[i].lastHeartbeatNs.store(initialTimestampNs, std::memory_order_release);
                return true;
            }
            if (_services[i].serviceId == serviceId && expected) {
                // Already registered; update timeout and baseline
                _services[i].timeoutNs = timeoutNs;
                _services[i].lastHeartbeatNs.store(initialTimestampNs, std::memory_order_release);
                return true;
            }
        }
        return false;
    }
 
    void beat(uint32_t serviceId, uint64_t nowNs) noexcept
    {
        for (std::size_t i = 0; i < MaxServices; ++i) {
            if (_services[i].active.load(std::memory_order_relaxed) && _services[i].serviceId == serviceId) {
                _services[i].lastHeartbeatNs.store(nowNs, std::memory_order_release);
                return;
            }
        }
    }
 
    void unregisterService(uint32_t serviceId) noexcept
    {
        for (std::size_t i = 0; i < MaxServices; ++i) {
            if (_services[i].serviceId == serviceId) {
                _services[i].active.store(false, std::memory_order_release);
                return;
            }
        }
    }
 
    [[nodiscard]] bool checkHealth(
        uint64_t nowNs,
        uint32_t& outTimedOutServiceId,
        uint64_t& outLastHeartbeatNs,
        uint64_t& outTimeoutBudgetNs
    ) const noexcept
    {
        for (std::size_t i = 0; i < MaxServices; ++i) {
            if (_services[i].active.load(std::memory_order_acquire)) {
                const uint64_t last = _services[i].lastHeartbeatNs.load(std::memory_order_acquire);
                const uint64_t limit = _services[i].timeoutNs;
                if (nowNs > last && (nowNs - last) > limit) {
                    outTimedOutServiceId = _services[i].serviceId;
                    outLastHeartbeatNs = last;
                    outTimeoutBudgetNs = limit;
                    return false;
                }
            }
        }
        return true;
    }
 
    [[nodiscard]] constexpr std::size_t maxServices() const noexcept
    {
        return MaxServices;
    }
 
private:
    std::array<ServiceEntry, MaxServices> _services{};
};
 
} // namespace corium::safety