Git Repo - qemu.git/blame_incremental

... / ...

Commit	Line	Data
	1	/*
	2	* QEMU coroutines
	3	*
	4	* Copyright IBM, Corp. 2011
	5	*
	6	* Authors:
	7	* Stefan Hajnoczi <[email protected]>
	8	* Kevin Wolf <[email protected]>
	9	*
	10	* This work is licensed under the terms of the GNU LGPL, version 2 or later.
	11	* See the COPYING.LIB file in the top-level directory.
	12	*
	13	*/
	14
	15	#include "trace.h"
	16	#include "qemu-common.h"
	17	#include "qemu/thread.h"
	18	#include "qemu/atomic.h"
	19	#include "block/coroutine.h"
	20	#include "block/coroutine_int.h"
	21
	22	enum {
	23	POOL_BATCH_SIZE = 64,
	24	};
	25
	26	/** Free list to speed up creation */
	27	static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool);
	28	static unsigned int release_pool_size;
	29	static __thread QSLIST_HEAD(, Coroutine) alloc_pool = QSLIST_HEAD_INITIALIZER(pool);
	30	static __thread unsigned int alloc_pool_size;
	31	static __thread Notifier coroutine_pool_cleanup_notifier;
	32
	33	static void coroutine_pool_cleanup(Notifier n, void value)
	34	{
	35	Coroutine *co;
	36	Coroutine *tmp;
	37
	38	QSLIST_FOREACH_SAFE(co, &alloc_pool, pool_next, tmp) {
	39	QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
	40	qemu_coroutine_delete(co);
	41	}
	42	}
	43
	44	Coroutine qemu_coroutine_create(CoroutineEntry entry)
	45	{
	46	Coroutine *co = NULL;
	47
	48	if (CONFIG_COROUTINE_POOL) {
	49	co = QSLIST_FIRST(&alloc_pool);
	50	if (!co) {
	51	if (release_pool_size > POOL_BATCH_SIZE) {
	52	/* Slow path; a good place to register the destructor, too. */
	53	if (!coroutine_pool_cleanup_notifier.notify) {
	54	coroutine_pool_cleanup_notifier.notify = coroutine_pool_cleanup;
	55	qemu_thread_atexit_add(&coroutine_pool_cleanup_notifier);
	56	}
	57
	58	/* This is not exact; there could be a little skew between
	59	* release_pool_size and the actual size of release_pool. But
	60	* it is just a heuristic, it does not need to be perfect.
	61	*/
	62	alloc_pool_size = atomic_xchg(&release_pool_size, 0);
	63	QSLIST_MOVE_ATOMIC(&alloc_pool, &release_pool);
	64	co = QSLIST_FIRST(&alloc_pool);
	65	}
	66	}
	67	if (co) {
	68	QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
	69	alloc_pool_size--;
	70	}
	71	}
	72
	73	if (!co) {
	74	co = qemu_coroutine_new();
	75	}
	76
	77	co->entry = entry;
	78	QTAILQ_INIT(&co->co_queue_wakeup);
	79	return co;
	80	}
	81
	82	static void coroutine_delete(Coroutine *co)
	83	{
	84	co->caller = NULL;
	85
	86	if (CONFIG_COROUTINE_POOL) {
	87	if (release_pool_size < POOL_BATCH_SIZE * 2) {
	88	QSLIST_INSERT_HEAD_ATOMIC(&release_pool, co, pool_next);
	89	atomic_inc(&release_pool_size);
	90	return;
	91	}
	92	if (alloc_pool_size < POOL_BATCH_SIZE) {
	93	QSLIST_INSERT_HEAD(&alloc_pool, co, pool_next);
	94	alloc_pool_size++;
	95	return;
	96	}
	97	}
	98
	99	qemu_coroutine_delete(co);
	100	}
	101
	102	static void coroutine_swap(Coroutine from, Coroutine to)
	103	{
	104	CoroutineAction ret;
	105
	106	ret = qemu_coroutine_switch(from, to, COROUTINE_YIELD);
	107
	108	qemu_co_queue_run_restart(to);
	109
	110	switch (ret) {
	111	case COROUTINE_YIELD:
	112	return;
	113	case COROUTINE_TERMINATE:
	114	trace_qemu_coroutine_terminate(to);
	115	coroutine_delete(to);
	116	return;
	117	default:
	118	abort();
	119	}
	120	}
	121
	122	void qemu_coroutine_enter(Coroutine co, void opaque)
	123	{
	124	Coroutine *self = qemu_coroutine_self();
	125
	126	trace_qemu_coroutine_enter(self, co, opaque);
	127
	128	if (co->caller) {
	129	fprintf(stderr, "Co-routine re-entered recursively\n");
	130	abort();
	131	}
	132
	133	co->caller = self;
	134	co->entry_arg = opaque;
	135	coroutine_swap(self, co);
	136	}
	137
	138	void coroutine_fn qemu_coroutine_yield(void)
	139	{
	140	Coroutine *self = qemu_coroutine_self();
	141	Coroutine *to = self->caller;
	142
	143	trace_qemu_coroutine_yield(self, to);
	144
	145	if (!to) {
	146	fprintf(stderr, "Co-routine is yielding to no one\n");
	147	abort();
	148	}
	149
	150	self->caller = NULL;
	151	coroutine_swap(self, to);
	152	}