* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**************************************************************************/
-#include <sys/timerfd.h>
+#include <time.h>
+#include <sys/time.h>
#include <stdlib.h>
-#include <unistd.h>
+#include <stdio.h>
#include "timer.h"
-GSList* timer_list = 0;
+GSList* timeout_list;
+struct timeval next_timeout;
+GHashTable* multi_timeouts;
-int install_timer(int value_sec, int value_nsec, int interval_sec, int interval_nsec, void (*_callback)())
+
+// functions and structs for multi timeouts
+typedef struct {
+ int current_count;
+ int count_to_expiration;
+} multi_timeout;
+
+typedef struct {
+ GSList* timeout_list;
+ timeout* parent_timeout;
+} multi_timeout_handler;
+
+struct _timeout {
+ int interval_msec;
+ struct timespec timeout_expires;
+ void (*_callback)(void*);
+ void* arg;
+ multi_timeout* multi_timeout;
+};
+
+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(timeout* t);
+void stop_multi_timeout(timeout* t);
+
+void default_timeout()
{
- if ( value_sec < 0 || interval_sec < 0 || _callback == 0 )
- return -1;
+ timeout_list = 0;
+ multi_timeouts = 0;
+}
- int timer_fd;
- struct itimerspec timer;
- timer.it_value = (struct timespec){ .tv_sec=value_sec, .tv_nsec=value_nsec };
- timer.it_interval = (struct timespec){ .tv_sec=interval_sec, .tv_nsec=interval_nsec };
- timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
- timerfd_settime(timer_fd, 0, &timer, 0);
- struct timer* t = malloc(sizeof(struct timer));
- t->id=timer_fd;
- t->_callback = _callback;
- timer_list = g_slist_prepend(timer_list, t);
- return timer_fd;
+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.
+ * That means that update_next_timeout() only have to consider the first timeout in the list,
+ * and callback_timeout_expired() only have to consider the timeouts as long as the expiration time
+ * is in the past to the current time.
+ * As time measurement we use clock_gettime(CLOCK_MONOTONIC) because this refers to a timer, which
+ * reference point lies somewhere in the past and cannot be changed, but just queried.
+ * If a single shot timer is installed it will be automatically deleted. I.e. the returned value
+ * of add_timeout will not be valid anymore. You do not need to call stop_timeout for these timeouts,
+ * however it's save to call it.
+**/
-void reset_timer(int id, int value_sec, int value_nsec, int interval_sec, int interval_nsec)
+timeout* add_timeout(int value_msec, int interval_msec, void (*_callback)(void*), void* arg)
{
- struct itimerspec timer;
- timer.it_value = (struct timespec){ .tv_sec=value_sec, .tv_nsec=value_nsec };
- timer.it_interval = (struct timespec){ .tv_sec=interval_sec, .tv_nsec=interval_nsec };
- timerfd_settime(id, 0, &timer, 0);
+ timeout* t = malloc(sizeof(timeout));
+ t->multi_timeout = 0;
+ add_timeout_intern(value_msec, interval_msec, _callback, arg, t);
+ return t;
}
-void uninstall_timer(int id)
+void change_timeout(timeout *t, int value_msec, int interval_msec, void(*_callback)(), void* arg)
{
- close(id);
- GSList* timer_iter = timer_list;
- while (timer_iter) {
- struct timer* t = timer_iter->data;
- if (t->id == id) {
- timer_list = g_slist_remove(timer_list, t);
- free(t);
+ 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((timeout*)t);
+ else
+ timeout_list = g_slist_remove(timeout_list, t);
+ add_timeout_intern(value_msec, interval_msec, _callback, arg, (timeout*)t);
+ }
+}
+
+
+void update_next_timeout()
+{
+ if (timeout_list) {
+ 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);
+ if (timespec_subtract(&next_timeout2, &t->timeout_expires, &cur_time)) {
+ next_timeout.tv_sec = 0;
+ next_timeout.tv_usec = 0;
+ }
+ else {
+ next_timeout.tv_sec = next_timeout2.tv_sec;
+ next_timeout.tv_usec = next_timeout2.tv_nsec/1000;
+ }
+ }
+ else
+ next_timeout.tv_sec = -1;
+}
+
+
+void callback_timeout_expired()
+{
+ struct timespec cur_time;
+ timeout* t;
+ while (timeout_list) {
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ t = timeout_list->data;
+ if (compare_timespecs(&t->timeout_expires, &cur_time) <= 0) {
+ // it's time for the callback function
+ t->_callback(t->arg);
+ if (g_slist_find(timeout_list, t)) {
+ // if _callback() calls stop_timeout(t) the timeout 't' was freed and is not in the timeout_list
+ timeout_list = g_slist_remove(timeout_list, t);
+ if (t->interval_msec > 0)
+ add_timeout_intern(t->interval_msec, t->interval_msec, t->_callback, t->arg, t);
+ else
+ free(t);
+ }
+ }
+ else
return;
+ }
+}
+
+
+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((timeout*)t);
+ timeout_list = g_slist_remove(timeout_list, t);
+ free((void*)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;
+ t->arg = arg;
+ struct timespec cur_time;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ t->timeout_expires = add_msec_to_timespec(cur_time, value_msec);
+
+ int can_align = 0;
+ if (interval_msec > 0 && !t->multi_timeout)
+ can_align = align_with_existing_timeouts(t);
+ if (!can_align)
+ timeout_list = g_slist_insert_sorted(timeout_list, t, compare_timeouts);
+}
+
+
+gint compare_timeouts(gconstpointer t1, gconstpointer t2)
+{
+ return compare_timespecs(&((timeout*)t1)->timeout_expires,
+ &((timeout*)t2)->timeout_expires);
+}
+
+
+gint compare_timespecs(const struct timespec* t1, const struct timespec* t2)
+{
+ if (t1->tv_sec < t2->tv_sec)
+ return -1;
+ else if (t1->tv_sec == t2->tv_sec) {
+ if (t1->tv_nsec < t2->tv_nsec)
+ return -1;
+ else if (t1->tv_nsec == t2->tv_nsec)
+ return 0;
+ else
+ return 1;
+ }
+ else
+ return 1;
+}
+
+int timespec_subtract(struct timespec* result, struct timespec* x, struct timespec* y)
+{
+ /* Perform the carry for the later subtraction by updating y. */
+ if (x->tv_nsec < y->tv_nsec) {
+ int nsec = (y->tv_nsec - x->tv_nsec) / 1000000000 + 1;
+ y->tv_nsec -= 1000000000 * nsec;
+ y->tv_sec += nsec;
+ }
+ if (x->tv_nsec - y->tv_nsec > 1000000000) {
+ int nsec = (x->tv_nsec - y->tv_nsec) / 1000000000;
+ y->tv_nsec += 1000000000 * nsec;
+ y->tv_sec -= nsec;
+ }
+
+ /* Compute the time remaining to wait. tv_nsec is certainly positive. */
+ result->tv_sec = x->tv_sec - y->tv_sec;
+ result->tv_nsec = x->tv_nsec - y->tv_nsec;
+
+ /* Return 1 if result is negative. */
+ return x->tv_sec < y->tv_sec;
+}
+
+
+struct timespec add_msec_to_timespec(struct timespec ts, int msec)
+{
+ ts.tv_sec += msec / 1000;
+ ts.tv_nsec += (msec % 1000)*1000000;
+ if (ts.tv_nsec >= 1000000000) { // 10^9
+ ts.tv_sec++;
+ ts.tv_nsec -= 1000000000;
+ }
+ return ts;
+}
+
+
+int align_with_existing_timeouts(timeout *t)
+{
+ GSList* it = timeout_list;
+ while (it) {
+ 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)
+ multi_timeouts = g_hash_table_new(0, 0);
+ if (!t->multi_timeout && !t2->multi_timeout)
+ // both timeouts can be aligned, but there is no multi timeout for them
+ create_multi_timeout(t, t2);
+ else
+ // there is already a multi timeout, so we append the new timeout to the multi timeout
+ append_multi_timeout(t, t2);
+ return 1;
+ }
}
- timer_iter = timer_iter->next;
+ it = it->next;
+ }
+ return 0;
+}
+
+
+int calc_multi_timeout_interval(multi_timeout_handler* mth)
+{
+ GSList* it = mth->timeout_list;
+ timeout* t = it->data;
+ int min_interval = t->interval_msec;
+ it = it->next;
+ while (it) {
+ t = it->data;
+ if (t->interval_msec < min_interval)
+ min_interval = t->interval_msec;
+ it = it->next;
+ }
+ return min_interval;
+}
+
+
+void create_multi_timeout(timeout* t1, timeout* t2)
+{
+ 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);
+ mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
+ mth->parent_timeout = real_timeout;
+
+ g_hash_table_insert(multi_timeouts, t1, mth);
+ g_hash_table_insert(multi_timeouts, t2, mth);
+ g_hash_table_insert(multi_timeouts, real_timeout, mth);
+
+ t1->multi_timeout = mt1;
+ t2->multi_timeout = mt2;
+ // 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);
+
+ update_multi_timeout_values(mth);
+}
+
+
+void append_multi_timeout(timeout* t1, timeout* t2)
+{
+ if (t2->multi_timeout) {
+ // swap t1 and t2 such that t1 is the multi timeout
+ timeout* tmp = t2;
+ t2 = t1;
+ t1 = tmp;
+ }
+
+ 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);
+
+ t2->multi_timeout = mt;
+
+ update_multi_timeout_values(mth);
+}
+
+
+void update_multi_timeout_values(multi_timeout_handler* mth)
+{
+ int interval = calc_multi_timeout_interval(mth);
+ int next_timeout_msec = interval;
+
+ struct timespec cur_time;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+
+ GSList* it = mth->timeout_list;
+ struct timespec diff_time;
+ while (it) {
+ 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);
+ 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;
+ }
+
+ mth->parent_timeout->interval_msec = interval;
+ timeout_list = g_slist_remove(timeout_list, mth->parent_timeout);
+ add_timeout_intern(next_timeout_msec, interval, callback_multi_timeout, mth, mth->parent_timeout);
+}
+
+
+void callback_multi_timeout(void* arg)
+{
+ multi_timeout_handler* mth = arg;
+ struct timespec cur_time;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ GSList* it = mth->timeout_list;
+ while (it) {
+ timeout* t = it->data;
+ if (++t->multi_timeout->current_count >= t->multi_timeout->count_to_expiration) {
+ t->_callback(t->arg);
+ 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(timeout* 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);
+ free(t->multi_timeout);
+ t->multi_timeout = 0;
+
+ if (g_slist_length(mth->timeout_list) == 1) {
+ 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);
+ g_hash_table_remove(multi_timeouts, mth->parent_timeout);
+ mth->parent_timeout->multi_timeout = 0;
+ stop_timeout(mth->parent_timeout);
+ free(mth);
+
+ struct timespec cur_time, diff_time;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
+ int msec_to_expiration = diff_time.tv_sec*1000 + diff_time.tv_nsec/1000000;
+ add_timeout_intern(msec_to_expiration, last_timeout->interval_msec, last_timeout->_callback, last_timeout->arg, last_timeout);
+ }
+ else
+ update_multi_timeout_values(mth);
+}
+
+
+void stop_multi_timeout(timeout* 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) {
+ 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