OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity
e2k-v9.0.0
qemu-e2k/tests/unit/test-throttle.c
Peter Maydell 43199b1393 tests/unit/test-throttle: Avoid unintended integer division 
In test_compute_wait() we do
 double units = bkt.max / 10;
which does an integer division and then assigns it to a double variable,
and similarly later on in the expression for an assertion.

Use 10.0 so that we do a floating point division and calculate the
exact value, rather than doing an integer division.

Spotted by Coverity.

Resolves: Coverity CID 1432564
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Message-id: 20240312183810.557768-7-peter.maydell@linaro.org
2024-03-25 14:17:06 +00:00

836 lines
25 KiB
C
Raw Permalink Blame History

/*
* Throttle infrastructure tests
*
* Copyright Nodalink, EURL. 2013-2014
* Copyright Igalia, S.L. 2015
*
* Authors:
* Benoît Canet <benoit.canet@nodalink.com>
* Alberto Garcia <berto@igalia.com>
*
* 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 <math.h>
#include "block/aio.h"
#include "qapi/error.h"
#include "qemu/throttle.h"
#include "qemu/error-report.h"
#include "qemu/main-loop.h"
#include "qemu/module.h"
#include "block/throttle-groups.h"
#include "sysemu/block-backend.h"
static AioContext *ctx;
static LeakyBucket bkt;
static ThrottleConfig cfg;
static ThrottleGroupMember tgm;
static ThrottleState ts;
static ThrottleTimers *tt;
/* useful function */
static bool double_cmp(double x, double y)
{
return fabsl(x - y) < 1e-6;
}
/* tests for single bucket operations */
static void test_leak_bucket(void)
{
throttle_config_init(&cfg);
bkt = cfg.buckets[THROTTLE_BPS_TOTAL];
/* set initial value */
bkt.avg = 150;
bkt.max = 15;
bkt.level = 1.5;
/* leak an op work of time */
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
g_assert(bkt.avg == 150);
g_assert(bkt.max == 15);
g_assert(double_cmp(bkt.level, 0.5));
/* leak again emptying the bucket */
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
g_assert(bkt.avg == 150);
g_assert(bkt.max == 15);
g_assert(double_cmp(bkt.level, 0));
/* check that the bucket level won't go lower */
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
g_assert(bkt.avg == 150);
g_assert(bkt.max == 15);
g_assert(double_cmp(bkt.level, 0));
/* check that burst_level leaks correctly */
bkt.burst_level = 6;
bkt.max = 250;
bkt.burst_length = 2; /* otherwise burst_level will not leak */
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
g_assert(double_cmp(bkt.burst_level, 3.5));
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
g_assert(double_cmp(bkt.burst_level, 1));
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
g_assert(double_cmp(bkt.burst_level, 0));
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
g_assert(double_cmp(bkt.burst_level, 0));
}
static void test_compute_wait(void)
{
unsigned i;
int64_t wait;
int64_t result;
throttle_config_init(&cfg);
bkt = cfg.buckets[THROTTLE_BPS_TOTAL];
/* no operation limit set */
bkt.avg = 0;
bkt.max = 15;
bkt.level = 1.5;
wait = throttle_compute_wait(&bkt);
g_assert(!wait);
/* zero delta */
bkt.avg = 150;
bkt.max = 15;
bkt.level = 15;
wait = throttle_compute_wait(&bkt);
g_assert(!wait);
/* below zero delta */
bkt.avg = 150;
bkt.max = 15;
bkt.level = 9;
wait = throttle_compute_wait(&bkt);
g_assert(!wait);
/* half an operation above max */
bkt.avg = 150;
bkt.max = 15;
bkt.level = 15.5;
wait = throttle_compute_wait(&bkt);
/* time required to do half an operation */
result = (int64_t) NANOSECONDS_PER_SECOND / 150 / 2;
g_assert(wait == result);
/* Perform I/O for 2.2 seconds at a rate of bkt.max */
bkt.burst_length = 2;
bkt.level = 0;
bkt.avg = 10;
bkt.max = 200;
for (i = 0; i < 22; i++) {
double units = bkt.max / 10.0;
bkt.level += units;
bkt.burst_level += units;
throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 10);
wait = throttle_compute_wait(&bkt);
g_assert(double_cmp(bkt.burst_level, 0));
g_assert(double_cmp(bkt.level, (i + 1) * (bkt.max - bkt.avg) / 10.0));
/* We can do bursts for the 2 seconds we have configured in
* burst_length. We have 100 extra milliseconds of burst
* because bkt.level has been leaking during this time.
* After that, we have to wait. */
result = i < 21 ? 0 : 1.8 * NANOSECONDS_PER_SECOND;
g_assert(wait == result);
}
}
/* functions to test ThrottleState initialization/destroy methods */
static void read_timer_cb(void *opaque)
{
}
static void write_timer_cb(void *opaque)
{
}
static void test_init(void)
{
int i;
tt = &tgm.throttle_timers;
/* fill the structures with crap */
memset(&ts, 1, sizeof(ts));
memset(tt, 1, sizeof(*tt));
/* init structures */
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
read_timer_cb, write_timer_cb, &ts);
/* check initialized fields */
g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
g_assert(tt->timers[THROTTLE_READ]);
g_assert(tt->timers[THROTTLE_WRITE]);
/* check other fields where cleared */
g_assert(!ts.previous_leak);
g_assert(!ts.cfg.op_size);
for (i = 0; i < BUCKETS_COUNT; i++) {
g_assert(!ts.cfg.buckets[i].avg);
g_assert(!ts.cfg.buckets[i].max);
g_assert(!ts.cfg.buckets[i].level);
}
throttle_timers_destroy(tt);
}
static void test_init_readonly(void)
{
int i;
tt = &tgm.throttle_timers;
/* fill the structures with crap */
memset(&ts, 1, sizeof(ts));
memset(tt, 1, sizeof(*tt));
/* init structures */
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
read_timer_cb, NULL, &ts);
/* check initialized fields */
g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
g_assert(tt->timers[THROTTLE_READ]);
g_assert(!tt->timers[THROTTLE_WRITE]);
/* check other fields where cleared */
g_assert(!ts.previous_leak);
g_assert(!ts.cfg.op_size);
for (i = 0; i < BUCKETS_COUNT; i++) {
g_assert(!ts.cfg.buckets[i].avg);
g_assert(!ts.cfg.buckets[i].max);
g_assert(!ts.cfg.buckets[i].level);
}
throttle_timers_destroy(tt);
}
static void test_init_writeonly(void)
{
int i;
tt = &tgm.throttle_timers;
/* fill the structures with crap */
memset(&ts, 1, sizeof(ts));
memset(tt, 1, sizeof(*tt));
/* init structures */
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
NULL, write_timer_cb, &ts);
/* check initialized fields */
g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
g_assert(!tt->timers[THROTTLE_READ]);
g_assert(tt->timers[THROTTLE_WRITE]);
/* check other fields where cleared */
g_assert(!ts.previous_leak);
g_assert(!ts.cfg.op_size);
for (i = 0; i < BUCKETS_COUNT; i++) {
g_assert(!ts.cfg.buckets[i].avg);
g_assert(!ts.cfg.buckets[i].max);
g_assert(!ts.cfg.buckets[i].level);
}
throttle_timers_destroy(tt);
}
static void test_destroy(void)
{
int i;
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
read_timer_cb, write_timer_cb, &ts);
throttle_timers_destroy(tt);
for (i = 0; i < THROTTLE_MAX; i++) {
g_assert(!tt->timers[i]);
}
}
/* function to test throttle_config and throttle_get_config */
static void test_config_functions(void)
{
int i;
ThrottleConfig orig_cfg, final_cfg;
orig_cfg.buckets[THROTTLE_BPS_TOTAL].avg = 153;
orig_cfg.buckets[THROTTLE_BPS_READ].avg = 56;
orig_cfg.buckets[THROTTLE_BPS_WRITE].avg = 1;
orig_cfg.buckets[THROTTLE_OPS_TOTAL].avg = 150;
orig_cfg.buckets[THROTTLE_OPS_READ].avg = 69;
orig_cfg.buckets[THROTTLE_OPS_WRITE].avg = 23;
orig_cfg.buckets[THROTTLE_BPS_TOTAL].max = 0;
orig_cfg.buckets[THROTTLE_BPS_READ].max = 56;
orig_cfg.buckets[THROTTLE_BPS_WRITE].max = 120;
orig_cfg.buckets[THROTTLE_OPS_TOTAL].max = 150;
orig_cfg.buckets[THROTTLE_OPS_READ].max = 400;
orig_cfg.buckets[THROTTLE_OPS_WRITE].max = 500;
orig_cfg.buckets[THROTTLE_BPS_TOTAL].level = 45;
orig_cfg.buckets[THROTTLE_BPS_READ].level = 65;
orig_cfg.buckets[THROTTLE_BPS_WRITE].level = 23;
orig_cfg.buckets[THROTTLE_OPS_TOTAL].level = 1;
orig_cfg.buckets[THROTTLE_OPS_READ].level = 90;
orig_cfg.buckets[THROTTLE_OPS_WRITE].level = 75;
orig_cfg.op_size = 1;
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
read_timer_cb, write_timer_cb, &ts);
/* structure reset by throttle_init previous_leak should be null */
g_assert(!ts.previous_leak);
throttle_config(&ts, QEMU_CLOCK_VIRTUAL, &orig_cfg);
/* has previous leak been initialized by throttle_config ? */
g_assert(ts.previous_leak);
/* get back the fixed configuration */
throttle_get_config(&ts, &final_cfg);
throttle_timers_destroy(tt);
g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].avg == 153);
g_assert(final_cfg.buckets[THROTTLE_BPS_READ].avg == 56);
g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].avg == 1);
g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].avg == 150);
g_assert(final_cfg.buckets[THROTTLE_OPS_READ].avg == 69);
g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].avg == 23);
g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].max == 0);
g_assert(final_cfg.buckets[THROTTLE_BPS_READ].max == 56);
g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].max == 120);
g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].max == 150);
g_assert(final_cfg.buckets[THROTTLE_OPS_READ].max == 400);
g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].max == 500);
g_assert(final_cfg.op_size == 1);
/* check bucket have been cleared */
for (i = 0; i < BUCKETS_COUNT; i++) {
g_assert(!final_cfg.buckets[i].level);
}
}
/* functions to test is throttle is enabled by a config */
static void set_cfg_value(bool is_max, int index, int value)
{
if (is_max) {
cfg.buckets[index].max = value;
/* If max is set, avg should never be 0 */
cfg.buckets[index].avg = MAX(cfg.buckets[index].avg, 1);
} else {
cfg.buckets[index].avg = value;
}
}
static void test_enabled(void)
{
int i;
throttle_config_init(&cfg);
g_assert(!throttle_enabled(&cfg));
for (i = 0; i < BUCKETS_COUNT; i++) {
throttle_config_init(&cfg);
set_cfg_value(false, i, 150);
g_assert(throttle_is_valid(&cfg, NULL));
g_assert(throttle_enabled(&cfg));
}
for (i = 0; i < BUCKETS_COUNT; i++) {
throttle_config_init(&cfg);
set_cfg_value(false, i, -150);
g_assert(!throttle_is_valid(&cfg, NULL));
}
}
/* tests functions for throttle_conflicting */
static void test_conflicts_for_one_set(bool is_max,
int total,
int read,
int write)
{
throttle_config_init(&cfg);
g_assert(throttle_is_valid(&cfg, NULL));
set_cfg_value(is_max, total, 1);
set_cfg_value(is_max, read, 1);
g_assert(!throttle_is_valid(&cfg, NULL));
throttle_config_init(&cfg);
set_cfg_value(is_max, total, 1);
set_cfg_value(is_max, write, 1);
g_assert(!throttle_is_valid(&cfg, NULL));
throttle_config_init(&cfg);
set_cfg_value(is_max, total, 1);
set_cfg_value(is_max, read, 1);
set_cfg_value(is_max, write, 1);
g_assert(!throttle_is_valid(&cfg, NULL));
throttle_config_init(&cfg);
set_cfg_value(is_max, total, 1);
g_assert(throttle_is_valid(&cfg, NULL));
throttle_config_init(&cfg);
set_cfg_value(is_max, read, 1);
set_cfg_value(is_max, write, 1);
g_assert(throttle_is_valid(&cfg, NULL));
}
static void test_conflicting_config(void)
{
/* bps average conflicts */
test_conflicts_for_one_set(false,
THROTTLE_BPS_TOTAL,
THROTTLE_BPS_READ,
THROTTLE_BPS_WRITE);
/* ops average conflicts */
test_conflicts_for_one_set(false,
THROTTLE_OPS_TOTAL,
THROTTLE_OPS_READ,
THROTTLE_OPS_WRITE);
/* bps average conflicts */
test_conflicts_for_one_set(true,
THROTTLE_BPS_TOTAL,
THROTTLE_BPS_READ,
THROTTLE_BPS_WRITE);
/* ops average conflicts */
test_conflicts_for_one_set(true,
THROTTLE_OPS_TOTAL,
THROTTLE_OPS_READ,
THROTTLE_OPS_WRITE);
}
/* functions to test the throttle_is_valid function */
static void test_is_valid_for_value(int value, bool should_be_valid)
{
int is_max, index;
for (is_max = 0; is_max < 2; is_max++) {
for (index = 0; index < BUCKETS_COUNT; index++) {
throttle_config_init(&cfg);
set_cfg_value(is_max, index, value);
g_assert(throttle_is_valid(&cfg, NULL) == should_be_valid);
}
}
}
static void test_is_valid(void)
{
/* negative numbesr are invalid */
test_is_valid_for_value(-1, false);
/* zero is valid */
test_is_valid_for_value(0, true);
/* positives numbers are valid */
test_is_valid_for_value(1, true);
}
static void test_ranges(void)
{
int i;
for (i = 0; i < BUCKETS_COUNT; i++) {
LeakyBucket *b = &cfg.buckets[i];
throttle_config_init(&cfg);
/* avg = 0 means throttling is disabled, but the config is valid */
b->avg = 0;
g_assert(throttle_is_valid(&cfg, NULL));
g_assert(!throttle_enabled(&cfg));
/* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
b->avg = 1;
g_assert(throttle_is_valid(&cfg, NULL));
b->avg = THROTTLE_VALUE_MAX;
g_assert(throttle_is_valid(&cfg, NULL));
b->avg = THROTTLE_VALUE_MAX;
b->max = THROTTLE_VALUE_MAX;
g_assert(throttle_is_valid(&cfg, NULL));
/* Values over THROTTLE_VALUE_MAX are not allowed */
b->avg = THROTTLE_VALUE_MAX + 1;
g_assert(!throttle_is_valid(&cfg, NULL));
b->avg = THROTTLE_VALUE_MAX;
b->max = THROTTLE_VALUE_MAX + 1;
g_assert(!throttle_is_valid(&cfg, NULL));
/* burst_length must be between 1 and THROTTLE_VALUE_MAX */
b->avg = 1;
b->max = 1;
b->burst_length = 0;
g_assert(!throttle_is_valid(&cfg, NULL));
b->avg = 1;
b->max = 1;
b->burst_length = 1;
g_assert(throttle_is_valid(&cfg, NULL));
b->avg = 1;
b->max = 1;
b->burst_length = THROTTLE_VALUE_MAX;
g_assert(throttle_is_valid(&cfg, NULL));
b->avg = 1;
b->max = 1;
b->burst_length = THROTTLE_VALUE_MAX + 1;
g_assert(!throttle_is_valid(&cfg, NULL));
/* burst_length * max cannot exceed THROTTLE_VALUE_MAX */
b->avg = 1;
b->max = 2;
b->burst_length = THROTTLE_VALUE_MAX / 2;
g_assert(throttle_is_valid(&cfg, NULL));
b->avg = 1;
b->max = 3;
b->burst_length = THROTTLE_VALUE_MAX / 2;
g_assert(!throttle_is_valid(&cfg, NULL));
b->avg = 1;
b->max = THROTTLE_VALUE_MAX;
b->burst_length = 1;
g_assert(throttle_is_valid(&cfg, NULL));
b->avg = 1;
b->max = THROTTLE_VALUE_MAX;
b->burst_length = 2;
g_assert(!throttle_is_valid(&cfg, NULL));
}
}
static void test_max_is_missing_limit(void)
{
int i;
for (i = 0; i < BUCKETS_COUNT; i++) {
throttle_config_init(&cfg);
cfg.buckets[i].max = 100;
cfg.buckets[i].avg = 0;
g_assert(!throttle_is_valid(&cfg, NULL));
cfg.buckets[i].max = 0;
cfg.buckets[i].avg = 0;
g_assert(throttle_is_valid(&cfg, NULL));
cfg.buckets[i].max = 0;
cfg.buckets[i].avg = 100;
g_assert(throttle_is_valid(&cfg, NULL));
cfg.buckets[i].max = 30;
cfg.buckets[i].avg = 100;
g_assert(!throttle_is_valid(&cfg, NULL));
cfg.buckets[i].max = 100;
cfg.buckets[i].avg = 100;
g_assert(throttle_is_valid(&cfg, NULL));
}
}
static void test_iops_size_is_missing_limit(void)
{
/* A total/read/write iops limit is required */
throttle_config_init(&cfg);
cfg.op_size = 4096;
g_assert(!throttle_is_valid(&cfg, NULL));
}
static void test_have_timer(void)
{
/* zero structures */
memset(&ts, 0, sizeof(ts));
memset(tt, 0, sizeof(*tt));
/* no timer set should return false */
g_assert(!throttle_timers_are_initialized(tt));
/* init structures */
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
read_timer_cb, write_timer_cb, &ts);
/* timer set by init should return true */
g_assert(throttle_timers_are_initialized(tt));
throttle_timers_destroy(tt);
}
static void test_detach_attach(void)
{
/* zero structures */
memset(&ts, 0, sizeof(ts));
memset(tt, 0, sizeof(*tt));
/* init the structure */
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
read_timer_cb, write_timer_cb, &ts);
/* timer set by init should return true */
g_assert(throttle_timers_are_initialized(tt));
/* timer should no longer exist after detaching */
throttle_timers_detach_aio_context(tt);
g_assert(!throttle_timers_are_initialized(tt));
/* timer should exist again after attaching */
throttle_timers_attach_aio_context(tt, ctx);
g_assert(throttle_timers_are_initialized(tt));
throttle_timers_destroy(tt);
}
static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
int size, /* size of the operation to do */
double avg, /* io limit */
uint64_t op_size, /* ideal size of an io */
double total_result,
double read_result,
double write_result)
{
BucketType to_test[2][3] = { { THROTTLE_BPS_TOTAL,
THROTTLE_BPS_READ,
THROTTLE_BPS_WRITE, },
{ THROTTLE_OPS_TOTAL,
THROTTLE_OPS_READ,
THROTTLE_OPS_WRITE, } };
BucketType index;
int i;
throttle_config_init(&cfg);
for (i = 0; i < 3; i++) {
index = to_test[is_ops][i];
cfg.buckets[index].avg = avg;
}
cfg.op_size = op_size;
throttle_init(&ts);
throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
read_timer_cb, write_timer_cb, &ts);
throttle_config(&ts, QEMU_CLOCK_VIRTUAL, &cfg);
/* account a read */
throttle_account(&ts, THROTTLE_READ, size);
/* account a write */
throttle_account(&ts, THROTTLE_WRITE, size);
/* check total result */
index = to_test[is_ops][0];
if (!double_cmp(ts.cfg.buckets[index].level, total_result)) {
return false;
}
/* check read result */
index = to_test[is_ops][1];
if (!double_cmp(ts.cfg.buckets[index].level, read_result)) {
return false;
}
/* check write result */
index = to_test[is_ops][2];
if (!double_cmp(ts.cfg.buckets[index].level, write_result)) {
return false;
}
throttle_timers_destroy(tt);
return true;
}
static void test_accounting(void)
{
/* tests for bps */
/* op of size 1 */
g_assert(do_test_accounting(false,
1 * 512,
150,
0,
1024,
512,
512));
/* op of size 2 */
g_assert(do_test_accounting(false,
2 * 512,
150,
0,
2048,
1024,
1024));
/* op of size 2 and orthogonal parameter change */
g_assert(do_test_accounting(false,
2 * 512,
150,
17,
2048,
1024,
1024));
/* tests for ops */
/* op of size 1 */
g_assert(do_test_accounting(true,
1 * 512,
150,
0,
2,
1,
1));
/* op of size 2 */
g_assert(do_test_accounting(true,
2 * 512,
150,
0,
2,
1,
1));
/* jumbo op accounting fragmentation : size 64 with op size of 13 units */
g_assert(do_test_accounting(true,
64 * 512,
150,
13 * 512,
(64.0 * 2) / 13,
(64.0 / 13),
(64.0 / 13)));
/* same with orthogonal parameters changes */
g_assert(do_test_accounting(true,
64 * 512,
300,
13 * 512,
(64.0 * 2) / 13,
(64.0 / 13),
(64.0 / 13)));
}
static void test_groups(void)
{
ThrottleConfig cfg1, cfg2;
BlockBackend *blk1, *blk2, *blk3;
BlockBackendPublic *blkp1, *blkp2, *blkp3;
ThrottleGroupMember *tgm1, *tgm2, *tgm3;
/* No actual I/O is performed on these devices */
blk1 = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
blk2 = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
blk3 = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
blkp1 = blk_get_public(blk1);
blkp2 = blk_get_public(blk2);
blkp3 = blk_get_public(blk3);
tgm1 = &blkp1->throttle_group_member;
tgm2 = &blkp2->throttle_group_member;
tgm3 = &blkp3->throttle_group_member;
g_assert(tgm1->throttle_state == NULL);
g_assert(tgm2->throttle_state == NULL);
g_assert(tgm3->throttle_state == NULL);
throttle_group_register_tgm(tgm1, "bar", blk_get_aio_context(blk1));
throttle_group_register_tgm(tgm2, "foo", blk_get_aio_context(blk2));
throttle_group_register_tgm(tgm3, "bar", blk_get_aio_context(blk3));
g_assert(tgm1->throttle_state != NULL);
g_assert(tgm2->throttle_state != NULL);
g_assert(tgm3->throttle_state != NULL);
g_assert(!strcmp(throttle_group_get_name(tgm1), "bar"));
g_assert(!strcmp(throttle_group_get_name(tgm2), "foo"));
g_assert(tgm1->throttle_state == tgm3->throttle_state);
/* Setting the config of a group member affects the whole group */
throttle_config_init(&cfg1);
cfg1.buckets[THROTTLE_BPS_READ].avg = 500000;
cfg1.buckets[THROTTLE_BPS_WRITE].avg = 285000;
cfg1.buckets[THROTTLE_OPS_READ].avg = 20000;
cfg1.buckets[THROTTLE_OPS_WRITE].avg = 12000;
throttle_group_config(tgm1, &cfg1);
throttle_group_get_config(tgm1, &cfg1);
throttle_group_get_config(tgm3, &cfg2);
g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1)));
cfg2.buckets[THROTTLE_BPS_READ].avg = 4547;
cfg2.buckets[THROTTLE_BPS_WRITE].avg = 1349;
cfg2.buckets[THROTTLE_OPS_READ].avg = 123;
cfg2.buckets[THROTTLE_OPS_WRITE].avg = 86;
throttle_group_config(tgm3, &cfg1);
throttle_group_get_config(tgm1, &cfg1);
throttle_group_get_config(tgm3, &cfg2);
g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1)));
throttle_group_unregister_tgm(tgm1);
throttle_group_unregister_tgm(tgm2);
throttle_group_unregister_tgm(tgm3);
g_assert(tgm1->throttle_state == NULL);
g_assert(tgm2->throttle_state == NULL);
g_assert(tgm3->throttle_state == NULL);
}
int main(int argc, char **argv)
{
qemu_init_main_loop(&error_fatal);
ctx = qemu_get_aio_context();
bdrv_init();
module_call_init(MODULE_INIT_QOM);
do {} while (g_main_context_iteration(NULL, false));
/* tests in the same order as the header function declarations */
g_test_init(&argc, &argv, NULL);
g_test_add_func("/throttle/leak_bucket", test_leak_bucket);
g_test_add_func("/throttle/compute_wait", test_compute_wait);
g_test_add_func("/throttle/init", test_init);
g_test_add_func("/throttle/init_readonly", test_init_readonly);
g_test_add_func("/throttle/init_writeonly", test_init_writeonly);
g_test_add_func("/throttle/destroy", test_destroy);
g_test_add_func("/throttle/have_timer", test_have_timer);
g_test_add_func("/throttle/detach_attach", test_detach_attach);
g_test_add_func("/throttle/config/enabled", test_enabled);
g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
g_test_add_func("/throttle/config/is_valid", test_is_valid);
g_test_add_func("/throttle/config/ranges", test_ranges);
g_test_add_func("/throttle/config/max", test_max_is_missing_limit);
g_test_add_func("/throttle/config/iops_size",
test_iops_size_is_missing_limit);
g_test_add_func("/throttle/config_functions", test_config_functions);
g_test_add_func("/throttle/accounting", test_accounting);
g_test_add_func("/throttle/groups", test_groups);
return g_test_run();
}
Reference in New Issue View Git Blame Copy Permalink