+ /* Remove the expired task */
+ silc_schedule_task_remove(schedule, t);
+
+ /* Balance when we have lots of small timeouts */
+ if (silc_unlikely((++count) > 40))
+ break;
+ } while (silc_likely((task = silc_list_get(schedule->timeout_queue))));
+}
+
+/* Calculates next timeout. This is the timeout value when at earliest some
+ of the timeout tasks expire. If this is in the past, they will be
+ dispatched now. */
+
+static void silc_schedule_select_timeout(SilcSchedule schedule)
+{
+ SilcTask t;
+ SilcTaskTimeout task;
+ struct timeval curtime;
+ SilcBool dispatch = TRUE;
+
+ /* Get the current time */
+ silc_gettimeofday(&curtime);
+ schedule->has_timeout = FALSE;
+
+ /* First task in the task queue has always the earliest timeout. */
+ silc_list_start(schedule->timeout_queue);
+ task = silc_list_get(schedule->timeout_queue);
+ if (silc_unlikely(!task))
+ return;
+ do {
+ t = (SilcTask)task;
+
+ /* Remove invalid task */
+ if (silc_unlikely(!t->valid)) {
+ silc_schedule_task_remove(schedule, t);
+ continue;
+ }
+
+ /* If the timeout is in past, we will run the task and all other
+ timeout tasks from the past. */
+ if (silc_compare_timeval(&task->timeout, &curtime) <= 0 && dispatch) {
+ silc_schedule_dispatch_timeout(schedule, FALSE);
+ if (silc_unlikely(!schedule->valid))
+ return;
+
+ /* Start selecting new timeout again after dispatch */
+ silc_list_start(schedule->timeout_queue);
+ dispatch = FALSE;
+ continue;
+ }
+
+ /* Calculate the next timeout */
+ curtime.tv_sec = task->timeout.tv_sec - curtime.tv_sec;
+ curtime.tv_usec = task->timeout.tv_usec - curtime.tv_usec;
+ if (curtime.tv_sec < 0)
+ curtime.tv_sec = 0;
+
+ /* We wouldn't want to go under zero, check for it. */
+ if (curtime.tv_usec < 0) {
+ curtime.tv_sec -= 1;
+ if (curtime.tv_sec < 0)
+ curtime.tv_sec = 0;
+ curtime.tv_usec += 1000000L;
+ }
+ break;
+ } while ((task = silc_list_get(schedule->timeout_queue)));
+
+ /* Save the timeout */
+ if (task) {
+ schedule->timeout = curtime;
+ schedule->has_timeout = TRUE;
+ SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout.tv_sec,
+ schedule->timeout.tv_usec));
+ }
+}
+
+/* Removes task from the scheduler. This must be called with scheduler
+ locked. */
+
+static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task)
+{
+ SilcSchedule parent;
+
+ if (silc_unlikely(task == SILC_ALL_TASKS)) {
+ SilcTask task;
+ SilcEventTask etask;
+ SilcHashTableList htl;
+ void *fd;
+
+ /* Delete from fd queue */
+ silc_hash_table_list(schedule->fd_queue, &htl);
+ while (silc_hash_table_get(&htl, &fd, (void *)&task))
+ silc_hash_table_del(schedule->fd_queue, fd);
+ silc_hash_table_list_reset(&htl);
+
+ /* Delete from timeout queue */
+ silc_list_start(schedule->timeout_queue);
+ while ((task = silc_list_get(schedule->timeout_queue))) {
+ silc_list_del(schedule->timeout_queue, task);
+ silc_free(task);
+ }
+
+ /* Delete even tasks */
+ parent = silc_schedule_get_parent(schedule);
+ silc_hash_table_list(parent->events, &htl);
+ while (silc_hash_table_get(&htl, NULL, (void *)&etask)) {
+ silc_hash_table_del_by_context(parent->events, etask->event, etask);
+ silc_free(etask->event);
+ silc_free(etask);
+ }
+ silc_hash_table_list_reset(&htl);
+ return;
+ }
+
+ switch (task->type) {
+ case SILC_TASK_FD:
+ {
+ /* Delete from fd queue */
+ SilcTaskFd ftask = (SilcTaskFd)task;
+ silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd));
+ }
+ break;
+
+ case SILC_TASK_TIMEOUT:
+ {
+ /* Delete from timeout queue */
+ silc_list_del(schedule->timeout_queue, task);
+
+ /* Put to free list */
+ silc_list_add(schedule->free_tasks, task);
+ }
+ break;
+
+ case SILC_TASK_EVENT:
+ {
+ SilcEventTask etask = (SilcEventTask)task;
+ SilcScheduleEventConnection conn;
+
+ parent = silc_schedule_get_parent(schedule);
+
+ /* Delete event */
+ silc_hash_table_del_by_context(parent->events, etask->event, etask);
+
+ /* Remove all connections */
+ silc_list_start(etask->connections);
+ while ((conn = silc_list_get(etask->connections)))
+ silc_free(conn);
+
+ silc_free(etask->event);
+ silc_free(etask);
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+/* Timeout freelist garbage collection */
+
+SILC_TASK_CALLBACK(silc_schedule_timeout_gc)
+{
+ SilcTaskTimeout t;
+ int c;
+
+ if (!schedule->valid)
+ return;
+
+ SILC_LOG_DEBUG(("Timeout freelist garbage collection"));
+
+ SILC_SCHEDULE_LOCK(schedule);
+
+ if (silc_list_count(schedule->free_tasks) <= 10) {
+ SILC_SCHEDULE_UNLOCK(schedule);
+ silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc,
+ schedule, 3600, 0);
+ return;
+ }
+ if (silc_list_count(schedule->timeout_queue) >
+ silc_list_count(schedule->free_tasks)) {
+ SILC_SCHEDULE_UNLOCK(schedule);
+ silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc,
+ schedule, 3600, 0);
+ return;
+ }
+
+ c = silc_list_count(schedule->free_tasks) / 2;
+ if (c > silc_list_count(schedule->timeout_queue))
+ c = (silc_list_count(schedule->free_tasks) -
+ silc_list_count(schedule->timeout_queue));
+ if (silc_list_count(schedule->free_tasks) - c < 10)
+ c -= (10 - (silc_list_count(schedule->free_tasks) - c));
+
+ SILC_LOG_DEBUG(("Freeing %d unused tasks, leaving %d", c,
+ silc_list_count(schedule->free_tasks) - c));
+
+ silc_list_start(schedule->free_tasks);
+ while ((t = silc_list_get(schedule->free_tasks)) && c-- > 0) {
+ silc_list_del(schedule->free_tasks, t);
+ silc_free(t);
+ }
+ silc_list_start(schedule->free_tasks);
+
+ SILC_SCHEDULE_UNLOCK(schedule);
+
+ silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc,
+ schedule, 3600, 0);
+}
+
+#ifdef SILC_DIST_INPLACE
+/* Print schedule statistics to stdout */
+
+void silc_schedule_stats(SilcSchedule schedule)
+{
+ SilcTaskFd ftask;
+ fprintf(stdout, "Schedule %p statistics:\n\n", schedule);
+ fprintf(stdout, "Num FD tasks : %d (%lu bytes allocated)\n",
+ silc_hash_table_count(schedule->fd_queue),
+ sizeof(*ftask) * silc_hash_table_count(schedule->fd_queue));
+ fprintf(stdout, "Num Timeout tasks : %d (%lu bytes allocated)\n",
+ silc_list_count(schedule->timeout_queue),
+ sizeof(struct SilcTaskTimeoutStruct) *
+ silc_list_count(schedule->timeout_queue));
+ fprintf(stdout, "Num Timeout freelist : %d (%lu bytes allocated)\n",
+ silc_list_count(schedule->free_tasks),
+ sizeof(struct SilcTaskTimeoutStruct) *
+ silc_list_count(schedule->free_tasks));
+}
+#endif /* SILC_DIST_INPLACE */
+
+/****************************** Public API **********************************/