X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fwin32%2Fsilcwin32schedule.c;h=32d345087cca5f4848741846d630ee8077fda68b;hb=40f8443d8d3a6577336ee66d18e04d9ac4d956bb;hp=f3bf02cc0f894d5ef98083bcd8baf7e8483917b2;hpb=a818c5b5411bbc4436d1c5f011236985c96bb787;p=silc.git diff --git a/lib/silcutil/win32/silcwin32schedule.c b/lib/silcutil/win32/silcwin32schedule.c index f3bf02cc..32d34508 100644 --- a/lib/silcutil/win32/silcwin32schedule.c +++ b/lib/silcutil/win32/silcwin32schedule.c @@ -4,13 +4,12 @@ Author: Pekka Riikonen - Copyright (C) 2001 Pekka Riikonen + Copyright (C) 2001 - 2005 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 - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - + the Free Software Foundation; version 2 of the License. + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the @@ -19,8 +18,7 @@ */ /* $Id$ */ -#include "silcincludes.h" -#include "silcschedule_i.h" +#include "silc.h" /* Our "select()" for WIN32. This mimics the behaviour of select() system call. It does not call the Winsock's select() though. Its functions @@ -41,7 +39,7 @@ References: o http://msdn.microsoft.com/library/default.asp? - url=/library/en-us/winui/hh/winui/messques_77zk.asp + url=/library/en-us/winui/hh/winui/messques_77zk.asp o http://msdn.microsoft.com/library/default.asp? url=/library/en-us/winsock/hh/winsock/apistart_9g1e.asp o http://msdn.microsoft.com/library/default.asp? @@ -50,38 +48,44 @@ */ -int silc_select(SilcScheduleFd fds, SilcUInt32 fds_count, struct timeval *timeout) +int silc_select(SilcSchedule schedule, void *context); { + SilcHashTableList htl; + SilcTaskFd task; HANDLE handles[MAXIMUM_WAIT_OBJECTS]; - DWORD ready, curtime, timeo; - int nhandles = 0, i; + DWORD ready, curtime; + LONG timeo; MSG msg; + int nhandles = 0, i, fd; - if (fds_count > MAXIMUM_WAIT_OBJECTS) - fds_count = MAXIMUM_WAIT_OBJECTS; - - for (i = 0; i < fds_count; i++) { - if (!fds[i].events) + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, (void **)&fd, (void **)&task)) { + if (!task->events) continue; + if (nhandles >= MAXIMUM_WAIT_OBJECTS) + break; - if (fds[i].events & SILC_TASK_READ) - handles[nhandles++] = (HANDLE)fds[i].fd; + if (task->events & SILC_TASK_READ) + handles[nhandles++] = (HANDLE)fd; /* If writing then just set the bit and return */ - if (fds[i].events & SILC_TASK_WRITE) { - fds[i].revents = SILC_TASK_WRITE; + if (task->events & SILC_TASK_WRITE) { + task->revents = SILC_TASK_WRITE; return 1; } - fds[i].revents = 0; + task->revents = 0; } + silc_hash_table_list_reset(&htl); - timeo = (timeout ? (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000) : - INFINITE); + timeo = (schedule->has_timeout ? ((schedule->timeout.tv_sec * 1000) + + (schedule->timeout.tv_usec / 1000)) + : INFINITE); /* If we have nothing to wait and timeout is set then register a timeout and wait just for windows messages. */ - if (nhandles == 0 && timeout) { + if (nhandles == 0 && schedule->has_timeout) { + SILC_SCHEDULE_UNLOCK(schedule); UINT timer = SetTimer(NULL, 0, timeo, NULL); curtime = GetTickCount(); while (timer) { @@ -90,26 +94,31 @@ int silc_select(SilcScheduleFd fds, SilcUInt32 fds_count, struct timeval *timeou while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (msg.message == WM_TIMER) { KillTimer(NULL, timer); + SILC_SCHEDULE_LOCK(schedule); return 0; } - TranslateMessage(&msg); - DispatchMessage(&msg); + TranslateMessage(&msg); + DispatchMessage(&msg); } KillTimer(NULL, timer); if (timeo != INFINITE) { timeo -= GetTickCount() - curtime; + curtime = GetTickCount(); if (timeo < 0) timeo = 0; } timer = SetTimer(NULL, 0, timeo, NULL); } + SILC_SCHEDULE_LOCK(schedule); } + SILC_SCHEDULE_UNLOCK(schedule); retry: curtime = GetTickCount(); - ready = MsgWaitForMultipleObjects(nhandles, handles, FALSE, timeo, + ready = MsgWaitForMultipleObjects(nhandles, handles, FALSE, timeo, QS_ALLINPUT); + SILC_SCHEDULE_LOCK(schedule); if (ready == WAIT_FAILED) { /* Wait failed with error */ @@ -128,15 +137,17 @@ int silc_select(SilcScheduleFd fds, SilcUInt32 fds_count, struct timeval *timeou creates a window then its main loop (and we're assuming that it is our SILC Scheduler) must handle the Windows messages, so do it here as the MSDN suggests. */ + SILC_SCHEDULE_UNLOCK(schedule); while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { - TranslateMessage(&msg); - DispatchMessage(&msg); + TranslateMessage(&msg); + DispatchMessage(&msg); } /* If timeout is set then we must update the timeout since we won't return and we will give the wait another try. */ if (timeo != INFINITE) { timeo -= GetTickCount() - curtime; + curtime = GetTickCount(); if (timeo < 0) timeo = 0; } @@ -148,24 +159,31 @@ int silc_select(SilcScheduleFd fds, SilcUInt32 fds_count, struct timeval *timeou /* Go through all fds even though only one was set. This is to avoid starvation of high numbered fds. */ + nhandles = silc_hash_table_count(schedule->fd_queue); ready -= WAIT_OBJECT_0; do { - for (i = 0; i < fds_count; i++) { - if (!fds[i].events) + i = 0; + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, (void **)&fd, (void **)&task)) { + if (!task->events) continue; - - if (fds[i].fd == (int)handles[ready]) { - fds[i].revents |= SILC_TASK_READ; + + if (fd == (int)handles[ready]) { + i++; + task->revents |= SILC_TASK_READ; break; } } + silc_hash_table_list_reset(&htl); /* Check the status of the next handle and set its fd to the fd set if data is available. */ - while (++ready < fds_count) + SILC_SCHEDULE_UNLOCK(schedule); + while (++ready < nhandles) if (WaitForSingleObject(handles[ready], 0) == WAIT_OBJECT_0) break; - } while (ready < fds_count); + SILC_SCHEDULE_LOCK(schedule); + } while (ready < nhandles); return i + 1; } @@ -188,19 +206,23 @@ SILC_TASK_CALLBACK(silc_schedule_wakeup_cb) #endif /* SILC_THREADS */ -/* Initializes the wakeup of the scheduler. In multi-threaded environment +/* Initializes the platform specific scheduler. This for example initializes + the wakeup mechanism of the scheduler. In multi-threaded environment the scheduler needs to be wakenup when tasks are added or removed from - the task queues. This will initialize the wakeup for the scheduler. - Any tasks that needs to be registered must be registered to the `queue'. - It is guaranteed that the scheduler will automatically free any - registered tasks in this queue. This is system specific routine. */ + the task queues. Returns context to the platform specific scheduler. */ -void *silc_schedule_wakeup_init(SilcSchedule schedule) +void *silc_schedule_internal_init(SilcSchedule schedule, void *app_context) { #ifdef SILC_THREADS SilcWin32Wakeup wakeup; +#endif + + schedule->max_tasks = MAXIMUM_WAIT_OBJECTS; +#ifdef SILC_THREADS wakeup = silc_calloc(1, sizeof(*wakeup)); + if (!wakeup) + return NULL; wakeup->wakeup_sema = CreateSemaphore(NULL, 0, 100, NULL); if (!wakeup->wakeup_sema) { @@ -208,11 +230,10 @@ void *silc_schedule_wakeup_init(SilcSchedule schedule) return NULL; } - wakeup->wakeup_task = + wakeup->wakeup_task = silc_schedule_task_add(schedule, (int)wakeup->wakeup_sema, silc_schedule_wakeup_cb, wakeup, - 0, 0, SILC_TASK_FD, - SILC_TASK_PRI_NORMAL); + 0, 0, SILC_TASK_FD); if (!wakeup->wakeup_task) { CloseHandle(wakeup->wakeup_sema); silc_free(wakeup); @@ -225,9 +246,9 @@ void *silc_schedule_wakeup_init(SilcSchedule schedule) #endif } -/* Uninitializes the system specific wakeup. */ +/* Uninitializes the platform specific scheduler context. */ -void silc_schedule_wakeup_uninit(void *context) +void silc_schedule_internal_uninit(SilcSchedule schedule, void *context) { #ifdef SILC_THREADS SilcWin32Wakeup wakeup = (SilcWin32Wakeup)context; @@ -242,7 +263,7 @@ void silc_schedule_wakeup_uninit(void *context) /* Wakes up the scheduler */ -void silc_schedule_wakeup_internal(void *context) +void silc_schedule_internal_wakeup(SilcSchedule schedule, void *context) { #ifdef SILC_THREADS SilcWin32Wakeup wakeup = (SilcWin32Wakeup)context; @@ -253,3 +274,72 @@ void silc_schedule_wakeup_internal(void *context) ReleaseSemaphore(wakeup->wakeup_sema, 1, NULL); #endif } + +/* Register signal */ + +void silc_schedule_internal_signal_register(SilcSchedule schedule, + void *context, + SilcUInt32 signal, + SilcTaskCallback callback, + void *callback_context) +{ + +} + +/* Unregister signal */ + +void silc_schedule_internal_signal_unregister(SilcSchedule schedule, + void *context, + SilcUInt32 signal, + SilcTaskCallback callback, + void *callback_context) +{ + +} + +/* Mark signal to be called later. */ + +void silc_schedule_internal_signal_call(SilcSchedule schedule, + void *context, SilcUInt32 signal) +{ + +} + +/* Call all signals */ + +void silc_schedule_internal_signals_call(SilcSchedule schedule, + void *context, + SilcSchedule schedule) +{ + +} + +/* Block registered signals in scheduler. */ + +void silc_schedule_internal_signals_block(SilcSchedule schedule, + void *context) +{ + +} + +/* Unblock registered signals in schedule. */ + +void silc_schedule_internal_signals_unblock(SilcSchedule schedule, + void *context) +{ + +} + +const SilcScheduleOps schedule_ops = +{ + silc_schedule_internal_init, + silc_schedule_internal_uninit, + silc_select, + silc_schedule_internal_wakeup, + silc_schedule_internal_signal_register, + silc_schedule_internal_signal_unregister, + silc_schedule_internal_signal_call, + silc_schedule_internal_signals_call, + silc_schedule_internal_signals_block, + silc_schedule_internal_signals_unblock, +};