waiter.h

Go to the documentation of this file.

#ifndef ZTH_WAITER_H
#define ZTH_WAITER_H
/*
 * SPDX-FileCopyrightText: 2019-2026 Jochem Rutgers
 *
 * SPDX-License-Identifier: MPL-2.0
 */
 
#include <libzth/macros.h>
 
#ifdef __cplusplus
 
#  include <libzth/allocator.h>
#  include <libzth/fiber.h>
#  include <libzth/list.h>
#  include <libzth/time.h>
#  include <libzth/util.h>
 
#  if __cplusplus >= 201103L
#    include <type_traits>
#  endif
 
namespace zth {
class Worker;
 
class Waitable {
        ZTH_CLASS_NEW_DELETE(Waitable)
public:
        Waitable() noexcept
                : m_fiber()
        {}
 
        virtual ~Waitable() noexcept is_default
 
        Fiber& fiber() const noexcept
        {
                zth_assert(hasFiber());
                return *m_fiber;
        }
 
        virtual bool poll(Timestamp const& now = Timestamp::now()) noexcept = 0;
 
        virtual string str() const
        {
                return format("Waitable for %s", fiber().str().c_str());
        }
 
        void setFiber(Fiber& fiber) noexcept
        {
                m_fiber = &fiber;
        }
 
        void resetFiber() noexcept
        {
                m_fiber = nullptr;
        }
 
        bool hasFiber() const noexcept
        {
                return m_fiber;
        }
 
private:
        Fiber* m_fiber;
};
 
class TimedWaitable : public Waitable, public Listable {
        ZTH_CLASS_NEW_DELETE(TimedWaitable)
public:
        explicit TimedWaitable(Timestamp const& timeout = Timestamp()) noexcept
                : m_timeout(timeout)
        {}
 
        virtual ~TimedWaitable() noexcept override is_default
 
        Timestamp const& timeout() const noexcept
        {
                return m_timeout;
        }
 
        virtual bool poll(Timestamp const& now = Timestamp::now()) noexcept override
        {
                return timeout() <= now;
        }
 
        bool operator<(TimedWaitable const& rhs) const noexcept
        {
                return timeout() < rhs.timeout();
        }
 
        virtual string str() const override
        {
                if(hasFiber())
                        return format(
                                "Waitable with %s timeout for %s",
                                (timeout() - Timestamp::now()).str().c_str(),
                                fiber().str().c_str());
                else
                        return format(
                                "Waitable with %s timeout",
                                (timeout() - Timestamp::now()).str().c_str());
        }
 
protected:
        void setTimeout(Timestamp const& t) noexcept
        {
                m_timeout = t;
        }
 
private:
        Timestamp m_timeout;
};
 
template <typename F>
class PolledWaiting : public TimedWaitable {
        ZTH_CLASS_NEW_DELETE(PolledWaiting)
public:
        explicit PolledWaiting(F const& f, TimeInterval const& interval = TimeInterval())
                : TimedWaitable(Timestamp())
                , m_f(f)
        {
                setInterval(interval);
        }
 
        virtual ~PolledWaiting() noexcept override is_default
 
        virtual bool poll(Timestamp const& now = Timestamp::now()) noexcept override
        {
                if(m_f())
                        return true;
 
                Timestamp next_poll = timeout() + interval();
                if(unlikely(next_poll < now))
                        next_poll = now + interval();
 
                setTimeout(next_poll);
                return false;
        }
 
        TimeInterval const& interval() const noexcept
        {
                return m_interval;
        }
 
        void
        setInterval(TimeInterval const& interval, Timestamp const& now = Timestamp::now()) noexcept
        {
                m_interval = interval;
                setTimeout(now + interval);
        }
 
private:
        F m_f;
        TimeInterval m_interval;
};
 
template <typename C>
struct PolledMemberWaitingHelper {
        constexpr PolledMemberWaitingHelper(C& that_, bool (C::*f_)()) noexcept
                : that(that_)
                , f(f_)
        {}
 
        bool operator()() const
        {
                zth_assert(f != nullptr);
                // cppcheck-suppress nullPointerRedundantCheck
                return (that.*f)();
        }
 
        C& that;
        bool (C::*f)();
};
 
template <typename C>
class PolledMemberWaiting : public PolledWaiting<PolledMemberWaitingHelper<C> > {
        ZTH_CLASS_NEW_DELETE(PolledMemberWaiting)
public:
        typedef PolledWaiting<PolledMemberWaitingHelper<C> > base;
 
        constexpr PolledMemberWaiting(
                C& that, bool (C::*f)(), TimeInterval const& interval = TimeInterval()) noexcept
                : base(PolledMemberWaitingHelper<C>(that, f), interval)
        {}
 
        virtual ~PolledMemberWaiting() noexcept override is_default
};
 
class PollerServerBase;
 
class Waiter : public Runnable {
        ZTH_CLASS_NEW_DELETE(Waiter)
public:
        explicit Waiter(Worker& worker);
        virtual ~Waiter() noexcept override;
 
        void wait(TimedWaitable& w);
        void scheduleTask(TimedWaitable& w);
        void unscheduleTask(TimedWaitable& w);
        void wakeup(TimedWaitable& w);
 
        PollerServerBase& poller();
        void setPoller(PollerServerBase* p = nullptr);
        void wakeup();
 
protected:
        bool polling() const;
 
        virtual int fiberHook(Fiber& f) override
        {
                f.setName("zth::Waiter");
                f.suspend();
                return Runnable::fiberHook(f);
        }
 
        virtual void entry() override;
 
private:
        Worker& m_worker;
        SortedList<TimedWaitable> m_waiting;
        PollerServerBase* m_poller;
        PollerServerBase* m_defaultPoller;
};
 
ZTH_EXPORT void waitUntil(TimedWaitable& w);
 
#  if __cplusplus >= 201103L
template <
        typename F,
        typename std::enable_if<!std::is_base_of<TimedWaitable, F>::value, int>::type = 0>
void waitUntil(F f, TimeInterval const& pollInterval = TimeInterval())
{
        PolledWaiting<F> w(f, pollInterval);
        waitUntil(w);
}
#  else
ZTH_EXPORT inline void waitUntil(bool (*f)(), TimeInterval const& pollInterval = TimeInterval())
{
        PolledWaiting<bool (*)()> w(f, pollInterval);
        waitUntil(w);
}
#  endif
 
template <typename C>
void waitUntil(C& that, bool (C::*f)(), TimeInterval const& pollInterval = TimeInterval())
{
        PolledMemberWaiting<C> w(that, f, pollInterval);
        waitUntil(w);
}
 
void scheduleTask(TimedWaitable& w);
void unscheduleTask(TimedWaitable& w);
void wakeup(TimedWaitable& w);
 
ZTH_EXPORT inline void nap(Timestamp const& sleepUntil)
{
        TimedWaitable w(sleepUntil);
        waitUntil(w);
}
 
ZTH_EXPORT inline void nap(TimeInterval const& sleepFor)
{
        if(!sleepFor.hasPassed())
                nap(Timestamp::now() + sleepFor);
}
 
ZTH_EXPORT inline void mnap(long sleepFor_ms)
{
        nap(TimeInterval((time_t)(sleepFor_ms / 1000L), sleepFor_ms % 1000L * 1000000L));
}
 
ZTH_EXPORT inline void unap(long sleepFor_us)
{
        nap(TimeInterval((time_t)(sleepFor_us / 1000000L), sleepFor_us % 1000000L * 1000L));
}
 
class PeriodicWakeUp {
        ZTH_CLASS_NEW_DELETE(PeriodicWakeUp)
public:
        explicit PeriodicWakeUp(TimeInterval const& interval)
                : m_interval(interval)
                , m_t(Timestamp::now())
        {}
 
        Timestamp const& t() const noexcept
        {
                return m_t;
        }
 
        TimeInterval const& interval() const noexcept
        {
                return m_interval;
        }
 
        void setInterval(TimeInterval const& interval) noexcept
        {
                m_interval = interval;
        }
 
        PeriodicWakeUp& operator=(TimeInterval const& interval) noexcept
        {
                setInterval(interval);
                return *this;
        }
 
        bool nap()
        {
                return nap(t());
        }
 
        bool nap(Timestamp const& reference, Timestamp const& now = Timestamp::now());
 
        void operator()()
        {
                nap();
        }
 
private:
        TimeInterval m_interval;
        Timestamp m_t;
};
 
} // namespace zth
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_nap(struct timespec const* ts)
{
        if(likely(ts))
                zth::nap(zth::TimeInterval(*ts));
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_mnap(long sleepFor_ms)
{
        zth::mnap(sleepFor_ms);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_unap(long sleepFor_us)
{
        zth::unap(sleepFor_us);
}
 
#else // !__cplusplus
 
#  include <time.h>
 
ZTH_EXPORT void zth_nap(struct timespec const* ts);
ZTH_EXPORT void zth_mnap(long sleepFor_ms);
ZTH_EXPORT void zth_unap(long sleepFor_us);
 
#endif // __cplusplus
#endif // ZTH_WAITER_H