BroadcastTimeAlarm.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_BROADCASTTIMEALARM_HXX_
#define _OPENLCB_BROADCASTTIMEALARM_HXX_
 
#include "openlcb/BroadcastTime.hxx"
 
namespace openlcb
{
 
class BroadcastTimeAlarm : public StateFlowBase, protected Atomic
{
public:
    BroadcastTimeAlarm(Node *node, BroadcastTime *clock,
        std::function<void(BarrierNotifiable *)> callback)
        : StateFlowBase(node->iface())
        , clock_(clock)
        , wakeup_(this)
        , callback_(callback)
        , timer_(this)
        , bn_()
        , bnPtr_(nullptr)
        , expires_(0)
        , running_(false)
        , set_(false)
#if defined(GTEST)
        , shutdown_(false)
#endif
        , updateSubscribeHandle_(clock->update_subscribe_add(
              std::bind(&BroadcastTimeAlarm::update_notify, this)))
    {
        // By ensuring that the alarm runs in the same thread context as the
        // clock which it uses, we can have much simpler logic for avoiding
        // race conditions in this implementation.
        HASSERT(service()->executor() == clock_->service()->executor());
        start_flow(STATE(entry));
    }
 
    ~BroadcastTimeAlarm()
    {
        clock_->update_subscribe_remove(updateSubscribeHandle_);
    }
 
    void set_period(time_t period)
    {
        set(clock_->time() + period);
    }
 
    void set(time_t time)
    {
        bool need_wakeup = false;
        {
            AtomicHolder h(this);
            expires_ = time;
            running_ = true;
            if (!set_)
            {
                need_wakeup = true;
                set_ = true;
            }
        }
        if (need_wakeup)
        {
            wakeup_.trigger();
        }
    }
 
    void clear()
    {
        {
            AtomicHolder h(this);
            running_ = false;
            set_ = false;
        }
        // rather than waking up the state flow, just let it expire naturally.
    }
 
#if defined(GTEST)
    void shutdown()
    {
        shutdown_ = true;
        wakeup_.trigger();
    }
 
    bool is_shutdown()
    {
        return is_terminated();
    }
#endif
 
protected:
    virtual Action entry()
    {
        return call_immediately(STATE(setup));
    }
 
    virtual void update_notify()
    {
        bool need_wakeup = false;
        {
            AtomicHolder h(this);
            if (running_ && !set_)
            {
                set_ = true;
                need_wakeup = true;
            }
        }
        if (need_wakeup)
        {
            wakeup_.trigger();
        }
    }
 
    BroadcastTime *clock_; 
 
private:
    // Wakeup helper
    class Wakeup : public Executable, protected Atomic
    {
    public:
        Wakeup(BroadcastTimeAlarm *alarm)
            : alarm_(alarm)
            , armed(false)
        {
        }
 
        void trigger()
        {
            bool add = false;
            {
                AtomicHolder h(this);
                if (!armed)
                {
                    armed = true;
                    add = true;
                }
            }
            if (add)
            {
                alarm_->service()->executor()->add(this);
            }
        }
 
    private:
        void run() override
        {
            armed = false;
            alarm_->wakeup();
        }
 
        BroadcastTimeAlarm *alarm_; 
        bool armed;
    };
 
    Action setup()
    {
#if defined(GTEST)
        if (shutdown_)
        {
            return exit();
        }
#endif
 
        AtomicHolder h(this);
        if (set_)
        {
            set_ = false;
            time_t now = clock_->time();
 
            if ((now >= expires_ && clock_->get_rate_quarters() > 0) ||
                (now <= expires_ && clock_->get_rate_quarters() < 0))
            {
                // have already met the alarm conditions,
                // typically won't get here
                return call_immediately(STATE(expired));
            }
            else if (clock_->is_running())
            {
                long long real_expires = 0;
                bool result =
                    clock_->real_nsec_until_fast_time_abs(expires_,
                                                          &real_expires);
                HASSERT(result);
                return sleep_and_call(&timer_, real_expires, STATE(timeout));
            }
        }
 
        bnPtr_ = bn_.reset(this);
        return wait_and_call(STATE(setup));
    }
 
    Action timeout()
    {
        if (timer_.is_triggered())
        {
            // this is a wakeup, not a timeout
            return call_immediately(STATE(setup));
        }
        else
        {
            // timeout
            return call_immediately(STATE(expired));
        }
    }
 
    Action expired()
    {
        bnPtr_ = bn_.reset(this);
        if (running_ && clock_->is_running() && callback_)
        {
            running_ = false;
            callback_(bnPtr_->new_child());
        }
 
        return wait_and_call(STATE(setup));
    }
 
    void wakeup()
    {
        timer_.ensure_triggered();
        if (bnPtr_)
        {
            bnPtr_ = nullptr;
            bn_.notify();
        }
    }
 
    Wakeup wakeup_; 
    std::function<void(BarrierNotifiable *)> callback_;
    StateFlowTimer timer_; 
    BarrierNotifiable bn_; 
    BarrierNotifiable *bnPtr_; 
    time_t expires_; 
    uint8_t running_  : 1; 
    uint8_t set_      : 1; 
#if defined(GTEST)
    uint8_t shutdown_ : 1; 
#endif
    BroadcastTime::UpdateSubscribeHandle updateSubscribeHandle_;
 
    friend class BroadcastTimeAlarm::Wakeup;
 
    DISALLOW_COPY_AND_ASSIGN(BroadcastTimeAlarm);
};
 
class BroadcastTimeAlarmDate : public BroadcastTimeAlarm
{
public:
    BroadcastTimeAlarmDate(Node *node, BroadcastTime *clock,
        std::function<void(BarrierNotifiable *)> callback)
        : BroadcastTimeAlarm(
              node, clock, std::bind(&BroadcastTimeAlarmDate::expired_callback,
                                     this, std::placeholders::_1))
        , callbackUser_(callback)
    {
    }
 
    ~BroadcastTimeAlarmDate()
    {
    }
 
private:
    Action entry() override
    {
        update_notify();
 
        return BroadcastTimeAlarm::entry();
    }
 
    void reset_expired_time()
    {
        const struct tm *tm = clock_->gmtime_recalculate();
        time_t seconds = clock_->time();
 
        if (clock_->get_rate_quarters() > 0)
        {
            set(seconds + (60 - tm->tm_sec) +
                          (60 * (59 - tm->tm_min)) +
                          (60 * 60 * (23 - tm->tm_hour)));
        }
        else if (clock_->get_rate_quarters() < 0)
        {
            set(seconds - ((tm->tm_sec + 1) +
                           (60 * (tm->tm_min)) +
                           (60 * 60 * tm->tm_hour)));
        }
    }
 
    void expired_callback(BarrierNotifiable *done)
    {
        reset_expired_time();
        callbackUser_ ? callbackUser_(done) : done->notify();
    }
 
    void update_notify() override
    {
        reset_expired_time();
        BroadcastTimeAlarm::update_notify();
    }
 
    std::function<void(BarrierNotifiable *)> callbackUser_;
 
    DISALLOW_COPY_AND_ASSIGN(BroadcastTimeAlarmDate);
};
 
class BroadcastTimeAlarmMinute : public BroadcastTimeAlarm
{
public:
    BroadcastTimeAlarmMinute(Node *node, BroadcastTime *clock,
        std::function<void(BarrierNotifiable *)> callback)
        : BroadcastTimeAlarm(
              node, clock,
              std::bind(&BroadcastTimeAlarmMinute::expired_callback, this,
                        std::placeholders::_1))
        , callbackUser_(callback)
    {
    }
 
    ~BroadcastTimeAlarmMinute()
    {
    }
 
private:
    Action entry() override
    {
        update_notify();
 
        return BroadcastTimeAlarm::entry();
    }
 
    void reset_expired_time(bool force_on_match = false)
    {
        const struct tm *tm = clock_->gmtime_recalculate();
        time_t seconds = clock_->time();
 
        if (force_on_match)
        {
            if ((clock_->get_rate_quarters() > 0 && tm->tm_sec == 0) ||
                (clock_->get_rate_quarters() < 0 && tm->tm_sec == 59))
            {
                set(seconds);
                return;
            }
        }
        if (clock_->get_rate_quarters() > 0)
        {
            set(seconds + (60 - tm->tm_sec));
        }
        else if (clock_->get_rate_quarters() < 0)
        {
            set(seconds - (tm->tm_sec + 1));
        }
    }
 
    void expired_callback(BarrierNotifiable *done)
    {
        reset_expired_time();
        callbackUser_ ? callbackUser_(done) : done->notify();
    }
 
    void update_notify() override
    {
        reset_expired_time(true);
        BroadcastTimeAlarm::update_notify();
    }
 
    std::function<void(BarrierNotifiable *)> callbackUser_;
 
    DISALLOW_COPY_AND_ASSIGN(BroadcastTimeAlarmMinute);
};
 
} // namespace openlcb
 
#endif // _OPENLCB_BROADCASTTIMEALARM_HXX_