version 1.1.1.1, 2011/08/05 15:52:00
|
version 1.4.2.1, 2012/01/08 02:01:41
|
Line 85 sched_SetErr(int eno, char *estr, ...)
|
Line 85 sched_SetErr(int eno, char *estr, ...)
|
/* Init and prepare scheduler functions */ |
/* Init and prepare scheduler functions */ |
|
|
/* |
/* |
|
* 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; |
|
|
|
if (root->root_hooks.hook_root.fini) |
|
root->root_hooks.hook_root.fini(root, NULL); |
|
memset(&root->root_hooks, 0, sizeof root->root_hooks); |
|
|
|
root->root_hooks.hook_add.read = sched_hook_read; |
|
root->root_hooks.hook_add.write = sched_hook_write; |
|
|
|
root->root_hooks.hook_exec.cancel = sched_hook_cancel; |
|
root->root_hooks.hook_exec.fetch = sched_hook_fetch; |
|
root->root_hooks.hook_exec.exception = sched_hook_exception; |
|
|
|
root->root_hooks.hook_root.init = sched_hook_init; |
|
root->root_hooks.hook_root.fini = sched_hook_fini; |
|
return 0; |
|
} |
|
|
|
/* |
* schedInit() - Init scheduler |
* schedInit() - Init scheduler |
* @data = optional data if !=NULL |
* @data = optional data if !=NULL |
* @datlen = data len if data is set |
* @datlen = data len if data is set |
Line 95 schedInit(void ** __restrict data, size_t datlen)
|
Line 122 schedInit(void ** __restrict data, size_t datlen)
|
{ |
{ |
sched_root_task_t *root = NULL; |
sched_root_task_t *root = NULL; |
int (*func)(sched_root_task_t *); |
int (*func)(sched_root_task_t *); |
|
#ifdef HAVE_LIBPTHREAD |
|
register int i; |
|
#endif |
|
|
root = malloc(sizeof(sched_root_task_t)); |
root = malloc(sizeof(sched_root_task_t)); |
if (!root) | if (!root) { |
LOGERR | LOGERR; |
else { | } else { |
memset(root, 0, sizeof(sched_root_task_t)); |
memset(root, 0, sizeof(sched_root_task_t)); |
|
|
|
#ifdef HAVE_LIBPTHREAD |
|
for (i = 0; i < taskMAX; i++) |
|
if (pthread_mutex_init(&root->root_mtx[i], NULL)) { |
|
LOGERR; |
|
while (i) |
|
pthread_mutex_destroy(&root->root_mtx[--i]); |
|
free(root); |
|
return NULL; |
|
} |
|
|
|
for (i = 0; i < taskMAX; i++) |
|
ROOT_QLOCK(root, i); |
|
#endif |
|
|
|
TAILQ_INIT(&root->root_read); |
|
TAILQ_INIT(&root->root_write); |
|
TAILQ_INIT(&root->root_timer); |
|
TAILQ_INIT(&root->root_event); |
|
TAILQ_INIT(&root->root_eventlo); |
|
TAILQ_INIT(&root->root_ready); |
|
TAILQ_INIT(&root->root_unuse); |
|
|
|
#ifdef HAVE_LIBPTHREAD |
|
for (i = 0; i < taskMAX; i++) |
|
ROOT_QUNLOCK(root, i); |
|
#endif |
|
|
if (data && *data) { |
if (data && *data) { |
if (datlen) { |
if (datlen) { |
root->root_data.iov_base = *data; |
root->root_data.iov_base = *data; |
root->root_data.iov_len = datlen; |
root->root_data.iov_len = datlen; |
} else { | } else { /* if datlen == 0, switch to callbacks init mode */ |
func = *data; | /* little hack :) for correct initialization of scheduler */ |
| func = (int(*)(sched_root_task_t*)) data; |
func(root); |
func(root); |
} |
} |
} |
} |
|
|
|
if (root->root_hooks.hook_root.init) |
|
root->root_hooks.hook_root.init(root, NULL); |
} |
} |
|
|
if (root->root_hooks.hook_root.init) |
|
root->root_hooks.hook_root.init(root, NULL); |
|
return root; |
return root; |
} |
} |
|
|
/* |
/* |
* schedRegisterIO() - Register IO handles and bind tasks to it |
|
* @root = root task |
|
* return: -1 error or 0 ok |
|
*/ |
|
int |
|
schedRegisterIO(sched_root_task_t * __restrict root) |
|
{ |
|
if (!root || (root->root_data.iov_base && root->root_data.iov_len)) |
|
return -1; |
|
|
|
if (root->root_hooks.hook_root.fini) |
|
root->root_hooks.hook_root.fini(root, NULL); |
|
memset(&root->root_hooks, 0, sizeof root->root_hooks); |
|
|
|
root->root_hooks.hook_add.read = sched_hook_read; |
|
root->root_hooks.hook_add.write = sched_hook_write; |
|
|
|
root->root_hooks.hook_exec.cancel = sched_hook_cancel; |
|
root->root_hooks.hook_exec.fetch = sched_hook_fetch; |
|
|
|
root->root_hooks.hook_root.init = sched_hook_init; |
|
root->root_hooks.hook_root.fini = sched_hook_fini; |
|
|
|
if (root->root_hooks.hook_root.init) |
|
root->root_hooks.hook_root.init(root, NULL); |
|
return 0; |
|
} |
|
|
|
/* |
|
* schedEnd() - End scheduler & free all resources |
* schedEnd() - End scheduler & free all resources |
* @root = root task |
* @root = root task |
* return: -1 error or 0 ok |
* return: -1 error or 0 ok |
*/ |
*/ |
int |
int |
schedEnd(sched_root_task_t * __restrict root) | schedEnd(sched_root_task_t ** __restrict root) |
{ |
{ |
sched_task_t *task; |
sched_task_t *task; |
|
#ifdef HAVE_LIBPTHREAD |
|
register int i; |
|
#endif |
|
|
if (!root) | if (!root || !*root) |
return -1; |
return -1; |
|
|
TAILQ_FOREACH(task, &root->root_read, task_node) { | #ifdef HAVE_LIBPTHREAD |
| for (i = 0; i < taskMAX; i++) |
| ROOT_QLOCK(*root, i); |
| #endif |
| TAILQ_FOREACH(task, &(*root)->root_read, task_node) { |
schedCancel(task); |
schedCancel(task); |
} |
} |
TAILQ_FOREACH(task, &root->root_write, task_node) { | TAILQ_FOREACH(task, &(*root)->root_write, task_node) { |
schedCancel(task); |
schedCancel(task); |
} |
} |
TAILQ_FOREACH(task, &root->root_timer, task_node) { | TAILQ_FOREACH(task, &(*root)->root_timer, task_node) { |
schedCancel(task); |
schedCancel(task); |
} |
} |
TAILQ_FOREACH(task, &root->root_event, task_node) { | TAILQ_FOREACH(task, &(*root)->root_event, task_node) { |
schedCancel(task); |
schedCancel(task); |
} |
} |
TAILQ_FOREACH(task, &root->root_ready, task_node) { | TAILQ_FOREACH(task, &(*root)->root_ready, task_node) { |
schedCancel(task); |
schedCancel(task); |
} |
} |
|
|
while ((task = TAILQ_FIRST(&root->root_unuse))) { | while ((task = TAILQ_FIRST(&(*root)->root_unuse))) { |
TAILQ_REMOVE(&root->root_unuse, task, task_node); | TAILQ_REMOVE(&(*root)->root_unuse, task, task_node); |
free(task); |
free(task); |
} |
} |
|
#ifdef HAVE_LIBPTHREAD |
|
for (i = 0; i < taskMAX; i++) |
|
ROOT_QUNLOCK(*root, i); |
|
#endif |
|
|
if (root->root_hooks.hook_root.fini) | if ((*root)->root_hooks.hook_root.fini) |
root->root_hooks.hook_root.fini(root, NULL); | (*root)->root_hooks.hook_root.fini(*root, NULL); |
|
|
free(root); | #ifdef HAVE_LIBPTHREAD |
| for (i = 0; i < taskMAX; i++) |
| pthread_mutex_destroy(&(*root)->root_mtx[i]); |
| #endif |
| |
| free(*root); |
| *root = NULL; |
return 0; |
return 0; |
} |
} |
|
|
Line 196 schedEnd(sched_root_task_t * __restrict root)
|
Line 243 schedEnd(sched_root_task_t * __restrict root)
|
inline void * |
inline void * |
schedCall(sched_task_t * __restrict task) |
schedCall(sched_task_t * __restrict task) |
{ |
{ |
|
void *ptr = (void*) -1; |
|
|
if (!task) |
if (!task) |
return (void*) -1; | return ptr; |
|
|
|
if (!TASK_ISLOCKED(task)) |
|
TASK_LOCK(task); |
|
|
task->task_id++; |
task->task_id++; |
return task->task_func(task); | ptr = task->task_func(task); |
| |
| TASK_UNLOCK(task); |
| return ptr; |
} |
} |
|
|
/* |
/* |
Line 262 schedCancel(sched_task_t * __restrict task)
|
Line 317 schedCancel(sched_task_t * __restrict task)
|
} |
} |
if (queue) |
if (queue) |
TAILQ_REMOVE(queue, task, task_node); |
TAILQ_REMOVE(queue, task, task_node); |
if (task->task_type != taskUNUSE) { | if (task->task_type != taskUNUSE) |
task->task_type = taskUNUSE; | _sched_unuseTask(task); |
TAILQ_INSERT_TAIL(&task->task_root->root_unuse, task, task_node); | |
} | |
|
|
return 0; |
return 0; |
} |
} |
Line 277 schedCancel(sched_task_t * __restrict task)
|
Line 330 schedCancel(sched_task_t * __restrict task)
|
* @criteria = find task by criteria [CRITERIA_CALL|CRITERIA_ARG|CRITERIA_FD|CRITERIA_VAL|CRITERIA_TV] |
* @criteria = find task by criteria [CRITERIA_CALL|CRITERIA_ARG|CRITERIA_FD|CRITERIA_VAL|CRITERIA_TV] |
* @param = search parameter |
* @param = search parameter |
* @hook = custom cleanup hook function, may be NULL |
* @hook = custom cleanup hook function, may be NULL |
* return: -1 error or 0 ok | * return: -1 error, -2 error in sub-stage cancel execution, -3 error from custom hook or 0 ok |
*/ |
*/ |
int |
int |
schedCancelby(sched_root_task_t * __restrict root, sched_queue_t * __restrict queue, |
schedCancelby(sched_root_task_t * __restrict root, sched_queue_t * __restrict queue, |
Line 316 schedCancelby(sched_root_task_t * __restrict root, sch
|
Line 369 schedCancelby(sched_root_task_t * __restrict root, sch
|
break; |
break; |
} |
} |
} else if (criteria == CRITERIA_FD) { |
} else if (criteria == CRITERIA_FD) { |
if (TASK_FD(task) == (u_long) param) { | if (TASK_FD(task) == (intptr_t) param) { |
flg++; |
flg++; |
break; |
break; |
} |
} |
Line 326 schedCancelby(sched_root_task_t * __restrict root, sch
|
Line 379 schedCancelby(sched_root_task_t * __restrict root, sch
|
break; |
break; |
} |
} |
} else if (criteria == CRITERIA_TV) { |
} else if (criteria == CRITERIA_TV) { |
if (&TASK_TV(task) == (struct timeval*) param) { | if (!timercmp(&TASK_TV(task), (struct timeval*) param, -)) { |
flg++; |
flg++; |
break; |
break; |
} |
} |
Line 346 schedCancelby(sched_root_task_t * __restrict root, sch
|
Line 399 schedCancelby(sched_root_task_t * __restrict root, sch
|
|
|
TAILQ_REMOVE(queue, task, task_node); |
TAILQ_REMOVE(queue, task, task_node); |
|
|
if (task->task_type != taskUNUSE) { | if (task->task_type != taskUNUSE) |
task->task_type = taskUNUSE; | _sched_unuseTask(task); |
TAILQ_INSERT_TAIL(&task->task_root->root_unuse, task, task_node); | |
} | |
return 0; |
return 0; |
} |
} |
|
|
/* |
/* |
* schedRun() - Scheduler *run loop* |
* schedRun() - Scheduler *run loop* |
* @root = root task |
* @root = root task |
|
* @killState = kill condition variable, if !=0 stop scheduler loop |
* return: -1 error or 0 ok |
* return: -1 error or 0 ok |
*/ |
*/ |
int |
int |
schedRun(sched_root_task_t * __restrict root) | schedRun(sched_root_task_t * __restrict root, volatile intptr_t * __restrict killState) |
{ |
{ |
sched_task_t *task; |
sched_task_t *task; |
|
|
Line 369 schedRun(sched_root_task_t * __restrict root)
|
Line 421 schedRun(sched_root_task_t * __restrict root)
|
if (root->root_hooks.hook_exec.run) |
if (root->root_hooks.hook_exec.run) |
if (root->root_hooks.hook_exec.run(root, NULL)) |
if (root->root_hooks.hook_exec.run(root, NULL)) |
return -1; |
return -1; |
if (root->root_hooks.hook_exec.fetch) | if (root->root_hooks.hook_exec.fetch) { |
while ((task = root->root_hooks.hook_exec.fetch(root, NULL))) | if (killState) |
schedCall(task); | while (!*killState) { |
| if ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
| schedCall(task); |
| } |
| else |
| while ((task = root->root_hooks.hook_exec.fetch(root, NULL))) |
| schedCall(task); |
| } |
|
|
return 0; |
return 0; |
} |
} |