timers.c File Reference

#include <signal.h>
#include "gwlib/gwlib.h"
#include "wap_events.h"
#include "timers.h"

Go to the source code of this file.

Data Structures
struct	TimerHeap
struct	Timerset
struct	Timer

Typedefs
typedef struct TimerHeap	TimerHeap
typedef struct Timerset	Timerset

Functions
static void	abort_elapsed (Timer *timer)
static TimerHeap *	heap_create (void)
static void	heap_destroy (TimerHeap *heap)
static void	heap_delete (TimerHeap *heap, long index)
static int	heap_adjust (TimerHeap *heap, long index)
static void	heap_insert (TimerHeap *heap, Timer *timer)
static void	heap_swap (TimerHeap *heap, long index1, long index2)
static void	lock (Timerset *set)
static void	unlock (Timerset *set)
static void	watch_timers (void *arg)
static void	elapse_timer (Timer *timer)
void	timers_init (void)
void	timers_shutdown (void)
Timer *	gwtimer_create (List *outputlist)
void	gwtimer_destroy (Timer *timer)
void	gwtimer_start (Timer *timer, int interval, WAPEvent *event)
void	gwtimer_stop (Timer *timer)

Variables
static Timerset *	timers
static int	initialized = 0

Typedef Documentation

TimerHeap

typedef struct TimerHeap TimerHeap

Definition at line 88 of file timers.c.

Timerset

typedef struct Timerset Timerset

Definition at line 114 of file timers.c.

Function Documentation

abort_elapsed()

static void abort_elapsed ( Timer *  timer )

static

Definition at line 338 of file timers.c.

References debug(), Timer::elapsed_event, gwlist_delete_equal(), Timer::output, WAPEvent::type, wap_event_destroy(), and wap_event_name().

Referenced by gwtimer_start(), and gwtimer_stop().

{
    long count;

    if (timer->elapsed_event == NULL)
        return;

    count = gwlist_delete_equal(timer->output, timer->elapsed_event);
    if (count > 0) {
        debug("timers", 0, "Aborting %s timer.",
              wap_event_name(timer->elapsed_event->type));
        wap_event_destroy(timer->elapsed_event);
    }
    timer->elapsed_event = NULL;
}

elapse_timer()

static void elapse_timer ( Timer *  timer )

static

Definition at line 514 of file timers.c.

References debug(), Timer::elapsed_event, Timer::elapses, Timer::event, gw_assert(), gwlist_produce(), Timer::output, timers, WAPEvent::type, wap_event_duplicate(), and wap_event_name().

Referenced by watch_timers().

{
    gw_assert(timer != NULL);
    gw_assert(timers != NULL);
    /* This must be true because abort_elapsed is always called
     * before a timer is activated. */
    gw_assert(timer->elapsed_event == NULL);

    debug("timers", 0, "%s elapsed.", wap_event_name(timer->event->type));

    timer->elapsed_event = wap_event_duplicate(timer->event);
    gwlist_produce(timer->output, timer->elapsed_event);
    timer->elapses = -1;
}

gwtimer_create()

Timer* gwtimer_create

(

List *

outputlist

)

Definition at line 224 of file timers.c.

References Timer::elapsed_event, Timer::elapses, Timer::event, gw_assert(), gwlist_add_producer(), Timer::index, initialized, and Timer::output.

{
    Timer *t;

    gw_assert(initialized);

    t = gw_malloc(sizeof(*t));
    t->elapses = -1;
    t->event = NULL;
    t->elapsed_event = NULL;
    t->index = -1;
    t->output = outputlist;
    gwlist_add_producer(outputlist);

    return t;
}

gwtimer_destroy()

void gwtimer_destroy

(

Timer *

timer

)

Definition at line 241 of file timers.c.

References Timer::event, gw_assert(), gwlist_remove_producer(), gwtimer_stop(), initialized, Timer::output, and wap_event_destroy().

{
    gw_assert(initialized);

    if (timer == NULL)
        return;

    gwtimer_stop(timer);
    gwlist_remove_producer(timer->output);
    wap_event_destroy(timer->event);
    gw_free(timer);
}

gwtimer_start()

void gwtimer_start	(	Timer *	timer,
		int	interval,
		WAPEvent *	event
	)

Definition at line 254 of file timers.c.

References abort_elapsed(), Timer::elapses, Timer::event, gw_assert(), gwthread_wakeup(), Timerset::heap, heap_adjust(), heap_insert(), Timer::index, initialized, interval, lock(), TimerHeap::tab, Timerset::thread, timers, unlock(), and wap_event_destroy().

Referenced by start_initiator_timer_R(), start_timer_A(), start_timer_R(), and start_timer_W().

{
    int wakeup = 0;

    gw_assert(initialized);
    gw_assert(timer != NULL);
    gw_assert(event != NULL || timer->event != NULL);

    lock(timers);

    /* Convert to absolute time */
    interval += time(NULL);

    if (timer->elapses > 0) {
        /* Resetting an existing timer.  Move it to its new
         * position in the heap. */
        if (interval < timer->elapses && timer->index == 0)
            wakeup = 1;
        timer->elapses = interval;
        gw_assert(timers->heap->tab[timer->index] == timer);
        wakeup |= heap_adjust(timers->heap, timer->index);
    } else {
        /* Setting a new timer, or resetting an elapsed one.
         * First deal with a possible elapse event that may
         * still be on the output list. */
        abort_elapsed(timer);

        /* Then activate the timer. */
        timer->elapses = interval;
        gw_assert(timer->index < 0);
        heap_insert(timers->heap, timer);
        wakeup = timer->index == 0;  /* Do we have a new top? */
    }

    if (event != NULL) {
    wap_event_destroy(timer->event);
    timer->event = event;
    }

    unlock(timers);

    if (wakeup)
        gwthread_wakeup(timers->thread);
}

gwtimer_stop()

void gwtimer_stop

(

Timer *

timer

)

Definition at line 299 of file timers.c.

References abort_elapsed(), Timer::elapses, gw_assert(), Timerset::heap, heap_delete(), Timer::index, initialized, lock(), TimerHeap::tab, timers, and unlock().

Referenced by gwtimer_destroy(), stop_initiator_timer(), and timers_shutdown().

{
    gw_assert(initialized);
    gw_assert(timer != NULL);
    lock(timers);

    /*
     * If the timer is active, make it inactive and remove it from
     * the heap.
     */
    if (timer->elapses > 0) {
        timer->elapses = -1;
        gw_assert(timers->heap->tab[timer->index] == timer);
        heap_delete(timers->heap, timer->index);
    }

    abort_elapsed(timer);

    unlock(timers);
}

heap_adjust()

static int heap_adjust ( TimerHeap *  heap, long  index  )

static

Definition at line 446 of file timers.c.

References Timer::elapses, gw_assert(), heap_swap(), TimerHeap::len, and TimerHeap::tab.

Referenced by gwtimer_start(), heap_delete(), and heap_insert().

{
    Timer *t;
    Timer *parent;
    long child_index;

    /*
     * We can assume that the heap was fine before this element's
     * elapse time was changed.  There are three cases to deal
     * with:
     *  - Element's new elapse time is too small; it should be
     *    moved toward the top.
     *  - Element's new elapse time is too large; it should be
     *    moved toward the bottom.
     *  - Element's new elapse time still fits here, we don't
     *    have to do anything.
     */

    gw_assert(index >= 0);
    gw_assert(index < heap->len);

    /* Move to top? */
    t = heap->tab[index];
    parent = heap->tab[index / 2];
    if (t->elapses < parent->elapses) {
        /* This will automatically terminate when it reaches
         * the top, because in that t == parent. */
        do {
            heap_swap(heap, index, index / 2);
            index = index / 2;
            parent = heap->tab[index / 2];
        } while (t->elapses < parent->elapses);
        /* We're done.  Return 1 if we changed the top. */
        return index == 0;
    }

    /* Move to bottom? */
    for (; ; ) {
        child_index = index * 2;
        if (child_index >= heap->len)
            return 0;   /* Already at bottom */
        if (child_index == heap->len - 1) {
            /* Only one child */
            if (heap->tab[child_index]->elapses < t->elapses)
                heap_swap(heap, index, child_index);
            break;
        }

        /* Find out which child elapses first */
        if (heap->tab[child_index + 1]->elapses <
            heap->tab[child_index]->elapses) {
            child_index++;
        }

        if (heap->tab[child_index]->elapses < t->elapses) {
            heap_swap(heap, index, child_index);
            index = child_index;
        } else {
            break;
        }
    }

    return 0;
}

heap_create()

static TimerHeap * heap_create ( void  )

static

Definition at line 357 of file timers.c.

References TimerHeap::len, TimerHeap::size, and TimerHeap::tab.

Referenced by timers_init().

{
    TimerHeap *heap;

    heap = gw_malloc(sizeof(*heap));
    heap->tab = gw_malloc(sizeof(heap->tab[0]));
    heap->size = 1;
    heap->len = 0;

    return heap;
}

heap_delete()

static void heap_delete ( TimerHeap *  heap, long  index  )

static

Definition at line 383 of file timers.c.

References gw_assert(), heap_adjust(), heap_swap(), Timer::index, TimerHeap::len, and TimerHeap::tab.

Referenced by gwtimer_stop(), and watch_timers().

{
    long last;

    gw_assert(index >= 0);
    gw_assert(index < heap->len);
    gw_assert(heap->tab[index]->index == index);

    last = heap->len - 1;
    heap_swap(heap, index, last);
    heap->tab[last]->index = -1;
    heap->len--;
    if (index != last)
        heap_adjust(heap, index);
}

heap_destroy()

static void heap_destroy ( TimerHeap *  heap )

static

Definition at line 369 of file timers.c.

References TimerHeap::tab.

Referenced by timers_shutdown().

{
    if (heap == NULL)
        return;

    gw_free(heap->tab);
    gw_free(heap);
}

heap_insert()

static void heap_insert ( TimerHeap *  heap, Timer *  timer  )

static

Definition at line 403 of file timers.c.

References heap_adjust(), Timer::index, TimerHeap::len, TimerHeap::size, and TimerHeap::tab.

Referenced by gwtimer_start().

{
    heap->len++;
    if (heap->len > heap->size) {
        heap->tab = gw_realloc(heap->tab,
                                heap->len * sizeof(heap->tab[0]));
        heap->size = heap->len;
    }
    heap->tab[heap->len - 1] = timer;
    timer->index = heap->len - 1;
    heap_adjust(heap, timer->index);
}

heap_swap()

static void heap_swap ( TimerHeap *  heap, long  index1, long  index2  )

static

Definition at line 420 of file timers.c.

References gw_assert(), Timer::index, and TimerHeap::tab.

Referenced by heap_adjust(), and heap_delete().

{
    Timer *t;

    gw_assert(index1 >= 0);
    gw_assert(index1 < heap->len);
    gw_assert(index2 >= 0);
    gw_assert(index2 < heap->len);

    if (index1 == index2)
        return;

    t = heap->tab[index1];
    heap->tab[index1] = heap->tab[index2];
    heap->tab[index2] = t;
    heap->tab[index1]->index = index1;
    heap->tab[index2]->index = index2;
}

lock()

static void lock ( Timerset *  set )

static

Definition at line 320 of file timers.c.

References gw_assert(), and mutex_lock.

Referenced by gwtimer_start(), gwtimer_stop(), and watch_timers().

{
    gw_assert(set != NULL);
    mutex_lock(set->mutex);
}

timers_init()

void timers_init

(

void

)

Definition at line 184 of file timers.c.

References gwthread_create, Timerset::heap, heap_create(), initialized, Timerset::mutex, mutex_create, Timerset::stopping, Timerset::thread, timers, and watch_timers().

Referenced by wtp_initiator_init(), and wtp_resp_init().

{
    if (initialized == 0) {
        timers = gw_malloc(sizeof(*timers));
        timers->mutex = mutex_create();
        timers->heap = heap_create();
        timers->stopping = 0;
        timers->thread = gwthread_create(watch_timers, timers);
    }
    initialized++;
}

timers_shutdown()

void timers_shutdown

(

void

)

Definition at line 196 of file timers.c.

References gwthread_join(), gwthread_wakeup(), gwtimer_stop(), Timerset::heap, heap_destroy(), initialized, TimerHeap::len, Timerset::mutex, mutex_destroy(), Timerset::stopping, TimerHeap::tab, Timerset::thread, timers, and warning().

Referenced by wtp_initiator_shutdown(), and wtp_resp_shutdown().

{
    if (initialized > 1) {
        initialized--;
        return;
    }
       
    /* Stop all timers. */
    if (timers->heap->len > 0)
        warning(0, "Timers shutting down with %ld active timers.",
                timers->heap->len);
    while (timers->heap->len > 0)
        gwtimer_stop(timers->heap->tab[0]);

    /* Kill timer thread */
    timers->stopping = 1;
    gwthread_wakeup(timers->thread);
    gwthread_join(timers->thread);

    initialized = 0;

    /* Free resources */
    heap_destroy(timers->heap);
    mutex_destroy(timers->mutex);
    gw_free(timers);
}

unlock()

static void unlock ( Timerset *  set )

static

Definition at line 326 of file timers.c.

References gw_assert(), and mutex_unlock.

Referenced by gwtimer_start(), gwtimer_stop(), and watch_timers().

{
    gw_assert(set != NULL);
    mutex_unlock(set->mutex);
}

watch_timers()

static void watch_timers ( void *  arg )

static

Definition at line 532 of file timers.c.

References elapse_timer(), gwthread_sleep(), heap_delete(), lock(), and unlock().

Referenced by timers_init().

{
    Timerset *set;
    long top_time;
    long now;

    set = arg;

    while (!set->stopping) {
        lock(set);

    now = time(NULL);

    while (set->heap->len > 0 && set->heap->tab[0]->elapses <= now) {
        elapse_timer(set->heap->tab[0]);
        heap_delete(set->heap, 0);
    }

    /*
     * Now sleep until the next timer elapses.  If there isn't one,
     * then just sleep very long.  We will get woken up if the
     * top of the heap changes before we wake.
     */

        if (set->heap->len == 0) {
            unlock(set);
            gwthread_sleep(1000000.0);
        } else {
        top_time = set->heap->tab[0]->elapses;
        unlock(set);
        gwthread_sleep(top_time - now);
    }
    }
}

Variable Documentation

initialized

int initialized = 0

static

Definition at line 166 of file timers.c.

Referenced by gwtimer_create(), gwtimer_destroy(), gwtimer_start(), gwtimer_stop(), timers_init(), and timers_shutdown().

timers

Timerset* timers

static

Definition at line 160 of file timers.c.

Referenced by elapse_timer(), gwtimer_start(), gwtimer_stop(), timers_init(), and timers_shutdown().