libaitsched/src/tasks.c - diff

Return to tasks.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitsched / src

Diff for /libaitsched/src/tasks.c between versions 1.2 and 1.5

version 1.2, 2011/10/04 12:34:33	version 1.5, 2012/01/24 21:59:47
Line 46 SUCH DAMAGE.	Line 46 SUCH DAMAGE.
#include "global.h"	#include "global.h"


	#pragma GCC visibility push(hidden)

	inline sched_task_t *
	_sched_useTask(sched_root_task_t * __restrict root)
	{
	sched_task_t *task;

	TAILQ_FOREACH(task, &root->root_unuse, task_node) {
	if (!TASK_ISLOCKED(task)) {
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskUNUSE]);
	#endif
	TAILQ_REMOVE(&root->root_unuse, task, task_node);
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_unlock(&root->root_mtx[taskUNUSE]);
	#endif
	break;
	}
	}

	if (!task) {
	task = malloc(sizeof(sched_task_t));
	if (!task) {
	LOGERR;
	return NULL;
	}
	}

	return task;
	}

	inline sched_task_t *
	_sched_unuseTask(sched_task_t * __restrict task)
	{
	TASK_UNLOCK(task);
	TASK_TYPE(task) = taskUNUSE;
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&TASK_ROOT(task)->root_mtx[taskUNUSE]);
	#endif
	TAILQ_INSERT_TAIL(&TASK_ROOT(task)->root_unuse, task, task_node);
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_unlock(&TASK_ROOT(task)->root_mtx[taskUNUSE]);
	#endif
	task = NULL;

	return task;
	}

	#pragma GCC visibility pop


/*	/*
* schedRead() - Add READ I/O task to scheduler queue	* schedRead() - Add READ I/O task to scheduler queue
* @root = root task	* @root = root task
* @func = task execution function	* @func = task execution function
* @arg = 1st func argument	* @arg = 1st func argument
* @fd = fd handle	* @fd = fd handle
	* @opt_data = Optional data
	* @opt_dlen = Optional data length
* return: NULL error or !=NULL new queued task	* return: NULL error or !=NULL new queued task
*/	*/
sched_task_t *	sched_task_t *
schedRead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd)	schedRead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
	void *opt_data, size_t opt_dlen)
{	{
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;
Line 64 schedRead(sched_root_task_t * __restrict root, sched_t	Line 118 schedRead(sched_root_task_t * __restrict root, sched_t
return NULL;	return NULL;

/* get new task */	/* get new task */
if ((task = TAILQ_FIRST(&root->root_unuse)))	if (!(task = _sched_useTask(root)))
TAILQ_REMOVE(&root->root_unuse, task, task_node);	return NULL;
else {
task = malloc(sizeof(sched_task_t));
if (!task) {
LOGERR;
return NULL;
}
}

memset(task, 0, sizeof(sched_task_t));	memset(task, 0, sizeof(sched_task_t));
task->task_id = 0;	task->task_id = 0;
task->task_type = taskREAD;	task->task_lock = 0;
task->task_root = root;
task->task_func = func;	task->task_func = func;
	TASK_TYPE(task) = taskREAD;
	TASK_ROOT(task) = root;

TASK_ARG(task) = arg;	TASK_ARG(task) = arg;
TASK_FD(task) = fd;	TASK_FD(task) = fd;

	TASK_DATA(task) = opt_data;
	TASK_DATLEN(task) = opt_dlen;

if (root->root_hooks.hook_add.read)	if (root->root_hooks.hook_add.read)
ptr = root->root_hooks.hook_add.read(task, NULL);	ptr = root->root_hooks.hook_add.read(task, NULL);
else	else
ptr = NULL;	ptr = NULL;

if (!ptr)	if (!ptr) {
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskREAD]);
	#endif
TAILQ_INSERT_TAIL(&root->root_read, task, task_node);	TAILQ_INSERT_TAIL(&root->root_read, task, task_node);
else {	#ifdef HAVE_LIBPTHREAD
task->task_type = taskUNUSE;	pthread_mutex_unlock(&root->root_mtx[taskREAD]);
TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);	#endif
task = NULL;	} else
}	task = _sched_unuseTask(task);

return task;	return task;
}	}
Line 105 schedRead(sched_root_task_t * __restrict root, sched_t	Line 159 schedRead(sched_root_task_t * __restrict root, sched_t
* @func = task execution function	* @func = task execution function
* @arg = 1st func argument	* @arg = 1st func argument
* @fd = fd handle	* @fd = fd handle
	* @opt_data = Optional data
	* @opt_dlen = Optional data length
* return: NULL error or !=NULL new queued task	* return: NULL error or !=NULL new queued task
*/	*/
sched_task_t *	sched_task_t *
schedWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd)	schedWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
	void *opt_data, size_t opt_dlen)
{	{
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;
Line 117 schedWrite(sched_root_task_t * __restrict root, sched_	Line 174 schedWrite(sched_root_task_t * __restrict root, sched_
return NULL;	return NULL;

/* get new task */	/* get new task */
if ((task = TAILQ_FIRST(&root->root_unuse)))	if (!(task = _sched_useTask(root)))
TAILQ_REMOVE(&root->root_unuse, task, task_node);	return NULL;
else {
task = malloc(sizeof(sched_task_t));
if (!task) {
LOGERR;
return NULL;
}
}

memset(task, 0, sizeof(sched_task_t));	memset(task, 0, sizeof(sched_task_t));
task->task_id = 0;	task->task_id = 0;
task->task_type = taskWRITE;	task->task_lock = 0;
task->task_root = root;
task->task_func = func;	task->task_func = func;
	TASK_TYPE(task) = taskWRITE;
	TASK_ROOT(task) = root;

TASK_ARG(task) = arg;	TASK_ARG(task) = arg;
TASK_FD(task) = fd;	TASK_FD(task) = fd;

	TASK_DATA(task) = opt_data;
	TASK_DATLEN(task) = opt_dlen;

if (root->root_hooks.hook_add.write)	if (root->root_hooks.hook_add.write)
ptr = root->root_hooks.hook_add.write(task, NULL);	ptr = root->root_hooks.hook_add.write(task, NULL);
else	else
ptr = NULL;	ptr = NULL;

if (!ptr)	if (!ptr) {
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskWRITE]);
	#endif
TAILQ_INSERT_TAIL(&root->root_write, task, task_node);	TAILQ_INSERT_TAIL(&root->root_write, task, task_node);
else {	#ifdef HAVE_LIBPTHREAD
task->task_type = taskUNUSE;	pthread_mutex_unlock(&root->root_mtx[taskWRITE]);
TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);	#endif
task = NULL;	} else
}	task = _sched_unuseTask(task);

return task;	return task;
}	}
Line 157 schedWrite(sched_root_task_t * __restrict root, sched_	Line 214 schedWrite(sched_root_task_t * __restrict root, sched_
* @root = root task	* @root = root task
* @func = task execution function	* @func = task execution function
* @arg = 1st func argument	* @arg = 1st func argument
* @ms = arguments in microSecs, define period 1sec == 1000000	* @ts = timeout argument structure
	* @opt_data = Optional data
	* @opt_dlen = Optional data length
* return: NULL error or !=NULL new queued task	* return: NULL error or !=NULL new queued task
*/	*/
sched_task_t *	sched_task_t *
schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_int ms)	schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,
	void *opt_data, size_t opt_dlen)
{	{
sched_task_t task, t = NULL;	sched_task_t task, t = NULL;
void *ptr;	void *ptr;
struct timeval now;	struct timespec now;
struct timespec nw;

if (!root \|\| !func)	if (!root \|\| !func)
return NULL;	return NULL;

/* get new task */	/* get new task */
if ((task = TAILQ_FIRST(&root->root_unuse)))	if (!(task = _sched_useTask(root)))
TAILQ_REMOVE(&root->root_unuse, task, task_node);	return NULL;
else {
task = malloc(sizeof(sched_task_t));
if (!task) {
LOGERR;
return NULL;
}
}

memset(task, 0, sizeof(sched_task_t));	memset(task, 0, sizeof(sched_task_t));
task->task_id = 0;	task->task_id = 0;
task->task_type = taskTIMER;	task->task_lock = 0;
task->task_root = root;
task->task_func = func;	task->task_func = func;
	TASK_TYPE(task) = taskTIMER;
	TASK_ROOT(task) = root;

TASK_ARG(task) = arg;	TASK_ARG(task) = arg;

	TASK_DATA(task) = opt_data;
	TASK_DATLEN(task) = opt_dlen;

/* calculate timeval structure */	/* calculate timeval structure */
clock_gettime(CLOCK_MONOTONIC, &nw);	clock_gettime(CLOCK_MONOTONIC, &now);
now.tv_sec = nw.tv_sec + ms / 1000000;	now.tv_sec += ts.tv_sec;
now.tv_usec = nw.tv_nsec / 1000 + (ms % 1000000);	now.tv_nsec += ts.tv_nsec;
if (now.tv_usec >= 1000000) {	if (now.tv_nsec >= 1000000000L) {
now.tv_sec++;	now.tv_sec++;
now.tv_usec -= 1000000;	now.tv_nsec -= 1000000000L;
} else if (now.tv_usec < 0) {	} else if (now.tv_nsec < 0) {
now.tv_sec--;	now.tv_sec--;
now.tv_usec += 1000000;	now.tv_nsec += 1000000000L;
}	}
TASK_TV(task) = now;	TASK_TS(task) = now;

if (root->root_hooks.hook_add.timer)	if (root->root_hooks.hook_add.timer)
ptr = root->root_hooks.hook_add.timer(task, NULL);	ptr = root->root_hooks.hook_add.timer(task, NULL);
Line 209 schedTimer(sched_root_task_t * __restrict root, sched_	Line 265 schedTimer(sched_root_task_t * __restrict root, sched_
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr) {
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskTIMER]);
	#endif
#ifdef TIMER_WITHOUT_SORT	#ifdef TIMER_WITHOUT_SORT
TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);	TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
#else	#else
TAILQ_FOREACH(t, &root->root_timer, task_node)	TAILQ_FOREACH(t, &root->root_timer, task_node)
if (timercmp(&TASK_TV(task), &TASK_TV(t), -) < 1)	if (sched_timespeccmp(&TASK_TS(task), &TASK_TS(t), -) < 1)
break;	break;
if (!t)	if (!t)
TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);	TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
else	else
TAILQ_INSERT_BEFORE(t, task, task_node);	TAILQ_INSERT_BEFORE(t, task, task_node);
#endif	#endif
} else {	#ifdef HAVE_LIBPTHREAD
task->task_type = taskUNUSE;	pthread_mutex_unlock(&root->root_mtx[taskTIMER]);
TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);	#endif
task = NULL;	} else
}	task = _sched_unuseTask(task);

return task;	return task;
}	}
Line 235 schedTimer(sched_root_task_t * __restrict root, sched_	Line 294 schedTimer(sched_root_task_t * __restrict root, sched_
* @func = task execution function	* @func = task execution function
* @arg = 1st func argument	* @arg = 1st func argument
* @val = additional func argument	* @val = additional func argument
	* @opt_data = Optional data
	* @opt_dlen = Optional data length
* return: NULL error or !=NULL new queued task	* return: NULL error or !=NULL new queued task
*/	*/
sched_task_t *	sched_task_t *
schedEvent(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val)	schedEvent(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val,
	void *opt_data, size_t opt_dlen)
{	{
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;
Line 247 schedEvent(sched_root_task_t * __restrict root, sched_	Line 309 schedEvent(sched_root_task_t * __restrict root, sched_
return NULL;	return NULL;

/* get new task */	/* get new task */
if ((task = TAILQ_FIRST(&root->root_unuse)))	if (!(task = _sched_useTask(root)))
TAILQ_REMOVE(&root->root_unuse, task, task_node);	return NULL;
else {
task = malloc(sizeof(sched_task_t));
if (!task) {
LOGERR;
return NULL;
}
}

memset(task, 0, sizeof(sched_task_t));	memset(task, 0, sizeof(sched_task_t));
task->task_id = 0;	task->task_id = 0;
task->task_type = taskEVENT;	task->task_lock = 0;
task->task_root = root;
task->task_func = func;	task->task_func = func;
	TASK_TYPE(task) = taskEVENT;
	TASK_ROOT(task) = root;

TASK_ARG(task) = arg;	TASK_ARG(task) = arg;
TASK_VAL(task) = val;	TASK_VAL(task) = val;

	TASK_DATA(task) = opt_data;
	TASK_DATLEN(task) = opt_dlen;

if (root->root_hooks.hook_add.event)	if (root->root_hooks.hook_add.event)
ptr = root->root_hooks.hook_add.event(task, NULL);	ptr = root->root_hooks.hook_add.event(task, NULL);
else	else
ptr = NULL;	ptr = NULL;

if (!ptr)	if (!ptr) {
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskEVENT]);
	#endif
TAILQ_INSERT_TAIL(&root->root_event, task, task_node);	TAILQ_INSERT_TAIL(&root->root_event, task, task_node);
else {	#ifdef HAVE_LIBPTHREAD
task->task_type = taskUNUSE;	pthread_mutex_unlock(&root->root_mtx[taskEVENT]);
TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);	#endif
task = NULL;	} else
}	task = _sched_unuseTask(task);

return task;	return task;
}	}
Line 289 schedEvent(sched_root_task_t * __restrict root, sched_	Line 351 schedEvent(sched_root_task_t * __restrict root, sched_
* @func = task execution function	* @func = task execution function
* @arg = 1st func argument	* @arg = 1st func argument
* @val = additional func argument	* @val = additional func argument
	* @opt_data = Optional data
	* @opt_dlen = Optional data length
* return: NULL error or !=NULL new queued task	* return: NULL error or !=NULL new queued task
*/	*/
sched_task_t *	sched_task_t *
schedEventLo(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val)	schedEventLo(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val,
	void *opt_data, size_t opt_dlen)
{	{
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;
Line 301 schedEventLo(sched_root_task_t * __restrict root, sche	Line 366 schedEventLo(sched_root_task_t * __restrict root, sche
return NULL;	return NULL;

/* get new task */	/* get new task */
if ((task = TAILQ_FIRST(&root->root_unuse)))	if (!(task = _sched_useTask(root)))
TAILQ_REMOVE(&root->root_unuse, task, task_node);	return NULL;
else {
task = malloc(sizeof(sched_task_t));
if (!task) {
LOGERR;
return NULL;
}
}

memset(task, 0, sizeof(sched_task_t));	memset(task, 0, sizeof(sched_task_t));
task->task_id = 0;	task->task_id = 0;
task->task_type = taskEVENT;	task->task_lock = 0;
task->task_root = root;
task->task_func = func;	task->task_func = func;
	TASK_TYPE(task) = taskEVENT;
	TASK_ROOT(task) = root;

TASK_ARG(task) = arg;	TASK_ARG(task) = arg;
TASK_VAL(task) = val;	TASK_VAL(task) = val;

	TASK_DATA(task) = opt_data;
	TASK_DATLEN(task) = opt_dlen;

if (root->root_hooks.hook_add.eventlo)	if (root->root_hooks.hook_add.eventlo)
ptr = root->root_hooks.hook_add.eventlo(task, NULL);	ptr = root->root_hooks.hook_add.eventlo(task, NULL);
else	else
ptr = NULL;	ptr = NULL;

if (!ptr)	if (!ptr) {
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskEVENTLO]);
	#endif
TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node);	TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node);
else {	#ifdef HAVE_LIBPTHREAD
task->task_type = taskUNUSE;	pthread_mutex_unlock(&root->root_mtx[taskEVENTLO]);
TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);	#endif
task = NULL;	} else
}	task = _sched_unuseTask(task);

return task;	return task;
}	}
Line 342 schedEventLo(sched_root_task_t * __restrict root, sche	Line 407 schedEventLo(sched_root_task_t * __restrict root, sche
* @func = task execution function	* @func = task execution function
* @arg = 1st func argument	* @arg = 1st func argument
* @val = additional func argument	* @val = additional func argument
	* @opt_data = Optional data
	* @opt_dlen = Optional data length
* return: return value from called func	* return: return value from called func
*/	*/
sched_task_t *	sched_task_t *
schedCallOnce(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val)	schedCallOnce(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val,
	void *opt_data, size_t opt_dlen)
{	{
sched_task_t *task;	sched_task_t *task;
void *ret;	void *ret;
Line 354 schedCallOnce(sched_root_task_t * __restrict root, sch	Line 422 schedCallOnce(sched_root_task_t * __restrict root, sch
return NULL;	return NULL;

/* get new task */	/* get new task */
if ((task = TAILQ_FIRST(&root->root_unuse)))	if (!(task = _sched_useTask(root)))
TAILQ_REMOVE(&root->root_unuse, task, task_node);	return NULL;
else {
task = malloc(sizeof(sched_task_t));
if (!task) {
LOGERR;
return NULL;
}
}

memset(task, 0, sizeof(sched_task_t));	memset(task, 0, sizeof(sched_task_t));
task->task_id = 0;	task->task_id = 0;
task->task_type = taskEVENT;	task->task_lock = 0;
task->task_root = root;
task->task_func = func;	task->task_func = func;
	TASK_TYPE(task) = taskEVENT;
	TASK_ROOT(task) = root;

TASK_ARG(task) = arg;	TASK_ARG(task) = arg;
TASK_VAL(task) = val;	TASK_VAL(task) = val;

	TASK_DATA(task) = opt_data;
	TASK_DATLEN(task) = opt_dlen;

ret = schedCall(task);	ret = schedCall(task);

task->task_type = taskUNUSE;	_sched_unuseTask(task);
TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);
return ret;	return ret;
}	}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.2
changed lines
	Added in v.1.5