Merge remote-tracking branch 'remotes/ehabkost/tags/machine-next-pull-request' into...
[qemu.git] / tests / test-coroutine.c
1 /*
2 * Coroutine tests
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
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
14 #include "qemu/osdep.h"
15 #include "qemu/coroutine.h"
16 #include "qemu/coroutine_int.h"
17 #include "qemu/lockable.h"
18
19 /*
20 * Check that qemu_in_coroutine() works
21 */
22
23 static void coroutine_fn verify_in_coroutine(void *opaque)
24 {
25 g_assert(qemu_in_coroutine());
26 }
27
28 static void test_in_coroutine(void)
29 {
30 Coroutine *coroutine;
31
32 g_assert(!qemu_in_coroutine());
33
34 coroutine = qemu_coroutine_create(verify_in_coroutine, NULL);
35 qemu_coroutine_enter(coroutine);
36 }
37
38 /*
39 * Check that qemu_coroutine_self() works
40 */
41
42 static void coroutine_fn verify_self(void *opaque)
43 {
44 Coroutine **p_co = opaque;
45 g_assert(qemu_coroutine_self() == *p_co);
46 }
47
48 static void test_self(void)
49 {
50 Coroutine *coroutine;
51
52 coroutine = qemu_coroutine_create(verify_self, &coroutine);
53 qemu_coroutine_enter(coroutine);
54 }
55
56 /*
57 * Check that qemu_coroutine_entered() works
58 */
59
60 static void coroutine_fn verify_entered_step_2(void *opaque)
61 {
62 Coroutine *caller = (Coroutine *)opaque;
63
64 g_assert(qemu_coroutine_entered(caller));
65 g_assert(qemu_coroutine_entered(qemu_coroutine_self()));
66 qemu_coroutine_yield();
67
68 /* Once more to check it still works after yielding */
69 g_assert(qemu_coroutine_entered(caller));
70 g_assert(qemu_coroutine_entered(qemu_coroutine_self()));
71 }
72
73 static void coroutine_fn verify_entered_step_1(void *opaque)
74 {
75 Coroutine *self = qemu_coroutine_self();
76 Coroutine *coroutine;
77
78 g_assert(qemu_coroutine_entered(self));
79
80 coroutine = qemu_coroutine_create(verify_entered_step_2, self);
81 g_assert(!qemu_coroutine_entered(coroutine));
82 qemu_coroutine_enter(coroutine);
83 g_assert(!qemu_coroutine_entered(coroutine));
84 qemu_coroutine_enter(coroutine);
85 }
86
87 static void test_entered(void)
88 {
89 Coroutine *coroutine;
90
91 coroutine = qemu_coroutine_create(verify_entered_step_1, NULL);
92 g_assert(!qemu_coroutine_entered(coroutine));
93 qemu_coroutine_enter(coroutine);
94 }
95
96 /*
97 * Check that coroutines may nest multiple levels
98 */
99
100 typedef struct {
101 unsigned int n_enter; /* num coroutines entered */
102 unsigned int n_return; /* num coroutines returned */
103 unsigned int max; /* maximum level of nesting */
104 } NestData;
105
106 static void coroutine_fn nest(void *opaque)
107 {
108 NestData *nd = opaque;
109
110 nd->n_enter++;
111
112 if (nd->n_enter < nd->max) {
113 Coroutine *child;
114
115 child = qemu_coroutine_create(nest, nd);
116 qemu_coroutine_enter(child);
117 }
118
119 nd->n_return++;
120 }
121
122 static void test_nesting(void)
123 {
124 Coroutine *root;
125 NestData nd = {
126 .n_enter = 0,
127 .n_return = 0,
128 .max = 128,
129 };
130
131 root = qemu_coroutine_create(nest, &nd);
132 qemu_coroutine_enter(root);
133
134 /* Must enter and return from max nesting level */
135 g_assert_cmpint(nd.n_enter, ==, nd.max);
136 g_assert_cmpint(nd.n_return, ==, nd.max);
137 }
138
139 /*
140 * Check that yield/enter transfer control correctly
141 */
142
143 static void coroutine_fn yield_5_times(void *opaque)
144 {
145 bool *done = opaque;
146 int i;
147
148 for (i = 0; i < 5; i++) {
149 qemu_coroutine_yield();
150 }
151 *done = true;
152 }
153
154 static void test_yield(void)
155 {
156 Coroutine *coroutine;
157 bool done = false;
158 int i = -1; /* one extra time to return from coroutine */
159
160 coroutine = qemu_coroutine_create(yield_5_times, &done);
161 while (!done) {
162 qemu_coroutine_enter(coroutine);
163 i++;
164 }
165 g_assert_cmpint(i, ==, 5); /* coroutine must yield 5 times */
166 }
167
168 static void coroutine_fn c2_fn(void *opaque)
169 {
170 qemu_coroutine_yield();
171 }
172
173 static void coroutine_fn c1_fn(void *opaque)
174 {
175 Coroutine *c2 = opaque;
176 qemu_coroutine_enter(c2);
177 }
178
179 static void test_no_dangling_access(void)
180 {
181 Coroutine *c1;
182 Coroutine *c2;
183 Coroutine tmp;
184
185 c2 = qemu_coroutine_create(c2_fn, NULL);
186 c1 = qemu_coroutine_create(c1_fn, c2);
187
188 qemu_coroutine_enter(c1);
189
190 /* c1 shouldn't be used any more now; make sure we segfault if it is */
191 tmp = *c1;
192 memset(c1, 0xff, sizeof(Coroutine));
193 qemu_coroutine_enter(c2);
194
195 /* Must restore the coroutine now to avoid corrupted pool */
196 *c1 = tmp;
197 }
198
199 static bool locked;
200 static int done;
201
202 static void coroutine_fn mutex_fn(void *opaque)
203 {
204 CoMutex *m = opaque;
205 qemu_co_mutex_lock(m);
206 assert(!locked);
207 locked = true;
208 qemu_coroutine_yield();
209 locked = false;
210 qemu_co_mutex_unlock(m);
211 done++;
212 }
213
214 static void coroutine_fn lockable_fn(void *opaque)
215 {
216 QemuLockable *x = opaque;
217 qemu_lockable_lock(x);
218 assert(!locked);
219 locked = true;
220 qemu_coroutine_yield();
221 locked = false;
222 qemu_lockable_unlock(x);
223 done++;
224 }
225
226 static void do_test_co_mutex(CoroutineEntry *entry, void *opaque)
227 {
228 Coroutine *c1 = qemu_coroutine_create(entry, opaque);
229 Coroutine *c2 = qemu_coroutine_create(entry, opaque);
230
231 done = 0;
232 qemu_coroutine_enter(c1);
233 g_assert(locked);
234 qemu_coroutine_enter(c2);
235
236 /* Unlock queues c2. It is then started automatically when c1 yields or
237 * terminates.
238 */
239 qemu_coroutine_enter(c1);
240 g_assert_cmpint(done, ==, 1);
241 g_assert(locked);
242
243 qemu_coroutine_enter(c2);
244 g_assert_cmpint(done, ==, 2);
245 g_assert(!locked);
246 }
247
248 static void test_co_mutex(void)
249 {
250 CoMutex m;
251
252 qemu_co_mutex_init(&m);
253 do_test_co_mutex(mutex_fn, &m);
254 }
255
256 static void test_co_mutex_lockable(void)
257 {
258 CoMutex m;
259 CoMutex *null_pointer = NULL;
260
261 qemu_co_mutex_init(&m);
262 do_test_co_mutex(lockable_fn, QEMU_MAKE_LOCKABLE(&m));
263
264 g_assert(QEMU_MAKE_LOCKABLE(null_pointer) == NULL);
265 }
266
267 /*
268 * Check that creation, enter, and return work
269 */
270
271 static void coroutine_fn set_and_exit(void *opaque)
272 {
273 bool *done = opaque;
274
275 *done = true;
276 }
277
278 static void test_lifecycle(void)
279 {
280 Coroutine *coroutine;
281 bool done = false;
282
283 /* Create, enter, and return from coroutine */
284 coroutine = qemu_coroutine_create(set_and_exit, &done);
285 qemu_coroutine_enter(coroutine);
286 g_assert(done); /* expect done to be true (first time) */
287
288 /* Repeat to check that no state affects this test */
289 done = false;
290 coroutine = qemu_coroutine_create(set_and_exit, &done);
291 qemu_coroutine_enter(coroutine);
292 g_assert(done); /* expect done to be true (second time) */
293 }
294
295
296 #define RECORD_SIZE 10 /* Leave some room for expansion */
297 struct coroutine_position {
298 int func;
299 int state;
300 };
301 static struct coroutine_position records[RECORD_SIZE];
302 static unsigned record_pos;
303
304 static void record_push(int func, int state)
305 {
306 struct coroutine_position *cp = &records[record_pos++];
307 g_assert_cmpint(record_pos, <, RECORD_SIZE);
308 cp->func = func;
309 cp->state = state;
310 }
311
312 static void coroutine_fn co_order_test(void *opaque)
313 {
314 record_push(2, 1);
315 g_assert(qemu_in_coroutine());
316 qemu_coroutine_yield();
317 record_push(2, 2);
318 g_assert(qemu_in_coroutine());
319 }
320
321 static void do_order_test(void)
322 {
323 Coroutine *co;
324
325 co = qemu_coroutine_create(co_order_test, NULL);
326 record_push(1, 1);
327 qemu_coroutine_enter(co);
328 record_push(1, 2);
329 g_assert(!qemu_in_coroutine());
330 qemu_coroutine_enter(co);
331 record_push(1, 3);
332 g_assert(!qemu_in_coroutine());
333 }
334
335 static void test_order(void)
336 {
337 int i;
338 const struct coroutine_position expected_pos[] = {
339 {1, 1,}, {2, 1}, {1, 2}, {2, 2}, {1, 3}
340 };
341 do_order_test();
342 g_assert_cmpint(record_pos, ==, 5);
343 for (i = 0; i < record_pos; i++) {
344 g_assert_cmpint(records[i].func , ==, expected_pos[i].func );
345 g_assert_cmpint(records[i].state, ==, expected_pos[i].state);
346 }
347 }
348 /*
349 * Lifecycle benchmark
350 */
351
352 static void coroutine_fn empty_coroutine(void *opaque)
353 {
354 /* Do nothing */
355 }
356
357 static void perf_lifecycle(void)
358 {
359 Coroutine *coroutine;
360 unsigned int i, max;
361 double duration;
362
363 max = 1000000;
364
365 g_test_timer_start();
366 for (i = 0; i < max; i++) {
367 coroutine = qemu_coroutine_create(empty_coroutine, NULL);
368 qemu_coroutine_enter(coroutine);
369 }
370 duration = g_test_timer_elapsed();
371
372 g_test_message("Lifecycle %u iterations: %f s", max, duration);
373 }
374
375 static void perf_nesting(void)
376 {
377 unsigned int i, maxcycles, maxnesting;
378 double duration;
379
380 maxcycles = 10000;
381 maxnesting = 1000;
382 Coroutine *root;
383
384 g_test_timer_start();
385 for (i = 0; i < maxcycles; i++) {
386 NestData nd = {
387 .n_enter = 0,
388 .n_return = 0,
389 .max = maxnesting,
390 };
391 root = qemu_coroutine_create(nest, &nd);
392 qemu_coroutine_enter(root);
393 }
394 duration = g_test_timer_elapsed();
395
396 g_test_message("Nesting %u iterations of %u depth each: %f s",
397 maxcycles, maxnesting, duration);
398 }
399
400 /*
401 * Yield benchmark
402 */
403
404 static void coroutine_fn yield_loop(void *opaque)
405 {
406 unsigned int *counter = opaque;
407
408 while ((*counter) > 0) {
409 (*counter)--;
410 qemu_coroutine_yield();
411 }
412 }
413
414 static void perf_yield(void)
415 {
416 unsigned int i, maxcycles;
417 double duration;
418
419 maxcycles = 100000000;
420 i = maxcycles;
421 Coroutine *coroutine = qemu_coroutine_create(yield_loop, &i);
422
423 g_test_timer_start();
424 while (i > 0) {
425 qemu_coroutine_enter(coroutine);
426 }
427 duration = g_test_timer_elapsed();
428
429 g_test_message("Yield %u iterations: %f s", maxcycles, duration);
430 }
431
432 static __attribute__((noinline)) void dummy(unsigned *i)
433 {
434 (*i)--;
435 }
436
437 static void perf_baseline(void)
438 {
439 unsigned int i, maxcycles;
440 double duration;
441
442 maxcycles = 100000000;
443 i = maxcycles;
444
445 g_test_timer_start();
446 while (i > 0) {
447 dummy(&i);
448 }
449 duration = g_test_timer_elapsed();
450
451 g_test_message("Function call %u iterations: %f s", maxcycles, duration);
452 }
453
454 static __attribute__((noinline)) void perf_cost_func(void *opaque)
455 {
456 qemu_coroutine_yield();
457 }
458
459 static void perf_cost(void)
460 {
461 const unsigned long maxcycles = 40000000;
462 unsigned long i = 0;
463 double duration;
464 unsigned long ops;
465 Coroutine *co;
466
467 g_test_timer_start();
468 while (i++ < maxcycles) {
469 co = qemu_coroutine_create(perf_cost_func, &i);
470 qemu_coroutine_enter(co);
471 qemu_coroutine_enter(co);
472 }
473 duration = g_test_timer_elapsed();
474 ops = (long)(maxcycles / (duration * 1000));
475
476 g_test_message("Run operation %lu iterations %f s, %luK operations/s, "
477 "%luns per coroutine",
478 maxcycles,
479 duration, ops,
480 (unsigned long)(1000000000.0 * duration / maxcycles));
481 }
482
483 int main(int argc, char **argv)
484 {
485 g_test_init(&argc, &argv, NULL);
486
487 /* This test assumes there is a freelist and marks freed coroutine memory
488 * with a sentinel value. If there is no freelist this would legitimately
489 * crash, so skip it.
490 */
491 if (CONFIG_COROUTINE_POOL) {
492 g_test_add_func("/basic/no-dangling-access", test_no_dangling_access);
493 }
494
495 g_test_add_func("/basic/lifecycle", test_lifecycle);
496 g_test_add_func("/basic/yield", test_yield);
497 g_test_add_func("/basic/nesting", test_nesting);
498 g_test_add_func("/basic/self", test_self);
499 g_test_add_func("/basic/entered", test_entered);
500 g_test_add_func("/basic/in_coroutine", test_in_coroutine);
501 g_test_add_func("/basic/order", test_order);
502 g_test_add_func("/locking/co-mutex", test_co_mutex);
503 g_test_add_func("/locking/co-mutex/lockable", test_co_mutex_lockable);
504 if (g_test_perf()) {
505 g_test_add_func("/perf/lifecycle", perf_lifecycle);
506 g_test_add_func("/perf/nesting", perf_nesting);
507 g_test_add_func("/perf/yield", perf_yield);
508 g_test_add_func("/perf/function-call", perf_baseline);
509 g_test_add_func("/perf/cost", perf_cost);
510 }
511 return g_test_run();
512 }