**************************************************************************/
#include <time.h>
+#include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#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.
* 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);
}
}
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);
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;
}
-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;
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);
}
}
-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)
}
-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) {
}
-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);
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);
}
-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);
}
-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;
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;
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;
}
-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);
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;
+ mth->timeout_list = 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);
}
-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);
}
projects / chaz / tint2 / blobdiff