timers.h File Reference

#include "gwlib/gwlib.h"
#include "wap_events.h"

Go to the source code of this file.

Typedefs
typedef struct Timer	Timer

Functions
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)

Typedef Documentation

Timer

typedef struct Timer Timer

Definition at line 93 of file timers.h.

Function Documentation

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);
}

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);
}