tests/test-throttle.c

   1 /*
   2  * Throttle infrastructure tests
   3  *
   4  * Copyright Nodalink, EURL. 2013-2014
   5  * Copyright Igalia, S.L. 2015
   6  *
   7  * Authors:
   8  *  Benoît Canet     <benoit.canet@nodalink.com>
   9  *  Alberto Garcia   <berto@igalia.com>
  10  *
  11  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  12  * See the COPYING.LIB file in the top-level directory.
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include <glib.h>
  17 #include <math.h>
  18 #include "block/aio.h"
  19 #include "qapi/error.h"
  20 #include "qemu/throttle.h"
  21 #include "qemu/error-report.h"
  22 #include "block/throttle-groups.h"
  23 #include "sysemu/block-backend.h"
  24
  25 static AioContext     *ctx;
  26 static LeakyBucket    bkt;
  27 static ThrottleConfig cfg;
  28 static ThrottleState  ts;
  29 static ThrottleTimers tt;
  30
  31 /* useful function */
  32 static bool double_cmp(double x, double y)
  33 {
  34     return fabsl(x - y) < 1e-6;
  35 }
  36
  37 /* tests for single bucket operations */
  38 static void test_leak_bucket(void)
  39 {
  40     throttle_config_init(&cfg);
  41     bkt = cfg.buckets[THROTTLE_BPS_TOTAL];
  42
  43     /* set initial value */
  44     bkt.avg = 150;
  45     bkt.max = 15;
  46     bkt.level = 1.5;
  47
  48     /* leak an op work of time */
  49     throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
  50     g_assert(bkt.avg == 150);
  51     g_assert(bkt.max == 15);
  52     g_assert(double_cmp(bkt.level, 0.5));
  53
  54     /* leak again emptying the bucket */
  55     throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
  56     g_assert(bkt.avg == 150);
  57     g_assert(bkt.max == 15);
  58     g_assert(double_cmp(bkt.level, 0));
  59
  60     /* check that the bucket level won't go lower */
  61     throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
  62     g_assert(bkt.avg == 150);
  63     g_assert(bkt.max == 15);
  64     g_assert(double_cmp(bkt.level, 0));
  65
  66     /* check that burst_level leaks correctly */
  67     bkt.burst_level = 6;
  68     bkt.max = 250;
  69     bkt.burst_length = 2; /* otherwise burst_level will not leak */
  70     throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
  71     g_assert(double_cmp(bkt.burst_level, 3.5));
  72
  73     throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
  74     g_assert(double_cmp(bkt.burst_level, 1));
  75
  76     throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
  77     g_assert(double_cmp(bkt.burst_level, 0));
  78
  79     throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
  80     g_assert(double_cmp(bkt.burst_level, 0));
  81 }
  82
  83 static void test_compute_wait(void)
  84 {
  85     unsigned i;
  86     int64_t wait;
  87     int64_t result;
  88
  89     throttle_config_init(&cfg);
  90     bkt = cfg.buckets[THROTTLE_BPS_TOTAL];
  91
  92     /* no operation limit set */
  93     bkt.avg = 0;
  94     bkt.max = 15;
  95     bkt.level = 1.5;
  96     wait = throttle_compute_wait(&bkt);
  97     g_assert(!wait);
  98
  99     /* zero delta */
 100     bkt.avg = 150;
 101     bkt.max = 15;
 102     bkt.level = 15;
 103     wait = throttle_compute_wait(&bkt);
 104     g_assert(!wait);
 105
 106     /* below zero delta */
 107     bkt.avg = 150;
 108     bkt.max = 15;
 109     bkt.level = 9;
 110     wait = throttle_compute_wait(&bkt);
 111     g_assert(!wait);
 112
 113     /* half an operation above max */
 114     bkt.avg = 150;
 115     bkt.max = 15;
 116     bkt.level = 15.5;
 117     wait = throttle_compute_wait(&bkt);
 118     /* time required to do half an operation */
 119     result = (int64_t)  NANOSECONDS_PER_SECOND / 150 / 2;
 120     g_assert(wait == result);
 121
 122     /* Perform I/O for 2.2 seconds at a rate of bkt.max */
 123     bkt.burst_length = 2;
 124     bkt.level = 0;
 125     bkt.avg = 10;
 126     bkt.max = 200;
 127     for (i = 0; i < 22; i++) {
 128         double units = bkt.max / 10;
 129         bkt.level += units;
 130         bkt.burst_level += units;
 131         throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 10);
 132         wait = throttle_compute_wait(&bkt);
 133         g_assert(double_cmp(bkt.burst_level, 0));
 134         g_assert(double_cmp(bkt.level, (i + 1) * (bkt.max - bkt.avg) / 10));
 135         /* We can do bursts for the 2 seconds we have configured in
 136          * burst_length. We have 100 extra miliseconds of burst
 137          * because bkt.level has been leaking during this time.
 138          * After that, we have to wait. */
 139         result = i < 21 ? 0 : 1.8 * NANOSECONDS_PER_SECOND;
 140         g_assert(wait == result);
 141     }
 142 }
 143
 144 /* functions to test ThrottleState initialization/destroy methods */
 145 static void read_timer_cb(void *opaque)
 146 {
 147 }
 148
 149 static void write_timer_cb(void *opaque)
 150 {
 151 }
 152
 153 static void test_init(void)
 154 {
 155     int i;
 156
 157     /* fill the structures with crap */
 158     memset(&ts, 1, sizeof(ts));
 159     memset(&tt, 1, sizeof(tt));
 160
 161     /* init structures */
 162     throttle_init(&ts);
 163     throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL,
 164                          read_timer_cb, write_timer_cb, &ts);
 165
 166     /* check initialized fields */
 167     g_assert(tt.clock_type == QEMU_CLOCK_VIRTUAL);
 168     g_assert(tt.timers[0]);
 169     g_assert(tt.timers[1]);
 170
 171     /* check other fields where cleared */
 172     g_assert(!ts.previous_leak);
 173     g_assert(!ts.cfg.op_size);
 174     for (i = 0; i < BUCKETS_COUNT; i++) {
 175         g_assert(!ts.cfg.buckets[i].avg);
 176         g_assert(!ts.cfg.buckets[i].max);
 177         g_assert(!ts.cfg.buckets[i].level);
 178     }
 179
 180     throttle_timers_destroy(&tt);
 181 }
 182
 183 static void test_destroy(void)
 184 {
 185     int i;
 186     throttle_init(&ts);
 187     throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL,
 188                          read_timer_cb, write_timer_cb, &ts);
 189     throttle_timers_destroy(&tt);
 190     for (i = 0; i < 2; i++) {
 191         g_assert(!tt.timers[i]);
 192     }
 193 }
 194
 195 /* function to test throttle_config and throttle_get_config */
 196 static void test_config_functions(void)
 197 {
 198     int i;
 199     ThrottleConfig orig_cfg, final_cfg;
 200
 201     orig_cfg.buckets[THROTTLE_BPS_TOTAL].avg = 153;
 202     orig_cfg.buckets[THROTTLE_BPS_READ].avg  = 56;
 203     orig_cfg.buckets[THROTTLE_BPS_WRITE].avg = 1;
 204
 205     orig_cfg.buckets[THROTTLE_OPS_TOTAL].avg = 150;
 206     orig_cfg.buckets[THROTTLE_OPS_READ].avg  = 69;
 207     orig_cfg.buckets[THROTTLE_OPS_WRITE].avg = 23;
 208
 209     orig_cfg.buckets[THROTTLE_BPS_TOTAL].max = 0; /* should be corrected */
 210     orig_cfg.buckets[THROTTLE_BPS_READ].max  = 1; /* should not be corrected */
 211     orig_cfg.buckets[THROTTLE_BPS_WRITE].max = 120;
 212
 213     orig_cfg.buckets[THROTTLE_OPS_TOTAL].max = 150;
 214     orig_cfg.buckets[THROTTLE_OPS_READ].max  = 400;
 215     orig_cfg.buckets[THROTTLE_OPS_WRITE].max = 500;
 216
 217     orig_cfg.buckets[THROTTLE_BPS_TOTAL].level = 45;
 218     orig_cfg.buckets[THROTTLE_BPS_READ].level  = 65;
 219     orig_cfg.buckets[THROTTLE_BPS_WRITE].level = 23;
 220
 221     orig_cfg.buckets[THROTTLE_OPS_TOTAL].level = 1;
 222     orig_cfg.buckets[THROTTLE_OPS_READ].level  = 90;
 223     orig_cfg.buckets[THROTTLE_OPS_WRITE].level = 75;
 224
 225     orig_cfg.op_size = 1;
 226
 227     throttle_init(&ts);
 228     throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL,
 229                          read_timer_cb, write_timer_cb, &ts);
 230     /* structure reset by throttle_init previous_leak should be null */
 231     g_assert(!ts.previous_leak);
 232     throttle_config(&ts, &tt, &orig_cfg);
 233
 234     /* has previous leak been initialized by throttle_config ? */
 235     g_assert(ts.previous_leak);
 236
 237     /* get back the fixed configuration */
 238     throttle_get_config(&ts, &final_cfg);
 239
 240     throttle_timers_destroy(&tt);
 241
 242     g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].avg == 153);
 243     g_assert(final_cfg.buckets[THROTTLE_BPS_READ].avg  == 56);
 244     g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].avg == 1);
 245
 246     g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].avg == 150);
 247     g_assert(final_cfg.buckets[THROTTLE_OPS_READ].avg  == 69);
 248     g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].avg == 23);
 249
 250     g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].max == 15.3);/* fixed */
 251     g_assert(final_cfg.buckets[THROTTLE_BPS_READ].max  == 1);   /* not fixed */
 252     g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].max == 120);
 253
 254     g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].max == 150);
 255     g_assert(final_cfg.buckets[THROTTLE_OPS_READ].max  == 400);
 256     g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].max == 500);
 257
 258     g_assert(final_cfg.op_size == 1);
 259
 260     /* check bucket have been cleared */
 261     for (i = 0; i < BUCKETS_COUNT; i++) {
 262         g_assert(!final_cfg.buckets[i].level);
 263     }
 264 }
 265
 266 /* functions to test is throttle is enabled by a config */
 267 static void set_cfg_value(bool is_max, int index, int value)
 268 {
 269     if (is_max) {
 270         cfg.buckets[index].max = value;
 271         /* If max is set, avg should never be 0 */
 272         cfg.buckets[index].avg = MAX(cfg.buckets[index].avg, 1);
 273     } else {
 274         cfg.buckets[index].avg = value;
 275     }
 276 }
 277
 278 static void test_enabled(void)
 279 {
 280     int i;
 281
 282     throttle_config_init(&cfg);
 283     g_assert(!throttle_enabled(&cfg));
 284
 285     for (i = 0; i < BUCKETS_COUNT; i++) {
 286         throttle_config_init(&cfg);
 287         set_cfg_value(false, i, 150);
 288         g_assert(throttle_enabled(&cfg));
 289     }
 290
 291     for (i = 0; i < BUCKETS_COUNT; i++) {
 292         throttle_config_init(&cfg);
 293         set_cfg_value(false, i, -150);
 294         g_assert(!throttle_enabled(&cfg));
 295     }
 296 }
 297
 298 /* tests functions for throttle_conflicting */
 299
 300 static void test_conflicts_for_one_set(bool is_max,
 301                                        int total,
 302                                        int read,
 303                                        int write)
 304 {
 305     throttle_config_init(&cfg);
 306     g_assert(throttle_is_valid(&cfg, NULL));
 307
 308     set_cfg_value(is_max, total, 1);
 309     set_cfg_value(is_max, read,  1);
 310     g_assert(!throttle_is_valid(&cfg, NULL));
 311
 312     throttle_config_init(&cfg);
 313     set_cfg_value(is_max, total, 1);
 314     set_cfg_value(is_max, write, 1);
 315     g_assert(!throttle_is_valid(&cfg, NULL));
 316
 317     throttle_config_init(&cfg);
 318     set_cfg_value(is_max, total, 1);
 319     set_cfg_value(is_max, read,  1);
 320     set_cfg_value(is_max, write, 1);
 321     g_assert(!throttle_is_valid(&cfg, NULL));
 322
 323     throttle_config_init(&cfg);
 324     set_cfg_value(is_max, total, 1);
 325     g_assert(throttle_is_valid(&cfg, NULL));
 326
 327     throttle_config_init(&cfg);
 328     set_cfg_value(is_max, read,  1);
 329     set_cfg_value(is_max, write, 1);
 330     g_assert(throttle_is_valid(&cfg, NULL));
 331 }
 332
 333 static void test_conflicting_config(void)
 334 {
 335     /* bps average conflicts */
 336     test_conflicts_for_one_set(false,
 337                                THROTTLE_BPS_TOTAL,
 338                                THROTTLE_BPS_READ,
 339                                THROTTLE_BPS_WRITE);
 340
 341     /* ops average conflicts */
 342     test_conflicts_for_one_set(false,
 343                                THROTTLE_OPS_TOTAL,
 344                                THROTTLE_OPS_READ,
 345                                THROTTLE_OPS_WRITE);
 346
 347     /* bps average conflicts */
 348     test_conflicts_for_one_set(true,
 349                                THROTTLE_BPS_TOTAL,
 350                                THROTTLE_BPS_READ,
 351                                THROTTLE_BPS_WRITE);
 352     /* ops average conflicts */
 353     test_conflicts_for_one_set(true,
 354                                THROTTLE_OPS_TOTAL,
 355                                THROTTLE_OPS_READ,
 356                                THROTTLE_OPS_WRITE);
 357 }
 358 /* functions to test the throttle_is_valid function */
 359 static void test_is_valid_for_value(int value, bool should_be_valid)
 360 {
 361     int is_max, index;
 362     for (is_max = 0; is_max < 2; is_max++) {
 363         for (index = 0; index < BUCKETS_COUNT; index++) {
 364             throttle_config_init(&cfg);
 365             set_cfg_value(is_max, index, value);
 366             g_assert(throttle_is_valid(&cfg, NULL) == should_be_valid);
 367         }
 368     }
 369 }
 370
 371 static void test_is_valid(void)
 372 {
 373     /* negative number are invalid */
 374     test_is_valid_for_value(-1, false);
 375     /* zero are valids */
 376     test_is_valid_for_value(0, true);
 377     /* positives numers are valids */
 378     test_is_valid_for_value(1, true);
 379 }
 380
 381 static void test_max_is_missing_limit(void)
 382 {
 383     int i;
 384
 385     for (i = 0; i < BUCKETS_COUNT; i++) {
 386         throttle_config_init(&cfg);
 387         cfg.buckets[i].max = 100;
 388         cfg.buckets[i].avg = 0;
 389         g_assert(!throttle_is_valid(&cfg, NULL));
 390
 391         cfg.buckets[i].max = 0;
 392         cfg.buckets[i].avg = 0;
 393         g_assert(throttle_is_valid(&cfg, NULL));
 394
 395         cfg.buckets[i].max = 0;
 396         cfg.buckets[i].avg = 100;
 397         g_assert(throttle_is_valid(&cfg, NULL));
 398     }
 399 }
 400
 401 static void test_have_timer(void)
 402 {
 403     /* zero structures */
 404     memset(&ts, 0, sizeof(ts));
 405     memset(&tt, 0, sizeof(tt));
 406
 407     /* no timer set should return false */
 408     g_assert(!throttle_timers_are_initialized(&tt));
 409
 410     /* init structures */
 411     throttle_init(&ts);
 412     throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL,
 413                          read_timer_cb, write_timer_cb, &ts);
 414
 415     /* timer set by init should return true */
 416     g_assert(throttle_timers_are_initialized(&tt));
 417
 418     throttle_timers_destroy(&tt);
 419 }
 420
 421 static void test_detach_attach(void)
 422 {
 423     /* zero structures */
 424     memset(&ts, 0, sizeof(ts));
 425     memset(&tt, 0, sizeof(tt));
 426
 427     /* init the structure */
 428     throttle_init(&ts);
 429     throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL,
 430                          read_timer_cb, write_timer_cb, &ts);
 431
 432     /* timer set by init should return true */
 433     g_assert(throttle_timers_are_initialized(&tt));
 434
 435     /* timer should no longer exist after detaching */
 436     throttle_timers_detach_aio_context(&tt);
 437     g_assert(!throttle_timers_are_initialized(&tt));
 438
 439     /* timer should exist again after attaching */
 440     throttle_timers_attach_aio_context(&tt, ctx);
 441     g_assert(throttle_timers_are_initialized(&tt));
 442
 443     throttle_timers_destroy(&tt);
 444 }
 445
 446 static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
 447                 int size,                   /* size of the operation to do */
 448                 double avg,                 /* io limit */
 449                 uint64_t op_size,           /* ideal size of an io */
 450                 double total_result,
 451                 double read_result,
 452                 double write_result)
 453 {
 454     BucketType to_test[2][3] = { { THROTTLE_BPS_TOTAL,
 455                                    THROTTLE_BPS_READ,
 456                                    THROTTLE_BPS_WRITE, },
 457                                  { THROTTLE_OPS_TOTAL,
 458                                    THROTTLE_OPS_READ,
 459                                    THROTTLE_OPS_WRITE, } };
 460     ThrottleConfig cfg;
 461     BucketType index;
 462     int i;
 463
 464     for (i = 0; i < 3; i++) {
 465         BucketType index = to_test[is_ops][i];
 466         cfg.buckets[index].avg = avg;
 467     }
 468
 469     cfg.op_size = op_size;
 470
 471     throttle_init(&ts);
 472     throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL,
 473                          read_timer_cb, write_timer_cb, &ts);
 474     throttle_config(&ts, &tt, &cfg);
 475
 476     /* account a read */
 477     throttle_account(&ts, false, size);
 478     /* account a write */
 479     throttle_account(&ts, true, size);
 480
 481     /* check total result */
 482     index = to_test[is_ops][0];
 483     if (!double_cmp(ts.cfg.buckets[index].level, total_result)) {
 484         return false;
 485     }
 486
 487     /* check read result */
 488     index = to_test[is_ops][1];
 489     if (!double_cmp(ts.cfg.buckets[index].level, read_result)) {
 490         return false;
 491     }
 492
 493     /* check write result */
 494     index = to_test[is_ops][2];
 495     if (!double_cmp(ts.cfg.buckets[index].level, write_result)) {
 496         return false;
 497     }
 498
 499     throttle_timers_destroy(&tt);
 500
 501     return true;
 502 }
 503
 504 static void test_accounting(void)
 505 {
 506     /* tests for bps */
 507
 508     /* op of size 1 */
 509     g_assert(do_test_accounting(false,
 510                                 1 * 512,
 511                                 150,
 512                                 0,
 513                                 1024,
 514                                 512,
 515                                 512));
 516
 517     /* op of size 2 */
 518     g_assert(do_test_accounting(false,
 519                                 2 * 512,
 520                                 150,
 521                                 0,
 522                                 2048,
 523                                 1024,
 524                                 1024));
 525
 526     /* op of size 2 and orthogonal parameter change */
 527     g_assert(do_test_accounting(false,
 528                                 2 * 512,
 529                                 150,
 530                                 17,
 531                                 2048,
 532                                 1024,
 533                                 1024));
 534
 535
 536     /* tests for ops */
 537
 538     /* op of size 1 */
 539     g_assert(do_test_accounting(true,
 540                                 1 * 512,
 541                                 150,
 542                                 0,
 543                                 2,
 544                                 1,
 545                                 1));
 546
 547     /* op of size 2 */
 548     g_assert(do_test_accounting(true,
 549                                 2 *  512,
 550                                 150,
 551                                 0,
 552                                 2,
 553                                 1,
 554                                 1));
 555
 556     /* jumbo op accounting fragmentation : size 64 with op size of 13 units */
 557     g_assert(do_test_accounting(true,
 558                                 64 * 512,
 559                                 150,
 560                                 13 * 512,
 561                                 (64.0 * 2) / 13,
 562                                 (64.0 / 13),
 563                                 (64.0 / 13)));
 564
 565     /* same with orthogonal parameters changes */
 566     g_assert(do_test_accounting(true,
 567                                 64 * 512,
 568                                 300,
 569                                 13 * 512,
 570                                 (64.0 * 2) / 13,
 571                                 (64.0 / 13),
 572                                 (64.0 / 13)));
 573 }
 574
 575 static void test_groups(void)
 576 {
 577     ThrottleConfig cfg1, cfg2;
 578     BlockBackend *blk1, *blk2, *blk3;
 579     BlockBackendPublic *blkp1, *blkp2, *blkp3;
 580
 581     blk1 = blk_new();
 582     blk2 = blk_new();
 583     blk3 = blk_new();
 584
 585     blkp1 = blk_get_public(blk1);
 586     blkp2 = blk_get_public(blk2);
 587     blkp3 = blk_get_public(blk3);
 588
 589     g_assert(blkp1->throttle_state == NULL);
 590     g_assert(blkp2->throttle_state == NULL);
 591     g_assert(blkp3->throttle_state == NULL);
 592
 593     throttle_group_register_blk(blk1, "bar");
 594     throttle_group_register_blk(blk2, "foo");
 595     throttle_group_register_blk(blk3, "bar");
 596
 597     g_assert(blkp1->throttle_state != NULL);
 598     g_assert(blkp2->throttle_state != NULL);
 599     g_assert(blkp3->throttle_state != NULL);
 600
 601     g_assert(!strcmp(throttle_group_get_name(blk1), "bar"));
 602     g_assert(!strcmp(throttle_group_get_name(blk2), "foo"));
 603     g_assert(blkp1->throttle_state == blkp3->throttle_state);
 604
 605     /* Setting the config of a group member affects the whole group */
 606     throttle_config_init(&cfg1);
 607     cfg1.buckets[THROTTLE_BPS_READ].avg  = 500000;
 608     cfg1.buckets[THROTTLE_BPS_WRITE].avg = 285000;
 609     cfg1.buckets[THROTTLE_OPS_READ].avg  = 20000;
 610     cfg1.buckets[THROTTLE_OPS_WRITE].avg = 12000;
 611     throttle_group_config(blk1, &cfg1);
 612
 613     throttle_group_get_config(blk1, &cfg1);
 614     throttle_group_get_config(blk3, &cfg2);
 615     g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1)));
 616
 617     cfg2.buckets[THROTTLE_BPS_READ].avg  = 4547;
 618     cfg2.buckets[THROTTLE_BPS_WRITE].avg = 1349;
 619     cfg2.buckets[THROTTLE_OPS_READ].avg  = 123;
 620     cfg2.buckets[THROTTLE_OPS_WRITE].avg = 86;
 621     throttle_group_config(blk3, &cfg1);
 622
 623     throttle_group_get_config(blk1, &cfg1);
 624     throttle_group_get_config(blk3, &cfg2);
 625     g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1)));
 626
 627     throttle_group_unregister_blk(blk1);
 628     throttle_group_unregister_blk(blk2);
 629     throttle_group_unregister_blk(blk3);
 630
 631     g_assert(blkp1->throttle_state == NULL);
 632     g_assert(blkp2->throttle_state == NULL);
 633     g_assert(blkp3->throttle_state == NULL);
 634 }
 635
 636 int main(int argc, char **argv)
 637 {
 638     qemu_init_main_loop(&error_fatal);
 639     ctx = qemu_get_aio_context();
 640     bdrv_init();
 641
 642     do {} while (g_main_context_iteration(NULL, false));
 643
 644     /* tests in the same order as the header function declarations */
 645     g_test_init(&argc, &argv, NULL);
 646     g_test_add_func("/throttle/leak_bucket",        test_leak_bucket);
 647     g_test_add_func("/throttle/compute_wait",       test_compute_wait);
 648     g_test_add_func("/throttle/init",               test_init);
 649     g_test_add_func("/throttle/destroy",            test_destroy);
 650     g_test_add_func("/throttle/have_timer",         test_have_timer);
 651     g_test_add_func("/throttle/detach_attach",      test_detach_attach);
 652     g_test_add_func("/throttle/config/enabled",     test_enabled);
 653     g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
 654     g_test_add_func("/throttle/config/is_valid",    test_is_valid);
 655     g_test_add_func("/throttle/config/max",         test_max_is_missing_limit);
 656     g_test_add_func("/throttle/config_functions",   test_config_functions);
 657     g_test_add_func("/throttle/accounting",         test_accounting);
 658     g_test_add_func("/throttle/groups",             test_groups);
 659     return g_test_run();
 660 }
 661