Timer.hxx

Go to the documentation of this file.

 
#ifndef _EXECUTOR_TIMER_HXX_
#define _EXECUTOR_TIMER_HXX_
 
#include "executor/Notifiable.hxx"
#include "utils/Buffer.hxx"
#include "utils/QMember.hxx"
#include "os/OS.hxx"
 
class Timer;
class ExecutorBase;
 
class ActiveTimers : public Executable
{
public:
    ActiveTimers(ExecutorBase *executor)
        : executor_(executor)
        , isPending_(0)
    {
    }
 
    ~ActiveTimers();
 
    long long get_next_timeout();
 
    bool empty();
    
    void schedule_timer(::Timer *timer);
 
    void update_timer(::Timer *timer);
 
    void remove_timer(::Timer *timer);
 
    ExecutorBase *executor()
    {
        return executor_;
    }
 
    void notify() override;
 
    void run() override;
 
private:
    void remove_locked(::Timer *timer);
 
    void insert_locked(::Timer *timer);
 
    ExecutorBase *executor_;
    OSMutex lock_;
    QMember activeTimers_;
    std::atomic_uint_least8_t isPending_;
 
    friend class TimerTest;
 
    DISALLOW_COPY_AND_ASSIGN(ActiveTimers);
};
 
class Timer : public Executable
{
public:
    Timer(ActiveTimers *timers)
        : activeTimers_(timers)
        , priority_(UINT_MAX)
        , when_(0)
        , period_(0)
        , isActive_(0)
        , isExpired_(0)
        , isCancelled_(0)
        , tcRequestStop_(0)
    {
    }
 
    ~Timer();
 
    void run() override;
 
    enum
    {
        NONE = 0,    
        RESTART = 1, 
        DELETE = -1, 
    };
 
    virtual long long timeout() = 0;
 
    long long schedule_time()
    {
        return when_;
    }
 
    void start(long long period = -1)
    {
        HASSERT(!isActive_);
        HASSERT(!isExpired_);
        isActive_ = 1;
        isCancelled_ = 0;
        when_ = OSTime::get_monotonic() + period;
        period_ = period;
        activeTimers_->schedule_timer(this);
    }
 
    void start_absolute(long long expiry_time_nsec)
    {
        HASSERT(!isActive_);
        HASSERT(!isExpired_);
        isActive_ = 1;
        isCancelled_ = 0;
        when_ = expiry_time_nsec;
        period_ = when_ - OSTime::get_monotonic();
        activeTimers_->schedule_timer(this);
    }
 
    void restart()
    {
        if (isExpired_)
            return;
        when_ = OSTime::get_monotonic() + period_;
        isCancelled_ = 0;
        if (isActive_)
        {
            activeTimers_->update_timer(this);
        }
        else
        {
            isActive_ = 1;
            activeTimers_->schedule_timer(this);
        }
    }
 
    void trigger()
    {
        if (isExpired_)
            return;
        HASSERT(isActive_);
        isCancelled_ = 1;
        when_ = 2; // in the past
        activeTimers_->update_timer(this);
    }
 
    void ensure_triggered()
    {
        if (isActive_) trigger();
    }
 
    void cancel()
    {
        when_ = INT64_MAX;  // This will ensure the we don't get from active to
                            // expired from now on.
        HASSERT(!isExpired_);
        isCancelled_ = 1;
        if (isActive_) {
            activeTimers_->remove_timer(this);
        }
    }
 
    bool is_triggered()
    {
        return isCancelled_;
    }
 
    void set_triggered()
    {
        isCancelled_ = 1;
    }
 
protected:
    void update_period(long long period)
    {
        period_ = period;
    }
 
private:
    friend class ActiveTimers;  // for scheduling an expiring timers
    friend class CountingTimer; // for testing
 
    ActiveTimers *activeTimers_;
    unsigned priority_;
    long long when_;
    long long period_;
    unsigned isActive_ : 1;
    unsigned isExpired_ : 1;
    unsigned isCancelled_ : 1;
    unsigned tcRequestStop_ : 1;
 
    DISALLOW_COPY_AND_ASSIGN(Timer);
};
 
class SyncTimeout : public ::Timer {
public:
    SyncTimeout(ActiveTimers *timers) : Timer(timers)
    {
    }
 
    void wait_for_notification() {
        n_.wait_for_notification();
    }
 
private:
    long long timeout() OVERRIDE {
        n_.notify();
        return NONE;
    }
 
    SyncNotifiable n_;
};
 
#endif // _EXECUTOR_TIMER_HXX_