Timer.cxx

Go to the documentation of this file.

 
#include "executor/Timer.hxx"
#include "executor/Executor.hxx"
#include "os/os.h"
 
Timer::~Timer()
{
    HASSERT(!isActive_);
    HASSERT(!isExpired_);
}
 
void Timer::run()
{
    isExpired_ = 0;
    long long new_period = timeout();
    if (new_period == RESTART)
    {
        when_ += period_;
        isActive_ = 1;
        activeTimers_->schedule_timer(this);
    }
    else if (new_period == DELETE)
    {
        delete this;
    }
    else if (new_period > 0)
    {
        start(new_period);
    }
}
 
ActiveTimers::~ActiveTimers()
{
}
 
void ActiveTimers::notify()
{
    if (isPending_.exchange(1) == 0)
    {
        executor_->add(this);
    }
}
 
void ActiveTimers::run()
{
    isPending_ = 0;
    // Do nothing; the work of scheduling users is done in the get_next_timeout
    // call.
}
 
long long ActiveTimers::get_next_timeout()
{
    OSMutexLock l(&lock_);
 
    QMember **last = &activeTimers_.next;
    Timer *current_timer = static_cast<Timer *>(*last);
    long long now = OSTime::get_monotonic();
    bool found_timer = false;
    while (current_timer && current_timer->when_ <= now)
    {
        // Deques next timer.
        found_timer = true;
        *last = current_timer->next;
        current_timer->next = nullptr;
 
        current_timer->isActive_ = 0;
        current_timer->isExpired_ = 1;
        // Puts it on the executor.
        executor_->add(current_timer, current_timer->priority_);
        // Takes the next timer.
        current_timer = static_cast<Timer *>(*last);
    }
 
    if (found_timer)
    {
        return 0;
    }
    else if (current_timer)
    {
        long long ret = current_timer->when_ - now;
        return ret;
    }
    else
    {
        // Wakes up the timer service every now and then. It won't make any
        // difference.
        return SEC_TO_NSEC(3600);
    }
}
 
bool ActiveTimers::empty() {
    OSMutexLock l(&lock_);
 
    QMember **last = &activeTimers_.next;
    Timer *current_timer = static_cast<Timer *>(*last);
    return (current_timer == nullptr);
}
 
void ActiveTimers::schedule_timer(Timer *timer)
{
    OSMutexLock l(&lock_);
    insert_locked(timer);
}
 
void ActiveTimers::insert_locked(Timer *timer)
{
    HASSERT(timer);
    HASSERT(timer->next == nullptr);
 
    QMember **last = &activeTimers_.next;
    Timer *current_timer = static_cast<Timer *>(*last);
    while (current_timer && current_timer->when_ <= timer->when_)
    {
        last = &current_timer->next;
        current_timer = static_cast<Timer *>(*last);
    }
    // Inserts into the queue.
    timer->next = current_timer;
    *last = timer;
 
    // This will wake up the executor, which will schedule all expired timers
    // and recompute sleep length.
    notify();
}
 
void ActiveTimers::remove_locked(Timer *timer)
{
    HASSERT(timer);
    // Removes the timer from the queue.
    QMember **last = &activeTimers_.next;
    while (*last && *last != timer)
    {
        last = &((*last)->next);
    }
    HASSERT(*last == timer);
    *last = timer->next;
    timer->next = nullptr;
}
 
void ActiveTimers::update_timer(Timer *timer)
{
    HASSERT(timer);
    OSMutexLock l(&lock_);
    remove_locked(timer);
    insert_locked(timer);
}
 
void ActiveTimers::remove_timer(Timer *timer)
{
    HASSERT(timer);
    OSMutexLock l(&lock_);
    remove_locked(timer);
    timer->isActive_ = 0;
}