2 * Throttle infrastructure tests
4 * Copyright Nodalink, EURL. 2013-2014
5 * Copyright Igalia, S.L. 2015
8 * BenoƮt Canet <benoit.canet@nodalink.com>
9 * Alberto Garcia <berto@igalia.com>
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.
15 #include "qemu/osdep.h"
17 #include "block/aio.h"
18 #include "qapi/error.h"
19 #include "qemu/throttle.h"
20 #include "qemu/error-report.h"
21 #include "qemu/main-loop.h"
22 #include "qemu/module.h"
23 #include "block/throttle-groups.h"
24 #include "sysemu/block-backend.h"
26 static AioContext
*ctx
;
27 static LeakyBucket bkt
;
28 static ThrottleConfig cfg
;
29 static ThrottleGroupMember tgm
;
30 static ThrottleState ts
;
31 static ThrottleTimers
*tt
;
34 static bool double_cmp(double x
, double y
)
36 return fabsl(x
- y
) < 1e-6;
39 /* tests for single bucket operations */
40 static void test_leak_bucket(void)
42 throttle_config_init(&cfg
);
43 bkt
= cfg
.buckets
[THROTTLE_BPS_TOTAL
];
45 /* set initial value */
50 /* leak an op work of time */
51 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 150);
52 g_assert(bkt
.avg
== 150);
53 g_assert(bkt
.max
== 15);
54 g_assert(double_cmp(bkt
.level
, 0.5));
56 /* leak again emptying the bucket */
57 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 150);
58 g_assert(bkt
.avg
== 150);
59 g_assert(bkt
.max
== 15);
60 g_assert(double_cmp(bkt
.level
, 0));
62 /* check that the bucket level won't go lower */
63 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 150);
64 g_assert(bkt
.avg
== 150);
65 g_assert(bkt
.max
== 15);
66 g_assert(double_cmp(bkt
.level
, 0));
68 /* check that burst_level leaks correctly */
71 bkt
.burst_length
= 2; /* otherwise burst_level will not leak */
72 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 100);
73 g_assert(double_cmp(bkt
.burst_level
, 3.5));
75 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 100);
76 g_assert(double_cmp(bkt
.burst_level
, 1));
78 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 100);
79 g_assert(double_cmp(bkt
.burst_level
, 0));
81 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 100);
82 g_assert(double_cmp(bkt
.burst_level
, 0));
85 static void test_compute_wait(void)
91 throttle_config_init(&cfg
);
92 bkt
= cfg
.buckets
[THROTTLE_BPS_TOTAL
];
94 /* no operation limit set */
98 wait
= throttle_compute_wait(&bkt
);
105 wait
= throttle_compute_wait(&bkt
);
108 /* below zero delta */
112 wait
= throttle_compute_wait(&bkt
);
115 /* half an operation above max */
119 wait
= throttle_compute_wait(&bkt
);
120 /* time required to do half an operation */
121 result
= (int64_t) NANOSECONDS_PER_SECOND
/ 150 / 2;
122 g_assert(wait
== result
);
124 /* Perform I/O for 2.2 seconds at a rate of bkt.max */
125 bkt
.burst_length
= 2;
129 for (i
= 0; i
< 22; i
++) {
130 double units
= bkt
.max
/ 10;
132 bkt
.burst_level
+= units
;
133 throttle_leak_bucket(&bkt
, NANOSECONDS_PER_SECOND
/ 10);
134 wait
= throttle_compute_wait(&bkt
);
135 g_assert(double_cmp(bkt
.burst_level
, 0));
136 g_assert(double_cmp(bkt
.level
, (i
+ 1) * (bkt
.max
- bkt
.avg
) / 10));
137 /* We can do bursts for the 2 seconds we have configured in
138 * burst_length. We have 100 extra miliseconds of burst
139 * because bkt.level has been leaking during this time.
140 * After that, we have to wait. */
141 result
= i
< 21 ? 0 : 1.8 * NANOSECONDS_PER_SECOND
;
142 g_assert(wait
== result
);
146 /* functions to test ThrottleState initialization/destroy methods */
147 static void read_timer_cb(void *opaque
)
151 static void write_timer_cb(void *opaque
)
155 static void test_init(void)
159 tt
= &tgm
.throttle_timers
;
161 /* fill the structures with crap */
162 memset(&ts
, 1, sizeof(ts
));
163 memset(tt
, 1, sizeof(*tt
));
165 /* init structures */
167 throttle_timers_init(tt
, ctx
, QEMU_CLOCK_VIRTUAL
,
168 read_timer_cb
, write_timer_cb
, &ts
);
170 /* check initialized fields */
171 g_assert(tt
->clock_type
== QEMU_CLOCK_VIRTUAL
);
172 g_assert(tt
->timers
[0]);
173 g_assert(tt
->timers
[1]);
175 /* check other fields where cleared */
176 g_assert(!ts
.previous_leak
);
177 g_assert(!ts
.cfg
.op_size
);
178 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
179 g_assert(!ts
.cfg
.buckets
[i
].avg
);
180 g_assert(!ts
.cfg
.buckets
[i
].max
);
181 g_assert(!ts
.cfg
.buckets
[i
].level
);
184 throttle_timers_destroy(tt
);
187 static void test_destroy(void)
191 throttle_timers_init(tt
, ctx
, QEMU_CLOCK_VIRTUAL
,
192 read_timer_cb
, write_timer_cb
, &ts
);
193 throttle_timers_destroy(tt
);
194 for (i
= 0; i
< 2; i
++) {
195 g_assert(!tt
->timers
[i
]);
199 /* function to test throttle_config and throttle_get_config */
200 static void test_config_functions(void)
203 ThrottleConfig orig_cfg
, final_cfg
;
205 orig_cfg
.buckets
[THROTTLE_BPS_TOTAL
].avg
= 153;
206 orig_cfg
.buckets
[THROTTLE_BPS_READ
].avg
= 56;
207 orig_cfg
.buckets
[THROTTLE_BPS_WRITE
].avg
= 1;
209 orig_cfg
.buckets
[THROTTLE_OPS_TOTAL
].avg
= 150;
210 orig_cfg
.buckets
[THROTTLE_OPS_READ
].avg
= 69;
211 orig_cfg
.buckets
[THROTTLE_OPS_WRITE
].avg
= 23;
213 orig_cfg
.buckets
[THROTTLE_BPS_TOTAL
].max
= 0;
214 orig_cfg
.buckets
[THROTTLE_BPS_READ
].max
= 56;
215 orig_cfg
.buckets
[THROTTLE_BPS_WRITE
].max
= 120;
217 orig_cfg
.buckets
[THROTTLE_OPS_TOTAL
].max
= 150;
218 orig_cfg
.buckets
[THROTTLE_OPS_READ
].max
= 400;
219 orig_cfg
.buckets
[THROTTLE_OPS_WRITE
].max
= 500;
221 orig_cfg
.buckets
[THROTTLE_BPS_TOTAL
].level
= 45;
222 orig_cfg
.buckets
[THROTTLE_BPS_READ
].level
= 65;
223 orig_cfg
.buckets
[THROTTLE_BPS_WRITE
].level
= 23;
225 orig_cfg
.buckets
[THROTTLE_OPS_TOTAL
].level
= 1;
226 orig_cfg
.buckets
[THROTTLE_OPS_READ
].level
= 90;
227 orig_cfg
.buckets
[THROTTLE_OPS_WRITE
].level
= 75;
229 orig_cfg
.op_size
= 1;
232 throttle_timers_init(tt
, ctx
, QEMU_CLOCK_VIRTUAL
,
233 read_timer_cb
, write_timer_cb
, &ts
);
234 /* structure reset by throttle_init previous_leak should be null */
235 g_assert(!ts
.previous_leak
);
236 throttle_config(&ts
, QEMU_CLOCK_VIRTUAL
, &orig_cfg
);
238 /* has previous leak been initialized by throttle_config ? */
239 g_assert(ts
.previous_leak
);
241 /* get back the fixed configuration */
242 throttle_get_config(&ts
, &final_cfg
);
244 throttle_timers_destroy(tt
);
246 g_assert(final_cfg
.buckets
[THROTTLE_BPS_TOTAL
].avg
== 153);
247 g_assert(final_cfg
.buckets
[THROTTLE_BPS_READ
].avg
== 56);
248 g_assert(final_cfg
.buckets
[THROTTLE_BPS_WRITE
].avg
== 1);
250 g_assert(final_cfg
.buckets
[THROTTLE_OPS_TOTAL
].avg
== 150);
251 g_assert(final_cfg
.buckets
[THROTTLE_OPS_READ
].avg
== 69);
252 g_assert(final_cfg
.buckets
[THROTTLE_OPS_WRITE
].avg
== 23);
254 g_assert(final_cfg
.buckets
[THROTTLE_BPS_TOTAL
].max
== 0);
255 g_assert(final_cfg
.buckets
[THROTTLE_BPS_READ
].max
== 56);
256 g_assert(final_cfg
.buckets
[THROTTLE_BPS_WRITE
].max
== 120);
258 g_assert(final_cfg
.buckets
[THROTTLE_OPS_TOTAL
].max
== 150);
259 g_assert(final_cfg
.buckets
[THROTTLE_OPS_READ
].max
== 400);
260 g_assert(final_cfg
.buckets
[THROTTLE_OPS_WRITE
].max
== 500);
262 g_assert(final_cfg
.op_size
== 1);
264 /* check bucket have been cleared */
265 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
266 g_assert(!final_cfg
.buckets
[i
].level
);
270 /* functions to test is throttle is enabled by a config */
271 static void set_cfg_value(bool is_max
, int index
, int value
)
274 cfg
.buckets
[index
].max
= value
;
275 /* If max is set, avg should never be 0 */
276 cfg
.buckets
[index
].avg
= MAX(cfg
.buckets
[index
].avg
, 1);
278 cfg
.buckets
[index
].avg
= value
;
282 static void test_enabled(void)
286 throttle_config_init(&cfg
);
287 g_assert(!throttle_enabled(&cfg
));
289 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
290 throttle_config_init(&cfg
);
291 set_cfg_value(false, i
, 150);
292 g_assert(throttle_is_valid(&cfg
, NULL
));
293 g_assert(throttle_enabled(&cfg
));
296 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
297 throttle_config_init(&cfg
);
298 set_cfg_value(false, i
, -150);
299 g_assert(!throttle_is_valid(&cfg
, NULL
));
303 /* tests functions for throttle_conflicting */
305 static void test_conflicts_for_one_set(bool is_max
,
310 throttle_config_init(&cfg
);
311 g_assert(throttle_is_valid(&cfg
, NULL
));
313 set_cfg_value(is_max
, total
, 1);
314 set_cfg_value(is_max
, read
, 1);
315 g_assert(!throttle_is_valid(&cfg
, NULL
));
317 throttle_config_init(&cfg
);
318 set_cfg_value(is_max
, total
, 1);
319 set_cfg_value(is_max
, write
, 1);
320 g_assert(!throttle_is_valid(&cfg
, NULL
));
322 throttle_config_init(&cfg
);
323 set_cfg_value(is_max
, total
, 1);
324 set_cfg_value(is_max
, read
, 1);
325 set_cfg_value(is_max
, write
, 1);
326 g_assert(!throttle_is_valid(&cfg
, NULL
));
328 throttle_config_init(&cfg
);
329 set_cfg_value(is_max
, total
, 1);
330 g_assert(throttle_is_valid(&cfg
, NULL
));
332 throttle_config_init(&cfg
);
333 set_cfg_value(is_max
, read
, 1);
334 set_cfg_value(is_max
, write
, 1);
335 g_assert(throttle_is_valid(&cfg
, NULL
));
338 static void test_conflicting_config(void)
340 /* bps average conflicts */
341 test_conflicts_for_one_set(false,
346 /* ops average conflicts */
347 test_conflicts_for_one_set(false,
352 /* bps average conflicts */
353 test_conflicts_for_one_set(true,
357 /* ops average conflicts */
358 test_conflicts_for_one_set(true,
363 /* functions to test the throttle_is_valid function */
364 static void test_is_valid_for_value(int value
, bool should_be_valid
)
367 for (is_max
= 0; is_max
< 2; is_max
++) {
368 for (index
= 0; index
< BUCKETS_COUNT
; index
++) {
369 throttle_config_init(&cfg
);
370 set_cfg_value(is_max
, index
, value
);
371 g_assert(throttle_is_valid(&cfg
, NULL
) == should_be_valid
);
376 static void test_is_valid(void)
378 /* negative number are invalid */
379 test_is_valid_for_value(-1, false);
380 /* zero are valids */
381 test_is_valid_for_value(0, true);
382 /* positives numers are valids */
383 test_is_valid_for_value(1, true);
386 static void test_ranges(void)
390 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
391 LeakyBucket
*b
= &cfg
.buckets
[i
];
392 throttle_config_init(&cfg
);
394 /* avg = 0 means throttling is disabled, but the config is valid */
396 g_assert(throttle_is_valid(&cfg
, NULL
));
397 g_assert(!throttle_enabled(&cfg
));
399 /* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
401 g_assert(throttle_is_valid(&cfg
, NULL
));
403 b
->avg
= THROTTLE_VALUE_MAX
;
404 g_assert(throttle_is_valid(&cfg
, NULL
));
406 b
->avg
= THROTTLE_VALUE_MAX
;
407 b
->max
= THROTTLE_VALUE_MAX
;
408 g_assert(throttle_is_valid(&cfg
, NULL
));
410 /* Values over THROTTLE_VALUE_MAX are not allowed */
411 b
->avg
= THROTTLE_VALUE_MAX
+ 1;
412 g_assert(!throttle_is_valid(&cfg
, NULL
));
414 b
->avg
= THROTTLE_VALUE_MAX
;
415 b
->max
= THROTTLE_VALUE_MAX
+ 1;
416 g_assert(!throttle_is_valid(&cfg
, NULL
));
418 /* burst_length must be between 1 and THROTTLE_VALUE_MAX */
422 g_assert(!throttle_is_valid(&cfg
, NULL
));
427 g_assert(throttle_is_valid(&cfg
, NULL
));
431 b
->burst_length
= THROTTLE_VALUE_MAX
;
432 g_assert(throttle_is_valid(&cfg
, NULL
));
436 b
->burst_length
= THROTTLE_VALUE_MAX
+ 1;
437 g_assert(!throttle_is_valid(&cfg
, NULL
));
439 /* burst_length * max cannot exceed THROTTLE_VALUE_MAX */
442 b
->burst_length
= THROTTLE_VALUE_MAX
/ 2;
443 g_assert(throttle_is_valid(&cfg
, NULL
));
447 b
->burst_length
= THROTTLE_VALUE_MAX
/ 2;
448 g_assert(!throttle_is_valid(&cfg
, NULL
));
451 b
->max
= THROTTLE_VALUE_MAX
;
453 g_assert(throttle_is_valid(&cfg
, NULL
));
456 b
->max
= THROTTLE_VALUE_MAX
;
458 g_assert(!throttle_is_valid(&cfg
, NULL
));
462 static void test_max_is_missing_limit(void)
466 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
467 throttle_config_init(&cfg
);
468 cfg
.buckets
[i
].max
= 100;
469 cfg
.buckets
[i
].avg
= 0;
470 g_assert(!throttle_is_valid(&cfg
, NULL
));
472 cfg
.buckets
[i
].max
= 0;
473 cfg
.buckets
[i
].avg
= 0;
474 g_assert(throttle_is_valid(&cfg
, NULL
));
476 cfg
.buckets
[i
].max
= 0;
477 cfg
.buckets
[i
].avg
= 100;
478 g_assert(throttle_is_valid(&cfg
, NULL
));
480 cfg
.buckets
[i
].max
= 30;
481 cfg
.buckets
[i
].avg
= 100;
482 g_assert(!throttle_is_valid(&cfg
, NULL
));
484 cfg
.buckets
[i
].max
= 100;
485 cfg
.buckets
[i
].avg
= 100;
486 g_assert(throttle_is_valid(&cfg
, NULL
));
490 static void test_iops_size_is_missing_limit(void)
492 /* A total/read/write iops limit is required */
493 throttle_config_init(&cfg
);
495 g_assert(!throttle_is_valid(&cfg
, NULL
));
498 static void test_have_timer(void)
500 /* zero structures */
501 memset(&ts
, 0, sizeof(ts
));
502 memset(tt
, 0, sizeof(*tt
));
504 /* no timer set should return false */
505 g_assert(!throttle_timers_are_initialized(tt
));
507 /* init structures */
509 throttle_timers_init(tt
, ctx
, QEMU_CLOCK_VIRTUAL
,
510 read_timer_cb
, write_timer_cb
, &ts
);
512 /* timer set by init should return true */
513 g_assert(throttle_timers_are_initialized(tt
));
515 throttle_timers_destroy(tt
);
518 static void test_detach_attach(void)
520 /* zero structures */
521 memset(&ts
, 0, sizeof(ts
));
522 memset(tt
, 0, sizeof(*tt
));
524 /* init the structure */
526 throttle_timers_init(tt
, ctx
, QEMU_CLOCK_VIRTUAL
,
527 read_timer_cb
, write_timer_cb
, &ts
);
529 /* timer set by init should return true */
530 g_assert(throttle_timers_are_initialized(tt
));
532 /* timer should no longer exist after detaching */
533 throttle_timers_detach_aio_context(tt
);
534 g_assert(!throttle_timers_are_initialized(tt
));
536 /* timer should exist again after attaching */
537 throttle_timers_attach_aio_context(tt
, ctx
);
538 g_assert(throttle_timers_are_initialized(tt
));
540 throttle_timers_destroy(tt
);
543 static bool do_test_accounting(bool is_ops
, /* are we testing bps or ops */
544 int size
, /* size of the operation to do */
545 double avg
, /* io limit */
546 uint64_t op_size
, /* ideal size of an io */
551 BucketType to_test
[2][3] = { { THROTTLE_BPS_TOTAL
,
553 THROTTLE_BPS_WRITE
, },
554 { THROTTLE_OPS_TOTAL
,
556 THROTTLE_OPS_WRITE
, } };
561 throttle_config_init(&cfg
);
563 for (i
= 0; i
< 3; i
++) {
564 BucketType index
= to_test
[is_ops
][i
];
565 cfg
.buckets
[index
].avg
= avg
;
568 cfg
.op_size
= op_size
;
571 throttle_timers_init(tt
, ctx
, QEMU_CLOCK_VIRTUAL
,
572 read_timer_cb
, write_timer_cb
, &ts
);
573 throttle_config(&ts
, QEMU_CLOCK_VIRTUAL
, &cfg
);
576 throttle_account(&ts
, false, size
);
577 /* account a write */
578 throttle_account(&ts
, true, size
);
580 /* check total result */
581 index
= to_test
[is_ops
][0];
582 if (!double_cmp(ts
.cfg
.buckets
[index
].level
, total_result
)) {
586 /* check read result */
587 index
= to_test
[is_ops
][1];
588 if (!double_cmp(ts
.cfg
.buckets
[index
].level
, read_result
)) {
592 /* check write result */
593 index
= to_test
[is_ops
][2];
594 if (!double_cmp(ts
.cfg
.buckets
[index
].level
, write_result
)) {
598 throttle_timers_destroy(tt
);
603 static void test_accounting(void)
608 g_assert(do_test_accounting(false,
617 g_assert(do_test_accounting(false,
625 /* op of size 2 and orthogonal parameter change */
626 g_assert(do_test_accounting(false,
638 g_assert(do_test_accounting(true,
647 g_assert(do_test_accounting(true,
655 /* jumbo op accounting fragmentation : size 64 with op size of 13 units */
656 g_assert(do_test_accounting(true,
664 /* same with orthogonal parameters changes */
665 g_assert(do_test_accounting(true,
674 static void test_groups(void)
676 ThrottleConfig cfg1
, cfg2
;
677 BlockBackend
*blk1
, *blk2
, *blk3
;
678 BlockBackendPublic
*blkp1
, *blkp2
, *blkp3
;
679 ThrottleGroupMember
*tgm1
, *tgm2
, *tgm3
;
681 /* No actual I/O is performed on these devices */
682 blk1
= blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL
);
683 blk2
= blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL
);
684 blk3
= blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL
);
686 blkp1
= blk_get_public(blk1
);
687 blkp2
= blk_get_public(blk2
);
688 blkp3
= blk_get_public(blk3
);
690 tgm1
= &blkp1
->throttle_group_member
;
691 tgm2
= &blkp2
->throttle_group_member
;
692 tgm3
= &blkp3
->throttle_group_member
;
694 g_assert(tgm1
->throttle_state
== NULL
);
695 g_assert(tgm2
->throttle_state
== NULL
);
696 g_assert(tgm3
->throttle_state
== NULL
);
698 throttle_group_register_tgm(tgm1
, "bar", blk_get_aio_context(blk1
));
699 throttle_group_register_tgm(tgm2
, "foo", blk_get_aio_context(blk2
));
700 throttle_group_register_tgm(tgm3
, "bar", blk_get_aio_context(blk3
));
702 g_assert(tgm1
->throttle_state
!= NULL
);
703 g_assert(tgm2
->throttle_state
!= NULL
);
704 g_assert(tgm3
->throttle_state
!= NULL
);
706 g_assert(!strcmp(throttle_group_get_name(tgm1
), "bar"));
707 g_assert(!strcmp(throttle_group_get_name(tgm2
), "foo"));
708 g_assert(tgm1
->throttle_state
== tgm3
->throttle_state
);
710 /* Setting the config of a group member affects the whole group */
711 throttle_config_init(&cfg1
);
712 cfg1
.buckets
[THROTTLE_BPS_READ
].avg
= 500000;
713 cfg1
.buckets
[THROTTLE_BPS_WRITE
].avg
= 285000;
714 cfg1
.buckets
[THROTTLE_OPS_READ
].avg
= 20000;
715 cfg1
.buckets
[THROTTLE_OPS_WRITE
].avg
= 12000;
716 throttle_group_config(tgm1
, &cfg1
);
718 throttle_group_get_config(tgm1
, &cfg1
);
719 throttle_group_get_config(tgm3
, &cfg2
);
720 g_assert(!memcmp(&cfg1
, &cfg2
, sizeof(cfg1
)));
722 cfg2
.buckets
[THROTTLE_BPS_READ
].avg
= 4547;
723 cfg2
.buckets
[THROTTLE_BPS_WRITE
].avg
= 1349;
724 cfg2
.buckets
[THROTTLE_OPS_READ
].avg
= 123;
725 cfg2
.buckets
[THROTTLE_OPS_WRITE
].avg
= 86;
726 throttle_group_config(tgm3
, &cfg1
);
728 throttle_group_get_config(tgm1
, &cfg1
);
729 throttle_group_get_config(tgm3
, &cfg2
);
730 g_assert(!memcmp(&cfg1
, &cfg2
, sizeof(cfg1
)));
732 throttle_group_unregister_tgm(tgm1
);
733 throttle_group_unregister_tgm(tgm2
);
734 throttle_group_unregister_tgm(tgm3
);
736 g_assert(tgm1
->throttle_state
== NULL
);
737 g_assert(tgm2
->throttle_state
== NULL
);
738 g_assert(tgm3
->throttle_state
== NULL
);
741 int main(int argc
, char **argv
)
743 qemu_init_main_loop(&error_fatal
);
744 ctx
= qemu_get_aio_context();
746 module_call_init(MODULE_INIT_QOM
);
748 do {} while (g_main_context_iteration(NULL
, false));
750 /* tests in the same order as the header function declarations */
751 g_test_init(&argc
, &argv
, NULL
);
752 g_test_add_func("/throttle/leak_bucket", test_leak_bucket
);
753 g_test_add_func("/throttle/compute_wait", test_compute_wait
);
754 g_test_add_func("/throttle/init", test_init
);
755 g_test_add_func("/throttle/destroy", test_destroy
);
756 g_test_add_func("/throttle/have_timer", test_have_timer
);
757 g_test_add_func("/throttle/detach_attach", test_detach_attach
);
758 g_test_add_func("/throttle/config/enabled", test_enabled
);
759 g_test_add_func("/throttle/config/conflicting", test_conflicting_config
);
760 g_test_add_func("/throttle/config/is_valid", test_is_valid
);
761 g_test_add_func("/throttle/config/ranges", test_ranges
);
762 g_test_add_func("/throttle/config/max", test_max_is_missing_limit
);
763 g_test_add_func("/throttle/config/iops_size",
764 test_iops_size_is_missing_limit
);
765 g_test_add_func("/throttle/config_functions", test_config_functions
);
766 g_test_add_func("/throttle/accounting", test_accounting
);
767 g_test_add_func("/throttle/groups", test_groups
);