X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fsilcschedule.c;h=53cb0aa7426f22eb883c7fc5ee73fc427a9db48f;hb=52e57c880aba9c5e89f59d962eb9af75670b76e0;hp=c7ce66dcc190ef795fbfb96ebc93db1c18476345;hpb=c27a4ecc3e616e8a5ee09b8ca888ed6ff3e501f7;p=silc.git diff --git a/lib/silcutil/silcschedule.c b/lib/silcutil/silcschedule.c index c7ce66dc..53cb0aa7 100644 --- a/lib/silcutil/silcschedule.c +++ b/lib/silcutil/silcschedule.c @@ -4,7 +4,7 @@ Author: Pekka Riikonen - Copyright (C) 1998 - 2005 Pekka Riikonen + Copyright (C) 1998 - 2007 Pekka Riikonen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -18,7 +18,9 @@ */ /* $Id$ */ -#include "silcincludes.h" +#include "silc.h" + +/************************** Types and definitions ***************************/ /* Platform specific implementation */ extern const SilcScheduleOps schedule_ops; @@ -28,6 +30,9 @@ static void silc_schedule_dispatch_fd(SilcSchedule schedule); static void silc_schedule_dispatch_timeout(SilcSchedule schedule, SilcBool dispatch_all); + +/************************ Static utility functions **************************/ + /* Fd task hash table destructor */ static void silc_schedule_fd_destructor(void *key, void *context, @@ -36,135 +41,38 @@ static void silc_schedule_fd_destructor(void *key, void *context, silc_free(context); } -/* Initializes the scheduler. This returns the scheduler context that - is given as arugment usually to all silc_schedule_* functions. - The `max_tasks' indicates the number of maximum tasks that the - scheduler can handle. The `app_context' is application specific - context that is delivered to task callbacks. */ - -SilcSchedule silc_schedule_init(int max_tasks, void *app_context) -{ - SilcSchedule schedule; - - SILC_LOG_DEBUG(("Initializing scheduler")); - - schedule = silc_calloc(1, sizeof(*schedule)); - if (!schedule) - return NULL; - - schedule->fd_queue = - silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL, - silc_schedule_fd_destructor, NULL, TRUE); - if (!schedule->fd_queue) - return NULL; - - silc_list_init(schedule->timeout_queue, struct SilcTaskTimeoutStruct, next); - - schedule->app_context = app_context; - schedule->valid = TRUE; - schedule->max_tasks = max_tasks; - - /* Allocate scheduler lock */ - silc_mutex_alloc(&schedule->lock); - - /* Initialize the platform specific scheduler. */ - schedule->internal = schedule_ops.init(schedule, app_context); - - return schedule; -} - -/* Uninitializes the schedule. This is called when the program is ready - to end. This removes all tasks and task queues. Returns FALSE if the - scheduler could not be uninitialized. This happens when the scheduler - is still valid and silc_schedule_stop has not been called. */ - -SilcBool silc_schedule_uninit(SilcSchedule schedule) -{ - SILC_LOG_DEBUG(("Uninitializing scheduler")); - - if (schedule->valid == TRUE) - return FALSE; - - /* Dispatch all timeouts before going away */ - SILC_SCHEDULE_LOCK(schedule); - silc_schedule_dispatch_timeout(schedule, TRUE); - SILC_SCHEDULE_UNLOCK(schedule); - - /* Deliver signals before going away */ - if (schedule->signal_tasks) { - schedule_ops.signals_call(schedule, schedule->internal); - schedule->signal_tasks = FALSE; - } - - /* Unregister all tasks */ - silc_schedule_task_remove(schedule, SILC_ALL_TASKS); - silc_schedule_task_remove(schedule, SILC_ALL_TASKS); - - /* Unregister all task queues */ - silc_hash_table_free(schedule->fd_queue); - - /* Uninit the platform specific scheduler. */ - schedule_ops.uninit(schedule, schedule->internal); - - silc_mutex_free(schedule->lock); - silc_free(schedule); - - return TRUE; -} - -/* Stops the schedule even if it is not supposed to be stopped yet. - After calling this, one should call silc_schedule_uninit (after the - silc_schedule has returned). */ - -void silc_schedule_stop(SilcSchedule schedule) -{ - SILC_LOG_DEBUG(("Stopping scheduler")); - SILC_SCHEDULE_LOCK(schedule); - schedule->valid = FALSE; - SILC_SCHEDULE_UNLOCK(schedule); -} - /* Executes file descriptor tasks. Invalid tasks are removed here. */ static void silc_schedule_dispatch_fd(SilcSchedule schedule) { - SilcHashTableList htl; - SilcTask t; SilcTaskFd task; - SilcUInt32 fd; + SilcTask t; - silc_hash_table_list(schedule->fd_queue, &htl); - while (silc_hash_table_get(&htl, (void **)&fd, (void **)&task)) { + /* The dispatch list includes only valid tasks, and tasks that have + something to dispatch. Dispatching is atomic; no matter if another + thread invalidates a task when we unlock, we dispatch to completion. */ + SILC_SCHEDULE_UNLOCK(schedule); + silc_list_start(schedule->fd_dispatch); + while ((task = silc_list_get(schedule->fd_dispatch))) { t = (SilcTask)task; - if (!t->valid) { - silc_schedule_task_remove(schedule, t); - continue; - } - if (!task->events || !task->revents) - continue; - /* Is the task ready for reading */ - if (task->revents & SILC_TASK_READ) { - SILC_SCHEDULE_UNLOCK(schedule); + if (task->revents & SILC_TASK_READ) t->callback(schedule, schedule->app_context, SILC_TASK_READ, task->fd, t->context); - SILC_SCHEDULE_LOCK(schedule); - } /* Is the task ready for writing */ - if (t->valid && task->revents & SILC_TASK_WRITE) { - SILC_SCHEDULE_UNLOCK(schedule); + if (t->valid && task->revents & SILC_TASK_WRITE) t->callback(schedule, schedule->app_context, SILC_TASK_WRITE, task->fd, t->context); - SILC_SCHEDULE_LOCK(schedule); - } - - /* Remove if task was invalidated in the task callback */ - if (!t->valid) - silc_schedule_task_remove(schedule, t); } - silc_hash_table_list_reset(&htl); + SILC_SCHEDULE_LOCK(schedule); + + /* Remove invalidated tasks */ + silc_list_start(schedule->fd_dispatch); + while ((task = silc_list_get(schedule->fd_dispatch))) + if (silc_unlikely(!task->header.valid)) + silc_schedule_task_remove(schedule, (SilcTask)task); } /* Executes all tasks whose timeout has expired. The task is removed from @@ -185,30 +93,35 @@ static void silc_schedule_dispatch_timeout(SilcSchedule schedule, /* First task in the task queue has always the earliest timeout. */ silc_list_start(schedule->timeout_queue); - while ((task = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) { + task = silc_list_get(schedule->timeout_queue); + if (silc_unlikely(!task)) + return; + do { t = (SilcTask)task; /* Remove invalid task */ - if (!t->valid) { + if (silc_unlikely(!t->valid)) { silc_schedule_task_remove(schedule, t); continue; } /* Execute the task if the timeout has expired */ - if (dispatch_all || silc_compare_timeval(&task->timeout, &curtime)) { - SILC_SCHEDULE_UNLOCK(schedule); - t->callback(schedule, schedule->app_context, SILC_TASK_EXPIRE, 0, - t->context); - SILC_SCHEDULE_LOCK(schedule); + if (silc_compare_timeval(&task->timeout, &curtime) > 0 && !dispatch_all) + break; - /* Remove the expired task */ - silc_schedule_task_remove(schedule, t); + t->valid = FALSE; + SILC_SCHEDULE_UNLOCK(schedule); + t->callback(schedule, schedule->app_context, SILC_TASK_EXPIRE, 0, + t->context); + SILC_SCHEDULE_LOCK(schedule); - /* Balance when we have lots of small timeouts */ - if ((++count) > 50) - break; - } - } + /* 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 @@ -228,20 +141,23 @@ static void silc_schedule_select_timeout(SilcSchedule schedule) /* First task in the task queue has always the earliest timeout. */ silc_list_start(schedule->timeout_queue); - while ((task = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) { + task = silc_list_get(schedule->timeout_queue); + if (silc_unlikely(!task)) + return; + do { t = (SilcTask)task; /* Remove invalid task */ - if (!t->valid) { + 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) && dispatch) { + if (silc_compare_timeval(&task->timeout, &curtime) <= 0 && dispatch) { silc_schedule_dispatch_timeout(schedule, FALSE); - if (!schedule->valid) + if (silc_unlikely(!schedule->valid)) return; /* Start selecting new timeout again after dispatch */ @@ -263,9 +179,8 @@ static void silc_schedule_select_timeout(SilcSchedule schedule) curtime.tv_sec = 0; curtime.tv_usec += 1000000L; } - break; - } + } while ((task = silc_list_get(schedule->timeout_queue))); /* Save the timeout */ if (task) { @@ -276,107 +191,335 @@ static void silc_schedule_select_timeout(SilcSchedule schedule) } } -/* Runs the scheduler once and then returns. */ +/* Removes task from the scheduler. This must be called with scheduler + locked. */ -SilcBool silc_schedule_one(SilcSchedule schedule, int timeout_usecs) +static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task) { - struct timeval timeout; - int ret; + SilcTaskFd ftask; - SILC_LOG_DEBUG(("In scheduler loop")); + if (silc_unlikely(task == SILC_ALL_TASKS)) { + SilcTask task; + SilcHashTableList htl; + SilcUInt32 fd; - if (!schedule->is_locked) - SILC_SCHEDULE_LOCK(schedule); + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, (void *)&fd, (void *)&task)) + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(fd)); + silc_hash_table_list_reset(&htl); - /* Deliver signals if any has been set to be called */ - if (schedule->signal_tasks) { + /* 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); + } + + return; + } + + if (silc_likely(task->type == 1)) { + /* Delete from timeout queue */ + silc_list_del(schedule->timeout_queue, task); + + /* Put to free list */ + silc_list_add(schedule->free_tasks, task); + } else { + /* Delete from fd queue */ + ftask = (SilcTaskFd)task; + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd)); + } +} + +/* 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); - schedule_ops.signals_call(schedule, schedule->internal); - schedule->signal_tasks = FALSE; - SILC_SCHEDULE_LOCK(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; } - /* Check if scheduler is valid */ - if (schedule->valid == FALSE) { - SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); - if (!schedule->is_locked) - SILC_SCHEDULE_UNLOCK(schedule); - return FALSE; + 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); - /* Calculate next timeout for silc_select(). This is the timeout value - when at earliest some of the timeout tasks expire. This may dispatch - already expired timeouts. */ - silc_schedule_select_timeout(schedule); + SILC_SCHEDULE_UNLOCK(schedule); - /* Check if scheduler is valid */ - if (schedule->valid == FALSE) { - SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); - if (!schedule->is_locked) - SILC_SCHEDULE_UNLOCK(schedule); - return FALSE; + 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 : %lu (%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 (%d bytes allocated)\n", + silc_list_count(schedule->timeout_queue), + sizeof(struct SilcTaskTimeoutStruct) * + silc_list_count(schedule->timeout_queue)); + fprintf(stdout, "Num Timeout freelist : %d (%d bytes allocated)\n", + silc_list_count(schedule->free_tasks), + sizeof(struct SilcTaskTimeoutStruct) * + silc_list_count(schedule->free_tasks)); +} +#endif /* SILC_DIST_INPLACE */ + +/****************************** Public API **********************************/ + +/* Initializes the scheduler. This returns the scheduler context that + is given as arugment usually to all silc_schedule_* functions. + The `max_tasks' indicates the number of maximum tasks that the + scheduler can handle. The `app_context' is application specific + context that is delivered to task callbacks. */ + +SilcSchedule silc_schedule_init(int max_tasks, void *app_context) +{ + SilcSchedule schedule; + + SILC_LOG_DEBUG(("Initializing scheduler")); + + schedule = silc_calloc(1, sizeof(*schedule)); + if (!schedule) + return NULL; + + schedule->fd_queue = + silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL, + silc_schedule_fd_destructor, NULL, TRUE); + if (!schedule->fd_queue) { + silc_free(schedule); + return NULL; } - if (timeout_usecs >= 0) { - timeout.tv_sec = 0; - timeout.tv_usec = timeout_usecs; - schedule->timeout = timeout; - schedule->has_timeout = TRUE; + silc_list_init(schedule->timeout_queue, struct SilcTaskStruct, next); + silc_list_init(schedule->free_tasks, struct SilcTaskStruct, next); + + schedule->app_context = app_context; + schedule->valid = TRUE; + schedule->max_tasks = max_tasks; + + /* Allocate scheduler lock */ + silc_mutex_alloc(&schedule->lock); + + /* Initialize the platform specific scheduler. */ + schedule->internal = schedule_ops.init(schedule, app_context); + if (!schedule->internal) { + silc_hash_table_free(schedule->fd_queue); + silc_mutex_free(schedule->lock); + silc_free(schedule); + return NULL; } - /* This is the main silc_select(). The program blocks here until some - of the selected file descriptors change status or the selected - timeout expires. */ - SILC_LOG_DEBUG(("Select")); - ret = schedule_ops.select(schedule, schedule->internal); + /* Timeout freelist garbage collection */ + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); - switch (ret) { - case -1: - /* Error */ - if (errno == EINTR) - break; - SILC_LOG_ERROR(("Error in select(): %s", strerror(errno))); - break; - case 0: - /* Timeout */ - SILC_LOG_DEBUG(("Running timeout tasks")); - silc_schedule_dispatch_timeout(schedule, FALSE); - break; - default: - /* There is some data available now */ - SILC_LOG_DEBUG(("Running fd tasks")); - silc_schedule_dispatch_fd(schedule); - break; + return schedule; +} + +/* Uninitializes the schedule. This is called when the program is ready + to end. This removes all tasks and task queues. Returns FALSE if the + scheduler could not be uninitialized. This happens when the scheduler + is still valid and silc_schedule_stop has not been called. */ + +SilcBool silc_schedule_uninit(SilcSchedule schedule) +{ + SilcTask task; + + SILC_LOG_DEBUG(("Uninitializing scheduler")); + + if (schedule->valid == TRUE) + return FALSE; + + /* Dispatch all timeouts before going away */ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_dispatch_timeout(schedule, TRUE); + SILC_SCHEDULE_UNLOCK(schedule); + + /* Deliver signals before going away */ + if (schedule->signal_tasks) { + schedule_ops.signals_call(schedule, schedule->internal); + schedule->signal_tasks = FALSE; } - if (!schedule->is_locked) - SILC_SCHEDULE_UNLOCK(schedule); + /* Unregister all tasks */ + silc_schedule_task_del(schedule, SILC_ALL_TASKS); + silc_schedule_task_remove(schedule, SILC_ALL_TASKS); + + /* Delete timeout task freelist */ + silc_list_start(schedule->free_tasks); + while ((task = silc_list_get(schedule->free_tasks))) + silc_free(task); + + /* Unregister all task queues */ + silc_hash_table_free(schedule->fd_queue); + + /* Uninit the platform specific scheduler. */ + schedule_ops.uninit(schedule, schedule->internal); + + silc_mutex_free(schedule->lock); + silc_free(schedule); return TRUE; } -/* The SILC scheduler. This is actually the main routine in SILC programs. - When this returns the program is to be ended. Before this function can - be called, one must call silc_schedule_init function. */ +/* Stops the schedule even if it is not supposed to be stopped yet. + After calling this, one should call silc_schedule_uninit (after the + silc_schedule has returned). */ -void silc_schedule(SilcSchedule schedule) +void silc_schedule_stop(SilcSchedule schedule) { - SILC_LOG_DEBUG(("Running scheduler")); + SILC_LOG_DEBUG(("Stopping scheduler")); + SILC_SCHEDULE_LOCK(schedule); + schedule->valid = FALSE; + SILC_SCHEDULE_UNLOCK(schedule); +} - if (schedule->valid == FALSE) { - SILC_LOG_ERROR(("Scheduler is not valid, stopping")); - return; - } +/* Runs the scheduler once and then returns. Must be called locked. */ + +static SilcBool silc_schedule_iterate(SilcSchedule schedule, int timeout_usecs) +{ + struct timeval timeout; + int ret; + + do { + SILC_LOG_DEBUG(("In scheduler loop")); + + /* Deliver signals if any has been set to be called */ + if (silc_unlikely(schedule->signal_tasks)) { + SILC_SCHEDULE_UNLOCK(schedule); + schedule_ops.signals_call(schedule, schedule->internal); + schedule->signal_tasks = FALSE; + SILC_SCHEDULE_LOCK(schedule); + } + + /* Check if scheduler is valid */ + if (silc_unlikely(schedule->valid == FALSE)) { + SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); + return FALSE; + } + + /* Calculate next timeout for silc_select(). This is the timeout value + when at earliest some of the timeout tasks expire. This may dispatch + already expired timeouts. */ + silc_schedule_select_timeout(schedule); + + /* Check if scheduler is valid */ + if (silc_unlikely(schedule->valid == FALSE)) { + SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); + return FALSE; + } + + if (timeout_usecs >= 0) { + timeout.tv_sec = 0; + timeout.tv_usec = timeout_usecs; + schedule->timeout = timeout; + schedule->has_timeout = TRUE; + } + + /* This is the main silc_select(). The program blocks here until some + of the selected file descriptors change status or the selected + timeout expires. */ + SILC_LOG_DEBUG(("Select")); + ret = schedule_ops.schedule(schedule, schedule->internal); + + if (silc_likely(ret == 0)) { + /* Timeout */ + SILC_LOG_DEBUG(("Running timeout tasks")); + if (silc_likely(silc_list_count(schedule->timeout_queue))) + silc_schedule_dispatch_timeout(schedule, FALSE); + continue; + + } else if (silc_likely(ret > 0)) { + /* There is some data available now */ + SILC_LOG_DEBUG(("Running fd tasks")); + silc_schedule_dispatch_fd(schedule); + + /* If timeout was very short, dispatch also timeout tasks */ + if (schedule->has_timeout && schedule->timeout.tv_sec == 0 && + schedule->timeout.tv_usec < 50000) + silc_schedule_dispatch_timeout(schedule, FALSE); + continue; + + } else { + /* Error or special case handling */ + if (errno == EINTR) + continue; + if (ret == -2) + break; + + SILC_LOG_ERROR(("Error in select()/poll(): %s", strerror(errno))); + continue; + } + } while (timeout_usecs == -1); + + return TRUE; +} +/* Runs the scheduler once and then returns. */ + +SilcBool silc_schedule_one(SilcSchedule schedule, int timeout_usecs) +{ + SilcBool ret; SILC_SCHEDULE_LOCK(schedule); - schedule->is_locked = TRUE; + ret = silc_schedule_iterate(schedule, timeout_usecs); + SILC_SCHEDULE_UNLOCK(schedule); + return ret; +} - /* Start the scheduler loop */ - while (silc_schedule_one(schedule, -1)) - ; +/* Runs the scheduler and blocks here. When this returns the scheduler + has ended. */ +#ifndef SILC_SYMBIAN +void silc_schedule(SilcSchedule schedule) +{ + SILC_LOG_DEBUG(("Running scheduler")); + + /* Start the scheduler loop */ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_iterate(schedule, -1); SILC_SCHEDULE_UNLOCK(schedule); } +#endif /* !SILC_SYMBIAN */ /* Wakes up the scheduler. This is used only in multi-threaded environments where threads may add new tasks or remove old tasks @@ -405,6 +548,15 @@ void *silc_schedule_get_context(SilcSchedule schedule) return schedule->app_context; } +/* Set notify callback */ + +void silc_schedule_set_notify(SilcSchedule schedule, + SilcTaskNotifyCb notify, void *context) +{ + schedule->notify = notify; + schedule->notify_context = context; +} + /* Add new task to the scheduler */ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, @@ -414,17 +566,23 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, { SilcTask task = NULL; - if (!schedule->valid) + if (silc_unlikely(!schedule->valid)) return NULL; SILC_SCHEDULE_LOCK(schedule); - if (type == SILC_TASK_TIMEOUT) { - SilcTaskTimeout tmp, prev, ttask = silc_calloc(1, sizeof(*ttask)); - if (!ttask) - goto out; + if (silc_likely(type == SILC_TASK_TIMEOUT)) { + SilcTaskTimeout tmp, prev, ttask; + SilcList list; - SILC_LOG_DEBUG(("Registering new timeout task %p", ttask)); + silc_list_start(schedule->free_tasks); + ttask = silc_list_get(schedule->free_tasks); + if (silc_unlikely(!ttask)) { + ttask = silc_calloc(1, sizeof(*ttask)); + if (silc_unlikely(!ttask)) + goto out; + } else + silc_list_del(schedule->free_tasks, ttask); ttask->header.type = 1; ttask->header.callback = callback; @@ -432,23 +590,27 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, ttask->header.valid = TRUE; /* Add timeout */ + silc_gettimeofday(&ttask->timeout); if ((seconds + useconds) > 0) { - silc_gettimeofday(&ttask->timeout); ttask->timeout.tv_sec += seconds + (useconds / 1000000L); ttask->timeout.tv_usec += (useconds % 1000000L); - if (ttask->timeout.tv_usec > 999999L) { + if (ttask->timeout.tv_usec >= 1000000L) { ttask->timeout.tv_sec += 1; ttask->timeout.tv_usec -= 1000000L; } } + SILC_LOG_DEBUG(("New timeout task %p: sec=%d, usec=%d", ttask, + seconds, useconds)); + /* Add task to correct spot so that the first task in the list has the earliest timeout. */ - silc_list_start(schedule->timeout_queue); + list = schedule->timeout_queue; + silc_list_start(list); prev = NULL; - while ((tmp = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) { + while ((tmp = silc_list_get(list)) != SILC_LIST_END) { /* If we have shorter timeout, we have found our spot */ - if (silc_compare_timeval(&ttask->timeout, &tmp->timeout)) { + if (silc_compare_timeval(&ttask->timeout, &tmp->timeout) < 0) { silc_list_insert(schedule->timeout_queue, prev, ttask); break; } @@ -458,24 +620,42 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, silc_list_add(schedule->timeout_queue, ttask); task = (SilcTask)ttask; - } else { + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, TRUE, task, FALSE, 0, 0, seconds, useconds, + schedule->notify_context); + + } else if (silc_likely(type == SILC_TASK_FD)) { + SilcTaskFd ftask; + /* Check if fd is already added */ - if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), - NULL, NULL)) - goto out; + if (silc_unlikely(silc_hash_table_find(schedule->fd_queue, + SILC_32_TO_PTR(fd), + NULL, (void *)&task))) { + if (task->valid) + goto out; + + /* Remove invalid task. We must have unique fd key to hash table. */ + silc_schedule_task_remove(schedule, task); + } /* Check max tasks */ - if (schedule->max_tasks > 0 && - silc_hash_table_count(schedule->fd_queue) >= schedule->max_tasks) { + if (silc_unlikely(schedule->max_tasks > 0 && + silc_hash_table_count(schedule->fd_queue) >= + schedule->max_tasks)) { SILC_LOG_WARNING(("Scheduler task limit reached: cannot add new task")); + task = NULL; goto out; } - SilcTaskFd ftask = silc_calloc(1, sizeof(*ftask)); - if (!ftask) + ftask = silc_calloc(1, sizeof(*ftask)); + if (silc_unlikely(!ftask)) { + task = NULL; goto out; + } - SILC_LOG_DEBUG(("Registering new fd task %p fd=%d", ftask, fd)); + SILC_LOG_DEBUG(("New fd task %p fd=%d", ftask, fd)); ftask->header.type = 0; ftask->header.callback = callback; @@ -484,23 +664,52 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, ftask->events = SILC_TASK_READ; ftask->fd = fd; - /* Add task */ - silc_hash_table_add(schedule->fd_queue, SILC_32_TO_PTR(fd), ftask); + /* Add task and schedule it */ + if (!silc_hash_table_add(schedule->fd_queue, SILC_32_TO_PTR(fd), ftask)) { + silc_free(ftask); + task = NULL; + goto out; + } + if (!schedule_ops.schedule_fd(schedule, schedule->internal, + ftask, ftask->events)) { + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(fd)); + task = NULL; + goto out; + } task = (SilcTask)ftask; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, TRUE, task, TRUE, ftask->fd, + SILC_TASK_READ, 0, 0, schedule->notify_context); + + } else if (silc_unlikely(type == SILC_TASK_SIGNAL)) { + SILC_SCHEDULE_UNLOCK(schedule); + schedule_ops.signal_register(schedule, schedule->internal, fd, + callback, context); + return NULL; } out: SILC_SCHEDULE_UNLOCK(schedule); + +#ifdef SILC_SYMBIAN + /* On symbian we wakeup scheduler immediately after adding timeout task + in case the task is added outside the scheduler loop (in some active + object). */ + if (task && task->type == 1) + silc_schedule_wakeup(schedule); +#endif /* SILC_SYMBIAN */ + return task; } /* Invalidates task */ -void silc_schedule_task_del(SilcSchedule schedule, SilcTask task) +SilcBool silc_schedule_task_del(SilcSchedule schedule, SilcTask task) { - if (task == SILC_ALL_TASKS) { - SilcTask task; + if (silc_unlikely(task == SILC_ALL_TASKS)) { SilcHashTableList htl; SILC_LOG_DEBUG(("Unregister all tasks")); @@ -509,51 +718,90 @@ void silc_schedule_task_del(SilcSchedule schedule, SilcTask task) /* Delete from fd queue */ silc_hash_table_list(schedule->fd_queue, &htl); - while (silc_hash_table_get(&htl, NULL, (void **)&task)) + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, + ((SilcTaskFd)task)->fd, 0, 0, 0, + schedule->notify_context); + } silc_hash_table_list_reset(&htl); /* Delete from timeout queue */ silc_list_start(schedule->timeout_queue); - while ((task = (SilcTask)silc_list_get(schedule->timeout_queue)) - != SILC_LIST_END) + while ((task = (SilcTask)silc_list_get(schedule->timeout_queue))) { task->valid = FALSE; + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + } + SILC_SCHEDULE_UNLOCK(schedule); - return; + return TRUE; } SILC_LOG_DEBUG(("Unregistering task %p", task)); SILC_SCHEDULE_LOCK(schedule); task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, !task->type, 0, 0, 0, 0, + schedule->notify_context); SILC_SCHEDULE_UNLOCK(schedule); + + return TRUE; } /* Invalidate task by fd */ -void silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd) +SilcBool silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd) { - SilcTask task; + SilcTask task = NULL; + SilcBool ret = FALSE; SILC_LOG_DEBUG(("Unregister task by fd %d", fd)); SILC_SCHEDULE_LOCK(schedule); /* fd is unique, so there is only one task with this fd in the table */ - if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), NULL, - (void **)&task)) + if (silc_likely(silc_hash_table_find(schedule->fd_queue, + SILC_32_TO_PTR(fd), NULL, + (void *)&task))) { + SILC_LOG_DEBUG(("Deleting task %p", task)); task->valid = FALSE; + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, fd, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } + SILC_SCHEDULE_UNLOCK(schedule); + + /* If it is signal, remove it */ + if (silc_unlikely(!task)) { + schedule_ops.signal_unregister(schedule, schedule->internal, fd); + ret = TRUE; + } + + return ret; } /* Invalidate task by task callback. */ -void silc_schedule_task_del_by_callback(SilcSchedule schedule, - SilcTaskCallback callback) +SilcBool silc_schedule_task_del_by_callback(SilcSchedule schedule, + SilcTaskCallback callback) { SilcTask task; SilcHashTableList htl; + SilcList list; + SilcBool ret = FALSE; SILC_LOG_DEBUG(("Unregister task by callback")); @@ -561,29 +809,49 @@ void silc_schedule_task_del_by_callback(SilcSchedule schedule, /* Delete from fd queue */ silc_hash_table_list(schedule->fd_queue, &htl); - while (silc_hash_table_get(&htl, NULL, (void **)&task)) { - if (task->callback == callback) + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { + if (task->callback == callback) { task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, + ((SilcTaskFd)task)->fd, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } } silc_hash_table_list_reset(&htl); /* Delete from timeout queue */ - silc_list_start(schedule->timeout_queue); - while ((task = (SilcTask)silc_list_get(schedule->timeout_queue)) - != SILC_LIST_END) { - if (task->callback == callback) + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->callback == callback) { task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } } SILC_SCHEDULE_UNLOCK(schedule); + + return ret; } /* Invalidate task by context. */ -void silc_schedule_task_del_by_context(SilcSchedule schedule, void *context) +SilcBool silc_schedule_task_del_by_context(SilcSchedule schedule, + void *context) { SilcTask task; SilcHashTableList htl; + SilcList list; + SilcBool ret = FALSE; SILC_LOG_DEBUG(("Unregister task by context")); @@ -591,154 +859,139 @@ void silc_schedule_task_del_by_context(SilcSchedule schedule, void *context) /* Delete from fd queue */ silc_hash_table_list(schedule->fd_queue, &htl); - while (silc_hash_table_get(&htl, NULL, (void **)&task)) { - if (task->context == context) + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { + if (task->context == context) { task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, + ((SilcTaskFd)task)->fd, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } } silc_hash_table_list_reset(&htl); /* Delete from timeout queue */ - silc_list_start(schedule->timeout_queue); - while ((task = (SilcTask)silc_list_get(schedule->timeout_queue)) - != SILC_LIST_END) { - if (task->context == context) + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->context == context) { task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } } SILC_SCHEDULE_UNLOCK(schedule); + + return ret; } /* Invalidate task by all */ -void silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, - SilcTaskCallback callback, void *context) +SilcBool silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, + SilcTaskCallback callback, + void *context) { SilcTask task; + SilcList list; + SilcBool ret = FALSE; SILC_LOG_DEBUG(("Unregister task by fd, callback and context")); /* For fd task, callback and context is irrelevant as fd is unique */ if (fd) - silc_schedule_task_del_by_fd(schedule, fd); + return silc_schedule_task_del_by_fd(schedule, fd); SILC_SCHEDULE_LOCK(schedule); /* Delete from timeout queue */ - silc_list_start(schedule->timeout_queue); - while ((task = (SilcTask)silc_list_get(schedule->timeout_queue)) - != SILC_LIST_END) { - if (task->callback == callback && task->context == context) + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->callback == callback && task->context == context) { task->valid = FALSE; - } - - SILC_SCHEDULE_UNLOCK(schedule); -} - -/* Removes task from the scheduler. This must be called with scheduler - locked. */ - -static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task) -{ - SilcTaskFd ftask; - SilcTaskTimeout ttask; - - if (task == SILC_ALL_TASKS) { - SilcTask task; - SilcHashTableList htl; - SilcUInt32 fd; - - /* Delete from fd queue */ - silc_hash_table_list(schedule->fd_queue, &htl); - while (silc_hash_table_get(&htl, (void **)&fd, (void **)&task)) - silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(fd)); - silc_hash_table_list_reset(&htl); - /* Delete from timeout queue */ - silc_list_start(schedule->timeout_queue); - while ((task = (SilcTask)silc_list_get(schedule->timeout_queue)) - != SILC_LIST_END) { - silc_list_del(schedule->timeout_queue, task); - silc_free(task); + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + ret = TRUE; } - - return; } - /* Delete from timeout queue */ - if (task->type == 1) { - silc_list_start(schedule->timeout_queue); - while ((ttask = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) { - if (ttask == (SilcTaskTimeout)task) { - silc_list_del(schedule->timeout_queue, ttask); - silc_free(ttask); - break; - } - } - - return; - } + SILC_SCHEDULE_UNLOCK(schedule); - /* Delete from fd queue */ - ftask = (SilcTaskFd)task; - silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd)); + return TRUE; } /* Sets a file descriptor to be listened by scheduler. One can call this directly if wanted. This can be called multiple times for one file descriptor to set different iomasks. */ -void silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, - SilcTaskEvent mask, SilcBool send_events) +SilcBool silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskEvent mask, SilcBool send_events) { SilcTaskFd task; - if (!schedule->valid) - return; + if (silc_unlikely(!schedule->valid)) + return FALSE; SILC_SCHEDULE_LOCK(schedule); if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), - NULL, (void **)&task)) { + NULL, (void *)&task)) { + if (!schedule_ops.schedule_fd(schedule, schedule->internal, task, mask)) { + SILC_SCHEDULE_UNLOCK(schedule); + return FALSE; + } task->events = mask; - if (send_events) { + if (silc_unlikely(send_events) && mask) { task->revents = mask; silc_schedule_dispatch_fd(schedule); } + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, TRUE, (SilcTask)task, + TRUE, task->fd, mask, 0, 0, + schedule->notify_context); } SILC_SCHEDULE_UNLOCK(schedule); -} -/* Removes a file descriptor from listen list. */ - -void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd) -{ - silc_schedule_set_listen_fd(schedule, fd, 0, FALSE); + return TRUE; } -/* Register a new signal */ +/* Returns the file descriptor's current requested event mask. */ -void silc_schedule_signal_register(SilcSchedule schedule, SilcUInt32 signal, - SilcTaskCallback callback, void *context) +SilcTaskEvent silc_schedule_get_fd_events(SilcSchedule schedule, + SilcUInt32 fd) { - schedule_ops.signal_register(schedule, schedule->internal, signal, - callback, context); -} + SilcTaskFd task; + SilcTaskEvent event = 0; -/* Unregister a new signal */ + if (silc_unlikely(!schedule->valid)) + return 0; -void silc_schedule_signal_unregister(SilcSchedule schedule, SilcUInt32 signal, - SilcTaskCallback callback, void *context) -{ - schedule_ops.signal_unregister(schedule, schedule->internal, signal, - callback, context); + SILC_SCHEDULE_LOCK(schedule); + if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), + NULL, (void *)&task)) + event = task->events; + SILC_SCHEDULE_UNLOCK(schedule); + + return event; } -/* Call signal indicated by `signal'. */ +/* Removes a file descriptor from listen list. */ -void silc_schedule_signal_call(SilcSchedule schedule, SilcUInt32 signal) +void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd) { - /* Mark that signals needs to be delivered later. */ - schedule_ops.signal_call(schedule, schedule->internal, signal); - schedule->signal_tasks = TRUE; + silc_schedule_set_listen_fd(schedule, fd, 0, FALSE); }