Le jeudi 9 juin 2011 19:41:06, Aneesh Kumar K.V a écrit : > On platforms that doesn't support makecontext use gthread > based coroutine implementation.
Why not using one of the existing lib of coroutine or improving it ? Could you give some hints ? Why not use http://cvs.schmorp.de/libcoro/coro.h what is the base of the perl coroutine lib and thus well tested on a lot of plateform? Bastien > > Signed-off-by: Aneesh Kumar K.V <aneesh.ku...@linux.vnet.ibm.com> > --- > > NOTE: Tested on linux with force compliation of coroutine-gthread.c > > Makefile.objs | 5 ++ > configure | 18 +++++ > coroutine-gthread.c | 172 > +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 195 > insertions(+), 0 deletions(-) > create mode 100644 coroutine-gthread.c > > diff --git a/Makefile.objs b/Makefile.objs > index 0f1d7df..d354d3c 100644 > --- a/Makefile.objs > +++ b/Makefile.objs > @@ -13,9 +13,14 @@ oslib-obj-$(CONFIG_POSIX) += oslib-posix.o > qemu-thread-posix.o > ####################################################################### # > coroutines > coroutine-obj-y = qemu-coroutine.o qemu-coroutine-lock.o > +ifeq ($(CONFIG_UCONTEXT_COROUTINE),y) > coroutine-obj-$(CONFIG_POSIX) += coroutine-ucontext.o > +else > +coroutine-obj-$(CONFIG_POSIX) += coroutine-gthread.o > +endif > coroutine-obj-$(CONFIG_WIN32) += coroutine-win32.o > > + > ####################################################################### > # block-obj-y is code used by both qemu system emulation and qemu-img > > diff --git a/configure b/configure > index 980914a..529d8c4 100755 > --- a/configure > +++ b/configure > @@ -2568,6 +2568,20 @@ if test "$trace_backend" = "dtrace"; then > fi > > ########################################## > +# check if we have makecontext > + > +ucontext_coroutine=no > +cat > $TMPC << EOF > +#include <ucontext.h> > +int main(void) { makecontext(0, 0, 0); } > +EOF > +if compile_prog "" "" ; then > + ucontext_coroutine=yes > +fi > + > + > + > +########################################## > # End of CC checks > # After here, no more $cc or $ld runs > > @@ -3031,6 +3045,10 @@ if test "$rbd" = "yes" ; then > echo "CONFIG_RBD=y" >> $config_host_mak > fi > > +if test "$ucontext_coroutine" = "yes" ; then > + echo "CONFIG_UCONTEXT_COROUTINE=y" >> $config_host_mak > +fi > + > # USB host support > case "$usb" in > linux) > diff --git a/coroutine-gthread.c b/coroutine-gthread.c > new file mode 100644 > index 0000000..37e5a16 > --- /dev/null > +++ b/coroutine-gthread.c > @@ -0,0 +1,172 @@ > +/* > + * > + * Copyright (C) 2006 Anthony Liguori <anth...@codemonkey.ws> > + * Copyright (C) 2011 Aneesh Kumar K.V <aneesh.ku...@linux.vnet.ibm.com> > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2.0 of the License, or (at your option) any later version. > + * > + * This library is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, write to the Free Software > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA > 02110-1301 USA + */ > + > +#include "qemu-common.h" > +#include "qemu-coroutine-int.h" > +#include <glib.h> > + > +typedef struct { > + Coroutine qemu_co; > + GThread *thread; > + gboolean runnable; > +} CoroutineGthread; > + > +typedef struct { > + /** Currently executing coroutine */ > + CoroutineGthread *current; > + > + /** The default coroutine */ > + CoroutineGthread leader; > +} CoroutineThreadState; > + > +static GCond *run_cond; > +static GMutex *run_lock; > +static pthread_key_t thread_state_key; > + > +static void qemu_coroutine_thread_cleanup(void *opaque) > +{ > + CoroutineThreadState *s = opaque; > + > + qemu_free(s); > +} > + > +static void __attribute__((constructor)) coroutine_system_init(void) > +{ > + int ret; > + if (!g_thread_supported()) { > + g_thread_init(NULL); > + } > + run_cond = g_cond_new(); > + run_lock = g_mutex_new(); > + > + ret = pthread_key_create(&thread_state_key, > qemu_coroutine_thread_cleanup); + if (ret != 0) { > + fprintf(stderr, "unable to create leader key: %s\n", > strerror(errno)); + abort(); > + } > +} > + > +static CoroutineThreadState *coroutine_get_thread_state(void) > +{ > + CoroutineThreadState *s = pthread_getspecific(thread_state_key); > + > + if (!s) { > + s = qemu_mallocz(sizeof(*s)); > + s->current = &s->leader; > + pthread_setspecific(thread_state_key, s); > + } > + return s; > +} > + > +static gpointer coroutine_thread(gpointer opaque) > +{ > + CoroutineGthread *co = opaque; > + CoroutineThreadState *s = coroutine_get_thread_state(); > + > + s->current = co; > + > + /* Wait for somebody make it runnable */ > + g_mutex_lock(run_lock); > + while (!co->runnable) { > + g_cond_wait(run_cond, run_lock); > + } > + g_mutex_unlock(run_lock); > + /* > + * run the coroutine function > + * Coroutines can run in parallel. > + */ > + co->qemu_co.entry(co->qemu_co.entry_arg); > + > + /* Now yield with terminating status */ > + qemu_coroutine_switch(&co->qemu_co, > + co->qemu_co.caller, COROUTINE_TERMINATE); > + return NULL; > +} > + > +Coroutine *qemu_coroutine_new(void) > +{ > + CoroutineGthread *co; > + if (run_cond == NULL) { > + abort(); > + } > + co = qemu_mallocz(sizeof(*co)); > + co->runnable = FALSE; > + co->thread = g_thread_create_full(coroutine_thread, co, 0, > + FALSE, TRUE, > + G_THREAD_PRIORITY_NORMAL, > + NULL); > + if (co->thread == NULL) { > + qemu_free(co); > + return NULL; > + } > + co->qemu_co.caller = NULL; > + return &co->qemu_co; > +} > + > +Coroutine *qemu_coroutine_self(void) > +{ > + CoroutineThreadState *s = coroutine_get_thread_state(); > + > + return &s->current->qemu_co; > +} > + > +CoroutineAction qemu_coroutine_switch(Coroutine *qemu_co_from, > + Coroutine *qemu_co_to, > + CoroutineAction action) > +{ > + CoroutineGthread *from = DO_UPCAST(CoroutineGthread, qemu_co, > qemu_co_from); + CoroutineGthread *to = DO_UPCAST(CoroutineGthread, > qemu_co, qemu_co_to); + > + /* Wakeup the runnable to coroutine */ > + g_mutex_lock(run_lock); > + to->qemu_co.caller = qemu_co_from; > + from->runnable = FALSE; > + to->runnable = TRUE; > + g_cond_broadcast(run_cond); > + g_mutex_unlock(run_lock); > + > + /* Don't wait if we are going to terminate */ > + if (action == COROUTINE_TERMINATE) { > + return action; > + } > + > + /* Now wait for somebody to make from runnable */ > + g_mutex_lock(run_lock); > + while (!from->runnable) { > + g_cond_wait(run_cond, run_lock); > + } > + g_mutex_unlock(run_lock); > + return action; > +} > + > +bool qemu_in_coroutine(void) > +{ > + CoroutineThreadState *s = pthread_getspecific(thread_state_key); > + > + return s && s->current->qemu_co.caller; > +} > + > +void qemu_coroutine_delete(Coroutine *qemu_co) > +{ > + CoroutineGthread *co = DO_UPCAST(CoroutineGthread, qemu_co, qemu_co); > + qemu_free(co); > + return; > +} > +
