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.19.2.1 and 1.22.8.1

version 1.19.2.1, 2013/08/26 13:26:56	version 1.22.8.1, 2014/01/28 10:21:43
Line 115 _sched_threadCleanup(sched_task_t *t)	Line 115 _sched_threadCleanup(sched_task_t *t)
if (!t \|\| !TASK_ROOT(t))	if (!t \|\| !TASK_ROOT(t))
return;	return;

if (TASK_FLAG(t) == PTHREAD_CREATE_JOINABLE)
pthread_detach(pthread_self());

pthread_mutex_lock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);	pthread_mutex_lock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
TAILQ_REMOVE(&TASK_ROOT(t)->root_thread, t, task_node);	TAILQ_REMOVE(&TASK_ROOT(t)->root_thread, t, task_node);
pthread_mutex_unlock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);	pthread_mutex_unlock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);

sched_unuseTask(t);	sched_unuseTask(t);
}	}
void *	void *
_sched_threadWrapper(sched_task_t *t)	_sched_threadWrapper(sched_task_t *t)
{	{
void *ret = NULL;	void *ret = NULL;
sem_t *s = NULL;
sched_root_task_t *r;

if (!t \|\| !TASK_ROOT(t) \|\| !TASK_RET(t))
pthread_exit(ret);
else {
s = (sem_t*) TASK_RET(t);
r = TASK_ROOT(t);
}

pthread_cleanup_push((void ()(void)) _sched_threadCleanup, t);	pthread_cleanup_push((void ()(void)) _sched_threadCleanup, t);

	if (!t \|\| !TASK_ROOT(t))
	pthread_exit(ret);

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
	/*
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
	*/

#ifdef HAVE_LIBPTHREAD
pthread_mutex_lock(&r->root_mtx[taskTHREAD]);
#endif
TAILQ_REMOVE(&r->root_thread, t, task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&r->root_mtx[taskTHREAD]);
#endif
t->task_type = taskUNUSE;
#ifdef HAVE_LIBPTHREAD
pthread_mutex_lock(&r->root_mtx[taskUNUSE]);
#endif
TAILQ_INSERT_TAIL(&r->root_unuse, t, task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&r->root_mtx[taskUNUSE]);
#endif

/* notify parent, thread is ready for execution */	/* notify parent, thread is ready for execution */
sem_post(s);
pthread_testcancel();	pthread_testcancel();

ret = TASK_FUNC(t)(t);	ret = schedCall(t);

pthread_cleanup_pop(42);	pthread_cleanup_pop(42);
TASK_ROOT(t)->root_ret = ret;	TASK_ROOT(t)->root_ret = ret;
Line 175 _sched_threadWrapper(sched_task_t *t)	Line 150 _sched_threadWrapper(sched_task_t *t)
void *	void *
_sched_rtcWrapper(sched_task_t *t)	_sched_rtcWrapper(sched_task_t *t)
{	{
void *ret = NULL;
sched_task_func_t func;	sched_task_func_t func;
sched_task_t *task;	sched_task_t *task;
sched_root_task_t *r;	sched_root_task_t *r;
Line 195 _sched_rtcWrapper(sched_task_t *t)	Line 169 _sched_rtcWrapper(sched_task_t *t)
#ifdef HAVE_LIBPTHREAD	#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&r->root_mtx[taskRTC]);	pthread_mutex_unlock(&r->root_mtx[taskRTC]);
#endif	#endif
task->task_type = taskUNUSE;	sched_unuseTask(task);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_lock(&r->root_mtx[taskUNUSE]);
#endif
TAILQ_INSERT_TAIL(&r->root_unuse, task, task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&r->root_mtx[taskUNUSE]);
#endif

ret = func(task);

timer_delete((timer_t) TASK_DATLEN(t));	timer_delete((timer_t) TASK_DATLEN(t));
return ret;
	return schedCall(task);
}	}
#endif	#endif

Line 357 sched_task_t *	Line 323 sched_task_t *
schedNode(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedNode(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;

Line 394 schedNode(sched_root_task_t * __restrict root, sched_t	Line 364 schedNode(sched_root_task_t * __restrict root, sched_t
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
	#endif /* KQ_DISABLE */
}	}

/*	/*
Line 411 sched_task_t *	Line 382 sched_task_t *
schedProc(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long pid,	schedProc(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long pid,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;

Line 448 schedProc(sched_root_task_t * __restrict root, sched_t	Line 423 schedProc(sched_root_task_t * __restrict root, sched_t
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
	#endif /* KQ_DISABLE */
}	}

/*	/*
Line 465 sched_task_t *	Line 441 sched_task_t *
schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id,	schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
#ifndef EVFILT_USER	#ifndef EVFILT_USER
sched_SetErr(ENOTSUP, "Not supported kevent() filter");	sched_SetErr(ENOTSUP, "Not supported kevent() filter");
return NULL;	return NULL;
Line 506 schedUser(sched_root_task_t * __restrict root, sched_t	Line 486 schedUser(sched_root_task_t * __restrict root, sched_t
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif	#endif /* EVFILT_USER */
	#endif /* KQ_DISABLE */
}	}

/*	/*
Line 578 sched_task_t *	Line 559 sched_task_t *
schedAlarm(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,	schedAlarm(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;

Line 615 schedAlarm(sched_root_task_t * __restrict root, sched_	Line 600 schedAlarm(sched_root_task_t * __restrict root, sched_
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
	#endif /* KQ_DISABLE */
}	}

#ifdef AIO_SUPPORT	#ifdef AIO_SUPPORT
Line 633 sched_task_t *	Line 619 sched_task_t *
schedAIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,	schedAIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,
struct aiocb * __restrict acb, void *opt_data, size_t opt_dlen)	struct aiocb * __restrict acb, void *opt_data, size_t opt_dlen)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;

Line 670 schedAIO(sched_root_task_t * __restrict root, sched_ta	Line 660 schedAIO(sched_root_task_t * __restrict root, sched_ta
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
	#endif /* KQ_DISABLE */
}	}

/*	/*
Line 688 sched_task_t *	Line 679 sched_task_t *
schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
void *buffer, size_t buflen, off_t offset)	void *buffer, size_t buflen, off_t offset)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
struct aiocb *acb;	struct aiocb *acb;
off_t off;	off_t off;

Line 724 schedAIORead(sched_root_task_t * __restrict root, sche	Line 719 schedAIORead(sched_root_task_t * __restrict root, sche
}	}

return schedAIO(root, func, arg, acb, buffer, buflen);	return schedAIO(root, func, arg, acb, buffer, buflen);
	#endif /* KQ_DISABLE */
}	}

/*	/*
Line 742 sched_task_t *	Line 738 sched_task_t *
schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
void *buffer, size_t buflen, off_t offset)	void *buffer, size_t buflen, off_t offset)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
struct aiocb *acb;	struct aiocb *acb;
off_t off;	off_t off;

Line 778 schedAIOWrite(sched_root_task_t * __restrict root, sch	Line 778 schedAIOWrite(sched_root_task_t * __restrict root, sch
}	}

return schedAIO(root, func, arg, acb, buffer, buflen);	return schedAIO(root, func, arg, acb, buffer, buflen);
	#endif /* KQ_DISABLE */
}	}

#ifdef EVFILT_LIO	#ifdef EVFILT_LIO
Line 796 sched_task_t *	Line 797 sched_task_t *
schedLIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,	schedLIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,
struct aiocb ** __restrict acbs, void *opt_data, size_t opt_dlen)	struct aiocb ** __restrict acbs, void *opt_data, size_t opt_dlen)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;

Line 833 schedLIO(sched_root_task_t * __restrict root, sched_ta	Line 838 schedLIO(sched_root_task_t * __restrict root, sched_ta
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
	#endif /* KQ_DISABLE */
}	}

/*	/*
Line 851 sched_task_t *	Line 857 sched_task_t *
schedLIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedLIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
struct iovec *bufs, size_t nbufs, off_t offset)	struct iovec *bufs, size_t nbufs, off_t offset)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
struct sigevent sig;	struct sigevent sig;
struct aiocb **acb;	struct aiocb **acb;
off_t off;	off_t off;
Line 905 schedLIORead(sched_root_task_t * __restrict root, sche	Line 915 schedLIORead(sched_root_task_t * __restrict root, sche
}	}

return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);	return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
	#endif /* KQ_DISABLE */
}	}

/*	/*
Line 923 sched_task_t *	Line 934 sched_task_t *
schedLIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedLIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
struct iovec *bufs, size_t nbufs, off_t offset)	struct iovec *bufs, size_t nbufs, off_t offset)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return NULL;
	#else
struct sigevent sig;	struct sigevent sig;
struct aiocb **acb;	struct aiocb **acb;
off_t off;	off_t off;
Line 977 schedLIOWrite(sched_root_task_t * __restrict root, sch	Line 992 schedLIOWrite(sched_root_task_t * __restrict root, sch
}	}

return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);	return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
	#endif /* KQ_DISABLE */
}	}
#endif /* EVFILT_LIO */	#endif /* EVFILT_LIO */
#endif /* AIO_SUPPORT */	#endif /* AIO_SUPPORT */
Line 1274 schedCallOnce(sched_root_task_t * __restrict root, sch	Line 1290 schedCallOnce(sched_root_task_t * __restrict root, sch
* @root = root task	* @root = root task
* @func = task execution function	* @func = task execution function
* @arg = 1st func argument	* @arg = 1st func argument
* @detach = Detach thread from scheduler, if !=0
* @ss = stack size	* @ss = stack size
* @opt_data = Optional data	* @opt_data = Optional data
* @opt_dlen = Optional data length	* @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 *
schedThread(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int detach,	schedThread(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,
size_t ss, void *opt_data, size_t opt_dlen)	size_t ss, void *opt_data, size_t opt_dlen)
{	{
#ifndef HAVE_LIBPTHREAD	#ifndef HAVE_LIBPTHREAD
Line 1289 schedThread(sched_root_task_t * __restrict root, sched	Line 1304 schedThread(sched_root_task_t * __restrict root, sched
return NULL;	return NULL;
#endif	#endif
sched_task_t *task;	sched_task_t *task;
void *ptr;
pthread_attr_t attr;	pthread_attr_t attr;
sem_t *s = NULL;

if (!root \|\| !func)	if (!root \|\| !func)
return NULL;	return NULL;
else {
/* normalizing stack size & detach state */
if (ss)
ss &= 0x7FFFFFFF;
detach = detach ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE;
}

if (!(s = (sem_t*) malloc(sizeof(sem_t)))) {
LOGERR;
return NULL;
}
if (sem_init(s, 0, 1)) {
LOGERR;
free(s);
return NULL;
}

/* get new task */	/* get new task */
if (!(task = sched_useTask(root))) {	if (!(task = sched_useTask(root))) {
sem_destroy(s);
free(s);

return NULL;	return NULL;
}	}
Line 1325 schedThread(sched_root_task_t * __restrict root, sched	Line 1320 schedThread(sched_root_task_t * __restrict root, sched
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

TASK_ARG(task) = arg;	TASK_ARG(task) = arg;
TASK_FLAG(task) = detach;
TASK_RET(task) = (intptr_t) s;

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

pthread_attr_init(&attr);	pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, detach);	pthread_attr_setdetachstate(&attr, PTHREAD_DETACHED);
if (ss && (errno = pthread_attr_setstacksize(&attr, ss))) {	if (ss && (errno = pthread_attr_setstacksize(&attr, ss))) {
LOGERR;	LOGERR;
pthread_attr_destroy(&attr);	pthread_attr_destroy(&attr);
sem_destroy(s);
free(s);
return sched_unuseTask(task);	return sched_unuseTask(task);
}	}
if ((errno = pthread_attr_getstacksize(&attr, &ss))) {	if ((errno = pthread_attr_getstacksize(&attr, &ss))) {
LOGERR;	LOGERR;
pthread_attr_destroy(&attr);	pthread_attr_destroy(&attr);
sem_destroy(s);
free(s);
return sched_unuseTask(task);	return sched_unuseTask(task);
} else	} else
TASK_FLAG(task) \|= (ss << 1);	TASK_FLAG(task) = ss;
if ((errno = pthread_attr_setguardsize(&attr, ss))) {	if ((errno = pthread_attr_setguardsize(&attr, ss))) {
LOGERR;	LOGERR;
pthread_attr_destroy(&attr);	pthread_attr_destroy(&attr);
sem_destroy(s);
free(s);
return sched_unuseTask(task);	return sched_unuseTask(task);
}	}
#ifdef SCHED_RR	#ifdef SCHED_RR
Line 1360 schedThread(sched_root_task_t * __restrict root, sched	Line 1347 schedThread(sched_root_task_t * __restrict root, sched
#else	#else
pthread_attr_setschedpolicy(&attr, SCHED_OTHER);	pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
#endif	#endif
if (root->root_hooks.hook_add.thread)
ptr = root->root_hooks.hook_add.thread(task, &attr);
else
ptr = NULL;
pthread_attr_destroy(&attr);

if (!ptr) {	pthread_mutex_lock(&root->root_mtx[taskTHREAD]);
pthread_mutex_lock(&root->root_mtx[taskTHREAD]);	TAILQ_INSERT_TAIL(&root->root_thread, TASK_ID(task), task_node);
TAILQ_INSERT_TAIL(&root->root_thread, TASK_ID(task), task_node);	pthread_mutex_unlock(&root->root_mtx[taskTHREAD]);
pthread_mutex_unlock(&root->root_mtx[taskTHREAD]);

/* wait for init thread actions */	if (root->root_hooks.hook_add.thread)
sem_wait(s);	if (root->root_hooks.hook_add.thread(task, &attr)) {
} else	schedCancel(task);
task = sched_unuseTask(task);	task = NULL;
	}
sem_destroy(s);	pthread_attr_destroy(&attr);
free(s);
return task;	return task;
}	}

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

Removed from v.1.19.2.1
changed lines
	Added in v.1.22.8.1