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.20.2.1 and 1.23

version 1.20.2.1, 2013/08/26 14:29:20	version 1.23, 2014/01/28 13:17:33
Line 12 terms:	Line 12 terms:
All of the documentation and software included in the ELWIX and AITNET	All of the documentation and software included in the ELWIX and AITNET
Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>	Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>

Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013	Copyright 2004 - 2014
by Michael Pounov <misho@elwix.org>. All rights reserved.	by Michael Pounov <misho@elwix.org>. All rights reserved.

Redistribution and use in source and binary forms, with or without	Redistribution and use in source and binary forms, with or without
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_mutex_lock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
pthread_detach(pthread_self());	TAILQ_REMOVE(&TASK_ROOT(t)->root_thread, t, task_node);
	pthread_mutex_unlock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
	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;

if (!t \|\| !TASK_ROOT(t) \|\| !TASK_RET(t))
pthread_exit(ret);
else
s = (sem_t*) TASK_RET(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);
	*/

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

/* 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 178 _sched_rtcWrapper(sched_task_t *t)	Line 173 _sched_rtcWrapper(sched_task_t *t)

timer_delete((timer_t) TASK_DATLEN(t));	timer_delete((timer_t) TASK_DATLEN(t));

return func(task);	return schedCall(task);
}	}
#endif	#endif

Line 328 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 365 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 382 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 419 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 436 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 477 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 495 sched_task_t *	Line 505 sched_task_t *
schedSignal(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long sig,	schedSignal(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long sig,
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 532 schedSignal(sched_root_task_t * __restrict root, sched	Line 546 schedSignal(sched_root_task_t * __restrict root, sched
task = sched_unuseTask(task);	task = sched_unuseTask(task);

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

/*	/*
Line 549 sched_task_t *	Line 564 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 586 schedAlarm(sched_root_task_t * __restrict root, sched_	Line 605 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 604 sched_task_t *	Line 624 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 641 schedAIO(sched_root_task_t * __restrict root, sched_ta	Line 665 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 659 sched_task_t *	Line 684 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 695 schedAIORead(sched_root_task_t * __restrict root, sche	Line 724 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 713 sched_task_t *	Line 743 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 749 schedAIOWrite(sched_root_task_t * __restrict root, sch	Line 783 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 767 sched_task_t *	Line 802 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 804 schedLIO(sched_root_task_t * __restrict root, sched_ta	Line 843 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 822 sched_task_t *	Line 862 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 876 schedLIORead(sched_root_task_t * __restrict root, sche	Line 920 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 894 sched_task_t *	Line 939 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 948 schedLIOWrite(sched_root_task_t * __restrict root, sch	Line 997 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 1245 schedCallOnce(sched_root_task_t * __restrict root, sch	Line 1295 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 1260 schedThread(sched_root_task_t * __restrict root, sched	Line 1309 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 1296 schedThread(sched_root_task_t * __restrict root, sched	Line 1325 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 1331 schedThread(sched_root_task_t * __restrict root, sched	Line 1352 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.20.2.1
changed lines
	Added in v.1.23