haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

coroutine: switch per-thread free pool to a global pool

Browse source 
ucontext-based coroutines use a free pool to reduce allocations and
deallocations of coroutine objects.  The pool is per-thread, presumably
to improve locality.  However, as coroutines are usually allocated in
a vcpu thread and freed in the I/O thread, the pool accounting gets
screwed up and we end allocating and freeing a coroutine for every I/O
request.  This is expensive since large objects are allocated via the
kernel, and are not cached by the C runtime.

Fix by switching to a global pool.  This is safe since we're protected
by the global mutex.

Signed-off-by: Avi Kivity <avi@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Avi Kivity 2011-12-05 19:20:12 +02:00 committed by Kevin Wolf
parent c2c9a46609
commit 39a7a362e1
1 changed files with 16 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
coroutine-ucontext.c
View file

@ -35,6 +35,10 @@ enum {
POOL_MAX_SIZE = 64, POOL_MAX_SIZE = 64,
}; };
/** Free list to speed up creation */
static QLIST_HEAD(, Coroutine) pool = QLIST_HEAD_INITIALIZER(pool);
static unsigned int pool_size;
typedef struct { typedef struct {
Coroutine base; Coroutine base;
void *stack; void *stack;
@ -48,10 +52,6 @@ typedef struct {
/** Currently executing coroutine */ /** Currently executing coroutine */
Coroutine *current; Coroutine *current;
/** Free list to speed up creation */
QLIST_HEAD(, Coroutine) pool;
unsigned int pool_size;
/** The default coroutine */ /** The default coroutine */
CoroutineUContext leader; CoroutineUContext leader;
} CoroutineThreadState; } CoroutineThreadState;
@ -75,7 +75,6 @@ static CoroutineThreadState *coroutine_get_thread_state(void)
if (!s) { if (!s) {
s = g_malloc0(sizeof(*s)); s = g_malloc0(sizeof(*s));
s->current = &s->leader.base; s->current = &s->leader.base;
QLIST_INIT(&s->pool);
pthread_setspecific(thread_state_key, s); pthread_setspecific(thread_state_key, s);
} }
return s; return s;
@ -84,14 +83,19 @@ static CoroutineThreadState *coroutine_get_thread_state(void)
static void qemu_coroutine_thread_cleanup(void *opaque) static void qemu_coroutine_thread_cleanup(void *opaque)
{ {
CoroutineThreadState *s = opaque; CoroutineThreadState *s = opaque;
g_free(s);
}
static void __attribute__((destructor)) coroutine_cleanup(void)
{
Coroutine *co; Coroutine *co;
Coroutine *tmp; Coroutine *tmp;
QLIST_FOREACH_SAFE(co, &s->pool, pool_next, tmp) { QLIST_FOREACH_SAFE(co, &pool, pool_next, tmp) {
g_free(DO_UPCAST(CoroutineUContext, base, co)->stack); g_free(DO_UPCAST(CoroutineUContext, base, co)->stack);
g_free(co); g_free(co);
} }
g_free(s);
} }
static void __attribute__((constructor)) coroutine_init(void) static void __attribute__((constructor)) coroutine_init(void)
@ -169,13 +173,12 @@ static Coroutine *coroutine_new(void)
Coroutine *qemu_coroutine_new(void) Coroutine *qemu_coroutine_new(void)
{ {
CoroutineThreadState *s = coroutine_get_thread_state();
Coroutine *co; Coroutine *co;
co = QLIST_FIRST(&s->pool); co = QLIST_FIRST(&pool);
if (co) { if (co) {
QLIST_REMOVE(co, pool_next); QLIST_REMOVE(co, pool_next);
s->pool_size--; pool_size--;
} else { } else {
co = coroutine_new(); co = coroutine_new();
} }
@ -184,13 +187,12 @@ Coroutine *qemu_coroutine_new(void)
void qemu_coroutine_delete(Coroutine *co_) void qemu_coroutine_delete(Coroutine *co_)
{ {
CoroutineThreadState *s = coroutine_get_thread_state();
CoroutineUContext *co = DO_UPCAST(CoroutineUContext, base, co_); CoroutineUContext *co = DO_UPCAST(CoroutineUContext, base, co_);
if (s->pool_size < POOL_MAX_SIZE) { if (pool_size < POOL_MAX_SIZE) {
QLIST_INSERT_HEAD(&s->pool, &co->base, pool_next); QLIST_INSERT_HEAD(&pool, &co->base, pool_next);
co->base.caller = NULL; co->base.caller = NULL;
s->pool_size++; pool_size++;
return; return;
} }