version 1.10.6.1, 2012/07/24 13:47:01
|
version 1.15.2.3, 2012/08/23 00:31:41
|
Line 108 schedRegisterHooks(sched_root_task_t * __restrict root
|
Line 108 schedRegisterHooks(sched_root_task_t * __restrict root
|
#ifdef EVFILT_USER |
#ifdef EVFILT_USER |
root->root_hooks.hook_add.user = sched_hook_user; |
root->root_hooks.hook_add.user = sched_hook_user; |
#endif |
#endif |
|
#ifdef HAVE_LIBPTHREAD |
|
root->root_hooks.hook_add.thread = sched_hook_thread; |
|
#endif |
|
|
root->root_hooks.hook_exec.cancel = sched_hook_cancel; |
root->root_hooks.hook_exec.cancel = sched_hook_cancel; |
root->root_hooks.hook_exec.fetch = sched_hook_fetch; |
root->root_hooks.hook_exec.fetch = sched_hook_fetch; |
Line 118 schedRegisterHooks(sched_root_task_t * __restrict root
|
Line 121 schedRegisterHooks(sched_root_task_t * __restrict root
|
return 0; |
return 0; |
} |
} |
|
|
|
#ifdef HAVE_LIBPTHREAD |
|
static void |
|
_sched_threadChild() |
|
{ |
|
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); |
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); |
|
pthread_testcancel(); |
|
} |
|
#endif |
|
|
/* |
/* |
* schedInit() - Init scheduler |
* schedInit() - Init scheduler |
* |
* |
Line 140 schedInit(void ** __restrict data, size_t datlen)
|
Line 153 schedInit(void ** __restrict data, size_t datlen)
|
} else { |
} else { |
memset(root, 0, sizeof(sched_root_task_t)); |
memset(root, 0, sizeof(sched_root_task_t)); |
|
|
|
/* set default maximum regular task hit misses */ |
|
root->root_miss = MAX_TASK_MISS; |
|
|
/* INFINIT polling period by default */ |
/* INFINIT polling period by default */ |
sched_timespecinf(&root->root_poll); |
sched_timespecinf(&root->root_poll); |
|
|
Line 163 schedInit(void ** __restrict data, size_t datlen)
|
Line 179 schedInit(void ** __restrict data, size_t datlen)
|
TAILQ_INIT(&root->root_alarm); |
TAILQ_INIT(&root->root_alarm); |
TAILQ_INIT(&root->root_node); |
TAILQ_INIT(&root->root_node); |
TAILQ_INIT(&root->root_proc); |
TAILQ_INIT(&root->root_proc); |
TAILQ_INIT(&root->root_user); |
|
TAILQ_INIT(&root->root_signal); |
TAILQ_INIT(&root->root_signal); |
|
TAILQ_INIT(&root->root_aio); |
|
TAILQ_INIT(&root->root_lio); |
|
TAILQ_INIT(&root->root_user); |
TAILQ_INIT(&root->root_event); |
TAILQ_INIT(&root->root_event); |
TAILQ_INIT(&root->root_eventlo); | TAILQ_INIT(&root->root_task); |
TAILQ_INIT(&root->root_suspend); |
TAILQ_INIT(&root->root_suspend); |
TAILQ_INIT(&root->root_ready); |
TAILQ_INIT(&root->root_ready); |
TAILQ_INIT(&root->root_unuse); |
TAILQ_INIT(&root->root_unuse); |
|
TAILQ_INIT(&root->root_thread); |
|
|
#ifdef HAVE_LIBPTHREAD |
#ifdef HAVE_LIBPTHREAD |
|
pthread_atfork(NULL, NULL, _sched_threadChild); |
|
|
for (i = 0; i < taskMAX; i++) |
for (i = 0; i < taskMAX; i++) |
pthread_mutex_unlock(&root->root_mtx[i]); |
pthread_mutex_unlock(&root->root_mtx[i]); |
#endif |
#endif |
Line 223 schedEnd(sched_root_task_t ** __restrict root)
|
Line 244 schedEnd(sched_root_task_t ** __restrict root)
|
schedCancel(task); |
schedCancel(task); |
TAILQ_FOREACH_SAFE(task, &(*root)->root_proc, task_node, tmp) |
TAILQ_FOREACH_SAFE(task, &(*root)->root_proc, task_node, tmp) |
schedCancel(task); |
schedCancel(task); |
TAILQ_FOREACH_SAFE(task, &(*root)->root_user, task_node, tmp) |
|
schedCancel(task); |
|
TAILQ_FOREACH_SAFE(task, &(*root)->root_signal, task_node, tmp) |
TAILQ_FOREACH_SAFE(task, &(*root)->root_signal, task_node, tmp) |
schedCancel(task); |
schedCancel(task); |
TAILQ_FOREACH_SAFE(task, &(*root)->root_event, task_node, tmp) | TAILQ_FOREACH_SAFE(task, &(*root)->root_aio, task_node, tmp) |
schedCancel(task); |
schedCancel(task); |
TAILQ_FOREACH_SAFE(task, &(*root)->root_eventlo, task_node, tmp) | TAILQ_FOREACH_SAFE(task, &(*root)->root_lio, task_node, tmp) |
schedCancel(task); |
schedCancel(task); |
|
TAILQ_FOREACH_SAFE(task, &(*root)->root_user, task_node, tmp) |
|
schedCancel(task); |
|
TAILQ_FOREACH_SAFE(task, &(*root)->root_event, task_node, tmp) |
|
schedCancel(task); |
TAILQ_FOREACH_SAFE(task, &(*root)->root_suspend, task_node, tmp) |
TAILQ_FOREACH_SAFE(task, &(*root)->root_suspend, task_node, tmp) |
schedCancel(task); |
schedCancel(task); |
TAILQ_FOREACH_SAFE(task, &(*root)->root_ready, task_node, tmp) |
TAILQ_FOREACH_SAFE(task, &(*root)->root_ready, task_node, tmp) |
schedCancel(task); |
schedCancel(task); |
|
TAILQ_FOREACH_SAFE(task, &(*root)->root_thread, task_node, tmp) |
|
schedCancel(task); |
|
TAILQ_FOREACH_SAFE(task, &(*root)->root_task, task_node, tmp) |
|
schedCancel(task); |
|
|
#ifdef HAVE_LIBPTHREAD |
#ifdef HAVE_LIBPTHREAD |
pthread_mutex_lock(&(*root)->root_mtx[taskUNUSE]); |
pthread_mutex_lock(&(*root)->root_mtx[taskUNUSE]); |
Line 375 schedCancel(sched_task_t * __restrict task)
|
Line 402 schedCancel(sched_task_t * __restrict task)
|
case taskPROC: |
case taskPROC: |
queue = &TASK_ROOT(task)->root_proc; |
queue = &TASK_ROOT(task)->root_proc; |
break; |
break; |
case taskUSER: |
|
queue = &TASK_ROOT(task)->root_user; |
|
break; |
|
case taskSIGNAL: |
case taskSIGNAL: |
queue = &TASK_ROOT(task)->root_signal; |
queue = &TASK_ROOT(task)->root_signal; |
break; |
break; |
|
case taskAIO: |
|
queue = &TASK_ROOT(task)->root_aio; |
|
break; |
|
case taskLIO: |
|
queue = &TASK_ROOT(task)->root_lio; |
|
break; |
|
case taskUSER: |
|
queue = &TASK_ROOT(task)->root_user; |
|
break; |
case taskEVENT: |
case taskEVENT: |
queue = &TASK_ROOT(task)->root_event; |
queue = &TASK_ROOT(task)->root_event; |
break; |
break; |
case taskEVENTLO: | case taskTASK: |
queue = &TASK_ROOT(task)->root_eventlo; | queue = &TASK_ROOT(task)->root_task; |
break; |
break; |
case taskSUSPEND: |
case taskSUSPEND: |
queue = &TASK_ROOT(task)->root_suspend; |
queue = &TASK_ROOT(task)->root_suspend; |
Line 393 schedCancel(sched_task_t * __restrict task)
|
Line 426 schedCancel(sched_task_t * __restrict task)
|
case taskREADY: |
case taskREADY: |
queue = &TASK_ROOT(task)->root_ready; |
queue = &TASK_ROOT(task)->root_ready; |
break; |
break; |
|
case taskTHREAD: |
|
queue = &TASK_ROOT(task)->root_thread; |
|
break; |
default: |
default: |
queue = NULL; |
queue = NULL; |
} |
} |
Line 406 schedCancel(sched_task_t * __restrict task)
|
Line 442 schedCancel(sched_task_t * __restrict task)
|
#endif |
#endif |
} |
} |
if (TASK_TYPE(task) != taskUNUSE) |
if (TASK_TYPE(task) != taskUNUSE) |
_sched_unuseTask(task); | sched_unuseTask(task); |
|
|
return 0; |
return 0; |
} |
} |
Line 446 schedCancelby(sched_root_task_t * __restrict root, sch
|
Line 482 schedCancelby(sched_root_task_t * __restrict root, sch
|
return -2; |
return -2; |
if (schedCancelby(root, taskPROC, criteria, param, hook)) |
if (schedCancelby(root, taskPROC, criteria, param, hook)) |
return -2; |
return -2; |
if (schedCancelby(root, taskUSER, criteria, param, hook)) |
|
return -2; |
|
if (schedCancelby(root, taskSIGNAL, criteria, param, hook)) |
if (schedCancelby(root, taskSIGNAL, criteria, param, hook)) |
return -2; |
return -2; |
|
if (schedCancelby(root, taskAIO, criteria, param, hook)) |
|
return -2; |
|
if (schedCancelby(root, taskLIO, criteria, param, hook)) |
|
return -2; |
|
if (schedCancelby(root, taskUSER, criteria, param, hook)) |
|
return -2; |
if (schedCancelby(root, taskEVENT, criteria, param, hook)) |
if (schedCancelby(root, taskEVENT, criteria, param, hook)) |
return -2; |
return -2; |
if (schedCancelby(root, taskEVENTLO, criteria, param, hook)) | if (schedCancelby(root, taskTASK, criteria, param, hook)) |
return -2; |
return -2; |
if (schedCancelby(root, taskSUSPEND, criteria, param, hook)) |
if (schedCancelby(root, taskSUSPEND, criteria, param, hook)) |
return -2; |
return -2; |
if (schedCancelby(root, taskREADY, criteria, param, hook)) |
if (schedCancelby(root, taskREADY, criteria, param, hook)) |
return -2; |
return -2; |
|
if (schedCancelby(root, taskTHREAD, criteria, param, hook)) |
|
return -2; |
return 0; |
return 0; |
} |
} |
/* choosen queue */ |
/* choosen queue */ |
Line 480 schedCancelby(sched_root_task_t * __restrict root, sch
|
Line 522 schedCancelby(sched_root_task_t * __restrict root, sch
|
case taskPROC: |
case taskPROC: |
queue = &root->root_proc; |
queue = &root->root_proc; |
break; |
break; |
case taskUSER: |
|
queue = &root->root_user; |
|
break; |
|
case taskSIGNAL: |
case taskSIGNAL: |
queue = &root->root_signal; |
queue = &root->root_signal; |
break; |
break; |
|
case taskAIO: |
|
queue = &root->root_aio; |
|
break; |
|
case taskLIO: |
|
queue = &root->root_lio; |
|
break; |
|
case taskUSER: |
|
queue = &root->root_user; |
|
break; |
case taskEVENT: |
case taskEVENT: |
queue = &root->root_event; |
queue = &root->root_event; |
break; |
break; |
case taskEVENTLO: | case taskTASK: |
queue = &root->root_eventlo; | queue = &root->root_task; |
break; |
break; |
case taskSUSPEND: |
case taskSUSPEND: |
queue = &root->root_suspend; |
queue = &root->root_suspend; |
Line 498 schedCancelby(sched_root_task_t * __restrict root, sch
|
Line 546 schedCancelby(sched_root_task_t * __restrict root, sch
|
case taskREADY: |
case taskREADY: |
queue = &root->root_ready; |
queue = &root->root_ready; |
break; |
break; |
|
case taskTHREAD: |
|
queue = &root->root_thread; |
|
break; |
default: |
default: |
return 0; |
return 0; |
} |
} |
Line 558 schedCancelby(sched_root_task_t * __restrict root, sch
|
Line 609 schedCancelby(sched_root_task_t * __restrict root, sch
|
|
|
TAILQ_REMOVE(queue, task, task_node); |
TAILQ_REMOVE(queue, task, task_node); |
if (TASK_TYPE(task) != taskUNUSE) |
if (TASK_TYPE(task) != taskUNUSE) |
_sched_unuseTask(task); | sched_unuseTask(task); |
|
|
flg ^= flg; /* ok */ |
flg ^= flg; /* ok */ |
} |
} |
Line 595 schedRun(sched_root_task_t *root, volatile intptr_t *
|
Line 646 schedRun(sched_root_task_t *root, volatile intptr_t *
|
root->root_hooks.hook_exec.condition && |
root->root_hooks.hook_exec.condition && |
root->root_hooks.hook_exec.condition(root, (void*) killState)) { |
root->root_hooks.hook_exec.condition(root, (void*) killState)) { |
if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
schedCall(task); | root->root_ret = schedCall(task); |
} |
} |
else |
else |
/* trigger scheduler loop */ |
/* trigger scheduler loop */ |
while (!*killState && root && root->root_hooks.hook_exec.fetch) { |
while (!*killState && root && root->root_hooks.hook_exec.fetch) { |
if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
schedCall(task); | root->root_ret = schedCall(task); |
} |
} |
} else |
} else |
/* infinite scheduler loop */ |
/* infinite scheduler loop */ |
while (root && root->root_hooks.hook_exec.fetch) |
while (root && root->root_hooks.hook_exec.fetch) |
if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
schedCall(task); | root->root_ret = schedCall(task); |
|
|
return 0; |
return 0; |
} |
} |
Line 643 schedPolling(sched_root_task_t * __restrict root, stru
|
Line 694 schedPolling(sched_root_task_t * __restrict root, stru
|
* |
* |
* @root = root task |
* @root = root task |
* @condValue = condition value, kill schedRun() if condValue == killState |
* @condValue = condition value, kill schedRun() if condValue == killState |
* return: -1 error ok 0 ok | * return: -1 error or 0 ok |
*/ |
*/ |
inline int |
inline int |
schedTermCondition(sched_root_task_t * __restrict root, intptr_t condValue) |
schedTermCondition(sched_root_task_t * __restrict root, intptr_t condValue) |