RefreshLoop.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_REFRESHLOOP_HXX_
#define _OPENLCB_REFRESHLOOP_HXX_
 
#include <vector>
 
#include "executor/StateFlow.hxx"
#include "executor/Timer.hxx"
#include "openlcb/WriteHelper.hxx"
 
namespace openlcb
{
 
class Polling
{
public:
    virtual void poll_33hz(WriteHelper *helper, Notifiable *done) = 0;
};
 
class RefreshLoop : public StateFlowBase, private Atomic
{
public:
    template <class Container = std::initializer_list<Polling*> >
    RefreshLoop(Node *node, const Container &members)
        : StateFlowBase(node->iface())
        , timer_(this)
        , lastTimeout_(os_get_time_monotonic())
        , members_(members.begin(), members.end())
    {
        start_flow(STATE(wait_for_tick));
    }
 
    void stop()
    {
        set_terminated();
        timer_.ensure_triggered();
    }
 
    void add_member(Polling *new_member)
    {
        AtomicHolder h(this);
        members_.push_back(new_member);
    }
 
    Action wait_for_tick()
    {
        lastTimeout_ += MSEC_TO_NSEC(30);
        nextMember_ = 0;
        // If we have overflowed our timer, this call will happen immediately.
        return sleep_and_call(&timer_, lastTimeout_ - os_get_time_monotonic(),
                              STATE(call_members));
    }
 
    Action call_members()
    {
        while (true)
        {
            Polling* member = nullptr;
            {
                AtomicHolder h(this);
                if (nextMember_ >= members_.size())
                {
                    return call_immediately(STATE(wait_for_tick));
                }
                member = members_[nextMember_];
                ++nextMember_;
            }
            bn_.reset(this);
            member->poll_33hz(&helper_, bn_.new_child());
            if (bn_.abort_if_almost_done())
            {
                // The polling member called done notifiable inline. Short
                // circuits the yield to the executor.
                continue;
            }
            bn_.maybe_done();
            return wait();
        }
    }
 
private:
    WriteHelper helper_;
    StateFlowTimer timer_;
    long long lastTimeout_;
    BarrierNotifiable bn_;
    typedef vector<Polling*> members_type;
    members_type members_;
    unsigned nextMember_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_REFRESHLOOP_HXX_