--- libaitsched/src/aitsched.c 2012/01/08 03:28:26 1.4.2.3 +++ libaitsched/src/aitsched.c 2012/05/31 22:31:48 1.10 @@ -3,7 +3,7 @@ * by Michael Pounov * * $Author: misho $ -* $Id: aitsched.c,v 1.4.2.3 2012/01/08 03:28:26 misho Exp $ +* $Id: aitsched.c,v 1.10 2012/05/31 22:31:48 misho Exp $ * ************************************************************************** The ELWIX and AITNET software is distributed under the following @@ -12,7 +12,7 @@ terms: All of the documentation and software included in the ELWIX and AITNET Releases is copyrighted by ELWIX - Sofia/Bulgaria -Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 +Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 by Michael Pounov . All rights reserved. Redistribution and use in source and binary forms, with or without @@ -86,14 +86,14 @@ sched_SetErr(int eno, char *estr, ...) /* * schedRegisterHooks() - Register IO handles and bind tasks to it + * * @root = root task * return: -1 error or 0 ok */ int schedRegisterHooks(sched_root_task_t * __restrict root) { - if (!root || (root->root_data.iov_base && root->root_data.iov_len)) - return -1; + assert(root); if (root->root_hooks.hook_root.fini) root->root_hooks.hook_root.fini(root, NULL); @@ -101,6 +101,13 @@ schedRegisterHooks(sched_root_task_t * __restrict root root->root_hooks.hook_add.read = sched_hook_read; root->root_hooks.hook_add.write = sched_hook_write; + root->root_hooks.hook_add.alarm = sched_hook_alarm; + root->root_hooks.hook_add.node = sched_hook_node; + root->root_hooks.hook_add.proc = sched_hook_proc; + root->root_hooks.hook_add.signal = sched_hook_signal; +#ifdef EVFILT_USER + root->root_hooks.hook_add.user = sched_hook_user; +#endif root->root_hooks.hook_exec.cancel = sched_hook_cancel; root->root_hooks.hook_exec.fetch = sched_hook_fetch; @@ -113,6 +120,7 @@ schedRegisterHooks(sched_root_task_t * __restrict root /* * schedInit() - Init scheduler + * * @data = optional data if !=NULL * @datlen = data len if data is set * return: allocated root task if ok or NULL error @@ -132,6 +140,9 @@ schedInit(void ** __restrict data, size_t datlen) } else { memset(root, 0, sizeof(sched_root_task_t)); + /* INFINIT polling period by default */ + sched_timespecinf(&root->root_poll); + #ifdef HAVE_LIBPTHREAD for (i = 0; i < taskMAX; i++) if (pthread_mutex_init(&root->root_mtx[i], NULL)) { @@ -149,6 +160,11 @@ schedInit(void ** __restrict data, size_t datlen) TAILQ_INIT(&root->root_read); TAILQ_INIT(&root->root_write); TAILQ_INIT(&root->root_timer); + TAILQ_INIT(&root->root_alarm); + TAILQ_INIT(&root->root_node); + TAILQ_INIT(&root->root_proc); + TAILQ_INIT(&root->root_user); + TAILQ_INIT(&root->root_signal); TAILQ_INIT(&root->root_event); TAILQ_INIT(&root->root_eventlo); TAILQ_INIT(&root->root_ready); @@ -179,13 +195,14 @@ schedInit(void ** __restrict data, size_t datlen) /* * schedEnd() - End scheduler & free all resources + * * @root = root task * return: -1 error or 0 ok */ int schedEnd(sched_root_task_t ** __restrict root) { - sched_task_t *task; + sched_task_t *task, *tmp; #ifdef HAVE_LIBPTHREAD register int i; #endif @@ -193,29 +210,33 @@ schedEnd(sched_root_task_t ** __restrict root) if (!root || !*root) return -1; - TAILQ_FOREACH(task, &(*root)->root_read, task_node) { + TAILQ_FOREACH_SAFE(task, &(*root)->root_read, task_node, tmp) schedCancel(task); - } - TAILQ_FOREACH(task, &(*root)->root_write, task_node) { + TAILQ_FOREACH_SAFE(task, &(*root)->root_write, task_node, tmp) schedCancel(task); - } - TAILQ_FOREACH(task, &(*root)->root_timer, task_node) { + TAILQ_FOREACH_SAFE(task, &(*root)->root_timer, task_node, tmp) schedCancel(task); - } - TAILQ_FOREACH(task, &(*root)->root_event, task_node) { + TAILQ_FOREACH_SAFE(task, &(*root)->root_alarm, task_node, tmp) schedCancel(task); - } - TAILQ_FOREACH(task, &(*root)->root_eventlo, task_node) { + TAILQ_FOREACH_SAFE(task, &(*root)->root_node, task_node, tmp) schedCancel(task); - } - TAILQ_FOREACH(task, &(*root)->root_ready, task_node) { + TAILQ_FOREACH_SAFE(task, &(*root)->root_proc, task_node, tmp) schedCancel(task); - } + TAILQ_FOREACH_SAFE(task, &(*root)->root_user, task_node, tmp) + schedCancel(task); + TAILQ_FOREACH_SAFE(task, &(*root)->root_signal, task_node, tmp) + schedCancel(task); + TAILQ_FOREACH_SAFE(task, &(*root)->root_event, task_node, tmp) + schedCancel(task); + TAILQ_FOREACH_SAFE(task, &(*root)->root_eventlo, task_node, tmp) + schedCancel(task); + TAILQ_FOREACH_SAFE(task, &(*root)->root_ready, task_node, tmp) + schedCancel(task); #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&(*root)->root_mtx[taskUNUSE]); #endif - while ((task = TAILQ_FIRST(&(*root)->root_unuse))) { + TAILQ_FOREACH_SAFE(task, &(*root)->root_unuse, task_node, tmp) { TAILQ_REMOVE(&(*root)->root_unuse, task, task_node); free(task); } @@ -238,6 +259,7 @@ schedEnd(sched_root_task_t ** __restrict root) /* * schedCall() - Call task execution function + * * @task = current task * return: !=NULL error or =NULL ok */ @@ -252,7 +274,6 @@ schedCall(sched_task_t * __restrict task) if (!TASK_ISLOCKED(task)) TASK_LOCK(task); - task->task_id++; ptr = task->task_func(task); TASK_UNLOCK(task); @@ -261,6 +282,7 @@ schedCall(sched_task_t * __restrict task) /* * schedFetch() - Fetch ready task + * * @root = root task * return: =NULL error or !=NULL ready task */ @@ -281,7 +303,41 @@ schedFetch(sched_root_task_t * __restrict root) } /* + * schedTrigger() - Triggering USER task + * + * @task = task + * return: -1 error or 0 ok + */ +int +schedTrigger(sched_task_t * __restrict task) +{ +#ifndef EVFILT_USER + sched_SetErr(ENOTSUP, "Not supported kevent() filter"); + return -1; +#else + struct kevent chg[1]; + struct timespec timeout = { 0, 0 }; + + if (!task || !TASK_ROOT(task)) + return -1; + +#ifdef __NetBSD__ + EV_SET(chg, TASK_VAL(task), EVFILT_USER, 0, NOTE_TRIGGER, 0, (intptr_t) TASK_VAL(task)); +#else + EV_SET(chg, TASK_VAL(task), EVFILT_USER, 0, NOTE_TRIGGER, 0, (void*) TASK_VAL(task)); +#endif + if (kevent(TASK_ROOT(task)->root_kq, chg, 1, NULL, 0, &timeout) == -1) { + LOGERR; + return -1; + } + + return 0; +#endif +} + +/* * schedCancel() - Cancel task from scheduler + * * @task = task * return: -1 error or 0 ok */ @@ -307,6 +363,21 @@ schedCancel(sched_task_t * __restrict task) case taskTIMER: queue = &TASK_ROOT(task)->root_timer; break; + case taskALARM: + queue = &TASK_ROOT(task)->root_alarm; + break; + case taskNODE: + queue = &TASK_ROOT(task)->root_node; + break; + case taskPROC: + queue = &TASK_ROOT(task)->root_proc; + break; + case taskUSER: + queue = &TASK_ROOT(task)->root_user; + break; + case taskSIGNAL: + queue = &TASK_ROOT(task)->root_signal; + break; case taskEVENT: queue = &TASK_ROOT(task)->root_event; break; @@ -323,7 +394,7 @@ schedCancel(sched_task_t * __restrict task) #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&TASK_ROOT(task)->root_mtx[TASK_TYPE(task)]); #endif - TAILQ_REMOVE(queue, task, task_node); + TAILQ_REMOVE(queue, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&TASK_ROOT(task)->root_mtx[TASK_TYPE(task)]); #endif @@ -336,9 +407,11 @@ schedCancel(sched_task_t * __restrict task) /* * schedCancelby() - Cancel task from scheduler by criteria + * * @root = root task * @type = cancel from queue type, if =taskMAX cancel same task from all queues - * @criteria = find task by criteria [CRITERIA_CALL|CRITERIA_ARG|CRITERIA_FD|CRITERIA_VAL|CRITERIA_TV] + * @criteria = find task by criteria + * [CRITERIA_ANY|CRITERIA_CALL|CRITERIA_ARG|CRITERIA_FD|CRITERIA_VAL|CRITERIA_TS|CRITERIA_DATA] * @param = search parameter * @hook = custom cleanup hook function, may be NULL * return: -1 error, -2 error in sub-stage cancel execution, -3 error from custom hook or 0 ok @@ -347,12 +420,13 @@ int schedCancelby(sched_root_task_t * __restrict root, sched_task_type_t type, u_char criteria, void *param, sched_hook_func_t hook) { - sched_task_t *task; + sched_task_t *task, *tmp; sched_queue_t *queue; - int flg = 0; + register int flg = 0; if (!root) return -1; + /* if type == taskMAX check in all queues */ if (type == taskMAX) { if (schedCancelby(root, taskREAD, criteria, param, hook)) return -2; @@ -360,6 +434,16 @@ schedCancelby(sched_root_task_t * __restrict root, sch return -2; if (schedCancelby(root, taskTIMER, criteria, param, hook)) return -2; + if (schedCancelby(root, taskALARM, criteria, param, hook)) + return -2; + if (schedCancelby(root, taskNODE, criteria, param, hook)) + return -2; + if (schedCancelby(root, taskPROC, criteria, param, hook)) + return -2; + if (schedCancelby(root, taskUSER, criteria, param, hook)) + return -2; + if (schedCancelby(root, taskSIGNAL, criteria, param, hook)) + return -2; if (schedCancelby(root, taskEVENT, criteria, param, hook)) return -2; if (schedCancelby(root, taskEVENTLO, criteria, param, hook)) @@ -368,6 +452,7 @@ schedCancelby(sched_root_task_t * __restrict root, sch return -2; return 0; } + /* choosen queue */ switch (type) { case taskREAD: queue = &root->root_read; @@ -378,6 +463,21 @@ schedCancelby(sched_root_task_t * __restrict root, sch case taskTIMER: queue = &root->root_timer; break; + case taskALARM: + queue = &root->root_alarm; + break; + case taskNODE: + queue = &root->root_node; + break; + case taskPROC: + queue = &root->root_proc; + break; + case taskUSER: + queue = &root->root_user; + break; + case taskSIGNAL: + queue = &root->root_signal; + break; case taskEVENT: queue = &root->root_event; break; @@ -394,73 +494,78 @@ schedCancelby(sched_root_task_t * __restrict root, sch #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[type]); #endif - TAILQ_FOREACH(task, queue, task_node) - if (criteria == CRITERIA_CALL) { - if (task->task_func == (sched_task_func_t) param) { - flg++; + TAILQ_FOREACH_SAFE(task, queue, task_node, tmp) { + flg ^= flg; + switch (criteria) { + case CRITERIA_ANY: + flg = 1; break; - } - } else if (criteria == CRITERIA_ARG) { - if (task->task_arg == param) { - flg++; + case CRITERIA_CALL: + if (TASK_FUNC(task) == (sched_task_func_t) param) + flg = 1; break; - } - } else if (criteria == CRITERIA_FD) { - if (TASK_FD(task) == (intptr_t) param) { - flg++; + case CRITERIA_ARG: + if (TASK_ARG(task) == param) + flg = 1; break; - } - } else if (criteria == CRITERIA_VAL) { - if (TASK_VAL(task) == (u_long) param) { - flg++; + case CRITERIA_FD: + if (TASK_FD(task) == (intptr_t) param) + flg = 1; break; - } - } else if (criteria == CRITERIA_TV) { - if (!timercmp(&TASK_TV(task), (struct timeval*) param, -)) { - flg++; + case CRITERIA_VAL: + if (TASK_VAL(task) == (u_long) param) + flg = 1; break; - } - } else { -#ifdef HAVE_LIBPTHREAD - pthread_mutex_unlock(&root->root_mtx[type]); -#endif - sched_SetErr(EINVAL, "Invalid parameter criteria %d", criteria); - return -1; + case CRITERIA_TS: + if (!sched_timespeccmp(&TASK_TS(task), (struct timespec*) param, -)) + flg = 1; + break; + case CRITERIA_DATA: + if (TASK_DATA(task) == param) + flg = 1; + break; + default: + sched_SetErr(EINVAL, "Invalid parameter criteria %d", criteria); + flg = -1; } -#ifdef HAVE_LIBPTHREAD - pthread_mutex_unlock(&root->root_mtx[type]); -#endif - if (!flg || !task) /* task not found */ - return 0; + if (flg < 0) /* error */ + break; + /* cancel choosen task */ + if (flg > 0) { + if (TASK_ROOT(task)->root_hooks.hook_exec.cancel) + if (TASK_ROOT(task)->root_hooks.hook_exec.cancel(task, NULL)) { + flg = -1; + break; + } + /* custom hook */ + if (hook) + if (hook(task, NULL)) { + flg = -3; + break; + } - if (TASK_ROOT(task)->root_hooks.hook_exec.cancel) - if (TASK_ROOT(task)->root_hooks.hook_exec.cancel(task, NULL)) - return -1; - if (hook) - if (hook(task, NULL)) - return -3; + TAILQ_REMOVE(queue, task, task_node); + if (TASK_TYPE(task) != taskUNUSE) + _sched_unuseTask(task); + flg ^= flg; /* ok */ + } + } #ifdef HAVE_LIBPTHREAD - pthread_mutex_lock(&TASK_ROOT(task)->root_mtx[type]); + pthread_mutex_unlock(&root->root_mtx[type]); #endif - TAILQ_REMOVE(queue, task, task_node); -#ifdef HAVE_LIBPTHREAD - pthread_mutex_unlock(&TASK_ROOT(task)->root_mtx[type]); -#endif - - if (TASK_TYPE(task) != taskUNUSE) - _sched_unuseTask(task); - return 0; + return flg; } /* * schedRun() - Scheduler *run loop* + * * @root = root task * @killState = kill condition variable, if !=0 stop scheduler loop * return: -1 error or 0 ok */ int -schedRun(sched_root_task_t * __restrict root, volatile intptr_t * __restrict killState) +schedRun(sched_root_task_t *root, volatile intptr_t * __restrict killState) { sched_task_t *task; @@ -470,16 +575,71 @@ schedRun(sched_root_task_t * __restrict root, volatile if (root->root_hooks.hook_exec.run) if (root->root_hooks.hook_exec.run(root, NULL)) return -1; - if (root->root_hooks.hook_exec.fetch) { - if (killState) - while (!*killState) { + + if (killState) { + if (root->root_hooks.hook_exec.condition) + /* condition scheduler loop */ + while (root && root->root_hooks.hook_exec.fetch && + root->root_hooks.hook_exec.condition && + root->root_hooks.hook_exec.condition(root, (void*) killState)) { if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) schedCall(task); } else - while ((task = root->root_hooks.hook_exec.fetch(root, NULL))) + /* trigger scheduler loop */ + while (!*killState && root && root->root_hooks.hook_exec.fetch) { + if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) + schedCall(task); + } + } else + /* infinite scheduler loop */ + while (root && root->root_hooks.hook_exec.fetch) + if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) schedCall(task); - } + return 0; +} + +/* + * schedPolling() - Polling timeout period if no timer task is present + * + * @root = root task + * @ts = timeout polling period, if ==NULL INFINIT timeout + * @tsold = old timeout polling if !=NULL + * return: -1 error or 0 ok + */ +inline int +schedPolling(sched_root_task_t * __restrict root, struct timespec * __restrict ts, + struct timespec * __restrict tsold) +{ + if (!root) + return -1; + + if (tsold) + *tsold = root->root_poll; + + if (!ts) + sched_timespecinf(&root->root_poll); + else + root->root_poll = *ts; + + return 0; +} + +/* + * schedTermCondition() - Activate hook for scheduler condition kill + * + * @root = root task + * @condValue = condition value, kill schedRun() if condValue == killState + * return: -1 error ok 0 ok + */ +inline int +schedTermCondition(sched_root_task_t * __restrict root, intptr_t condValue) +{ + if (!root) + return -1; + + root->root_cond = condValue; + root->root_hooks.hook_exec.condition = sched_hook_condition; return 0; }