gw-timer.c File Reference

#include <signal.h>
#include "gwlib/gwlib.h"
#include "gw-timer.h"

Go to the source code of this file.

Data Structures
struct	TimerHeap
struct	Timerset
struct	Timer

Typedefs
typedef struct TimerHeap	TimerHeap

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	watch_timers (void *arg)
static void	elapse_timer (Timer *timer)
static void	lock (Timerset *set)
static void	unlock (Timerset *set)
Timerset *	gw_timerset_create (void)
void	gw_timerset_destroy (Timerset *set)
void	gw_timerset_elapsed_destroy (Timerset *set)
long	gw_timerset_count (Timerset *set)
Timer *	gw_timer_create (Timerset *set, List *outputlist, void(*callback)(void *))
void	gw_timer_destroy (Timer *timer)
void	gw_timer_elapsed_destroy (Timer *timer)
void	gw_timer_elapsed_destroy_cb (Timer *timer)
void	gw_timer_start (Timer *timer, int interval, void *data)
void	gw_timer_elapsed_start (Timer *timer, int interval, void *data)
void	gw_timer_elapsed_start_cb (Timer *timer, int interval, void *data)
void	gw_timer_stop (Timer *timer)
void	gw_timer_elapsed_stop (Timer *timer)
void	gw_timer_elapsed_stop_cb (Timer *timer)
List *	gw_timer_break (Timerset *set)
void *	gw_timer_data (Timer *timer)

Typedef Documentation

TimerHeap

typedef struct TimerHeap TimerHeap

Definition at line 91 of file gw-timer.c.

Function Documentation

abort_elapsed()

static void abort_elapsed ( Timer *  timer )

static

Definition at line 583 of file gw-timer.c.

References Timer::elapsed_data, gwlist_delete_equal(), and Timer::output.

Referenced by gw_timer_break(), gw_timer_start(), and gw_timer_stop().

{
    if (timer->elapsed_data == NULL)
        return;

    if (timer->output != NULL)
        gwlist_delete_equal(timer->output, timer->elapsed_data);
    timer->elapsed_data = NULL;
}

elapse_timer()

static void elapse_timer ( Timer *  timer )

static

Definition at line 753 of file gw-timer.c.

References Timer::callback, Timer::data, Timer::elapsed_data, Timer::elapses, gw_assert(), gwlist_produce(), Timer::output, and Timer::timerset.

Referenced by watch_timers().

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

    timer->elapsed_data = timer->data;
    timer->elapses = -1;
    if (timer->output != NULL)
        gwlist_produce(timer->output, timer->elapsed_data);
    if (timer->callback != NULL)
        timer->callback(timer->elapsed_data);
}

gw_timer_break()

List* gw_timer_break

(

Timerset *

set

)

Definition at line 501 of file gw-timer.c.

References abort_elapsed(), Timer::elapses, gw_assert(), gwlist_append(), gwlist_create, heap_delete(), Timer::index, lock(), and unlock().

{
    List *ret = NULL;

    lock(set);

    if (set->heap->len == 0) {
        unlock(set);
        return NULL;
    }

    ret = gwlist_create();

    /* Stop all timers. */
    while (set->heap->len > 0) {
        Timer *timer = set->heap->tab[0];

        gwlist_append(ret, timer);

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

        abort_elapsed(timer);
    }

    unlock(set);

    return ret;
}

gw_timer_create()

Timer* gw_timer_create	(	Timerset *	set,
		List *	outputlist,
		void(*)(void *)	callback
	)

Definition at line 255 of file gw-timer.c.

References Timer::callback, Timer::data, Timer::elapsed_data, Timer::elapses, gwlist_add_producer(), Timer::index, Timer::output, and Timer::timerset.

Referenced by main(), retry_consumer_thread(), and url_result_thread().

{
    Timer *t;

    t = gw_malloc(sizeof(*t));
    t->timerset = set;
    t->elapses = -1;
    t->data = NULL;
    t->elapsed_data = NULL;
    t->index = -1;
    t->output = outputlist;
    if (t->output != NULL)
        gwlist_add_producer(outputlist);
    t->callback = callback;

    return t;
}

gw_timer_data()

void* gw_timer_data

(

Timer *

timer

)

Definition at line 538 of file gw-timer.c.

References Timer::data, and gw_assert().

{
    gw_assert(timer != NULL);

    return timer->data;
}

gw_timer_destroy()

void gw_timer_destroy

(

Timer *

timer

)

Definition at line 273 of file gw-timer.c.

References gw_timer_stop(), gwlist_remove_producer(), and Timer::output.

{
    if (timer == NULL)
        return;

    gw_timer_stop(timer);
    if (timer->output != NULL)
        gwlist_remove_producer(timer->output);
    gw_free(timer);
}

gw_timer_elapsed_destroy()

void gw_timer_elapsed_destroy

(

Timer *

timer

)

Definition at line 284 of file gw-timer.c.

References gw_timer_elapsed_stop(), gwlist_remove_producer(), and Timer::output.

Referenced by gw_timerset_elapsed_destroy(), http_queue_thread(), and timer_consumer_thread().

{
    if (timer == NULL)
        return;

    gw_timer_elapsed_stop(timer);
    if (timer->output != NULL)
        gwlist_remove_producer(timer->output);
    gw_free(timer);
}

gw_timer_elapsed_destroy_cb()

void gw_timer_elapsed_destroy_cb

(

Timer *

timer

)

Definition at line 295 of file gw-timer.c.

References gw_timer_elapsed_stop_cb(), gwlist_remove_producer(), and Timer::output.

Referenced by timer_retry_cb().

{
    if (timer == NULL)
        return;

    gw_timer_elapsed_stop_cb(timer);
    if (timer->output != NULL)
        gwlist_remove_producer(timer->output);
    gw_free(timer);
}

gw_timer_elapsed_start()

void gw_timer_elapsed_start	(	Timer *	timer,
		int	interval,
		void *	data
	)

Definition at line 352 of file gw-timer.c.

References Timer::data, Timer::elapsed_data, Timer::elapses, gw_assert(), gwthread_wakeup(), Timerset::heap, heap_adjust(), heap_insert(), Timer::index, interval, lock(), TimerHeap::tab, Timerset::thread, Timer::timerset, and unlock().

Referenced by main(), retry_consumer_thread(), timer_consumer_thread(), and url_result_thread().

{
    int wakeup = 0;

    gw_assert(timer != NULL);

    if (timer == NULL)
        return;

    lock(timer->timerset);

    /* 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(timer->index >= 0);
        gw_assert(timer->timerset->heap->tab[timer->index] == timer);
        wakeup |= heap_adjust(timer->timerset->heap, timer->index);
    } else {
        /* Setting a new timer, or resetting an elapsed one.
         * There should be no further elapse event on the
         * output list here. */
        /* abort_elapsed(timer); */
        timer->elapsed_data = NULL;

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

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

    unlock(timer->timerset);

    if (wakeup)
        gwthread_wakeup(timer->timerset->thread);
}

gw_timer_elapsed_start_cb()

void gw_timer_elapsed_start_cb	(	Timer *	timer,
		int	interval,
		void *	data
	)

Definition at line 399 of file gw-timer.c.

References Timer::data, Timer::elapsed_data, Timer::elapses, gw_assert(), gwthread_wakeup(), Timerset::heap, heap_adjust(), heap_insert(), Timer::index, interval, TimerHeap::tab, Timerset::thread, and Timer::timerset.

{
    int wakeup = 0;

    gw_assert(timer != NULL);

    if (timer == NULL)
        return;

    /* 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(timer->index >= 0);
        gw_assert(timer->timerset->heap->tab[timer->index] == timer);
        wakeup |= heap_adjust(timer->timerset->heap, timer->index);
    } else {
        /* Setting a new timer, or resetting an elapsed one.
         * There should be no further elapse event on the
         * output list here. */
        /* abort_elapsed(timer); */
        timer->elapsed_data = NULL;

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

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

    if (wakeup)
        gwthread_wakeup(timer->timerset->thread);
}

gw_timer_elapsed_stop()

void gw_timer_elapsed_stop

(

Timer *

timer

)

Definition at line 462 of file gw-timer.c.

References Timer::elapsed_data, Timer::elapses, gw_assert(), Timerset::heap, heap_delete(), Timer::index, lock(), TimerHeap::tab, Timer::timerset, and unlock().

Referenced by gw_timer_elapsed_destroy().

{
    gw_assert(timer != NULL);
    lock(timer->timerset);

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

    /* abort_elapsed(timer); */
    timer->elapsed_data = NULL;

    unlock(timer->timerset);
}

gw_timer_elapsed_stop_cb()

void gw_timer_elapsed_stop_cb

(

Timer *

timer

)

Definition at line 483 of file gw-timer.c.

References Timer::elapsed_data, Timer::elapses, gw_assert(), Timerset::heap, heap_delete(), Timer::index, TimerHeap::tab, and Timer::timerset.

Referenced by gw_timer_elapsed_destroy_cb().

{
    gw_assert(timer != NULL);

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

    /* abort_elapsed(timer); */
    timer->elapsed_data = NULL;
}

gw_timer_start()

void gw_timer_start	(	Timer *	timer,
		int	interval,
		void *	data
	)

Definition at line 306 of file gw-timer.c.

References abort_elapsed(), Timer::data, Timer::elapses, gw_assert(), gwthread_wakeup(), Timerset::heap, heap_adjust(), heap_insert(), Timer::index, interval, lock(), TimerHeap::tab, Timerset::thread, Timer::timerset, and unlock().

{
    int wakeup = 0;

    gw_assert(timer != NULL);

    if (timer == NULL)
        return;
        
    lock(timer->timerset);

    /* 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(timer->index >= 0);
        gw_assert(timer->timerset->heap->tab[timer->index] == timer);
        wakeup |= heap_adjust(timer->timerset->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(timer->timerset->heap, timer);
        wakeup = timer->index == 0;  /* Do we have a new top? */
    }

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

    unlock(timer->timerset);

    if (wakeup)
        gwthread_wakeup(timer->timerset->thread);
}

gw_timer_stop()

void gw_timer_stop

(

Timer *

timer

)

Definition at line 442 of file gw-timer.c.

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

Referenced by gw_timer_destroy(), and gw_timerset_destroy().

{
    gw_assert(timer != NULL);
    lock(timer->timerset);

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

    abort_elapsed(timer);

    unlock(timer->timerset);
}

gw_timerset_count()

long gw_timerset_count

(

Timerset *

set

)

Definition at line 244 of file gw-timer.c.

References lock(), and unlock().

Referenced by main().

{
    long ret;

    lock(set);
    ret = set->heap->len;
    unlock(set);

    return ret;
}

gw_timerset_create()

Timerset* gw_timerset_create

(

void

)

Definition at line 190 of file gw-timer.c.

References gwthread_create, heap_create(), mutex_create, and watch_timers().

Referenced by main().

{
    Timerset *set;

    set = gw_malloc(sizeof(Timerset));
    set->mutex = mutex_create();
    set->heap = heap_create();
    set->stopping = 0;
    set->thread = gwthread_create(watch_timers, set);

    return set;
}

gw_timerset_destroy()

void gw_timerset_destroy

(

Timerset *

set

)

Definition at line 203 of file gw-timer.c.

References gw_timer_stop(), gwthread_join(), gwthread_wakeup(), heap_destroy(), and mutex_destroy().

Referenced by main().

{
    if (set == NULL)
        return;
       
    /* Stop all timers. */
    while (set->heap->len > 0)
        gw_timer_stop(set->heap->tab[0]);

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

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

gw_timerset_elapsed_destroy()

void gw_timerset_elapsed_destroy

(

Timerset *

set

)

Definition at line 223 of file gw-timer.c.

References gw_timer_elapsed_destroy(), gwthread_join(), gwthread_wakeup(), heap_destroy(), and mutex_destroy().

{
    if (set == NULL)
        return;

    /* Stop all timers. */
    while (set->heap->len > 0)
        gw_timer_elapsed_destroy(set->heap->tab[0]);

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

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

heap_adjust()

static int heap_adjust ( TimerHeap *  heap, long  index  )

static

Definition at line 685 of file gw-timer.c.

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

Referenced by gw_timer_elapsed_start(), gw_timer_elapsed_start_cb(), gw_timer_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 596 of file gw-timer.c.

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

Referenced by gw_timerset_create().

{
    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 622 of file gw-timer.c.

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

Referenced by gw_timer_break(), gw_timer_elapsed_stop(), gw_timer_elapsed_stop_cb(), gw_timer_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 608 of file gw-timer.c.

References TimerHeap::tab.

Referenced by gw_timerset_destroy(), and gw_timerset_elapsed_destroy().

{
    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 642 of file gw-timer.c.

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

Referenced by gw_timer_elapsed_start(), gw_timer_elapsed_start_cb(), and gw_timer_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 659 of file gw-timer.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 563 of file gw-timer.c.

References gw_assert(), and mutex_lock.

Referenced by gw_timer_break(), gw_timer_elapsed_start(), gw_timer_elapsed_stop(), gw_timer_start(), gw_timer_stop(), gw_timerset_count(), and watch_timers().

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

unlock()

static void unlock ( Timerset *  set )

static

Definition at line 569 of file gw-timer.c.

References gw_assert(), and mutex_unlock.

Referenced by gw_timer_break(), gw_timer_elapsed_start(), gw_timer_elapsed_stop(), gw_timer_start(), gw_timer_stop(), gw_timerset_count(), and watch_timers().

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

watch_timers()

static void watch_timers ( void *  arg )

static

Definition at line 772 of file gw-timer.c.

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

Referenced by gw_timerset_create().

{
    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) {
            Timer *timer = set->heap->tab[0];
            heap_delete(set->heap, 0);
            elapse_timer(timer);
        }

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