test-coroutine.c (16478B)
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 static CoRwlock rwlock; 268 269 /* Test that readers are properly sent back to the queue when upgrading, 270 * even if they are the sole readers. The test scenario is as follows: 271 * 272 * 273 * | c1 | c2 | 274 * |--------------+------------+ 275 * | rdlock | | 276 * | yield | | 277 * | | wrlock | 278 * | | <queued> | 279 * | upgrade | | 280 * | <queued> | <dequeued> | 281 * | | unlock | 282 * | <dequeued> | | 283 * | unlock | | 284 */ 285 286 static void coroutine_fn rwlock_yield_upgrade(void *opaque) 287 { 288 qemu_co_rwlock_rdlock(&rwlock); 289 qemu_coroutine_yield(); 290 291 qemu_co_rwlock_upgrade(&rwlock); 292 qemu_co_rwlock_unlock(&rwlock); 293 294 *(bool *)opaque = true; 295 } 296 297 static void coroutine_fn rwlock_wrlock_yield(void *opaque) 298 { 299 qemu_co_rwlock_wrlock(&rwlock); 300 qemu_coroutine_yield(); 301 302 qemu_co_rwlock_unlock(&rwlock); 303 *(bool *)opaque = true; 304 } 305 306 static void test_co_rwlock_upgrade(void) 307 { 308 bool c1_done = false; 309 bool c2_done = false; 310 Coroutine *c1, *c2; 311 312 qemu_co_rwlock_init(&rwlock); 313 c1 = qemu_coroutine_create(rwlock_yield_upgrade, &c1_done); 314 c2 = qemu_coroutine_create(rwlock_wrlock_yield, &c2_done); 315 316 qemu_coroutine_enter(c1); 317 qemu_coroutine_enter(c2); 318 319 /* c1 now should go to sleep. */ 320 qemu_coroutine_enter(c1); 321 g_assert(!c1_done); 322 323 qemu_coroutine_enter(c2); 324 g_assert(c1_done); 325 g_assert(c2_done); 326 } 327 328 static void coroutine_fn rwlock_rdlock_yield(void *opaque) 329 { 330 qemu_co_rwlock_rdlock(&rwlock); 331 qemu_coroutine_yield(); 332 333 qemu_co_rwlock_unlock(&rwlock); 334 qemu_coroutine_yield(); 335 336 *(bool *)opaque = true; 337 } 338 339 static void coroutine_fn rwlock_wrlock_downgrade(void *opaque) 340 { 341 qemu_co_rwlock_wrlock(&rwlock); 342 343 qemu_co_rwlock_downgrade(&rwlock); 344 qemu_co_rwlock_unlock(&rwlock); 345 *(bool *)opaque = true; 346 } 347 348 static void coroutine_fn rwlock_rdlock(void *opaque) 349 { 350 qemu_co_rwlock_rdlock(&rwlock); 351 352 qemu_co_rwlock_unlock(&rwlock); 353 *(bool *)opaque = true; 354 } 355 356 static void coroutine_fn rwlock_wrlock(void *opaque) 357 { 358 qemu_co_rwlock_wrlock(&rwlock); 359 360 qemu_co_rwlock_unlock(&rwlock); 361 *(bool *)opaque = true; 362 } 363 364 /* 365 * Check that downgrading a reader-writer lock does not cause a hang. 366 * 367 * Four coroutines are used to produce a situation where there are 368 * both reader and writer hopefuls waiting to acquire an rwlock that 369 * is held by a reader. 370 * 371 * The correct sequence of operations we aim to provoke can be 372 * represented as: 373 * 374 * | c1 | c2 | c3 | c4 | 375 * |--------+------------+------------+------------| 376 * | rdlock | | | | 377 * | yield | | | | 378 * | | wrlock | | | 379 * | | <queued> | | | 380 * | | | rdlock | | 381 * | | | <queued> | | 382 * | | | | wrlock | 383 * | | | | <queued> | 384 * | unlock | | | | 385 * | yield | | | | 386 * | | <dequeued> | | | 387 * | | downgrade | | | 388 * | | | <dequeued> | | 389 * | | | unlock | | 390 * | | ... | | | 391 * | | unlock | | | 392 * | | | | <dequeued> | 393 * | | | | unlock | 394 */ 395 static void test_co_rwlock_downgrade(void) 396 { 397 bool c1_done = false; 398 bool c2_done = false; 399 bool c3_done = false; 400 bool c4_done = false; 401 Coroutine *c1, *c2, *c3, *c4; 402 403 qemu_co_rwlock_init(&rwlock); 404 405 c1 = qemu_coroutine_create(rwlock_rdlock_yield, &c1_done); 406 c2 = qemu_coroutine_create(rwlock_wrlock_downgrade, &c2_done); 407 c3 = qemu_coroutine_create(rwlock_rdlock, &c3_done); 408 c4 = qemu_coroutine_create(rwlock_wrlock, &c4_done); 409 410 qemu_coroutine_enter(c1); 411 qemu_coroutine_enter(c2); 412 qemu_coroutine_enter(c3); 413 qemu_coroutine_enter(c4); 414 415 qemu_coroutine_enter(c1); 416 417 g_assert(c2_done); 418 g_assert(c3_done); 419 g_assert(c4_done); 420 421 qemu_coroutine_enter(c1); 422 423 g_assert(c1_done); 424 } 425 426 /* 427 * Check that creation, enter, and return work 428 */ 429 430 static void coroutine_fn set_and_exit(void *opaque) 431 { 432 bool *done = opaque; 433 434 *done = true; 435 } 436 437 static void test_lifecycle(void) 438 { 439 Coroutine *coroutine; 440 bool done = false; 441 442 /* Create, enter, and return from coroutine */ 443 coroutine = qemu_coroutine_create(set_and_exit, &done); 444 qemu_coroutine_enter(coroutine); 445 g_assert(done); /* expect done to be true (first time) */ 446 447 /* Repeat to check that no state affects this test */ 448 done = false; 449 coroutine = qemu_coroutine_create(set_and_exit, &done); 450 qemu_coroutine_enter(coroutine); 451 g_assert(done); /* expect done to be true (second time) */ 452 } 453 454 455 #define RECORD_SIZE 10 /* Leave some room for expansion */ 456 struct coroutine_position { 457 int func; 458 int state; 459 }; 460 static struct coroutine_position records[RECORD_SIZE]; 461 static unsigned record_pos; 462 463 static void record_push(int func, int state) 464 { 465 struct coroutine_position *cp = &records[record_pos++]; 466 g_assert_cmpint(record_pos, <, RECORD_SIZE); 467 cp->func = func; 468 cp->state = state; 469 } 470 471 static void coroutine_fn co_order_test(void *opaque) 472 { 473 record_push(2, 1); 474 g_assert(qemu_in_coroutine()); 475 qemu_coroutine_yield(); 476 record_push(2, 2); 477 g_assert(qemu_in_coroutine()); 478 } 479 480 static void do_order_test(void) 481 { 482 Coroutine *co; 483 484 co = qemu_coroutine_create(co_order_test, NULL); 485 record_push(1, 1); 486 qemu_coroutine_enter(co); 487 record_push(1, 2); 488 g_assert(!qemu_in_coroutine()); 489 qemu_coroutine_enter(co); 490 record_push(1, 3); 491 g_assert(!qemu_in_coroutine()); 492 } 493 494 static void test_order(void) 495 { 496 int i; 497 const struct coroutine_position expected_pos[] = { 498 {1, 1,}, {2, 1}, {1, 2}, {2, 2}, {1, 3} 499 }; 500 do_order_test(); 501 g_assert_cmpint(record_pos, ==, 5); 502 for (i = 0; i < record_pos; i++) { 503 g_assert_cmpint(records[i].func , ==, expected_pos[i].func ); 504 g_assert_cmpint(records[i].state, ==, expected_pos[i].state); 505 } 506 } 507 /* 508 * Lifecycle benchmark 509 */ 510 511 static void coroutine_fn empty_coroutine(void *opaque) 512 { 513 /* Do nothing */ 514 } 515 516 static void perf_lifecycle(void) 517 { 518 Coroutine *coroutine; 519 unsigned int i, max; 520 double duration; 521 522 max = 1000000; 523 524 g_test_timer_start(); 525 for (i = 0; i < max; i++) { 526 coroutine = qemu_coroutine_create(empty_coroutine, NULL); 527 qemu_coroutine_enter(coroutine); 528 } 529 duration = g_test_timer_elapsed(); 530 531 g_test_message("Lifecycle %u iterations: %f s", max, duration); 532 } 533 534 static void perf_nesting(void) 535 { 536 unsigned int i, maxcycles, maxnesting; 537 double duration; 538 539 maxcycles = 10000; 540 maxnesting = 1000; 541 Coroutine *root; 542 543 g_test_timer_start(); 544 for (i = 0; i < maxcycles; i++) { 545 NestData nd = { 546 .n_enter = 0, 547 .n_return = 0, 548 .max = maxnesting, 549 }; 550 root = qemu_coroutine_create(nest, &nd); 551 qemu_coroutine_enter(root); 552 } 553 duration = g_test_timer_elapsed(); 554 555 g_test_message("Nesting %u iterations of %u depth each: %f s", 556 maxcycles, maxnesting, duration); 557 } 558 559 /* 560 * Yield benchmark 561 */ 562 563 static void coroutine_fn yield_loop(void *opaque) 564 { 565 unsigned int *counter = opaque; 566 567 while ((*counter) > 0) { 568 (*counter)--; 569 qemu_coroutine_yield(); 570 } 571 } 572 573 static void perf_yield(void) 574 { 575 unsigned int i, maxcycles; 576 double duration; 577 578 maxcycles = 100000000; 579 i = maxcycles; 580 Coroutine *coroutine = qemu_coroutine_create(yield_loop, &i); 581 582 g_test_timer_start(); 583 while (i > 0) { 584 qemu_coroutine_enter(coroutine); 585 } 586 duration = g_test_timer_elapsed(); 587 588 g_test_message("Yield %u iterations: %f s", maxcycles, duration); 589 } 590 591 static __attribute__((noinline)) void dummy(unsigned *i) 592 { 593 (*i)--; 594 } 595 596 static void perf_baseline(void) 597 { 598 unsigned int i, maxcycles; 599 double duration; 600 601 maxcycles = 100000000; 602 i = maxcycles; 603 604 g_test_timer_start(); 605 while (i > 0) { 606 dummy(&i); 607 } 608 duration = g_test_timer_elapsed(); 609 610 g_test_message("Function call %u iterations: %f s", maxcycles, duration); 611 } 612 613 static __attribute__((noinline)) void coroutine_fn perf_cost_func(void *opaque) 614 { 615 qemu_coroutine_yield(); 616 } 617 618 static void perf_cost(void) 619 { 620 const unsigned long maxcycles = 40000000; 621 unsigned long i = 0; 622 double duration; 623 unsigned long ops; 624 Coroutine *co; 625 626 g_test_timer_start(); 627 while (i++ < maxcycles) { 628 co = qemu_coroutine_create(perf_cost_func, &i); 629 qemu_coroutine_enter(co); 630 qemu_coroutine_enter(co); 631 } 632 duration = g_test_timer_elapsed(); 633 ops = (long)(maxcycles / (duration * 1000)); 634 635 g_test_message("Run operation %lu iterations %f s, %luK operations/s, " 636 "%luns per coroutine", 637 maxcycles, 638 duration, ops, 639 (unsigned long)(1000000000.0 * duration / maxcycles)); 640 } 641 642 int main(int argc, char **argv) 643 { 644 g_test_init(&argc, &argv, NULL); 645 646 /* This test assumes there is a freelist and marks freed coroutine memory 647 * with a sentinel value. If there is no freelist this would legitimately 648 * crash, so skip it. 649 */ 650 if (CONFIG_COROUTINE_POOL) { 651 g_test_add_func("/basic/no-dangling-access", test_no_dangling_access); 652 } 653 654 g_test_add_func("/basic/lifecycle", test_lifecycle); 655 g_test_add_func("/basic/yield", test_yield); 656 g_test_add_func("/basic/nesting", test_nesting); 657 g_test_add_func("/basic/self", test_self); 658 g_test_add_func("/basic/entered", test_entered); 659 g_test_add_func("/basic/in_coroutine", test_in_coroutine); 660 g_test_add_func("/basic/order", test_order); 661 g_test_add_func("/locking/co-mutex", test_co_mutex); 662 g_test_add_func("/locking/co-mutex/lockable", test_co_mutex_lockable); 663 g_test_add_func("/locking/co-rwlock/upgrade", test_co_rwlock_upgrade); 664 g_test_add_func("/locking/co-rwlock/downgrade", test_co_rwlock_downgrade); 665 if (g_test_perf()) { 666 g_test_add_func("/perf/lifecycle", perf_lifecycle); 667 g_test_add_func("/perf/nesting", perf_nesting); 668 g_test_add_func("/perf/yield", perf_yield); 669 g_test_add_func("/perf/function-call", perf_baseline); 670 g_test_add_func("/perf/cost", perf_cost); 671 } 672 return g_test_run(); 673 }