[qemu.git] / tests / test-throttle.c

/*
 * Throttle infrastructure tests
 *
 * Copyright Nodalink, SARL. 2013
 *
 * Authors:
 *  Benoît Canet     <benoit.canet@irqsave.net>
 *
 * 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 <glib.h>
#include <math.h>
#include "qemu/throttle.h"

LeakyBucket    bkt;
ThrottleConfig cfg;
ThrottleState  ts;

/* 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)
{
    /* 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));
}

static void test_compute_wait(void)
{
    int64_t wait;
    int64_t result;

    /* 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);
}

/* 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;

    /* fill the structure with crap */
    memset(&ts, 1, sizeof(ts));

    /* init the structure */
    throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);

    /* check initialized fields */
    g_assert(ts.clock_type == QEMU_CLOCK_VIRTUAL);
    g_assert(ts.timers[0]);
    g_assert(ts.timers[1]);

    /* 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_destroy(&ts);
}

static void test_destroy(void)
{
    int i;
    throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);
    throttle_destroy(&ts);
    for (i = 0; i < 2; i++) {
        g_assert(!ts.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; /* should be corrected */
    orig_cfg.buckets[THROTTLE_BPS_READ].max  = 1; /* should not be corrected */
    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, 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, &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_destroy(&ts);

    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 == 15.3);/* fixed */
    g_assert(final_cfg.buckets[THROTTLE_BPS_READ].max  == 1);   /* not fixed */
    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;
    } else {
        cfg.buckets[index].avg = value;
    }
}

static void test_enabled(void)
{
    int i;

    memset(&cfg, 0, sizeof(cfg));
    g_assert(!throttle_enabled(&cfg));

    for (i = 0; i < BUCKETS_COUNT; i++) {
        memset(&cfg, 0, sizeof(cfg));
        set_cfg_value(false, i, 150);
        g_assert(throttle_enabled(&cfg));
    }

    for (i = 0; i < BUCKETS_COUNT; i++) {
        memset(&cfg, 0, sizeof(cfg));
        set_cfg_value(false, i, -150);
        g_assert(!throttle_enabled(&cfg));
    }
}

/* tests functions for throttle_conflicting */

static void test_conflicts_for_one_set(bool is_max,
                                       int total,
                                       int read,
                                       int write)
{
    memset(&cfg, 0, sizeof(cfg));
    g_assert(!throttle_conflicting(&cfg));

    set_cfg_value(is_max, total, 1);
    set_cfg_value(is_max, read,  1);
    g_assert(throttle_conflicting(&cfg));

    memset(&cfg, 0, sizeof(cfg));
    set_cfg_value(is_max, total, 1);
    set_cfg_value(is_max, write, 1);
    g_assert(throttle_conflicting(&cfg));

    memset(&cfg, 0, sizeof(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_conflicting(&cfg));

    memset(&cfg, 0, sizeof(cfg));
    set_cfg_value(is_max, total, 1);
    g_assert(!throttle_conflicting(&cfg));

    memset(&cfg, 0, sizeof(cfg));
    set_cfg_value(is_max, read,  1);
    set_cfg_value(is_max, write, 1);
    g_assert(!throttle_conflicting(&cfg));
}

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++) {
            memset(&cfg, 0, sizeof(cfg));
            set_cfg_value(is_max, index, value);
            g_assert(throttle_is_valid(&cfg) == should_be_valid);
        }
    }
}

static void test_is_valid(void)
{
    /* negative number are invalid */
    test_is_valid_for_value(-1, false);
    /* zero are valids */
    test_is_valid_for_value(0, true);
    /* positives numers are valids */
    test_is_valid_for_value(1, true);
}

static void test_have_timer(void)
{
    /* zero the structure */
    memset(&ts, 0, sizeof(ts));

    /* no timer set should return false */
    g_assert(!throttle_have_timer(&ts));

    /* init the structure */
    throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);

    /* timer set by init should return true */
    g_assert(throttle_have_timer(&ts));

    throttle_destroy(&ts);
}

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, } };
    ThrottleConfig cfg;
    BucketType index;
    int i;

    for (i = 0; i < 3; i++) {
        BucketType index = to_test[is_ops][i];
        cfg.buckets[index].avg = avg;
    }

    cfg.op_size = op_size;

    throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);
    throttle_config(&ts, &cfg);

    /* account a read */
    throttle_account(&ts, false, size);
    /* account a write */
    throttle_account(&ts, true, 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_destroy(&ts);

    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)));
}

int main(int argc, char **argv)
{
    init_clocks();
    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/destroy",            test_destroy);
    g_test_add_func("/throttle/have_timer",         test_have_timer);
    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_functions",   test_config_functions);
    g_test_add_func("/throttle/accounting",         test_accounting);
    return g_test_run();
}
Commit	Line	Data
f17cfe81 BC	1	/*
	2	* Throttle infrastructure tests
	3	*
	4	* Copyright Nodalink, SARL. 2013
	5	*
	6	* Authors:
	7	* Benoît Canet <benoit.canet@irqsave.net>
	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	#include <glib.h>
	14	#include <math.h>
	15	#include "qemu/throttle.h"
	16
	17	LeakyBucket bkt;
	18	ThrottleConfig cfg;
	19	ThrottleState ts;
	20
73f395fa	21	/* useful function */
f17cfe81 BC	22	static bool double_cmp(double x, double y)
	23	{
	24	return fabsl(x - y) < 1e-6;
	25	}
	26
	27	/* tests for single bucket operations */
	28	static void test_leak_bucket(void)
	29	{
	30	/* set initial value */
	31	bkt.avg = 150;
	32	bkt.max = 15;
	33	bkt.level = 1.5;
	34
	35	/* leak an op work of time */
	36	throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
	37	g_assert(bkt.avg == 150);
	38	g_assert(bkt.max == 15);
	39	g_assert(double_cmp(bkt.level, 0.5));
	40
	41	/* leak again emptying the bucket */
	42	throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
	43	g_assert(bkt.avg == 150);
	44	g_assert(bkt.max == 15);
	45	g_assert(double_cmp(bkt.level, 0));
	46
	47	/* check that the bucket level won't go lower */
	48	throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
	49	g_assert(bkt.avg == 150);
	50	g_assert(bkt.max == 15);
	51	g_assert(double_cmp(bkt.level, 0));
	52	}
	53
	54	static void test_compute_wait(void)
	55	{
	56	int64_t wait;
	57	int64_t result;
	58
	59	/* no operation limit set */
	60	bkt.avg = 0;
	61	bkt.max = 15;
	62	bkt.level = 1.5;
	63	wait = throttle_compute_wait(&bkt);
	64	g_assert(!wait);
	65
	66	/* zero delta */
	67	bkt.avg = 150;
	68	bkt.max = 15;
	69	bkt.level = 15;
	70	wait = throttle_compute_wait(&bkt);
	71	g_assert(!wait);
	72
	73	/* below zero delta */
	74	bkt.avg = 150;
	75	bkt.max = 15;
	76	bkt.level = 9;
	77	wait = throttle_compute_wait(&bkt);
	78	g_assert(!wait);
	79
	80	/* half an operation above max */
	81	bkt.avg = 150;
	82	bkt.max = 15;
	83	bkt.level = 15.5;
	84	wait = throttle_compute_wait(&bkt);
	85	/* time required to do half an operation */
86	result = (int64_t) NANOSECONDS_PER_SECOND / 150 / 2;
87	g_assert(wait == result);
88	}
89
90	/* functions to test ThrottleState initialization/destroy methods */
91	static void read_timer_cb(void *opaque)
92	{
93	}
94
95	static void write_timer_cb(void *opaque)
96	{
97	}
98
99	static void test_init(void)
100	{
101	int i;
102
103	/* fill the structure with crap */
104	memset(&ts, 1, sizeof(ts));
105
106	/* init the structure */
107	throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);
108
109	/* check initialized fields */
110	g_assert(ts.clock_type == QEMU_CLOCK_VIRTUAL);
111	g_assert(ts.timers[0]);
112	g_assert(ts.timers[1]);
113
114	/* check other fields where cleared */
115	g_assert(!ts.previous_leak);
116	g_assert(!ts.cfg.op_size);
117	for (i = 0; i < BUCKETS_COUNT; i++) {
118	g_assert(!ts.cfg.buckets[i].avg);
119	g_assert(!ts.cfg.buckets[i].max);
120	g_assert(!ts.cfg.buckets[i].level);
121	}
122
123	throttle_destroy(&ts);
124	}
125
126	static void test_destroy(void)
127	{
128	int i;
129	throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);
130	throttle_destroy(&ts);
131	for (i = 0; i < 2; i++) {
132	g_assert(!ts.timers[i]);
133	}
134	}
135
136	/* function to test throttle_config and throttle_get_config */
137	static void test_config_functions(void)
138	{
139	int i;
140	ThrottleConfig orig_cfg, final_cfg;
141
142	orig_cfg.buckets[THROTTLE_BPS_TOTAL].avg = 153;
143	orig_cfg.buckets[THROTTLE_BPS_READ].avg = 56;
144	orig_cfg.buckets[THROTTLE_BPS_WRITE].avg = 1;
145
146	orig_cfg.buckets[THROTTLE_OPS_TOTAL].avg = 150;
147	orig_cfg.buckets[THROTTLE_OPS_READ].avg = 69;
148	orig_cfg.buckets[THROTTLE_OPS_WRITE].avg = 23;
149
150	orig_cfg.buckets[THROTTLE_BPS_TOTAL].max = 0; /* should be corrected */
151	orig_cfg.buckets[THROTTLE_BPS_READ].max = 1; /* should not be corrected */
152	orig_cfg.buckets[THROTTLE_BPS_WRITE].max = 120;
153
154	orig_cfg.buckets[THROTTLE_OPS_TOTAL].max = 150;
155	orig_cfg.buckets[THROTTLE_OPS_READ].max = 400;
156	orig_cfg.buckets[THROTTLE_OPS_WRITE].max = 500;
157
158	orig_cfg.buckets[THROTTLE_BPS_TOTAL].level = 45;
159	orig_cfg.buckets[THROTTLE_BPS_READ].level = 65;
160	orig_cfg.buckets[THROTTLE_BPS_WRITE].level = 23;
161
162	orig_cfg.buckets[THROTTLE_OPS_TOTAL].level = 1;
163	orig_cfg.buckets[THROTTLE_OPS_READ].level = 90;
164	orig_cfg.buckets[THROTTLE_OPS_WRITE].level = 75;
165
166	orig_cfg.op_size = 1;
167
168	throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);
169	/* structure reset by throttle_init previous_leak should be null */
170	g_assert(!ts.previous_leak);
171	throttle_config(&ts, &orig_cfg);
172
173	/* has previous leak been initialized by throttle_config ? */
174	g_assert(ts.previous_leak);
175
176	/* get back the fixed configuration */
177	throttle_get_config(&ts, &final_cfg);
178
179	throttle_destroy(&ts);
180
181	g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].avg == 153);
182	g_assert(final_cfg.buckets[THROTTLE_BPS_READ].avg == 56);
183	g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].avg == 1);
184
185	g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].avg == 150);
186	g_assert(final_cfg.buckets[THROTTLE_OPS_READ].avg == 69);
187	g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].avg == 23);
188
189	g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].max == 15.3);/* fixed */
190	g_assert(final_cfg.buckets[THROTTLE_BPS_READ].max == 1); /* not fixed */
191	g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].max == 120);
192
193	g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].max == 150);
194	g_assert(final_cfg.buckets[THROTTLE_OPS_READ].max == 400);
195	g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].max == 500);
196
197	g_assert(final_cfg.op_size == 1);
198
199	/* check bucket have been cleared */
200	for (i = 0; i < BUCKETS_COUNT; i++) {
201	g_assert(!final_cfg.buckets[i].level);
202	}
203	}
204
205	/* functions to test is throttle is enabled by a config */
206	static void set_cfg_value(bool is_max, int index, int value)
207	{
208	if (is_max) {
209	cfg.buckets[index].max = value;
210	} else {
211	cfg.buckets[index].avg = value;
212	}
213	}
214
215	static void test_enabled(void)
216	{
217	int i;
218
219	memset(&cfg, 0, sizeof(cfg));
220	g_assert(!throttle_enabled(&cfg));
221
222	for (i = 0; i < BUCKETS_COUNT; i++) {
223	memset(&cfg, 0, sizeof(cfg));
224	set_cfg_value(false, i, 150);
225	g_assert(throttle_enabled(&cfg));
226	}
227
228	for (i = 0; i < BUCKETS_COUNT; i++) {
229	memset(&cfg, 0, sizeof(cfg));
230	set_cfg_value(false, i, -150);
231	g_assert(!throttle_enabled(&cfg));
232	}
233	}
234
235	/* tests functions for throttle_conflicting */
236
237	static void test_conflicts_for_one_set(bool is_max,
238	int total,
239	int read,
240	int write)
241	{
242	memset(&cfg, 0, sizeof(cfg));
243	g_assert(!throttle_conflicting(&cfg));
244
245	set_cfg_value(is_max, total, 1);
246	set_cfg_value(is_max, read, 1);
247	g_assert(throttle_conflicting(&cfg));
248
249	memset(&cfg, 0, sizeof(cfg));
250	set_cfg_value(is_max, total, 1);
251	set_cfg_value(is_max, write, 1);
252	g_assert(throttle_conflicting(&cfg));
253
254	memset(&cfg, 0, sizeof(cfg));
255	set_cfg_value(is_max, total, 1);
256	set_cfg_value(is_max, read, 1);
257	set_cfg_value(is_max, write, 1);
258	g_assert(throttle_conflicting(&cfg));
259
260	memset(&cfg, 0, sizeof(cfg));
261	set_cfg_value(is_max, total, 1);
262	g_assert(!throttle_conflicting(&cfg));
263
264	memset(&cfg, 0, sizeof(cfg));
265	set_cfg_value(is_max, read, 1);
266	set_cfg_value(is_max, write, 1);
267	g_assert(!throttle_conflicting(&cfg));
268	}
269
270	static void test_conflicting_config(void)
271	{
272	/* bps average conflicts */
273	test_conflicts_for_one_set(false,
274	THROTTLE_BPS_TOTAL,
275	THROTTLE_BPS_READ,
276	THROTTLE_BPS_WRITE);
277
278	/* ops average conflicts */
279	test_conflicts_for_one_set(false,
280	THROTTLE_OPS_TOTAL,
281	THROTTLE_OPS_READ,
282	THROTTLE_OPS_WRITE);
283
284	/* bps average conflicts */
285	test_conflicts_for_one_set(true,
286	THROTTLE_BPS_TOTAL,
287	THROTTLE_BPS_READ,
288	THROTTLE_BPS_WRITE);
289	/* ops average conflicts */
290	test_conflicts_for_one_set(true,
291	THROTTLE_OPS_TOTAL,
292	THROTTLE_OPS_READ,
293	THROTTLE_OPS_WRITE);
294	}
295	/* functions to test the throttle_is_valid function */
296	static void test_is_valid_for_value(int value, bool should_be_valid)
297	{
298	int is_max, index;
299	for (is_max = 0; is_max < 2; is_max++) {
300	for (index = 0; index < BUCKETS_COUNT; index++) {
301	memset(&cfg, 0, sizeof(cfg));
302	set_cfg_value(is_max, index, value);
303	g_assert(throttle_is_valid(&cfg) == should_be_valid);
304	}
305	}
306	}
307
308	static void test_is_valid(void)
309	{
310	/* negative number are invalid */
311	test_is_valid_for_value(-1, false);
312	/* zero are valids */
313	test_is_valid_for_value(0, true);
314	/* positives numers are valids */
315	test_is_valid_for_value(1, true);
316	}
317
318	static void test_have_timer(void)
319	{
320	/* zero the structure */
321	memset(&ts, 0, sizeof(ts));
322
73f395fa	323	/* no timer set should return false */
f17cfe81 BC	324	g_assert(!throttle_have_timer(&ts));
	325
	326	/* init the structure */
	327	throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);
	328
	329	/* timer set by init should return true */
	330	g_assert(throttle_have_timer(&ts));
	331
	332	throttle_destroy(&ts);
	333	}
	334
	335	static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
	336	int size, /* size of the operation to do */
	337	double avg, /* io limit */
	338	uint64_t op_size, /* ideal size of an io */
	339	double total_result,
	340	double read_result,
	341	double write_result)
	342	{
	343	BucketType to_test[2][3] = { { THROTTLE_BPS_TOTAL,
	344	THROTTLE_BPS_READ,
	345	THROTTLE_BPS_WRITE, },
	346	{ THROTTLE_OPS_TOTAL,
	347	THROTTLE_OPS_READ,
	348	THROTTLE_OPS_WRITE, } };
	349	ThrottleConfig cfg;
	350	BucketType index;
	351	int i;
	352
	353	for (i = 0; i < 3; i++) {
	354	BucketType index = to_test[is_ops][i];
	355	cfg.buckets[index].avg = avg;
	356	}
	357
	358	cfg.op_size = op_size;
	359
	360	throttle_init(&ts, QEMU_CLOCK_VIRTUAL, read_timer_cb, write_timer_cb, &ts);
	361	throttle_config(&ts, &cfg);
	362
	363	/* account a read */
	364	throttle_account(&ts, false, size);
	365	/* account a write */
	366	throttle_account(&ts, true, size);
	367
	368	/* check total result */
	369	index = to_test[is_ops][0];
	370	if (!double_cmp(ts.cfg.buckets[index].level, total_result)) {
	371	return false;
	372	}
	373
	374	/* check read result */
	375	index = to_test[is_ops][1];
	376	if (!double_cmp(ts.cfg.buckets[index].level, read_result)) {
	377	return false;
	378	}
	379
	380	/* check write result */
	381	index = to_test[is_ops][2];
	382	if (!double_cmp(ts.cfg.buckets[index].level, write_result)) {
	383	return false;
	384	}
	385
	386	throttle_destroy(&ts);
	387
388	return true;
389	}
390
391	static void test_accounting(void)
392	{
393	/* tests for bps */
394
395	/* op of size 1 */
396	g_assert(do_test_accounting(false,
397	1 * 512,
398	150,
399	0,
400	1024,
401	512,
402	512));
403
404	/* op of size 2 */
405	g_assert(do_test_accounting(false,
406	2 * 512,
407	150,
408	0,
409	2048,
410	1024,
411	1024));
412
413	/* op of size 2 and orthogonal parameter change */
414	g_assert(do_test_accounting(false,
415	2 * 512,
416	150,
417	17,
418	2048,
419	1024,
420	1024));
421
422
423	/* tests for ops */
424
425	/* op of size 1 */
426	g_assert(do_test_accounting(true,
427	1 * 512,
428	150,
429	0,
430	2,
431	1,
432	1));
433
434	/* op of size 2 */
435	g_assert(do_test_accounting(true,
436	2 * 512,
437	150,
438	0,
439	2,
440	1,
441	1));
442
443	/* jumbo op accounting fragmentation : size 64 with op size of 13 units */
444	g_assert(do_test_accounting(true,
445	64 * 512,
446	150,
447	13 * 512,
448	(64.0 * 2) / 13,
449	(64.0 / 13),
450	(64.0 / 13)));
451
452	/* same with orthogonal parameters changes */
453	g_assert(do_test_accounting(true,
454	64 * 512,
455	300,
456	13 * 512,
457	(64.0 * 2) / 13,
458	(64.0 / 13),
459	(64.0 / 13)));
460	}
461
462	int main(int argc, char **argv)
463	{
464	init_clocks();
465	do {} while (g_main_context_iteration(NULL, false));
466
467	/* tests in the same order as the header function declarations */
468	g_test_init(&argc, &argv, NULL);
469	g_test_add_func("/throttle/leak_bucket", test_leak_bucket);
470	g_test_add_func("/throttle/compute_wait", test_compute_wait);
471	g_test_add_func("/throttle/init", test_init);
472	g_test_add_func("/throttle/destroy", test_destroy);
473	g_test_add_func("/throttle/have_timer", test_have_timer);
474	g_test_add_func("/throttle/config/enabled", test_enabled);
475	g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
476	g_test_add_func("/throttle/config/is_valid", test_is_valid);
477	g_test_add_func("/throttle/config_functions", test_config_functions);
478	g_test_add_func("/throttle/accounting", test_accounting);
479	return g_test_run();
480	}
481