[qemu.git] / tests / test-aio-multithread.c

/*
 * AioContext multithreading tests
 *
 * Copyright Red Hat, Inc. 2016
 *
 * Authors:
 *  Paolo Bonzini    <[email protected]>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
 * See the COPYING.LIB file in the top-level directory.
 */

#include "qemu/osdep.h"
#include "block/aio.h"
#include "qemu/coroutine.h"
#include "qemu/thread.h"
#include "qemu/error-report.h"
#include "iothread.h"

/* AioContext management */

#define NUM_CONTEXTS 5

static IOThread *threads[NUM_CONTEXTS];
static AioContext *ctx[NUM_CONTEXTS];
static __thread int id = -1;

static QemuEvent done_event;

/* Run a function synchronously on a remote iothread. */

typedef struct CtxRunData {
    QEMUBHFunc *cb;
    void *arg;
} CtxRunData;

static void ctx_run_bh_cb(void *opaque)
{
    CtxRunData *data = opaque;

    data->cb(data->arg);
    qemu_event_set(&done_event);
}

static void ctx_run(int i, QEMUBHFunc *cb, void *opaque)
{
    CtxRunData data = {
        .cb = cb,
        .arg = opaque
    };

    qemu_event_reset(&done_event);
    aio_bh_schedule_oneshot(ctx[i], ctx_run_bh_cb, &data);
    qemu_event_wait(&done_event);
}

/* Starting the iothreads. */

static void set_id_cb(void *opaque)
{
    int *i = opaque;

    id = *i;
}

static void create_aio_contexts(void)
{
    int i;

    for (i = 0; i < NUM_CONTEXTS; i++) {
        threads[i] = iothread_new();
        ctx[i] = iothread_get_aio_context(threads[i]);
    }

    qemu_event_init(&done_event, false);
    for (i = 0; i < NUM_CONTEXTS; i++) {
        ctx_run(i, set_id_cb, &i);
    }
}

/* Stopping the iothreads. */

static void join_aio_contexts(void)
{
    int i;

    for (i = 0; i < NUM_CONTEXTS; i++) {
        aio_context_ref(ctx[i]);
    }
    for (i = 0; i < NUM_CONTEXTS; i++) {
        iothread_join(threads[i]);
    }
    for (i = 0; i < NUM_CONTEXTS; i++) {
        aio_context_unref(ctx[i]);
    }
    qemu_event_destroy(&done_event);
}

/* Basic test for the stuff above. */

static void test_lifecycle(void)
{
    create_aio_contexts();
    join_aio_contexts();
}

/* aio_co_schedule test.  */

static Coroutine *to_schedule[NUM_CONTEXTS];

static bool now_stopping;

static int count_retry;
static int count_here;
static int count_other;

static bool schedule_next(int n)
{
    Coroutine *co;

    co = atomic_xchg(&to_schedule[n], NULL);
    if (!co) {
        atomic_inc(&count_retry);
        return false;
    }

    if (n == id) {
        atomic_inc(&count_here);
    } else {
        atomic_inc(&count_other);
    }

    aio_co_schedule(ctx[n], co);
    return true;
}

static void finish_cb(void *opaque)
{
    schedule_next(id);
}

static coroutine_fn void test_multi_co_schedule_entry(void *opaque)
{
    g_assert(to_schedule[id] == NULL);

    while (!atomic_mb_read(&now_stopping)) {
        int n;

        n = g_test_rand_int_range(0, NUM_CONTEXTS);
        schedule_next(n);

        atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
        qemu_coroutine_yield();
        g_assert(to_schedule[id] == NULL);
    }
}


static void test_multi_co_schedule(int seconds)
{
    int i;

    count_here = count_other = count_retry = 0;
    now_stopping = false;

    create_aio_contexts();
    for (i = 0; i < NUM_CONTEXTS; i++) {
        Coroutine *co1 = qemu_coroutine_create(test_multi_co_schedule_entry, NULL);
        aio_co_schedule(ctx[i], co1);
    }

    g_usleep(seconds * 1000000);

    atomic_mb_set(&now_stopping, true);
    for (i = 0; i < NUM_CONTEXTS; i++) {
        ctx_run(i, finish_cb, NULL);
        to_schedule[i] = NULL;
    }

    join_aio_contexts();
    g_test_message("scheduled %d, queued %d, retry %d, total %d\n",
                  count_other, count_here, count_retry,
                  count_here + count_other + count_retry);
}

static void test_multi_co_schedule_1(void)
{
    test_multi_co_schedule(1);
}

static void test_multi_co_schedule_10(void)
{
    test_multi_co_schedule(10);
}

/* CoMutex thread-safety.  */

static uint32_t atomic_counter;
static uint32_t running;
static uint32_t counter;
static CoMutex comutex;

static void coroutine_fn test_multi_co_mutex_entry(void *opaque)
{
    while (!atomic_mb_read(&now_stopping)) {
        qemu_co_mutex_lock(&comutex);
        counter++;
        qemu_co_mutex_unlock(&comutex);

        /* Increase atomic_counter *after* releasing the mutex.  Otherwise
         * there is a chance (it happens about 1 in 3 runs) that the iothread
         * exits before the coroutine is woken up, causing a spurious
         * assertion failure.
         */
        atomic_inc(&atomic_counter);
    }
    atomic_dec(&running);
}

static void test_multi_co_mutex(int threads, int seconds)
{
    int i;

    qemu_co_mutex_init(&comutex);
    counter = 0;
    atomic_counter = 0;
    now_stopping = false;

    create_aio_contexts();
    assert(threads <= NUM_CONTEXTS);
    running = threads;
    for (i = 0; i < threads; i++) {
        Coroutine *co1 = qemu_coroutine_create(test_multi_co_mutex_entry, NULL);
        aio_co_schedule(ctx[i], co1);
    }

    g_usleep(seconds * 1000000);

    atomic_mb_set(&now_stopping, true);
    while (running > 0) {
        g_usleep(100000);
    }

    join_aio_contexts();
    g_test_message("%d iterations/second\n", counter / seconds);
    g_assert_cmpint(counter, ==, atomic_counter);
}

/* Testing with NUM_CONTEXTS threads focuses on the queue.  The mutex however
 * is too contended (and the threads spend too much time in aio_poll)
 * to actually stress the handoff protocol.
 */
static void test_multi_co_mutex_1(void)
{
    test_multi_co_mutex(NUM_CONTEXTS, 1);
}

static void test_multi_co_mutex_10(void)
{
    test_multi_co_mutex(NUM_CONTEXTS, 10);
}

/* Testing with fewer threads stresses the handoff protocol too.  Still, the
 * case where the locker _can_ pick up a handoff is very rare, happening
 * about 10 times in 1 million, so increase the runtime a bit compared to
 * other "quick" testcases that only run for 1 second.
 */
static void test_multi_co_mutex_2_3(void)
{
    test_multi_co_mutex(2, 3);
}

static void test_multi_co_mutex_2_30(void)
{
    test_multi_co_mutex(2, 30);
}

/* Same test with fair mutexes, for performance comparison.  */

#ifdef CONFIG_LINUX
#include "qemu/futex.h"

/* The nodes for the mutex reside in this structure (on which we try to avoid
 * false sharing).  The head of the mutex is in the "mutex_head" variable.
 */
static struct {
    int next, locked;
    int padding[14];
} nodes[NUM_CONTEXTS] __attribute__((__aligned__(64)));

static int mutex_head = -1;

static void mcs_mutex_lock(void)
{
    int prev;

    nodes[id].next = -1;
    nodes[id].locked = 1;
    prev = atomic_xchg(&mutex_head, id);
    if (prev != -1) {
        atomic_set(&nodes[prev].next, id);
        qemu_futex_wait(&nodes[id].locked, 1);
    }
}

static void mcs_mutex_unlock(void)
{
    int next;
    if (atomic_read(&nodes[id].next) == -1) {
        if (atomic_read(&mutex_head) == id &&
            atomic_cmpxchg(&mutex_head, id, -1) == id) {
            /* Last item in the list, exit.  */
            return;
        }
        while (atomic_read(&nodes[id].next) == -1) {
            /* mcs_mutex_lock did the xchg, but has not updated
             * nodes[prev].next yet.
             */
        }
    }

    /* Wake up the next in line.  */
    next = atomic_read(&nodes[id].next);
    nodes[next].locked = 0;
    qemu_futex_wake(&nodes[next].locked, 1);
}

static void test_multi_fair_mutex_entry(void *opaque)
{
    while (!atomic_mb_read(&now_stopping)) {
        mcs_mutex_lock();
        counter++;
        mcs_mutex_unlock();
        atomic_inc(&atomic_counter);
    }
    atomic_dec(&running);
}

static void test_multi_fair_mutex(int threads, int seconds)
{
    int i;

    assert(mutex_head == -1);
    counter = 0;
    atomic_counter = 0;
    now_stopping = false;

    create_aio_contexts();
    assert(threads <= NUM_CONTEXTS);
    running = threads;
    for (i = 0; i < threads; i++) {
        Coroutine *co1 = qemu_coroutine_create(test_multi_fair_mutex_entry, NULL);
        aio_co_schedule(ctx[i], co1);
    }

    g_usleep(seconds * 1000000);

    atomic_mb_set(&now_stopping, true);
    while (running > 0) {
        g_usleep(100000);
    }

    join_aio_contexts();
    g_test_message("%d iterations/second\n", counter / seconds);
    g_assert_cmpint(counter, ==, atomic_counter);
}

static void test_multi_fair_mutex_1(void)
{
    test_multi_fair_mutex(NUM_CONTEXTS, 1);
}

static void test_multi_fair_mutex_10(void)
{
    test_multi_fair_mutex(NUM_CONTEXTS, 10);
}
#endif

/* Same test with pthread mutexes, for performance comparison and
 * portability.  */

static QemuMutex mutex;

static void test_multi_mutex_entry(void *opaque)
{
    while (!atomic_mb_read(&now_stopping)) {
        qemu_mutex_lock(&mutex);
        counter++;
        qemu_mutex_unlock(&mutex);
        atomic_inc(&atomic_counter);
    }
    atomic_dec(&running);
}

static void test_multi_mutex(int threads, int seconds)
{
    int i;

    qemu_mutex_init(&mutex);
    counter = 0;
    atomic_counter = 0;
    now_stopping = false;

    create_aio_contexts();
    assert(threads <= NUM_CONTEXTS);
    running = threads;
    for (i = 0; i < threads; i++) {
        Coroutine *co1 = qemu_coroutine_create(test_multi_mutex_entry, NULL);
        aio_co_schedule(ctx[i], co1);
    }

    g_usleep(seconds * 1000000);

    atomic_mb_set(&now_stopping, true);
    while (running > 0) {
        g_usleep(100000);
    }

    join_aio_contexts();
    g_test_message("%d iterations/second\n", counter / seconds);
    g_assert_cmpint(counter, ==, atomic_counter);
}

static void test_multi_mutex_1(void)
{
    test_multi_mutex(NUM_CONTEXTS, 1);
}

static void test_multi_mutex_10(void)
{
    test_multi_mutex(NUM_CONTEXTS, 10);
}

/* End of tests.  */

int main(int argc, char **argv)
{
    init_clocks(NULL);

    g_test_init(&argc, &argv, NULL);
    g_test_add_func("/aio/multi/lifecycle", test_lifecycle);
    if (g_test_quick()) {
        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
        g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_1);
        g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_3);
#ifdef CONFIG_LINUX
        g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_1);
#endif
        g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_1);
    } else {
        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
        g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_10);
        g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_30);
#ifdef CONFIG_LINUX
        g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_10);
#endif
        g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_10);
    }
    return g_test_run();
}
Commit	Line	Data
0c330a73 PB	1	/*
	2	* AioContext multithreading tests
	3	*
	4	* Copyright Red Hat, Inc. 2016
	5	*
	6	* Authors:
	7	* Paolo Bonzini <[email protected]>
	8	*
	9	* This work is licensed under the terms of the GNU LGPL, version 2 or later.
	10	* See the COPYING.LIB file in the top-level directory.
	11	*/
	12
	13	#include "qemu/osdep.h"
0c330a73	14	#include "block/aio.h"
0c330a73 PB	15	#include "qemu/coroutine.h"
	16	#include "qemu/thread.h"
	17	#include "qemu/error-report.h"
	18	#include "iothread.h"
	19
	20	/* AioContext management */
	21
	22	#define NUM_CONTEXTS 5
	23
	24	static IOThread *threads[NUM_CONTEXTS];
	25	static AioContext *ctx[NUM_CONTEXTS];
	26	static __thread int id = -1;
	27
	28	static QemuEvent done_event;
	29
	30	/* Run a function synchronously on a remote iothread. */
	31
	32	typedef struct CtxRunData {
	33	QEMUBHFunc *cb;
	34	void *arg;
	35	} CtxRunData;
	36
	37	static void ctx_run_bh_cb(void *opaque)
	38	{
	39	CtxRunData *data = opaque;
	40
	41	data->cb(data->arg);
	42	qemu_event_set(&done_event);
	43	}
	44
	45	static void ctx_run(int i, QEMUBHFunc cb, void opaque)
	46	{
	47	CtxRunData data = {
	48	.cb = cb,
	49	.arg = opaque
	50	};
	51
	52	qemu_event_reset(&done_event);
	53	aio_bh_schedule_oneshot(ctx[i], ctx_run_bh_cb, &data);
	54	qemu_event_wait(&done_event);
	55	}
	56
	57	/* Starting the iothreads. */
	58
	59	static void set_id_cb(void *opaque)
	60	{
	61	int *i = opaque;
	62
	63	id = *i;
	64	}
	65
	66	static void create_aio_contexts(void)
	67	{
	68	int i;
	69
	70	for (i = 0; i < NUM_CONTEXTS; i++) {
	71	threads[i] = iothread_new();
	72	ctx[i] = iothread_get_aio_context(threads[i]);
	73	}
	74
	75	qemu_event_init(&done_event, false);
	76	for (i = 0; i < NUM_CONTEXTS; i++) {
	77	ctx_run(i, set_id_cb, &i);
	78	}
79	}
80
81	/* Stopping the iothreads. */
82
83	static void join_aio_contexts(void)
84	{
85	int i;
86
87	for (i = 0; i < NUM_CONTEXTS; i++) {
88	aio_context_ref(ctx[i]);
89	}
90	for (i = 0; i < NUM_CONTEXTS; i++) {
91	iothread_join(threads[i]);
92	}
93	for (i = 0; i < NUM_CONTEXTS; i++) {
94	aio_context_unref(ctx[i]);
95	}
96	qemu_event_destroy(&done_event);
97	}
98
99	/* Basic test for the stuff above. */
100
101	static void test_lifecycle(void)
102	{
103	create_aio_contexts();
104	join_aio_contexts();
105	}
106
107	/* aio_co_schedule test. */
108
109	static Coroutine *to_schedule[NUM_CONTEXTS];
110
111	static bool now_stopping;
112
113	static int count_retry;
114	static int count_here;
115	static int count_other;
116
117	static bool schedule_next(int n)
118	{
119	Coroutine *co;
120
121	co = atomic_xchg(&to_schedule[n], NULL);
122	if (!co) {
123	atomic_inc(&count_retry);
124	return false;
125	}
126
127	if (n == id) {
128	atomic_inc(&count_here);
129	} else {
130	atomic_inc(&count_other);
131	}
132
133	aio_co_schedule(ctx[n], co);
134	return true;
135	}
136
137	static void finish_cb(void *opaque)
138	{
139	schedule_next(id);
140	}
141
142	static coroutine_fn void test_multi_co_schedule_entry(void *opaque)
143	{
144	g_assert(to_schedule[id] == NULL);
0c330a73 PB	145
	146	while (!atomic_mb_read(&now_stopping)) {
	147	int n;
	148
	149	n = g_test_rand_int_range(0, NUM_CONTEXTS);
	150	schedule_next(n);
0c330a73	151
0c330a73	152	atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
fb0c43f3 SH	153	qemu_coroutine_yield();
fb0c43f3 SH	154	g_assert(to_schedule[id] == NULL);
0c330a73 PB	155	}
	156	}
	157
	158
	159	static void test_multi_co_schedule(int seconds)
	160	{
	161	int i;
	162
	163	count_here = count_other = count_retry = 0;
	164	now_stopping = false;
	165
	166	create_aio_contexts();
	167	for (i = 0; i < NUM_CONTEXTS; i++) {
	168	Coroutine *co1 = qemu_coroutine_create(test_multi_co_schedule_entry, NULL);
	169	aio_co_schedule(ctx[i], co1);
	170	}
	171
	172	g_usleep(seconds * 1000000);
	173
	174	atomic_mb_set(&now_stopping, true);
	175	for (i = 0; i < NUM_CONTEXTS; i++) {
	176	ctx_run(i, finish_cb, NULL);
	177	to_schedule[i] = NULL;
	178	}
	179
	180	join_aio_contexts();
	181	g_test_message("scheduled %d, queued %d, retry %d, total %d\n",
	182	count_other, count_here, count_retry,
	183	count_here + count_other + count_retry);
	184	}
	185
	186	static void test_multi_co_schedule_1(void)
	187	{
	188	test_multi_co_schedule(1);
	189	}
	190
	191	static void test_multi_co_schedule_10(void)
	192	{
	193	test_multi_co_schedule(10);
	194	}
	195
fed20a70 PB	196	/* CoMutex thread-safety. */
	197
	198	static uint32_t atomic_counter;
	199	static uint32_t running;
	200	static uint32_t counter;
	201	static CoMutex comutex;
	202
	203	static void coroutine_fn test_multi_co_mutex_entry(void *opaque)
	204	{
	205	while (!atomic_mb_read(&now_stopping)) {
	206	qemu_co_mutex_lock(&comutex);
	207	counter++;
	208	qemu_co_mutex_unlock(&comutex);
	209
	210	/* Increase atomic_counter after releasing the mutex. Otherwise
	211	* there is a chance (it happens about 1 in 3 runs) that the iothread
	212	* exits before the coroutine is woken up, causing a spurious
	213	* assertion failure.
	214	*/
	215	atomic_inc(&atomic_counter);
	216	}
	217	atomic_dec(&running);
	218	}
	219
	220	static void test_multi_co_mutex(int threads, int seconds)
	221	{
	222	int i;
	223
	224	qemu_co_mutex_init(&comutex);
	225	counter = 0;
	226	atomic_counter = 0;
	227	now_stopping = false;
	228
	229	create_aio_contexts();
	230	assert(threads <= NUM_CONTEXTS);
	231	running = threads;
	232	for (i = 0; i < threads; i++) {
	233	Coroutine *co1 = qemu_coroutine_create(test_multi_co_mutex_entry, NULL);
	234	aio_co_schedule(ctx[i], co1);
	235	}
	236
	237	g_usleep(seconds * 1000000);
	238
	239	atomic_mb_set(&now_stopping, true);
	240	while (running > 0) {
	241	g_usleep(100000);
	242	}
	243
	244	join_aio_contexts();
	245	g_test_message("%d iterations/second\n", counter / seconds);
	246	g_assert_cmpint(counter, ==, atomic_counter);
	247	}
	248
	249	/* Testing with NUM_CONTEXTS threads focuses on the queue. The mutex however
	250	* is too contended (and the threads spend too much time in aio_poll)
	251	* to actually stress the handoff protocol.
	252	*/
	253	static void test_multi_co_mutex_1(void)
	254	{
	255	test_multi_co_mutex(NUM_CONTEXTS, 1);
	256	}
	257
	258	static void test_multi_co_mutex_10(void)
	259	{
260	test_multi_co_mutex(NUM_CONTEXTS, 10);
261	}
262
263	/* Testing with fewer threads stresses the handoff protocol too. Still, the
264	* case where the locker _can_ pick up a handoff is very rare, happening
265	* about 10 times in 1 million, so increase the runtime a bit compared to
266	* other "quick" testcases that only run for 1 second.
267	*/
268	static void test_multi_co_mutex_2_3(void)
269	{
270	test_multi_co_mutex(2, 3);
271	}
272
273	static void test_multi_co_mutex_2_30(void)
274	{
275	test_multi_co_mutex(2, 30);
276	}
277
c05df34a PB	278	/* Same test with fair mutexes, for performance comparison. */
	279
	280	#ifdef CONFIG_LINUX
	281	#include "qemu/futex.h"
	282
	283	/* The nodes for the mutex reside in this structure (on which we try to avoid
	284	* false sharing). The head of the mutex is in the "mutex_head" variable.
	285	*/
	286	static struct {
	287	int next, locked;
	288	int padding[14];
	289	} nodes[NUM_CONTEXTS] __attribute__((__aligned__(64)));
	290
	291	static int mutex_head = -1;
	292
	293	static void mcs_mutex_lock(void)
	294	{
	295	int prev;
	296
	297	nodes[id].next = -1;
	298	nodes[id].locked = 1;
	299	prev = atomic_xchg(&mutex_head, id);
	300	if (prev != -1) {
	301	atomic_set(&nodes[prev].next, id);
	302	qemu_futex_wait(&nodes[id].locked, 1);
	303	}
	304	}
	305
	306	static void mcs_mutex_unlock(void)
	307	{
	308	int next;
3b1d8169	309	if (atomic_read(&nodes[id].next) == -1) {
c05df34a PB	310	if (atomic_read(&mutex_head) == id &&
	311	atomic_cmpxchg(&mutex_head, id, -1) == id) {
	312	/* Last item in the list, exit. */
	313	return;
	314	}
	315	while (atomic_read(&nodes[id].next) == -1) {
	316	/* mcs_mutex_lock did the xchg, but has not updated
	317	* nodes[prev].next yet.
	318	*/
	319	}
	320	}
	321
	322	/* Wake up the next in line. */
3b1d8169	323	next = atomic_read(&nodes[id].next);
c05df34a PB	324	nodes[next].locked = 0;
	325	qemu_futex_wake(&nodes[next].locked, 1);
	326	}
	327
	328	static void test_multi_fair_mutex_entry(void *opaque)
	329	{
	330	while (!atomic_mb_read(&now_stopping)) {
	331	mcs_mutex_lock();
	332	counter++;
	333	mcs_mutex_unlock();
	334	atomic_inc(&atomic_counter);
	335	}
	336	atomic_dec(&running);
	337	}
	338
	339	static void test_multi_fair_mutex(int threads, int seconds)
	340	{
	341	int i;
	342
	343	assert(mutex_head == -1);
	344	counter = 0;
	345	atomic_counter = 0;
	346	now_stopping = false;
	347
	348	create_aio_contexts();
	349	assert(threads <= NUM_CONTEXTS);
	350	running = threads;
	351	for (i = 0; i < threads; i++) {
	352	Coroutine *co1 = qemu_coroutine_create(test_multi_fair_mutex_entry, NULL);
	353	aio_co_schedule(ctx[i], co1);
	354	}
	355
	356	g_usleep(seconds * 1000000);
	357
	358	atomic_mb_set(&now_stopping, true);
	359	while (running > 0) {
	360	g_usleep(100000);
	361	}
	362
	363	join_aio_contexts();
	364	g_test_message("%d iterations/second\n", counter / seconds);
	365	g_assert_cmpint(counter, ==, atomic_counter);
	366	}
	367
	368	static void test_multi_fair_mutex_1(void)
	369	{
	370	test_multi_fair_mutex(NUM_CONTEXTS, 1);
	371	}
	372
	373	static void test_multi_fair_mutex_10(void)
	374	{
	375	test_multi_fair_mutex(NUM_CONTEXTS, 10);
	376	}
	377	#endif
	378
	379	/* Same test with pthread mutexes, for performance comparison and
	380	* portability. */
	381
	382	static QemuMutex mutex;
	383
	384	static void test_multi_mutex_entry(void *opaque)
	385	{
	386	while (!atomic_mb_read(&now_stopping)) {
	387	qemu_mutex_lock(&mutex);
388	counter++;
389	qemu_mutex_unlock(&mutex);
390	atomic_inc(&atomic_counter);
391	}
392	atomic_dec(&running);
393	}
394
395	static void test_multi_mutex(int threads, int seconds)
396	{
397	int i;
398
399	qemu_mutex_init(&mutex);
400	counter = 0;
401	atomic_counter = 0;
402	now_stopping = false;
403
404	create_aio_contexts();
405	assert(threads <= NUM_CONTEXTS);
406	running = threads;
407	for (i = 0; i < threads; i++) {
408	Coroutine *co1 = qemu_coroutine_create(test_multi_mutex_entry, NULL);
409	aio_co_schedule(ctx[i], co1);
410	}
411
412	g_usleep(seconds * 1000000);
413
414	atomic_mb_set(&now_stopping, true);
415	while (running > 0) {
416	g_usleep(100000);
417	}
418
419	join_aio_contexts();
420	g_test_message("%d iterations/second\n", counter / seconds);
421	g_assert_cmpint(counter, ==, atomic_counter);
422	}
423
424	static void test_multi_mutex_1(void)
425	{
426	test_multi_mutex(NUM_CONTEXTS, 1);
427	}
428
429	static void test_multi_mutex_10(void)
430	{
431	test_multi_mutex(NUM_CONTEXTS, 10);
432	}
433
0c330a73 PB	434	/* End of tests. */
	435
	436	int main(int argc, char **argv)
	437	{
3f53bc61	438	init_clocks(NULL);
0c330a73 PB	439
	440	g_test_init(&argc, &argv, NULL);
	441	g_test_add_func("/aio/multi/lifecycle", test_lifecycle);
	442	if (g_test_quick()) {
	443	g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
fed20a70 PB	444	g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_1);
fed20a70 PB	445	g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_3);
c05df34a PB	446	#ifdef CONFIG_LINUX
	447	g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_1);
	448	#endif
	449	g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_1);
0c330a73 PB	450	} else {
0c330a73 PB	451	g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
fed20a70 PB	452	g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_10);
fed20a70 PB	453	g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_30);
c05df34a PB	454	#ifdef CONFIG_LINUX
	455	g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_10);
	456	#endif
	457	g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_10);
0c330a73 PB	458	}
	459	return g_test_run();
	460	}