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