X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Futil%2Ftimer.c;h=dd6847318569126796964e3caea4f70b64d0df44;hb=fc22af941cf7b9db65a703e9e697490119c70ec2;hp=3ccec7c9590216f919b9f88a69b78f4eb01f7c30;hpb=367bf8f76227dea6e7e10e974967ae1d60cfe38e;p=chaz%2Ftint2 diff --git a/src/util/timer.c b/src/util/timer.c index 3ccec7c..dd68473 100644 --- a/src/util/timer.c +++ b/src/util/timer.c @@ -16,41 +16,72 @@ **************************************************************************/ #include +#include #include #include #include "timer.h" -GSList* timeout_list = 0; +GSList* timeout_list; struct timeval next_timeout; +GHashTable* multi_timeouts; -void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(void*), void* arg, struct timeout* t); -gint compare_timeouts(gconstpointer t1, gconstpointer t2); -gint compare_timespecs(const struct timespec* t1, const struct timespec* t2); -int timespec_subtract(struct timespec* result, struct timespec* x, struct timespec* y); -struct timespec add_msec_to_timespec(struct timespec ts, int msec); // functions and structs for multi timeouts -struct multi_timeout { +typedef struct { int current_count; int count_to_expiration; -}; +} multi_timeout; -struct multi_timeout_handler { +typedef struct { GSList* timeout_list; - struct timeout* parent_timeout; + timeout* parent_timeout; +} multi_timeout_handler; + +struct _timeout { + int interval_msec; + struct timespec timeout_expires; + void (*_callback)(void*); + void* arg; + multi_timeout* multi_timeout; }; -int align_with_existing_timeouts(struct timeout* t); -void create_multi_timeout(struct timeout* t1, struct timeout* t2); -void append_multi_timeout(struct timeout* t1, struct timeout* t2); -int calc_multi_timeout_interval(struct multi_timeout_handler* mth); -void update_multi_timeout_values(struct multi_timeout_handler* mth); +void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(void*), void* arg, timeout* t); +gint compare_timeouts(gconstpointer t1, gconstpointer t2); +gint compare_timespecs(const struct timespec* t1, const struct timespec* t2); +int timespec_subtract(struct timespec* result, struct timespec* x, struct timespec* y); +struct timespec add_msec_to_timespec(struct timespec ts, int msec); + + +int align_with_existing_timeouts(timeout* t); +void create_multi_timeout(timeout* t1, timeout* t2); +void append_multi_timeout(timeout* t1, timeout* t2); +int calc_multi_timeout_interval(multi_timeout_handler* mth); +void update_multi_timeout_values(multi_timeout_handler* mth); void callback_multi_timeout(void* mth); -void remove_from_multi_timeout(struct timeout* t); -void stop_multi_timeout(struct timeout* t); +void remove_from_multi_timeout(timeout* t); +void stop_multi_timeout(timeout* t); + +void default_timeout() +{ + timeout_list = 0; + multi_timeouts = 0; +} -GHashTable* multi_timeouts = 0; +void cleanup_timeout() +{ + while (timeout_list) { + timeout* t = timeout_list->data; + if (t->multi_timeout) + stop_multi_timeout(t); + free(t); + timeout_list = g_slist_remove(timeout_list, t); + } + if (multi_timeouts) { + g_hash_table_destroy(multi_timeouts); + multi_timeouts = 0; + } +} /** Implementation notes for timeouts: The timeouts are kept in a GSList sorted by their * expiration time. @@ -64,25 +95,25 @@ GHashTable* multi_timeouts = 0; * however it's save to call it. **/ -const struct timeout* add_timeout(int value_msec, int interval_msec, void (*_callback)(void*), void* arg) +timeout* add_timeout(int value_msec, int interval_msec, void (*_callback)(void*), void* arg) { - struct timeout* t = malloc(sizeof(struct timeout)); + timeout* t = malloc(sizeof(timeout)); t->multi_timeout = 0; add_timeout_intern(value_msec, interval_msec, _callback, arg, t); return t; } -void change_timeout(const struct timeout *t, int value_msec, int interval_msec, void(*_callback)(), void* arg) +void change_timeout(timeout *t, int value_msec, int interval_msec, void(*_callback)(), void* arg) { if ( g_slist_find(timeout_list, t) == 0 && g_hash_table_lookup(multi_timeouts, t) == 0) printf("programming error: timeout already deleted..."); else { if (t->multi_timeout) - remove_from_multi_timeout((struct timeout*)t); + remove_from_multi_timeout((timeout*)t); else timeout_list = g_slist_remove(timeout_list, t); - add_timeout_intern(value_msec, interval_msec, _callback, arg, (struct timeout*)t); + add_timeout_intern(value_msec, interval_msec, _callback, arg, (timeout*)t); } } @@ -90,7 +121,7 @@ void change_timeout(const struct timeout *t, int value_msec, int interval_msec, void update_next_timeout() { if (timeout_list) { - struct timeout* t = timeout_list->data; + timeout* t = timeout_list->data; struct timespec cur_time; struct timespec next_timeout2 = { .tv_sec=next_timeout.tv_sec, .tv_nsec=next_timeout.tv_usec*1000 }; clock_gettime(CLOCK_MONOTONIC, &cur_time); @@ -111,7 +142,7 @@ void update_next_timeout() void callback_timeout_expired() { struct timespec cur_time; - struct timeout* t; + timeout* t; while (timeout_list) { clock_gettime(CLOCK_MONOTONIC, &cur_time); t = timeout_list->data; @@ -133,31 +164,19 @@ void callback_timeout_expired() } -void stop_timeout(const struct timeout* t) +void stop_timeout(timeout* t) { // if not in the list, it was deleted in callback_timeout_expired if (g_slist_find(timeout_list, t) || g_hash_table_lookup(multi_timeouts, t)) { if (t->multi_timeout) - remove_from_multi_timeout((struct timeout*)t); + remove_from_multi_timeout((timeout*)t); timeout_list = g_slist_remove(timeout_list, t); free((void*)t); } } -void stop_all_timeouts() -{ - while (timeout_list) { - struct timeout* t = timeout_list->data; - if (t->multi_timeout) - stop_multi_timeout(t); - free(t); - timeout_list = g_slist_remove(timeout_list, t); - } -} - - -void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(), void* arg, struct timeout *t) +void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(), void* arg, timeout *t) { t->interval_msec = interval_msec; t->_callback = _callback; @@ -176,8 +195,8 @@ void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(), v gint compare_timeouts(gconstpointer t1, gconstpointer t2) { - return compare_timespecs(&((const struct timeout*)t1)->timeout_expires, - &((const struct timeout*)t2)->timeout_expires); + return compare_timespecs(&((timeout*)t1)->timeout_expires, + &((timeout*)t2)->timeout_expires); } @@ -232,11 +251,11 @@ struct timespec add_msec_to_timespec(struct timespec ts, int msec) } -int align_with_existing_timeouts(struct timeout *t) +int align_with_existing_timeouts(timeout *t) { GSList* it = timeout_list; while (it) { - struct timeout* t2 = it->data; + timeout* t2 = it->data; if (t2->interval_msec > 0) { if (t->interval_msec % t2->interval_msec == 0 || t2->interval_msec % t->interval_msec == 0) { if (multi_timeouts == 0) @@ -256,10 +275,10 @@ int align_with_existing_timeouts(struct timeout *t) } -int calc_multi_timeout_interval(struct multi_timeout_handler* mth) +int calc_multi_timeout_interval(multi_timeout_handler* mth) { GSList* it = mth->timeout_list; - struct timeout* t = it->data; + timeout* t = it->data; int min_interval = t->interval_msec; it = it->next; while (it) { @@ -272,12 +291,12 @@ int calc_multi_timeout_interval(struct multi_timeout_handler* mth) } -void create_multi_timeout(struct timeout* t1, struct timeout* t2) +void create_multi_timeout(timeout* t1, timeout* t2) { - struct multi_timeout* mt1 = malloc(sizeof(struct multi_timeout)); - struct multi_timeout* mt2 = malloc(sizeof(struct multi_timeout)); - struct multi_timeout_handler* mth = malloc(sizeof(struct multi_timeout_handler)); - struct timeout* real_timeout = malloc(sizeof(struct timeout)); + multi_timeout* mt1 = malloc(sizeof(multi_timeout)); + multi_timeout* mt2 = malloc(sizeof(multi_timeout)); + multi_timeout_handler* mth = malloc(sizeof(multi_timeout_handler)); + timeout* real_timeout = malloc(sizeof(timeout)); mth->timeout_list = 0; mth->timeout_list = g_slist_prepend(mth->timeout_list, t1); @@ -290,7 +309,9 @@ void create_multi_timeout(struct timeout* t1, struct timeout* t2) t1->multi_timeout = mt1; t2->multi_timeout = mt2; - real_timeout->multi_timeout = real_timeout; + // set real_timeout->multi_timeout to something, such that we see in add_timeout_intern that + // it is already a multi_timeout (we never use it, except of checking for 0 ptr) + real_timeout->multi_timeout = (void*)real_timeout; timeout_list = g_slist_remove(timeout_list, t1); timeout_list = g_slist_remove(timeout_list, t2); @@ -299,17 +320,17 @@ void create_multi_timeout(struct timeout* t1, struct timeout* t2) } -void append_multi_timeout(struct timeout* t1, struct timeout* t2) +void append_multi_timeout(timeout* t1, timeout* t2) { if (t2->multi_timeout) { // swap t1 and t2 such that t1 is the multi timeout - struct timeout* tmp = t2; + timeout* tmp = t2; t2 = t1; t1 = tmp; } - struct multi_timeout* mt = malloc(sizeof(struct multi_timeout)); - struct multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t1); + multi_timeout* mt = malloc(sizeof(multi_timeout)); + multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t1); mth->timeout_list = g_slist_prepend(mth->timeout_list, t2); g_hash_table_insert(multi_timeouts, t2, mth); @@ -320,7 +341,7 @@ void append_multi_timeout(struct timeout* t1, struct timeout* t2) } -void update_multi_timeout_values(struct multi_timeout_handler* mth) +void update_multi_timeout_values(multi_timeout_handler* mth) { int interval = calc_multi_timeout_interval(mth); int next_timeout_msec = interval; @@ -331,13 +352,12 @@ void update_multi_timeout_values(struct multi_timeout_handler* mth) GSList* it = mth->timeout_list; struct timespec diff_time; while (it) { - struct timeout* t = it->data; - struct multi_timeout* mt = t->multi_timeout; - mt->count_to_expiration = t->interval_msec / interval; + timeout* t = it->data; + t->multi_timeout->count_to_expiration = t->interval_msec / interval; timespec_subtract(&diff_time, &t->timeout_expires, &cur_time); int msec_to_expiration = diff_time.tv_sec*1000 + diff_time.tv_nsec/1000000; int count_left = msec_to_expiration / interval + (msec_to_expiration%interval != 0); - mt->current_count = mt->count_to_expiration - count_left; + t->multi_timeout->current_count = t->multi_timeout->count_to_expiration - count_left; if (msec_to_expiration < next_timeout_msec) next_timeout_msec = msec_to_expiration; it = it->next; @@ -351,16 +371,15 @@ void update_multi_timeout_values(struct multi_timeout_handler* mth) void callback_multi_timeout(void* arg) { - struct multi_timeout_handler* mth = arg; + multi_timeout_handler* mth = arg; struct timespec cur_time; clock_gettime(CLOCK_MONOTONIC, &cur_time); GSList* it = mth->timeout_list; while (it) { - struct timeout* t = it->data; - struct multi_timeout* mt = t->multi_timeout; - if (++mt->current_count >= mt->count_to_expiration) { + timeout* t = it->data; + if (++t->multi_timeout->current_count >= t->multi_timeout->count_to_expiration) { t->_callback(t->arg); - mt->current_count = 0; + t->multi_timeout->current_count = 0; t->timeout_expires = add_msec_to_timespec(cur_time, t->interval_msec); } it = it->next; @@ -368,9 +387,9 @@ void callback_multi_timeout(void* arg) } -void remove_from_multi_timeout(struct timeout* t) +void remove_from_multi_timeout(timeout* t) { - struct multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t); + multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t); g_hash_table_remove(multi_timeouts, t); mth->timeout_list = g_slist_remove(mth->timeout_list, t); @@ -378,7 +397,8 @@ void remove_from_multi_timeout(struct timeout* t) t->multi_timeout = 0; if (g_slist_length(mth->timeout_list) == 1) { - struct timeout* last_timeout = mth->timeout_list->data; + timeout* last_timeout = mth->timeout_list->data; + g_slist_remove(mth->timeout_list, last_timeout); free(last_timeout->multi_timeout); last_timeout->multi_timeout = 0; g_hash_table_remove(multi_timeouts, last_timeout); @@ -398,15 +418,16 @@ void remove_from_multi_timeout(struct timeout* t) } -void stop_multi_timeout(struct timeout* t) +void stop_multi_timeout(timeout* t) { - struct multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t); + multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t); g_hash_table_remove(multi_timeouts, mth->parent_timeout); while (mth->timeout_list) { - struct timeout* t = mth->timeout_list->data; - mth->timeout_list = g_slist_remove(mth->timeout_list, t); - g_hash_table_remove(multi_timeouts, t); - free(t); + timeout* t1 = mth->timeout_list->data; + mth->timeout_list = g_slist_remove(mth->timeout_list, t1); + g_hash_table_remove(multi_timeouts, t1); + free(t1->multi_timeout); + free(t1); } free(mth); }