gate.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <promeki/atomic.h>
#include <promeki/namespace.h>
#include <promeki/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class OnceGate {
        public:
                bool fire() noexcept {
                        return !_fired.exchange(true, MemoryOrder::AcqRel);
                }
 
                bool hasFired() const noexcept {
                        return _fired.value();
                }
 
                void reset() noexcept {
                        _fired.setValue(false);
                }
 
        private:
                Atomic<bool> _fired{false};
};
 
class ThrottleGate {
        public:
                bool fire(int64_t intervalMs) noexcept {
                        if (intervalMs <= 0) return true;
                        const int64_t now = TimeStamp::now().milliseconds();
                        int64_t       prev = _lastMs.value();
                        for (;;) {
                                if (now - prev < intervalMs) {
                                        _suppressed.fetchAndAdd(1, MemoryOrder::Relaxed);
                                        return false;
                                }
                                if (_lastMs.compareAndSwap(prev, now)) return true;
                                // prev was updated by compareAndSwap; retry.
                        }
                }
 
                uint64_t suppressedCount() const noexcept {
                        return _suppressed.value();
                }
 
                uint64_t consumeSuppressed() noexcept {
                        return _suppressed.exchange(0, MemoryOrder::AcqRel);
                }
 
                void reset() noexcept {
                        _lastMs.setValue(INT64_MIN / 2);
                        _suppressed.setValue(0);
                }
 
        private:
                Atomic<int64_t>  _lastMs{INT64_MIN / 2};
                Atomic<uint64_t> _suppressed{0};
};
 
PROMEKI_NAMESPACE_END
 
#define PROMEKI_ONCE                                                                                                   \
        for (static ::promeki::OnceGate _promeki_once_gate; _promeki_once_gate.fire();)
 
#define PROMEKI_THROTTLED(intervalMs)                                                                                  \
        for (static ::promeki::ThrottleGate _promeki_throttled_gate;                                                   \
             _promeki_throttled_gate.fire(static_cast<int64_t>(intervalMs));)
 
#endif // PROMEKI_ENABLE_CORE