FlagsSaver.h

Go to the documentation of this file.

 
#ifndef HF_UTILS_RTOS_WRAP_FLAGSSAVER_H_
#define HF_UTILS_RTOS_WRAP_FLAGSSAVER_H_
 
#include <atomic>
#include <climits>
#include <cstddef>
#include <cstdint>
 
#include "OsAbstraction.h"
#include "OsUtility.h"
 
namespace hf {
 
template <std::size_t kWordCount>
struct FlagsSnapshot {
    uint64_t bits[kWordCount > 0 ? kWordCount : 1]{};
    uint32_t seq{0};
    uint32_t last_change_ms{0};
};
 
template <typename FlagId, std::size_t kCount>
class FlagsReader {
public:
    static constexpr std::size_t kWordCount =
        (kCount + 63U) / 64U > 0U ? (kCount + 63U) / 64U : 1U;
    using Snapshot = FlagsSnapshot<kWordCount>;
 
    virtual ~FlagsReader() noexcept = default;
 
    [[nodiscard]] virtual bool IsSet(FlagId id) const noexcept = 0;
 
    virtual void Snapshot_(Snapshot& out) const noexcept = 0;
 
    [[nodiscard]] virtual uint32_t Seq() const noexcept = 0;
 
    [[nodiscard]] virtual uint32_t LastChangeMs() const noexcept = 0;
 
    virtual bool WaitForChange(uint32_t timeout_ms) noexcept = 0;
 
    virtual bool ClearWaitEvent() noexcept = 0;
};
 
template <typename FlagId, std::size_t kCount>
class FlagsWriter {
public:
    virtual ~FlagsWriter() noexcept = default;
 
    virtual bool Set(FlagId id, uint32_t now_ms = 0) noexcept = 0;
 
    virtual bool Clear(FlagId id, uint32_t now_ms = 0) noexcept = 0;
 
    virtual bool ClearAll(uint32_t now_ms = 0) noexcept = 0;
};
 
template <typename FlagId, std::size_t kCount>
class FlagsSaver final
    : public FlagsReader<FlagId, kCount>
    , public FlagsWriter<FlagId, kCount>
{
public:
    using Base     = FlagsReader<FlagId, kCount>;
    using Snapshot = typename Base::Snapshot;
    static constexpr std::size_t kWordCount = Base::kWordCount;
 
    FlagsSaver() noexcept = default;
 
    ~FlagsSaver() override
    {
        if (event_group_created_) {
            (void)os_event_group_delete(&event_group_);
            event_group_created_ = false;
        }
    }
 
    FlagsSaver(const FlagsSaver&)            = delete;
    FlagsSaver& operator=(const FlagsSaver&) = delete;
 
    /* ── Writer surface ──────────────────────────────────────────── */
 
    bool Set(FlagId id, uint32_t now_ms = 0) noexcept override
    {
        return WriteSlot_(id, true, now_ms);
    }
 
    bool Clear(FlagId id, uint32_t now_ms = 0) noexcept override
    {
        return WriteSlot_(id, false, now_ms);
    }
 
    bool ClearAll(uint32_t now_ms = 0) noexcept override
    {
        bool changed = false;
        for (auto& w : words_) {
            const uint64_t prev = w.exchange(0, std::memory_order_acq_rel);
            if (prev != 0U) changed = true;
        }
        if (!changed) return false;
        if (now_ms != 0U) last_change_ms_.store(now_ms, std::memory_order_release);
        SignalChange_();
        return true;
    }
 
    /* ── Reader surface ──────────────────────────────────────────── */
 
    [[nodiscard]] bool IsSet(FlagId id) const noexcept override
    {
        const std::size_t idx = static_cast<std::size_t>(id);
        if (idx >= kCount) return false;
        const std::size_t word = idx / 64U;
        const std::size_t bit  = idx % 64U;
        return (words_[word].load(std::memory_order_acquire)
                & (uint64_t{1} << bit)) != 0U;
    }
 
    void Snapshot_(Snapshot& out) const noexcept override
    {
        for (std::size_t i = 0; i < kWordCount; ++i) {
            out.bits[i] = words_[i].load(std::memory_order_acquire);
        }
        out.seq            = seq_.load(std::memory_order_acquire);
        out.last_change_ms = last_change_ms_.load(std::memory_order_acquire);
    }
 
    [[nodiscard]] uint32_t Seq() const noexcept override
    {
        return seq_.load(std::memory_order_acquire);
    }
 
    [[nodiscard]] uint32_t LastChangeMs() const noexcept override
    {
        return last_change_ms_.load(std::memory_order_acquire);
    }
 
    bool WaitForChange(uint32_t timeout_ms) noexcept override
    {
        if (!EnsureEventGroup_()) return false;
        OS_Ulong actual = 0;
        const OS_Ulong wait = (timeout_ms == UINT32_MAX)
                                  ? static_cast<OS_Ulong>(OS_WAIT_FOREVER)
                                  : static_cast<OS_Ulong>(os_convert_msec_to_delay_ticks(timeout_ms));
        // Consume the signal: the next WaitForChange() waits for a new change.
        const OS_Uint rc = os_event_group_get(&event_group_, kEventBit_,
                                              static_cast<OS_Uint>(OS_OR) |
                                                  static_cast<OS_Uint>(OS_EVENT_CLEAR),
                                              &actual, wait);
        return (rc == OS_SUCCESS) && ((actual & kEventBit_) != 0U);
    }
 
    bool ClearWaitEvent() noexcept override
    {
        if (!EnsureEventGroup_()) return false;
        return os_event_group_clear(&event_group_, kEventBit_) == OS_SUCCESS;
    }
 
private:
    bool WriteSlot_(FlagId id, bool set, uint32_t now_ms) noexcept
    {
        const std::size_t idx = static_cast<std::size_t>(id);
        if (idx >= kCount) return false;
 
        const std::size_t word = idx / 64U;
        const uint64_t    mask = uint64_t{1} << (idx % 64U);
        auto&             w    = words_[word];
 
        const uint64_t prev = set
            ? w.fetch_or(mask,  std::memory_order_acq_rel)
            : w.fetch_and(~mask, std::memory_order_acq_rel);
 
        const bool was_set = (prev & mask) != 0U;
        if (was_set == set) return false;  // no transition
 
        if (now_ms != 0U) last_change_ms_.store(now_ms, std::memory_order_release);
        SignalChange_();
        return true;
    }
 
    void SignalChange_() noexcept
    {
        seq_.fetch_add(1, std::memory_order_acq_rel);
        if (EnsureEventGroup_()) {
            (void)os_event_group_set(&event_group_, kEventBit_);
        }
    }
 
    bool EnsureEventGroup_() noexcept
    {
        if (event_group_created_) return true;
        if (os_event_group_create(&event_group_, "FlagsSaver") == OS_SUCCESS) {
            event_group_created_ = true;
        }
        return event_group_created_;
    }
 
    static constexpr OS_Ulong kEventBit_ = 0x1U;
 
    std::atomic<uint64_t> words_[kWordCount]{};
    std::atomic<uint32_t> seq_{0};
    std::atomic<uint32_t> last_change_ms_{0};
    OS_EventGroup         event_group_{};
    bool                  event_group_created_{false};
};
 
}  // namespace hf
 
#endif /* HF_UTILS_RTOS_WRAP_FLAGSSAVER_H_ */