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.3 and 1.4.2.1

version 1.3, 2011/12/08 08:02:24	version 1.4.2.1, 2012/01/08 03:50:11
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
Line 64 schedRead(sched_root_task_t * __restrict root, sched_t	Line 115 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;
Line 88 schedRead(sched_root_task_t * __restrict root, sched_t	Line 133 schedRead(sched_root_task_t * __restrict root, sched_t
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 117 schedWrite(sched_root_task_t * __restrict root, sched_	Line 165 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;
Line 141 schedWrite(sched_root_task_t * __restrict root, sched_	Line 183 schedWrite(sched_root_task_t * __restrict root, sched_
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 172 schedTimer(sched_root_task_t * __restrict root, sched_	Line 217 schedTimer(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 = 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;

Line 209 schedTimer(sched_root_task_t * __restrict root, sched_	Line 248 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
Line 220 schedTimer(sched_root_task_t * __restrict root, sched_	Line 262 schedTimer(sched_root_task_t * __restrict root, sched_
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 247 schedEvent(sched_root_task_t * __restrict root, sched_	Line 289 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;
Line 271 schedEvent(sched_root_task_t * __restrict root, sched_	Line 307 schedEvent(sched_root_task_t * __restrict root, sched_
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 301 schedEventLo(sched_root_task_t * __restrict root, sche	Line 340 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;
Line 325 schedEventLo(sched_root_task_t * __restrict root, sche	Line 358 schedEventLo(sched_root_task_t * __restrict root, sche
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 354 schedCallOnce(sched_root_task_t * __restrict root, sch	Line 390 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;

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.3
changed lines
	Added in v.1.4.2.1