* [Qemu-devel] [PATCH v1 1/8] throttle: Extract timers from ThrottleState into a separate ThrottleTimers structure
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
2014-10-08 5:51 ` Fam Zheng
2014-10-08 15:06 ` Eric Blake
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 2/8] throttle: Add throttle group infrastructure Benoît Canet
` (6 subsequent siblings)
7 siblings, 2 replies; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
Group throttling will share ThrottleState between multiple bs.
As a consequence the ThrottleState will be accessed by multiple aio context.
Timers are tied to their aio context so they must go out of the ThrottleState structure.
This commit pave the way for each bs of a common ThrottleState to have it's own
timer.
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
block.c | 35 ++++++++++++--------
include/block/block_int.h | 1 +
include/qemu/throttle.h | 36 +++++++++++++--------
tests/test-throttle.c | 82 ++++++++++++++++++++++++++---------------------
util/throttle.c | 73 ++++++++++++++++++++++++-----------------
5 files changed, 134 insertions(+), 93 deletions(-)
diff --git a/block.c b/block.c
index d3aebeb..f209f55 100644
--- a/block.c
+++ b/block.c
@@ -129,7 +129,7 @@ void bdrv_set_io_limits(BlockDriverState *bs,
{
int i;
- throttle_config(&bs->throttle_state, cfg);
+ throttle_config(&bs->throttle_state, &bs->throttle_timers, cfg);
for (i = 0; i < 2; i++) {
qemu_co_enter_next(&bs->throttled_reqs[i]);
@@ -162,7 +162,7 @@ void bdrv_io_limits_disable(BlockDriverState *bs)
bdrv_start_throttled_reqs(bs);
- throttle_destroy(&bs->throttle_state);
+ throttle_timers_destroy(&bs->throttle_timers);
}
static void bdrv_throttle_read_timer_cb(void *opaque)
@@ -181,12 +181,13 @@ static void bdrv_throttle_write_timer_cb(void *opaque)
void bdrv_io_limits_enable(BlockDriverState *bs)
{
assert(!bs->io_limits_enabled);
- throttle_init(&bs->throttle_state,
- bdrv_get_aio_context(bs),
- QEMU_CLOCK_VIRTUAL,
- bdrv_throttle_read_timer_cb,
- bdrv_throttle_write_timer_cb,
- bs);
+ throttle_init(&bs->throttle_state);
+ throttle_timers_init(&bs->throttle_timers,
+ bdrv_get_aio_context(bs),
+ QEMU_CLOCK_VIRTUAL,
+ bdrv_throttle_read_timer_cb,
+ bdrv_throttle_write_timer_cb,
+ bs);
bs->io_limits_enabled = true;
}
@@ -200,7 +201,9 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs,
bool is_write)
{
/* does this io must wait */
- bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
+ bool must_wait = throttle_schedule_timer(&bs->throttle_state,
+ &bs->throttle_timers,
+ is_write);
/* if must wait or any request of this type throttled queue the IO */
if (must_wait ||
@@ -213,7 +216,8 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs,
/* if the next request must wait -> do nothing */
- if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
+ if (throttle_schedule_timer(&bs->throttle_state, &bs->throttle_timers,
+ is_write)) {
return;
}
@@ -1990,6 +1994,9 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
memcpy(&bs_dest->throttle_state,
&bs_src->throttle_state,
sizeof(ThrottleState));
+ memcpy(&bs_dest->throttle_timers,
+ &bs_src->throttle_timers,
+ sizeof(ThrottleTimers));
bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
@@ -2052,7 +2059,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
assert(bs_new->job == NULL);
assert(bs_new->dev == NULL);
assert(bs_new->io_limits_enabled == false);
- assert(!throttle_have_timer(&bs_new->throttle_state));
+ assert(!throttle_timers_are_init(&bs_new->throttle_timers));
tmp = *bs_new;
*bs_new = *bs_old;
@@ -2070,7 +2077,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
assert(bs_new->dev == NULL);
assert(bs_new->job == NULL);
assert(bs_new->io_limits_enabled == false);
- assert(!throttle_have_timer(&bs_new->throttle_state));
+ assert(!throttle_timers_are_init(&bs_new->throttle_timers));
/* insert the nodes back into the graph node list if needed */
if (bs_new->node_name[0] != '\0') {
@@ -5746,7 +5753,7 @@ void bdrv_detach_aio_context(BlockDriverState *bs)
}
if (bs->io_limits_enabled) {
- throttle_detach_aio_context(&bs->throttle_state);
+ throttle_timers_detach_aio_context(&bs->throttle_timers);
}
if (bs->drv->bdrv_detach_aio_context) {
bs->drv->bdrv_detach_aio_context(bs);
@@ -5782,7 +5789,7 @@ void bdrv_attach_aio_context(BlockDriverState *bs,
bs->drv->bdrv_attach_aio_context(bs, new_context);
}
if (bs->io_limits_enabled) {
- throttle_attach_aio_context(&bs->throttle_state, new_context);
+ throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
}
QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 8d86a6c..7af126f 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -356,6 +356,7 @@ struct BlockDriverState {
/* I/O throttling */
ThrottleState throttle_state;
+ ThrottleTimers throttle_timers;
CoQueue throttled_reqs[2];
bool io_limits_enabled;
diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index b890613..b89d4d8 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -65,6 +65,9 @@ typedef struct ThrottleConfig {
typedef struct ThrottleState {
ThrottleConfig cfg; /* configuration */
int64_t previous_leak; /* timestamp of the last leak done */
+} ThrottleState;
+
+typedef struct ThrottleTimers {
QEMUTimer * timers[2]; /* timers used to do the throttling */
QEMUClockType clock_type; /* the clock used */
@@ -72,7 +75,7 @@ typedef struct ThrottleState {
QEMUTimerCB *read_timer_cb;
QEMUTimerCB *write_timer_cb;
void *timer_opaque;
-} ThrottleState;
+} ThrottleTimers;
/* operations on single leaky buckets */
void throttle_leak_bucket(LeakyBucket *bkt, int64_t delta);
@@ -86,20 +89,23 @@ bool throttle_compute_timer(ThrottleState *ts,
int64_t *next_timestamp);
/* init/destroy cycle */
-void throttle_init(ThrottleState *ts,
- AioContext *aio_context,
- QEMUClockType clock_type,
- void (read_timer)(void *),
- void (write_timer)(void *),
- void *timer_opaque);
+void throttle_init(ThrottleState *ts);
+
+void throttle_timers_init(ThrottleTimers *tt,
+ AioContext *aio_context,
+ QEMUClockType clock_type,
+ QEMUTimerCB *read_timer_cb,
+ QEMUTimerCB *write_timer_cb,
+ void *timer_opaque);
-void throttle_destroy(ThrottleState *ts);
+void throttle_timers_destroy(ThrottleTimers *tt);
-void throttle_detach_aio_context(ThrottleState *ts);
+void throttle_timers_detach_aio_context(ThrottleTimers *tt);
-void throttle_attach_aio_context(ThrottleState *ts, AioContext *new_context);
+void throttle_timers_attach_aio_context(ThrottleTimers *tt,
+ AioContext *new_context);
-bool throttle_have_timer(ThrottleState *ts);
+bool throttle_timers_are_init(ThrottleTimers *tt);
/* configuration */
bool throttle_enabled(ThrottleConfig *cfg);
@@ -108,12 +114,16 @@ bool throttle_conflicting(ThrottleConfig *cfg);
bool throttle_is_valid(ThrottleConfig *cfg);
-void throttle_config(ThrottleState *ts, ThrottleConfig *cfg);
+void throttle_config(ThrottleState *ts,
+ ThrottleTimers *tt,
+ ThrottleConfig *cfg);
void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg);
/* usage */
-bool throttle_schedule_timer(ThrottleState *ts, bool is_write);
+bool throttle_schedule_timer(ThrottleState *ts,
+ ThrottleTimers *tt,
+ bool is_write);
void throttle_account(ThrottleState *ts, bool is_write, uint64_t size);
diff --git a/tests/test-throttle.c b/tests/test-throttle.c
index d8ba415..3e52df3 100644
--- a/tests/test-throttle.c
+++ b/tests/test-throttle.c
@@ -20,6 +20,7 @@ static AioContext *ctx;
static LeakyBucket bkt;
static ThrottleConfig cfg;
static ThrottleState ts;
+static ThrottleTimers tt;
/* useful function */
static bool double_cmp(double x, double y)
@@ -103,17 +104,19 @@ static void test_init(void)
{
int i;
- /* fill the structure with crap */
+ /* fill the structures with crap */
memset(&ts, 1, sizeof(ts));
+ memset(&tt, 1, sizeof(tt));
- /* init the structure */
- throttle_init(&ts, ctx, QEMU_CLOCK_VIRTUAL,
- read_timer_cb, write_timer_cb, &ts);
+ /* 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(ts.clock_type == QEMU_CLOCK_VIRTUAL);
- g_assert(ts.timers[0]);
- g_assert(ts.timers[1]);
+ g_assert(tt.clock_type == QEMU_CLOCK_VIRTUAL);
+ g_assert(tt.timers[0]);
+ g_assert(tt.timers[1]);
/* check other fields where cleared */
g_assert(!ts.previous_leak);
@@ -124,17 +127,18 @@ static void test_init(void)
g_assert(!ts.cfg.buckets[i].level);
}
- throttle_destroy(&ts);
+ throttle_timers_destroy(&tt);
}
static void test_destroy(void)
{
int i;
- throttle_init(&ts, ctx, QEMU_CLOCK_VIRTUAL,
- read_timer_cb, write_timer_cb, &ts);
- throttle_destroy(&ts);
+ 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 < 2; i++) {
- g_assert(!ts.timers[i]);
+ g_assert(!tt.timers[i]);
}
}
@@ -170,11 +174,12 @@ static void test_config_functions(void)
orig_cfg.op_size = 1;
- throttle_init(&ts, ctx, QEMU_CLOCK_VIRTUAL,
- read_timer_cb, write_timer_cb, &ts);
+ 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, &orig_cfg);
+ throttle_config(&ts, &tt, &orig_cfg);
/* has previous leak been initialized by throttle_config ? */
g_assert(ts.previous_leak);
@@ -182,7 +187,7 @@ static void test_config_functions(void)
/* get back the fixed configuration */
throttle_get_config(&ts, &final_cfg);
- throttle_destroy(&ts);
+ throttle_timers_destroy(&tt);
g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].avg == 153);
g_assert(final_cfg.buckets[THROTTLE_BPS_READ].avg == 56);
@@ -323,43 +328,47 @@ static void test_is_valid(void)
static void test_have_timer(void)
{
- /* zero the structure */
+ /* zero structures */
memset(&ts, 0, sizeof(ts));
+ memset(&tt, 0, sizeof(tt));
/* no timer set should return false */
- g_assert(!throttle_have_timer(&ts));
+ g_assert(!throttle_timers_are_init(&tt));
- /* init the structure */
- throttle_init(&ts, ctx, QEMU_CLOCK_VIRTUAL,
- read_timer_cb, write_timer_cb, &ts);
+ /* 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_have_timer(&ts));
+ g_assert(throttle_timers_are_init(&tt));
- throttle_destroy(&ts);
+ throttle_timers_destroy(&tt);
}
static void test_detach_attach(void)
{
- /* zero the structure */
+ /* zero structures */
memset(&ts, 0, sizeof(ts));
+ memset(&tt, 0, sizeof(tt));
/* init the structure */
- throttle_init(&ts, ctx, QEMU_CLOCK_VIRTUAL,
- read_timer_cb, write_timer_cb, &ts);
+ 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_have_timer(&ts));
+ g_assert(throttle_timers_are_init(&tt));
/* timer should no longer exist after detaching */
- throttle_detach_aio_context(&ts);
- g_assert(!throttle_have_timer(&ts));
+ throttle_timers_detach_aio_context(&tt);
+ g_assert(!throttle_timers_are_init(&tt));
/* timer should exist again after attaching */
- throttle_attach_aio_context(&ts, ctx);
- g_assert(throttle_have_timer(&ts));
+ throttle_timers_attach_aio_context(&tt, ctx);
+ g_assert(throttle_timers_are_init(&tt));
- throttle_destroy(&ts);
+ throttle_timers_destroy(&tt);
}
static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
@@ -387,9 +396,10 @@ static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
cfg.op_size = op_size;
- throttle_init(&ts, ctx, QEMU_CLOCK_VIRTUAL,
- read_timer_cb, write_timer_cb, &ts);
- throttle_config(&ts, &cfg);
+ throttle_init(&ts);
+ throttle_timers_init(&tt, ctx, QEMU_CLOCK_VIRTUAL,
+ read_timer_cb, write_timer_cb, &ts);
+ throttle_config(&ts, &tt, &cfg);
/* account a read */
throttle_account(&ts, false, size);
@@ -414,7 +424,7 @@ static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
return false;
}
- throttle_destroy(&ts);
+ throttle_timers_destroy(&tt);
return true;
}
diff --git a/util/throttle.c b/util/throttle.c
index f976ac7..4d7c8d4 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -159,29 +159,36 @@ bool throttle_compute_timer(ThrottleState *ts,
}
/* Add timers to event loop */
-void throttle_attach_aio_context(ThrottleState *ts, AioContext *new_context)
+void throttle_timers_attach_aio_context(ThrottleTimers *tt,
+ AioContext *new_context)
{
- ts->timers[0] = aio_timer_new(new_context, ts->clock_type, SCALE_NS,
- ts->read_timer_cb, ts->timer_opaque);
- ts->timers[1] = aio_timer_new(new_context, ts->clock_type, SCALE_NS,
- ts->write_timer_cb, ts->timer_opaque);
+ tt->timers[0] = aio_timer_new(new_context, tt->clock_type, SCALE_NS,
+ tt->read_timer_cb, tt->timer_opaque);
+ tt->timers[1] = aio_timer_new(new_context, tt->clock_type, SCALE_NS,
+ tt->write_timer_cb, tt->timer_opaque);
}
/* To be called first on the ThrottleState */
-void throttle_init(ThrottleState *ts,
- AioContext *aio_context,
- QEMUClockType clock_type,
- QEMUTimerCB *read_timer_cb,
- QEMUTimerCB *write_timer_cb,
- void *timer_opaque)
+void throttle_init(ThrottleState *ts)
{
memset(ts, 0, sizeof(ThrottleState));
+}
+
+/* To be called first on the ThrottleTimers */
+void throttle_timers_init(ThrottleTimers *tt,
+ AioContext *aio_context,
+ QEMUClockType clock_type,
+ QEMUTimerCB *read_timer_cb,
+ QEMUTimerCB *write_timer_cb,
+ void *timer_opaque)
+{
+ memset(tt, 0, sizeof(ThrottleTimers));
- ts->clock_type = clock_type;
- ts->read_timer_cb = read_timer_cb;
- ts->write_timer_cb = write_timer_cb;
- ts->timer_opaque = timer_opaque;
- throttle_attach_aio_context(ts, aio_context);
+ tt->clock_type = clock_type;
+ tt->read_timer_cb = read_timer_cb;
+ tt->write_timer_cb = write_timer_cb;
+ tt->timer_opaque = timer_opaque;
+ throttle_timers_attach_aio_context(tt, aio_context);
}
/* destroy a timer */
@@ -195,25 +202,25 @@ static void throttle_timer_destroy(QEMUTimer **timer)
}
/* Remove timers from event loop */
-void throttle_detach_aio_context(ThrottleState *ts)
+void throttle_timers_detach_aio_context(ThrottleTimers *tt)
{
int i;
for (i = 0; i < 2; i++) {
- throttle_timer_destroy(&ts->timers[i]);
+ throttle_timer_destroy(&tt->timers[i]);
}
}
-/* To be called last on the ThrottleState */
-void throttle_destroy(ThrottleState *ts)
+/* To be called last on the ThrottleTimers */
+void throttle_timers_destroy(ThrottleTimers *tt)
{
- throttle_detach_aio_context(ts);
+ throttle_timers_detach_aio_context(tt);
}
/* is any throttling timer configured */
-bool throttle_have_timer(ThrottleState *ts)
+bool throttle_timers_are_init(ThrottleTimers *tt)
{
- if (ts->timers[0]) {
+ if (tt->timers[0]) {
return true;
}
@@ -324,9 +331,12 @@ static void throttle_cancel_timer(QEMUTimer *timer)
/* Used to configure the throttle
*
* @ts: the throttle state we are working on
+ * @tt: the throttle timers we use in this aio context
* @cfg: the config to set
*/
-void throttle_config(ThrottleState *ts, ThrottleConfig *cfg)
+void throttle_config(ThrottleState *ts,
+ ThrottleTimers *tt,
+ ThrottleConfig *cfg)
{
int i;
@@ -336,10 +346,10 @@ void throttle_config(ThrottleState *ts, ThrottleConfig *cfg)
throttle_fix_bucket(&ts->cfg.buckets[i]);
}
- ts->previous_leak = qemu_clock_get_ns(ts->clock_type);
+ ts->previous_leak = qemu_clock_get_ns(tt->clock_type);
for (i = 0; i < 2; i++) {
- throttle_cancel_timer(ts->timers[i]);
+ throttle_cancel_timer(tt->timers[i]);
}
}
@@ -358,12 +368,15 @@ void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
*
* NOTE: this function is not unit tested due to it's usage of timer_mod
*
+ * @tt: the timers structure
* @is_write: the type of operation (read/write)
* @ret: true if the timer has been scheduled else false
*/
-bool throttle_schedule_timer(ThrottleState *ts, bool is_write)
+bool throttle_schedule_timer(ThrottleState *ts,
+ ThrottleTimers *tt,
+ bool is_write)
{
- int64_t now = qemu_clock_get_ns(ts->clock_type);
+ int64_t now = qemu_clock_get_ns(tt->clock_type);
int64_t next_timestamp;
bool must_wait;
@@ -378,12 +391,12 @@ bool throttle_schedule_timer(ThrottleState *ts, bool is_write)
}
/* request throttled and timer pending -> do nothing */
- if (timer_pending(ts->timers[is_write])) {
+ if (timer_pending(tt->timers[is_write])) {
return true;
}
/* request throttled and timer not pending -> arm timer */
- timer_mod(ts->timers[is_write], next_timestamp);
+ timer_mod(tt->timers[is_write], next_timestamp);
return true;
}
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [Qemu-devel] [PATCH v1 1/8] throttle: Extract timers from ThrottleState into a separate ThrottleTimers structure
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 1/8] throttle: Extract timers from ThrottleState into a separate ThrottleTimers structure Benoît Canet
@ 2014-10-08 5:51 ` Fam Zheng
2014-10-08 15:06 ` Eric Blake
1 sibling, 0 replies; 17+ messages in thread
From: Fam Zheng @ 2014-10-08 5:51 UTC (permalink / raw)
To: Benoît Canet; +Cc: kwolf, qemu-devel, stefanha
On Tue, 10/07 15:24, Benoît Canet wrote:
> Group throttling will share ThrottleState between multiple bs.
> As a consequence the ThrottleState will be accessed by multiple aio context.
>
> Timers are tied to their aio context so they must go out of the ThrottleState structure.
>
> This commit pave the way for each bs of a common ThrottleState to have it's own
s/pave/paves/
And a few trivial comments below.
Otherwise looks good.
> timer.
>
> Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
> ---
> block.c | 35 ++++++++++++--------
> include/block/block_int.h | 1 +
> include/qemu/throttle.h | 36 +++++++++++++--------
> tests/test-throttle.c | 82 ++++++++++++++++++++++++++---------------------
> util/throttle.c | 73 ++++++++++++++++++++++++-----------------
> 5 files changed, 134 insertions(+), 93 deletions(-)
>
> diff --git a/block.c b/block.c
> index d3aebeb..f209f55 100644
> --- a/block.c
> +++ b/block.c
> @@ -129,7 +129,7 @@ void bdrv_set_io_limits(BlockDriverState *bs,
> {
> int i;
>
> - throttle_config(&bs->throttle_state, cfg);
> + throttle_config(&bs->throttle_state, &bs->throttle_timers, cfg);
>
> for (i = 0; i < 2; i++) {
> qemu_co_enter_next(&bs->throttled_reqs[i]);
> @@ -162,7 +162,7 @@ void bdrv_io_limits_disable(BlockDriverState *bs)
>
> bdrv_start_throttled_reqs(bs);
>
> - throttle_destroy(&bs->throttle_state);
> + throttle_timers_destroy(&bs->throttle_timers);
> }
>
> static void bdrv_throttle_read_timer_cb(void *opaque)
> @@ -181,12 +181,13 @@ static void bdrv_throttle_write_timer_cb(void *opaque)
> void bdrv_io_limits_enable(BlockDriverState *bs)
> {
> assert(!bs->io_limits_enabled);
> - throttle_init(&bs->throttle_state,
> - bdrv_get_aio_context(bs),
> - QEMU_CLOCK_VIRTUAL,
> - bdrv_throttle_read_timer_cb,
> - bdrv_throttle_write_timer_cb,
> - bs);
> + throttle_init(&bs->throttle_state);
> + throttle_timers_init(&bs->throttle_timers,
> + bdrv_get_aio_context(bs),
> + QEMU_CLOCK_VIRTUAL,
> + bdrv_throttle_read_timer_cb,
> + bdrv_throttle_write_timer_cb,
> + bs);
> bs->io_limits_enabled = true;
> }
>
> @@ -200,7 +201,9 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs,
> bool is_write)
> {
> /* does this io must wait */
> - bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
> + bool must_wait = throttle_schedule_timer(&bs->throttle_state,
> + &bs->throttle_timers,
> + is_write);
>
> /* if must wait or any request of this type throttled queue the IO */
> if (must_wait ||
> @@ -213,7 +216,8 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs,
>
>
> /* if the next request must wait -> do nothing */
> - if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
> + if (throttle_schedule_timer(&bs->throttle_state, &bs->throttle_timers,
> + is_write)) {
> return;
> }
>
> @@ -1990,6 +1994,9 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
> memcpy(&bs_dest->throttle_state,
> &bs_src->throttle_state,
> sizeof(ThrottleState));
> + memcpy(&bs_dest->throttle_timers,
> + &bs_src->throttle_timers,
> + sizeof(ThrottleTimers));
> bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
> bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
> bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
> @@ -2052,7 +2059,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
> assert(bs_new->job == NULL);
> assert(bs_new->dev == NULL);
> assert(bs_new->io_limits_enabled == false);
> - assert(!throttle_have_timer(&bs_new->throttle_state));
> + assert(!throttle_timers_are_init(&bs_new->throttle_timers));
>
> tmp = *bs_new;
> *bs_new = *bs_old;
> @@ -2070,7 +2077,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
> assert(bs_new->dev == NULL);
> assert(bs_new->job == NULL);
> assert(bs_new->io_limits_enabled == false);
> - assert(!throttle_have_timer(&bs_new->throttle_state));
> + assert(!throttle_timers_are_init(&bs_new->throttle_timers));
>
> /* insert the nodes back into the graph node list if needed */
> if (bs_new->node_name[0] != '\0') {
> @@ -5746,7 +5753,7 @@ void bdrv_detach_aio_context(BlockDriverState *bs)
> }
>
> if (bs->io_limits_enabled) {
> - throttle_detach_aio_context(&bs->throttle_state);
> + throttle_timers_detach_aio_context(&bs->throttle_timers);
> }
> if (bs->drv->bdrv_detach_aio_context) {
> bs->drv->bdrv_detach_aio_context(bs);
> @@ -5782,7 +5789,7 @@ void bdrv_attach_aio_context(BlockDriverState *bs,
> bs->drv->bdrv_attach_aio_context(bs, new_context);
> }
> if (bs->io_limits_enabled) {
> - throttle_attach_aio_context(&bs->throttle_state, new_context);
> + throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
> }
>
> QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
> diff --git a/include/block/block_int.h b/include/block/block_int.h
> index 8d86a6c..7af126f 100644
> --- a/include/block/block_int.h
> +++ b/include/block/block_int.h
> @@ -356,6 +356,7 @@ struct BlockDriverState {
>
> /* I/O throttling */
> ThrottleState throttle_state;
> + ThrottleTimers throttle_timers;
> CoQueue throttled_reqs[2];
> bool io_limits_enabled;
>
> diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
> index b890613..b89d4d8 100644
> --- a/include/qemu/throttle.h
> +++ b/include/qemu/throttle.h
> @@ -65,6 +65,9 @@ typedef struct ThrottleConfig {
> typedef struct ThrottleState {
> ThrottleConfig cfg; /* configuration */
> int64_t previous_leak; /* timestamp of the last leak done */
> +} ThrottleState;
> +
> +typedef struct ThrottleTimers {
> QEMUTimer * timers[2]; /* timers used to do the throttling */
Since you are touching this structure, maybe also squash in:
- QEMUTimer * timers[2]; /* timers used to do the throttling */
+ QEMUTimer *timers[2]; /* timers used to do the throttling */
> QEMUClockType clock_type; /* the clock used */
>
> @@ -72,7 +75,7 @@ typedef struct ThrottleState {
> QEMUTimerCB *read_timer_cb;
> QEMUTimerCB *write_timer_cb;
> void *timer_opaque;
> -} ThrottleState;
> +} ThrottleTimers;
>
> /* operations on single leaky buckets */
> void throttle_leak_bucket(LeakyBucket *bkt, int64_t delta);
> @@ -86,20 +89,23 @@ bool throttle_compute_timer(ThrottleState *ts,
> int64_t *next_timestamp);
>
> /* init/destroy cycle */
> -void throttle_init(ThrottleState *ts,
> - AioContext *aio_context,
> - QEMUClockType clock_type,
> - void (read_timer)(void *),
> - void (write_timer)(void *),
> - void *timer_opaque);
> +void throttle_init(ThrottleState *ts);
> +
> +void throttle_timers_init(ThrottleTimers *tt,
> + AioContext *aio_context,
> + QEMUClockType clock_type,
> + QEMUTimerCB *read_timer_cb,
> + QEMUTimerCB *write_timer_cb,
> + void *timer_opaque);
>
> -void throttle_destroy(ThrottleState *ts);
> +void throttle_timers_destroy(ThrottleTimers *tt);
>
> -void throttle_detach_aio_context(ThrottleState *ts);
> +void throttle_timers_detach_aio_context(ThrottleTimers *tt);
>
> -void throttle_attach_aio_context(ThrottleState *ts, AioContext *new_context);
> +void throttle_timers_attach_aio_context(ThrottleTimers *tt,
> + AioContext *new_context);
>
> -bool throttle_have_timer(ThrottleState *ts);
> +bool throttle_timers_are_init(ThrottleTimers *tt);
Suggest s/_are_init/_initialized/
>
> /* configuration */
> bool throttle_enabled(ThrottleConfig *cfg);
> @@ -108,12 +114,16 @@ bool throttle_conflicting(ThrottleConfig *cfg);
>
> bool throttle_is_valid(ThrottleConfig *cfg);
>
> -void throttle_config(ThrottleState *ts, ThrottleConfig *cfg);
> +void throttle_config(ThrottleState *ts,
> + ThrottleTimers *tt,
> + ThrottleConfig *cfg);
>
> void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg);
>
> /* usage */
> -bool throttle_schedule_timer(ThrottleState *ts, bool is_write);
> +bool throttle_schedule_timer(ThrottleState *ts,
> + ThrottleTimers *tt,
> + bool is_write);
>
> void throttle_account(ThrottleState *ts, bool is_write, uint64_t size);
>
<snip>
Thanks,
Fam
^ permalink raw reply [flat|nested] 17+ messages in thread* Re: [Qemu-devel] [PATCH v1 1/8] throttle: Extract timers from ThrottleState into a separate ThrottleTimers structure
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 1/8] throttle: Extract timers from ThrottleState into a separate ThrottleTimers structure Benoît Canet
2014-10-08 5:51 ` Fam Zheng
@ 2014-10-08 15:06 ` Eric Blake
1 sibling, 0 replies; 17+ messages in thread
From: Eric Blake @ 2014-10-08 15:06 UTC (permalink / raw)
To: Benoît Canet, qemu-devel; +Cc: kwolf, famz, stefanha
[-- Attachment #1: Type: text/plain, Size: 660 bytes --]
On 10/07/2014 07:24 AM, Benoît Canet wrote:
> Group throttling will share ThrottleState between multiple bs.
> As a consequence the ThrottleState will be accessed by multiple aio context.
>
> Timers are tied to their aio context so they must go out of the ThrottleState structure.
>
> This commit pave the way for each bs of a common ThrottleState to have it's own
s/it's/its/ (remember, "it's" is only acceptable if you can say "it is"
in its place)
> timer.
>
> Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
> ---
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 539 bytes --]
^ permalink raw reply [flat|nested] 17+ messages in thread
* [Qemu-devel] [PATCH v1 2/8] throttle: Add throttle group infrastructure
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 1/8] throttle: Extract timers from ThrottleState into a separate ThrottleTimers structure Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 3/8] throttle: Add throttle group infrastructure tests Benoît Canet
` (5 subsequent siblings)
7 siblings, 0 replies; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
The throttle_group_incref increment the refcount of a throttle group given it's
name and return the associated throttle state.
The throttle_group_unref is the mirror function for cleaning up.
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
block/Makefile.objs | 1 +
block/throttle-groups.c | 212 ++++++++++++++++++++++++++++++++++++++++
include/block/block_int.h | 1 +
include/block/throttle-groups.h | 45 +++++++++
4 files changed, 259 insertions(+)
create mode 100644 block/throttle-groups.c
create mode 100644 include/block/throttle-groups.h
diff --git a/block/Makefile.objs b/block/Makefile.objs
index a833ed5..d257b05 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -10,6 +10,7 @@ block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o
block-obj-$(CONFIG_POSIX) += raw-posix.o
block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o
block-obj-y += null.o
+block-obj-y += throttle-groups.o
block-obj-y += nbd.o nbd-client.o sheepdog.o
block-obj-$(CONFIG_LIBISCSI) += iscsi.o
diff --git a/block/throttle-groups.c b/block/throttle-groups.c
new file mode 100644
index 0000000..ea5baca
--- /dev/null
+++ b/block/throttle-groups.c
@@ -0,0 +1,212 @@
+/*
+ * QEMU block throttling group infrastructure
+ *
+ * Copyright (C) Nodalink, EURL. 2014
+ *
+ * Author:
+ * Benoît Canet <benoit.canet@nodalink.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 or
+ * (at your option) version 3 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "block/throttle-groups.h"
+#include "qemu/queue.h"
+#include "qemu/thread.h"
+
+typedef struct ThrottleGroup {
+ char name[32];
+ ThrottleState ts;
+ uint64_t refcount;
+ QTAILQ_ENTRY(ThrottleGroup) list;
+ QLIST_HEAD(, BlockDriverState) head;
+ BlockDriverState *tokens[2]; /* current round-robin tokens */
+ QemuMutex lock; /* Used to synchronize all elements belonging to a group */
+} ThrottleGroup;
+
+static QTAILQ_HEAD(, ThrottleGroup) throttle_groups =
+ QTAILQ_HEAD_INITIALIZER(throttle_groups);
+
+/* increments a ThrottleGroup reference count given it's name
+ *
+ * If no ThrottleGroup is found with the given name a new one is created.
+ *
+ * @name: the name of the ThrottleGroup
+ * @ret: the ThrottleGroup's ThrottleState address
+ */
+ThrottleState *throttle_group_incref(const char *name)
+{
+ ThrottleGroup *tg;
+
+ /* return the correct ThrottleState if a group with this name exists */
+ QTAILQ_FOREACH(tg, &throttle_groups, list) {
+ /* group not found -> continue */
+ if (strcmp(name, tg->name)) {
+ continue;
+ }
+ /* group found -> increment it's refcount and return ThrottleState */
+ tg->refcount++;
+ return &tg->ts;
+ }
+
+ /* throttle group not found -> prepare new entry */
+ tg = g_new0(ThrottleGroup, 1);
+ pstrcpy(tg->name, sizeof(tg->name), name);
+ qemu_mutex_init(&tg->lock);
+ throttle_init(&tg->ts);
+ QLIST_INIT(&tg->head);
+ tg->refcount = 1;
+
+ /* insert new entry in the list */
+ QTAILQ_INSERT_TAIL(&throttle_groups, tg, list);
+
+ /* return newly allocated ThrottleState */
+ return &tg->ts;
+}
+
+/* decrement a ThrottleGroup given it's ThrottleState address
+ *
+ * When the refcount reach zero the ThrottleGroup is destroyed
+ *
+ * @ts: The ThrottleState address belonging to the ThrottleGroup to unref
+ * @ret: true on success else false
+ */
+bool throttle_group_unref(ThrottleState *ts)
+{
+ ThrottleGroup *tg;
+ bool found = false;
+
+ /* Find the ThrottleGroup of the given ThrottleState */
+ QTAILQ_FOREACH(tg, &throttle_groups, list) {
+ /* correct group found stop iterating */
+ if (&tg->ts == ts) {
+ qemu_mutex_lock(&tg->lock);
+ found = true;
+ break;
+ }
+ }
+
+ /* If the ThrottleState was not found something is seriously broken */
+ if (!found) {
+ return false;
+ }
+
+ tg->refcount--;
+
+ /* If ThrottleGroup is used keep it. */
+ if (tg->refcount) {
+ qemu_mutex_unlock(&tg->lock);
+ return true;
+ }
+
+ /* Else destroy it */
+ QTAILQ_REMOVE(&throttle_groups, tg, list);
+ qemu_mutex_unlock(&tg->lock);
+ qemu_mutex_destroy(&tg->lock);
+ g_free(tg);
+ return true;
+}
+
+/* Compare a name with a given ThrottleState group name
+ *
+ * @ts: the throttle state whose group we are inspecting
+ * @name: the name to compare
+ * @ret: true if names are equal else false
+ */
+bool throttle_group_compare(ThrottleState *ts, const char *name)
+{
+ ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+
+ if (!name) {
+ return false;
+ }
+
+ return !strcmp(name, tg->name);
+}
+
+/* Register a BlockDriverState in the doubly linked list
+ *
+ * @ts: the ThrottleState the code is working on
+ * @bs: the BlockDriverState to insert
+ */
+void throttle_group_register_bs(ThrottleState *ts, BlockDriverState *bs)
+{
+ ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+ QLIST_INSERT_HEAD(&tg->head, bs, round_robin);
+}
+
+/* Return the next BlockDriverState in the round-robin sequence
+ *
+ * This takes care of simulating a circular list
+ *
+ * @bs: the input current BlockDriverState
+ * @ret: the next BlockDriverState in the sequence
+ */
+BlockDriverState *throttle_group_next_bs(BlockDriverState *bs)
+{
+ ThrottleState *ts = &bs->throttle_state;
+ ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+ BlockDriverState *next = QLIST_NEXT(bs, round_robin);
+
+ if (!next) {
+ return QLIST_FIRST(&tg->head);
+ }
+
+ return next;
+}
+
+/* Used to set a token BlockDriverState into a ThrottleState's ThrottleGroup
+ *
+ * @ts: the ThrottleState the code is working on
+ * @token: the token BlockDriverState to set
+ * @is_write: true if we are talking about write operations else false
+ */
+void throttle_group_set_token(ThrottleState *ts,
+ BlockDriverState *token,
+ bool is_write)
+{
+ ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+ tg->tokens[is_write] = token;
+}
+
+/* Used to get the token BlockDriverState of a ThrottleState's ThrottleGroup
+ *
+ * @ts: the ThrottleState the code is working on
+ * @ret: the token BlockDriverState that is retrieved
+ * @is_write: true if we are talking about write operations else false
+ */
+BlockDriverState *throttle_group_token(ThrottleState *ts, bool is_write)
+{
+ ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+ return tg->tokens[is_write];
+}
+
+/* Used to lock a ThrottleState's ThrottleGroup
+ *
+ * @ts: the ThrottleState the code is working on
+ */
+void throttle_group_lock(ThrottleState *ts)
+{
+ ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+ qemu_mutex_lock(&tg->lock);
+}
+
+/* Used to unlock a ThrottleState's ThrottleGroup
+ *
+ * @ts: the ThrottleState the code is working on
+ */
+void throttle_group_unlock(ThrottleState *ts)
+{
+ ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
+ qemu_mutex_unlock(&tg->lock);
+}
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 7af126f..4b199f1 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -359,6 +359,7 @@ struct BlockDriverState {
ThrottleTimers throttle_timers;
CoQueue throttled_reqs[2];
bool io_limits_enabled;
+ QLIST_ENTRY(BlockDriverState) round_robin;
/* I/O stats (display with "info blockstats"). */
BlockAcctStats stats;
diff --git a/include/block/throttle-groups.h b/include/block/throttle-groups.h
new file mode 100644
index 0000000..d000067
--- /dev/null
+++ b/include/block/throttle-groups.h
@@ -0,0 +1,45 @@
+/*
+ * QEMU block throttling group infrastructure
+ *
+ * Copyright (C) Nodalink, EURL. 2014
+ *
+ * Author:
+ * Benoît Canet <benoit.canet@nodalink.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 or
+ * (at your option) version 3 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef THROTTLE_GROUPS_H
+#define THROTTLE_GROUPS_H
+
+#include "qemu/throttle.h"
+#include "block/block_int.h"
+
+ThrottleState *throttle_group_incref(const char *name);
+bool throttle_group_unref(ThrottleState *ts);
+
+bool throttle_group_compare(ThrottleState *ts, const char *name);
+
+void throttle_group_register_bs(ThrottleState *ts, BlockDriverState *bs);
+BlockDriverState *throttle_group_next_bs(BlockDriverState *bs);
+
+void throttle_group_set_token(ThrottleState *ts,
+ BlockDriverState *token,
+ bool is_write);
+BlockDriverState *throttle_group_token(ThrottleState *ts, bool is_write);
+
+void throttle_group_lock(ThrottleState *ts);
+void throttle_group_unlock(ThrottleState *ts);
+
+#endif
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread* [Qemu-devel] [PATCH v1 3/8] throttle: Add throttle group infrastructure tests
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 1/8] throttle: Extract timers from ThrottleState into a separate ThrottleTimers structure Benoît Canet
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 2/8] throttle: Add throttle group infrastructure Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
2014-10-08 6:20 ` Fam Zheng
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 4/8] throttle: Prepare to have multiple timers for one ThrottleState Benoît Canet
` (4 subsequent siblings)
7 siblings, 1 reply; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
tests/test-throttle.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git a/tests/test-throttle.c b/tests/test-throttle.c
index 3e52df3..ecb5504 100644
--- a/tests/test-throttle.c
+++ b/tests/test-throttle.c
@@ -15,6 +15,7 @@
#include "block/aio.h"
#include "qemu/throttle.h"
#include "qemu/error-report.h"
+#include "block/throttle-groups.h"
static AioContext *ctx;
static LeakyBucket bkt;
@@ -500,6 +501,55 @@ static void test_accounting(void)
(64.0 / 13)));
}
+static void test_groups(void)
+{
+ bool removed;
+
+ ThrottleState *ts_foo, *ts_bar, *tmp;
+
+ ts_bar = throttle_group_incref("bar");
+ throttle_group_set_token(ts_bar, (BlockDriverState *) 0x5, false);
+ ts_foo = throttle_group_incref("foo");
+
+ tmp = throttle_group_incref("foo");
+ throttle_group_set_token(tmp, (BlockDriverState *) 0x7, true);
+ g_assert(tmp == ts_foo);
+
+ tmp = throttle_group_incref("bar");
+ g_assert(tmp == ts_bar);
+
+ tmp = throttle_group_incref("bar");
+ g_assert(tmp == ts_bar);
+
+ g_assert((int64_t) throttle_group_token(ts_bar, false) == 0x5);
+ g_assert((int64_t) throttle_group_token(ts_foo, true) == 0x7);
+
+ removed = throttle_group_unref(ts_foo);
+ g_assert(removed);
+ removed = throttle_group_unref(ts_bar);
+ g_assert(removed);
+
+ g_assert((int64_t) throttle_group_token(ts_foo, true) == 0x7);
+
+ removed = throttle_group_unref(ts_foo);
+ g_assert(removed);
+ removed = throttle_group_unref(ts_bar);
+ g_assert(removed);
+
+ /* "foo" group should be destroyed when reaching this */
+ removed = throttle_group_unref(ts_foo);
+ g_assert(!removed);
+
+ g_assert((int64_t) throttle_group_token(ts_bar, false) == 0x5);
+
+ removed = throttle_group_unref(ts_bar);
+ g_assert(removed);
+
+ /* "bar" group should be destroyed when reaching this */
+ removed = throttle_group_unref(ts_bar);
+ g_assert(!removed);
+}
+
int main(int argc, char **argv)
{
GSource *src;
@@ -533,6 +583,7 @@ int main(int argc, char **argv)
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);
+ g_test_add_func("/throttle/groups", test_groups);
return g_test_run();
}
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [Qemu-devel] [PATCH v1 3/8] throttle: Add throttle group infrastructure tests
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 3/8] throttle: Add throttle group infrastructure tests Benoît Canet
@ 2014-10-08 6:20 ` Fam Zheng
0 siblings, 0 replies; 17+ messages in thread
From: Fam Zheng @ 2014-10-08 6:20 UTC (permalink / raw)
To: Benoît Canet; +Cc: kwolf, qemu-devel, stefanha
On Tue, 10/07 15:24, Benoît Canet wrote:
> Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
> ---
> tests/test-throttle.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 51 insertions(+)
>
> diff --git a/tests/test-throttle.c b/tests/test-throttle.c
> index 3e52df3..ecb5504 100644
> --- a/tests/test-throttle.c
> +++ b/tests/test-throttle.c
> @@ -15,6 +15,7 @@
> #include "block/aio.h"
> #include "qemu/throttle.h"
> #include "qemu/error-report.h"
> +#include "block/throttle-groups.h"
>
> static AioContext *ctx;
> static LeakyBucket bkt;
> @@ -500,6 +501,55 @@ static void test_accounting(void)
> (64.0 / 13)));
> }
>
> +static void test_groups(void)
> +{
> + bool removed;
> +
> + ThrottleState *ts_foo, *ts_bar, *tmp;
> +
> + ts_bar = throttle_group_incref("bar");
> + throttle_group_set_token(ts_bar, (BlockDriverState *) 0x5, false);
Why do you have the magic numbers cast to pointers instead of allocated objects
with bdrv_new?
Fam
> + ts_foo = throttle_group_incref("foo");
> +
> + tmp = throttle_group_incref("foo");
> + throttle_group_set_token(tmp, (BlockDriverState *) 0x7, true);
> + g_assert(tmp == ts_foo);
> +
> + tmp = throttle_group_incref("bar");
> + g_assert(tmp == ts_bar);
> +
> + tmp = throttle_group_incref("bar");
> + g_assert(tmp == ts_bar);
> +
> + g_assert((int64_t) throttle_group_token(ts_bar, false) == 0x5);
> + g_assert((int64_t) throttle_group_token(ts_foo, true) == 0x7);
> +
> + removed = throttle_group_unref(ts_foo);
> + g_assert(removed);
> + removed = throttle_group_unref(ts_bar);
> + g_assert(removed);
> +
> + g_assert((int64_t) throttle_group_token(ts_foo, true) == 0x7);
> +
> + removed = throttle_group_unref(ts_foo);
> + g_assert(removed);
> + removed = throttle_group_unref(ts_bar);
> + g_assert(removed);
> +
> + /* "foo" group should be destroyed when reaching this */
> + removed = throttle_group_unref(ts_foo);
> + g_assert(!removed);
> +
> + g_assert((int64_t) throttle_group_token(ts_bar, false) == 0x5);
> +
> + removed = throttle_group_unref(ts_bar);
> + g_assert(removed);
> +
> + /* "bar" group should be destroyed when reaching this */
> + removed = throttle_group_unref(ts_bar);
> + g_assert(!removed);
> +}
> +
> int main(int argc, char **argv)
> {
> GSource *src;
> @@ -533,6 +583,7 @@ int main(int argc, char **argv)
> 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);
> + g_test_add_func("/throttle/groups", test_groups);
> return g_test_run();
> }
>
> --
> 2.1.1
>
^ permalink raw reply [flat|nested] 17+ messages in thread
* [Qemu-devel] [PATCH v1 4/8] throttle: Prepare to have multiple timers for one ThrottleState
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
` (2 preceding siblings ...)
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 3/8] throttle: Add throttle group infrastructure tests Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 5/8] throttle: Add a way to know if throttle_schedule_timer had armed a timer Benoît Canet
` (3 subsequent siblings)
7 siblings, 0 replies; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
This patch transform the timer_pending call into two boolean values in the
ThrottleState structure.
This way we are sure that when multiple timers will be used only
one can be armed at a time.
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
block.c | 2 ++
include/qemu/throttle.h | 3 +++
util/throttle.c | 17 ++++++++++++++---
3 files changed, 19 insertions(+), 3 deletions(-)
diff --git a/block.c b/block.c
index f209f55..079b0dc 100644
--- a/block.c
+++ b/block.c
@@ -168,12 +168,14 @@ void bdrv_io_limits_disable(BlockDriverState *bs)
static void bdrv_throttle_read_timer_cb(void *opaque)
{
BlockDriverState *bs = opaque;
+ throttle_timer_fired(&bs->throttle_state, false);
qemu_co_enter_next(&bs->throttled_reqs[0]);
}
static void bdrv_throttle_write_timer_cb(void *opaque)
{
BlockDriverState *bs = opaque;
+ throttle_timer_fired(&bs->throttle_state, true);
qemu_co_enter_next(&bs->throttled_reqs[1]);
}
diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index b89d4d8..3aece3a 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -65,6 +65,7 @@ typedef struct ThrottleConfig {
typedef struct ThrottleState {
ThrottleConfig cfg; /* configuration */
int64_t previous_leak; /* timestamp of the last leak done */
+ bool any_timer_armed[2]; /* is any timer armed for this throttle state */
} ThrottleState;
typedef struct ThrottleTimers {
@@ -125,6 +126,8 @@ bool throttle_schedule_timer(ThrottleState *ts,
ThrottleTimers *tt,
bool is_write);
+void throttle_timer_fired(ThrottleState *ts, bool is_write);
+
void throttle_account(ThrottleState *ts, bool is_write, uint64_t size);
#endif
diff --git a/util/throttle.c b/util/throttle.c
index 4d7c8d4..0e305e3 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -172,6 +172,7 @@ void throttle_timers_attach_aio_context(ThrottleTimers *tt,
void throttle_init(ThrottleState *ts)
{
memset(ts, 0, sizeof(ThrottleState));
+ ts->any_timer_armed[0] = ts->any_timer_armed[1] = false;
}
/* To be called first on the ThrottleTimers */
@@ -390,16 +391,26 @@ bool throttle_schedule_timer(ThrottleState *ts,
return false;
}
- /* request throttled and timer pending -> do nothing */
- if (timer_pending(tt->timers[is_write])) {
+ /* request throttled and any timer pending -> do nothing */
+ if (ts->any_timer_armed[is_write]) {
return true;
}
- /* request throttled and timer not pending -> arm timer */
+ ts->any_timer_armed[is_write] = true;
timer_mod(tt->timers[is_write], next_timestamp);
return true;
}
+/* Remember that now timers are currently armed
+ *
+ * @ts: the throttle state we are working on
+ * @is_write: the type of operation (read/write)
+ */
+void throttle_timer_fired(ThrottleState *ts, bool is_write)
+{
+ ts->any_timer_armed[is_write] = false;
+}
+
/* do the accounting for this operation
*
* @is_write: the type of operation (read/write)
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread* [Qemu-devel] [PATCH v1 5/8] throttle: Add a way to know if throttle_schedule_timer had armed a timer
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
` (3 preceding siblings ...)
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 4/8] throttle: Prepare to have multiple timers for one ThrottleState Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 6/8] throttle: Add a way to fire one of the timers asap like a bottom half Benoît Canet
` (2 subsequent siblings)
7 siblings, 0 replies; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
This will be needed by the group throttling patches for the algorithm to be
accurate.
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
block.c | 7 +++++--
include/qemu/throttle.h | 3 ++-
util/throttle.c | 12 +++++++-----
3 files changed, 14 insertions(+), 8 deletions(-)
diff --git a/block.c b/block.c
index 079b0dc..527ea48 100644
--- a/block.c
+++ b/block.c
@@ -202,10 +202,13 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs,
unsigned int bytes,
bool is_write)
{
+ bool armed;
+
/* does this io must wait */
bool must_wait = throttle_schedule_timer(&bs->throttle_state,
&bs->throttle_timers,
- is_write);
+ is_write,
+ &armed);
/* if must wait or any request of this type throttled queue the IO */
if (must_wait ||
@@ -219,7 +222,7 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs,
/* if the next request must wait -> do nothing */
if (throttle_schedule_timer(&bs->throttle_state, &bs->throttle_timers,
- is_write)) {
+ is_write, &armed)) {
return;
}
diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index 3aece3a..3a16c48 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -124,7 +124,8 @@ void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg);
/* usage */
bool throttle_schedule_timer(ThrottleState *ts,
ThrottleTimers *tt,
- bool is_write);
+ bool is_write,
+ bool *armed);
void throttle_timer_fired(ThrottleState *ts, bool is_write);
diff --git a/util/throttle.c b/util/throttle.c
index 0e305e3..a273acb 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -375,11 +375,13 @@ void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
*/
bool throttle_schedule_timer(ThrottleState *ts,
ThrottleTimers *tt,
- bool is_write)
+ bool is_write,
+ bool *armed)
{
int64_t now = qemu_clock_get_ns(tt->clock_type);
int64_t next_timestamp;
bool must_wait;
+ *armed = false;
must_wait = throttle_compute_timer(ts,
is_write,
@@ -392,12 +394,12 @@ bool throttle_schedule_timer(ThrottleState *ts,
}
/* request throttled and any timer pending -> do nothing */
- if (ts->any_timer_armed[is_write]) {
- return true;
+ if (!ts->any_timer_armed[is_write]) {
+ *armed = true;
+ ts->any_timer_armed[is_write] = true;
+ timer_mod(tt->timers[is_write], next_timestamp);
}
- ts->any_timer_armed[is_write] = true;
- timer_mod(tt->timers[is_write], next_timestamp);
return true;
}
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread* [Qemu-devel] [PATCH v1 6/8] throttle: Add a way to fire one of the timers asap like a bottom half
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
` (4 preceding siblings ...)
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 5/8] throttle: Add a way to know if throttle_schedule_timer had armed a timer Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
2014-10-08 6:26 ` Fam Zheng
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support Benoît Canet
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 8/8] throttle: Update throttle infrastructure copyright Benoît Canet
7 siblings, 1 reply; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
This will be needed by the group throttling algorithm.
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
include/qemu/throttle.h | 2 ++
util/throttle.c | 11 +++++++++++
2 files changed, 13 insertions(+)
diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index 3a16c48..3b9d1b8 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -127,6 +127,8 @@ bool throttle_schedule_timer(ThrottleState *ts,
bool is_write,
bool *armed);
+void throttle_fire_timer(ThrottleTimers *tt, bool is_write);
+
void throttle_timer_fired(ThrottleState *ts, bool is_write);
void throttle_account(ThrottleState *ts, bool is_write, uint64_t size);
diff --git a/util/throttle.c b/util/throttle.c
index a273acb..163b9d0 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -403,6 +403,17 @@ bool throttle_schedule_timer(ThrottleState *ts,
return true;
}
+/* Schedule a throttle timer like a BH
+ *
+ * @tt: The timers structure
+ * @is_write: the type of operation (read/write)
+ */
+void throttle_fire_timer(ThrottleTimers *tt, bool is_write)
+{
+ int64_t now = qemu_clock_get_ns(tt->clock_type);
+ timer_mod(tt->timers[is_write], now + 1);
+}
+
/* Remember that now timers are currently armed
*
* @ts: the throttle state we are working on
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [Qemu-devel] [PATCH v1 6/8] throttle: Add a way to fire one of the timers asap like a bottom half
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 6/8] throttle: Add a way to fire one of the timers asap like a bottom half Benoît Canet
@ 2014-10-08 6:26 ` Fam Zheng
0 siblings, 0 replies; 17+ messages in thread
From: Fam Zheng @ 2014-10-08 6:26 UTC (permalink / raw)
To: Benoît Canet; +Cc: kwolf, qemu-devel, stefanha
On Tue, 10/07 15:24, Benoît Canet wrote:
> This will be needed by the group throttling algorithm.
>
> Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
> ---
> include/qemu/throttle.h | 2 ++
> util/throttle.c | 11 +++++++++++
> 2 files changed, 13 insertions(+)
>
> diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
> index 3a16c48..3b9d1b8 100644
> --- a/include/qemu/throttle.h
> +++ b/include/qemu/throttle.h
> @@ -127,6 +127,8 @@ bool throttle_schedule_timer(ThrottleState *ts,
> bool is_write,
> bool *armed);
>
> +void throttle_fire_timer(ThrottleTimers *tt, bool is_write);
> +
> void throttle_timer_fired(ThrottleState *ts, bool is_write);
>
> void throttle_account(ThrottleState *ts, bool is_write, uint64_t size);
> diff --git a/util/throttle.c b/util/throttle.c
> index a273acb..163b9d0 100644
> --- a/util/throttle.c
> +++ b/util/throttle.c
> @@ -403,6 +403,17 @@ bool throttle_schedule_timer(ThrottleState *ts,
> return true;
> }
>
> +/* Schedule a throttle timer like a BH
Why not use a real BH? It's more efficient than a timer scheduled at now + 1.
Fam
> + *
> + * @tt: The timers structure
> + * @is_write: the type of operation (read/write)
> + */
> +void throttle_fire_timer(ThrottleTimers *tt, bool is_write)
> +{
> + int64_t now = qemu_clock_get_ns(tt->clock_type);
> + timer_mod(tt->timers[is_write], now + 1);
> +}
> +
> /* Remember that now timers are currently armed
> *
> * @ts: the throttle state we are working on
> --
> 2.1.1
>
^ permalink raw reply [flat|nested] 17+ messages in thread
* [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
` (5 preceding siblings ...)
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 6/8] throttle: Add a way to fire one of the timers asap like a bottom half Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
2014-10-08 6:53 ` Fam Zheng
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 8/8] throttle: Update throttle infrastructure copyright Benoît Canet
7 siblings, 1 reply; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
The throttle group support use a cooperative round robin scheduling algorithm.
The principle of the algorithm are simple:
- Each BDS of the group is used as a token in a circular way.
- The active BDS compute if a wait must be done and arm the right timer.
- If a wait must be done the token timer will be armed so the token will become
the next active BDS.
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
block.c | 191 ++++++++++++++++++++++++++++++++++++++++------
block/qapi.c | 7 +-
block/throttle-groups.c | 2 +-
blockdev.c | 19 ++++-
hmp.c | 4 +-
include/block/block.h | 3 +-
include/block/block_int.h | 9 ++-
qapi/block-core.json | 5 +-
qemu-options.hx | 1 +
qmp-commands.hx | 3 +-
10 files changed, 209 insertions(+), 35 deletions(-)
diff --git a/block.c b/block.c
index 527ea48..e7e5607 100644
--- a/block.c
+++ b/block.c
@@ -36,6 +36,7 @@
#include "qmp-commands.h"
#include "qemu/timer.h"
#include "qapi-event.h"
+#include "block/throttle-groups.h"
#ifdef CONFIG_BSD
#include <sys/types.h>
@@ -129,7 +130,9 @@ void bdrv_set_io_limits(BlockDriverState *bs,
{
int i;
- throttle_config(&bs->throttle_state, &bs->throttle_timers, cfg);
+ throttle_group_lock(bs->throttle_state);
+ throttle_config(bs->throttle_state, &bs->throttle_timers, cfg);
+ throttle_group_unlock(bs->throttle_state);
for (i = 0; i < 2; i++) {
qemu_co_enter_next(&bs->throttled_reqs[i]);
@@ -156,34 +159,99 @@ static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
return drained;
}
+static void bdrv_throttle_group_add(BlockDriverState *bs)
+{
+ int i;
+ BlockDriverState *token;
+
+ for (i = 0; i < 2; i++) {
+ /* Get the BlockDriverState having the round robin token */
+ token = throttle_group_token(bs->throttle_state, i);
+
+ /* If the ThrottleGroup is new set the current BlockDriverState as
+ * token
+ */
+ if (!token) {
+ throttle_group_set_token(bs->throttle_state, bs, i);
+ }
+
+ }
+
+ throttle_group_register_bs(bs->throttle_state, bs);
+}
+
+static void bdrv_throttle_group_remove(BlockDriverState *bs)
+{
+ BlockDriverState *token;
+ int i;
+
+ for (i = 0; i < 2; i++) {
+ /* Get the BlockDriverState having the round robin token */
+ token = throttle_group_token(bs->throttle_state, i);
+ /* if this bs is the current token set the next bs as token */
+ if (token == bs) {
+ token = throttle_group_next_bs(token);
+ /* take care of the case where bs is the only bs of the group */
+ if (token == bs) {
+ token = NULL;
+ }
+ throttle_group_set_token(bs->throttle_state, token, i);
+ }
+ }
+
+ /* remove the current bs from the list */
+ QLIST_REMOVE(bs, round_robin);
+}
+
void bdrv_io_limits_disable(BlockDriverState *bs)
{
+
+ throttle_group_lock(bs->throttle_state);
bs->io_limits_enabled = false;
+ throttle_group_unlock(bs->throttle_state);
bdrv_start_throttled_reqs(bs);
+ throttle_group_lock(bs->throttle_state);
+ bdrv_throttle_group_remove(bs);
+ throttle_group_unlock(bs->throttle_state);
+
+ throttle_group_unref(bs->throttle_state);
+ bs->throttle_state = NULL;
+
throttle_timers_destroy(&bs->throttle_timers);
}
static void bdrv_throttle_read_timer_cb(void *opaque)
{
BlockDriverState *bs = opaque;
- throttle_timer_fired(&bs->throttle_state, false);
+
+ throttle_group_lock(bs->throttle_state);
+ throttle_timer_fired(bs->throttle_state, false);
+ throttle_group_unlock(bs->throttle_state);
+
qemu_co_enter_next(&bs->throttled_reqs[0]);
}
static void bdrv_throttle_write_timer_cb(void *opaque)
{
BlockDriverState *bs = opaque;
- throttle_timer_fired(&bs->throttle_state, true);
+
+ throttle_group_lock(bs->throttle_state);
+ throttle_timer_fired(bs->throttle_state, true);
+ throttle_group_unlock(bs->throttle_state);
+
qemu_co_enter_next(&bs->throttled_reqs[1]);
}
/* should be called before bdrv_set_io_limits if a limit is set */
-void bdrv_io_limits_enable(BlockDriverState *bs)
+void bdrv_io_limits_enable(BlockDriverState *bs, const char *group)
{
assert(!bs->io_limits_enabled);
- throttle_init(&bs->throttle_state);
+ bs->throttle_state = throttle_group_incref(group ? group : bs->device_name);
+
+ throttle_group_lock(bs->throttle_state);
+ bdrv_throttle_group_add(bs);
throttle_timers_init(&bs->throttle_timers,
bdrv_get_aio_context(bs),
QEMU_CLOCK_VIRTUAL,
@@ -191,6 +259,53 @@ void bdrv_io_limits_enable(BlockDriverState *bs)
bdrv_throttle_write_timer_cb,
bs);
bs->io_limits_enabled = true;
+ throttle_group_unlock(bs->throttle_state);
+}
+
+void bdrv_io_limits_update_group(BlockDriverState *bs, const char *group)
+{
+ /* this bs is not part of any group */
+ if (!bs->throttle_state) {
+ return;
+ }
+
+ /* this bs is a part of the same group than the one we want */
+ if (throttle_group_compare(bs->throttle_state, group)) {
+ return;
+ }
+
+ /* need to change the group this bs belong to */
+ bdrv_io_limits_disable(bs);
+ bdrv_io_limits_enable(bs, group);
+}
+
+/* This implement the round robin policy and must be called under ThrottleGroup
+ * lock
+ */
+static BlockDriverState *bdrv_next_throttle_token(BlockDriverState *bs,
+ bool is_write)
+{
+ BlockDriverState *token, *start;
+
+ start = token = throttle_group_token(bs->throttle_state, is_write);
+
+ /* get next bs round in round robin style */
+ token = throttle_group_next_bs(token);
+ while (token != start &&
+ qemu_co_queue_empty(&token->throttled_reqs[is_write])) {
+ token = throttle_group_next_bs(token);
+ }
+
+ /* If no IO are queued for scheduling on the next round robin token
+ * then decide the token is the current bs because chances are
+ * the current bs get the current request queued.
+ */
+ if (token == start &&
+ qemu_co_queue_empty(&token->throttled_reqs[is_write])) {
+ token = bs;
+ }
+
+ return token;
}
/* This function makes an IO wait if needed
@@ -202,32 +317,63 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs,
unsigned int bytes,
bool is_write)
{
+ bool empty;
bool armed;
+ bool token_queue_empty;
+ BlockDriverState *token;
+ throttle_group_lock(bs->throttle_state);
+ /* get the next bs to schedule */
+ token = bdrv_next_throttle_token(bs, is_write);
/* does this io must wait */
- bool must_wait = throttle_schedule_timer(&bs->throttle_state,
- &bs->throttle_timers,
+ bool must_wait = throttle_schedule_timer(bs->throttle_state,
+ &token->throttle_timers,
is_write,
&armed);
+ /* the timer got armed -> save the token */
+ if (armed) {
+ throttle_group_set_token(bs->throttle_state, token, is_write);
+ }
+ empty = qemu_co_queue_empty(&bs->throttled_reqs[is_write]);
+ throttle_group_unlock(bs->throttle_state);
/* if must wait or any request of this type throttled queue the IO */
- if (must_wait ||
- !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
+ if (must_wait || !empty) {
qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
}
- /* the IO will be executed, do the accounting */
- throttle_account(&bs->throttle_state, is_write, bytes);
-
+ throttle_group_lock(bs->throttle_state);
+ /* get the next bs to schedule */
+ token = bdrv_next_throttle_token(bs, is_write);
+ /* is there an IO to schedule in the round robin token ? */
+ token_queue_empty = qemu_co_queue_empty(&token->throttled_reqs[is_write]);
+ /* this IO will be executed, do the accounting */
+ throttle_account(bs->throttle_state, is_write, bytes);
+ /* does the next IO queued must wait ? */
+ must_wait = throttle_schedule_timer(bs->throttle_state,
+ &token->throttle_timers,
+ is_write,
+ &armed);
+ /* If a timer was armed or an IO is to be scheduled in the next round robin
+ * token then save the token.
+ */
+ if (armed || !token_queue_empty) {
+ throttle_group_set_token(bs->throttle_state, token, is_write);
+ }
/* if the next request must wait -> do nothing */
- if (throttle_schedule_timer(&bs->throttle_state, &bs->throttle_timers,
- is_write, &armed)) {
+ if (must_wait) {
+ throttle_group_unlock(bs->throttle_state);
return;
}
- /* else queue next request for execution */
- qemu_co_queue_next(&bs->throttled_reqs[is_write]);
+ /* else schedule next request for execution */
+ if (!qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
+ qemu_co_queue_next(&bs->throttled_reqs[is_write]);
+ } else if (!token_queue_empty) {
+ throttle_fire_timer(&token->throttle_timers, is_write);
+ }
+ throttle_group_unlock(bs->throttle_state);
}
size_t bdrv_opt_mem_align(BlockDriverState *bs)
@@ -1996,15 +2142,16 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
bs_dest->enable_write_cache = bs_src->enable_write_cache;
/* i/o throttled req */
- memcpy(&bs_dest->throttle_state,
- &bs_src->throttle_state,
- sizeof(ThrottleState));
+ bs_dest->throttle_state = bs_src->throttle_state,
+ bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
+ bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
+ bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
+ memcpy(&bs_dest->round_robin,
+ &bs_src->round_robin,
+ sizeof(bs_dest->round_robin));
memcpy(&bs_dest->throttle_timers,
&bs_src->throttle_timers,
sizeof(ThrottleTimers));
- bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
- bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
- bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
/* r/w error */
bs_dest->on_read_error = bs_src->on_read_error;
diff --git a/block/qapi.c b/block/qapi.c
index 9733ebd..4086055 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -24,6 +24,7 @@
#include "block/qapi.h"
#include "block/block_int.h"
+#include "block/throttle-groups.h"
#include "qmp-commands.h"
#include "qapi-visit.h"
#include "qapi/qmp-output-visitor.h"
@@ -61,7 +62,11 @@ BlockDeviceInfo *bdrv_block_device_info(BlockDriverState *bs)
if (bs->io_limits_enabled) {
ThrottleConfig cfg;
- throttle_get_config(&bs->throttle_state, &cfg);
+
+ throttle_group_lock(bs->throttle_state);
+ throttle_get_config(bs->throttle_state, &cfg);
+ throttle_group_unlock(bs->throttle_state);
+
info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg;
info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg;
info->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE].avg;
diff --git a/block/throttle-groups.c b/block/throttle-groups.c
index ea5baca..399ae5e 100644
--- a/block/throttle-groups.c
+++ b/block/throttle-groups.c
@@ -154,7 +154,7 @@ void throttle_group_register_bs(ThrottleState *ts, BlockDriverState *bs)
*/
BlockDriverState *throttle_group_next_bs(BlockDriverState *bs)
{
- ThrottleState *ts = &bs->throttle_state;
+ ThrottleState *ts = bs->throttle_state;
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
BlockDriverState *next = QLIST_NEXT(bs, round_robin);
diff --git a/blockdev.c b/blockdev.c
index e595910..415c18d 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -379,6 +379,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
bool has_driver_specific_opts;
BlockdevDetectZeroesOptions detect_zeroes;
BlockDriver *drv = NULL;
+ const char *throttling_group;
/* Check common options by copying from bs_opts to opts, all other options
* stay in bs_opts for processing by bdrv_open(). */
@@ -481,6 +482,8 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
cfg.op_size = qemu_opt_get_number(opts, "throttling.iops-size", 0);
+ throttling_group = qemu_opt_get(opts, "throttling.group");
+
if (!check_throttle_config(&cfg, &error)) {
error_propagate(errp, error);
goto early_err;
@@ -535,7 +538,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
/* disk I/O throttling */
if (throttle_enabled(&cfg)) {
- bdrv_io_limits_enable(bs);
+ bdrv_io_limits_enable(bs, throttling_group);
bdrv_set_io_limits(bs, &cfg);
}
@@ -742,6 +745,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
{ "iops_size", "throttling.iops-size" },
+ { "group", "throttling.group" },
+
{ "readonly", "read-only" },
};
@@ -1762,7 +1767,9 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
bool has_iops_wr_max,
int64_t iops_wr_max,
bool has_iops_size,
- int64_t iops_size, Error **errp)
+ int64_t iops_size,
+ bool has_group,
+ const char *group, Error **errp)
{
ThrottleConfig cfg;
BlockDriverState *bs;
@@ -1814,9 +1821,11 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
aio_context_acquire(aio_context);
if (!bs->io_limits_enabled && throttle_enabled(&cfg)) {
- bdrv_io_limits_enable(bs);
+ bdrv_io_limits_enable(bs, has_group ? group : NULL);
} else if (bs->io_limits_enabled && !throttle_enabled(&cfg)) {
bdrv_io_limits_disable(bs);
+ } else if (bs->io_limits_enabled && throttle_enabled(&cfg)) {
+ bdrv_io_limits_update_group(bs, has_group ? group : NULL);
}
if (bs->io_limits_enabled) {
@@ -2739,6 +2748,10 @@ QemuOptsList qemu_common_drive_opts = {
.type = QEMU_OPT_NUMBER,
.help = "when limiting by iops max size of an I/O in bytes",
},{
+ .name = "throttling.group",
+ .type = QEMU_OPT_STRING,
+ .help = "name of the block throttling group",
+ },{
.name = "copy-on-read",
.type = QEMU_OPT_BOOL,
.help = "copy read data from backing file into image file",
diff --git a/hmp.c b/hmp.c
index 63d7686..f2cd294 100644
--- a/hmp.c
+++ b/hmp.c
@@ -1167,7 +1167,9 @@ void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
false,
0,
false, /* No default I/O size */
- 0, &err);
+ 0,
+ false,
+ NULL, &err);
hmp_handle_error(mon, &err);
}
diff --git a/include/block/block.h b/include/block/block.h
index 3318f0d..454d86a 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -191,8 +191,9 @@ void bdrv_stats_print(Monitor *mon, const QObject *data);
void bdrv_info_stats(Monitor *mon, QObject **ret_data);
/* disk I/O throttling */
-void bdrv_io_limits_enable(BlockDriverState *bs);
+void bdrv_io_limits_enable(BlockDriverState *bs, const char *group);
void bdrv_io_limits_disable(BlockDriverState *bs);
+void bdrv_io_limits_update_group(BlockDriverState *bs, const char *group);
void bdrv_init(void);
void bdrv_init_with_whitelist(void);
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 4b199f1..a4e73f6 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -354,12 +354,13 @@ struct BlockDriverState {
/* number of in-flight serialising requests */
unsigned int serialising_in_flight;
- /* I/O throttling */
- ThrottleState throttle_state;
- ThrottleTimers throttle_timers;
- CoQueue throttled_reqs[2];
+ /* I/O throttling - following elements protected by ThrottleGroup lock */
+ ThrottleState *throttle_state;
bool io_limits_enabled;
+ CoQueue throttled_reqs[2];
QLIST_ENTRY(BlockDriverState) round_robin;
+ /* timers have their own locking */
+ ThrottleTimers throttle_timers;
/* I/O stats (display with "info blockstats"). */
BlockAcctStats stats;
diff --git a/qapi/block-core.json b/qapi/block-core.json
index 8f7089e..e6c5264 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -895,6 +895,9 @@
#
# @iops_size: #optional an I/O size in bytes (Since 1.7)
#
+#
+# @group: #optional throttle group name (Since 2.2)
+#
# Returns: Nothing on success
# If @device is not a valid block device, DeviceNotFound
#
@@ -906,7 +909,7 @@
'*bps_max': 'int', '*bps_rd_max': 'int',
'*bps_wr_max': 'int', '*iops_max': 'int',
'*iops_rd_max': 'int', '*iops_wr_max': 'int',
- '*iops_size': 'int' } }
+ '*iops_size': 'int', '*group': 'str' } }
##
# @block-stream:
diff --git a/qemu-options.hx b/qemu-options.hx
index 365b56c..269ca6f 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -437,6 +437,7 @@ DEF("drive", HAS_ARG, QEMU_OPTION_drive,
" [[,bps_max=bm]|[[,bps_rd_max=rm][,bps_wr_max=wm]]]\n"
" [[,iops_max=im]|[[,iops_rd_max=irm][,iops_wr_max=iwm]]]\n"
" [[,iops_size=is]]\n"
+ " [[,group=g]]\n"
" use 'file' as a drive image\n", QEMU_ARCH_ALL)
STEXI
@item -drive @var{option}[,@var{option}[,@var{option}[,...]]]
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 1abd619..1f61359 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -1662,7 +1662,7 @@ EQMP
{
.name = "block_set_io_throttle",
- .args_type = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l,bps_max:l?,bps_rd_max:l?,bps_wr_max:l?,iops_max:l?,iops_rd_max:l?,iops_wr_max:l?,iops_size:l?",
+ .args_type = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l,bps_max:l?,bps_rd_max:l?,bps_wr_max:l?,iops_max:l?,iops_rd_max:l?,iops_wr_max:l?,iops_size:l?,group:s?",
.mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
},
@@ -1688,6 +1688,7 @@ Arguments:
- "iops_rd_max": read I/O operations max (json-int)
- "iops_wr_max": write I/O operations max (json-int)
- "iops_size": I/O size in bytes when limiting (json-int)
+- "group": throttle group name (json-string)
Example:
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support Benoît Canet
@ 2014-10-08 6:53 ` Fam Zheng
2014-10-08 11:05 ` Benoît Canet
0 siblings, 1 reply; 17+ messages in thread
From: Fam Zheng @ 2014-10-08 6:53 UTC (permalink / raw)
To: Benoît Canet; +Cc: kwolf, qemu-devel, stefanha
On Tue, 10/07 15:24, Benoît Canet wrote:
> The throttle group support use a cooperative round robin scheduling algorithm.
>
> The principle of the algorithm are simple:
s/principle/principles/
> - Each BDS of the group is used as a token in a circular way.
> - The active BDS compute if a wait must be done and arm the right timer.
> - If a wait must be done the token timer will be armed so the token will become
> the next active BDS.
>
> Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
> ---
> block.c | 191 ++++++++++++++++++++++++++++++++++++++++------
> block/qapi.c | 7 +-
> block/throttle-groups.c | 2 +-
> blockdev.c | 19 ++++-
> hmp.c | 4 +-
> include/block/block.h | 3 +-
> include/block/block_int.h | 9 ++-
> qapi/block-core.json | 5 +-
> qemu-options.hx | 1 +
> qmp-commands.hx | 3 +-
> 10 files changed, 209 insertions(+), 35 deletions(-)
>
> diff --git a/block.c b/block.c
> index 527ea48..e7e5607 100644
> --- a/block.c
> +++ b/block.c
> @@ -36,6 +36,7 @@
> #include "qmp-commands.h"
> #include "qemu/timer.h"
> #include "qapi-event.h"
> +#include "block/throttle-groups.h"
>
> #ifdef CONFIG_BSD
> #include <sys/types.h>
> @@ -129,7 +130,9 @@ void bdrv_set_io_limits(BlockDriverState *bs,
> {
> int i;
>
> - throttle_config(&bs->throttle_state, &bs->throttle_timers, cfg);
> + throttle_group_lock(bs->throttle_state);
> + throttle_config(bs->throttle_state, &bs->throttle_timers, cfg);
> + throttle_group_unlock(bs->throttle_state);
>
> for (i = 0; i < 2; i++) {
> qemu_co_enter_next(&bs->throttled_reqs[i]);
> @@ -156,34 +159,99 @@ static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
> return drained;
> }
>
> +static void bdrv_throttle_group_add(BlockDriverState *bs)
> +{
> + int i;
> + BlockDriverState *token;
> +
> + for (i = 0; i < 2; i++) {
> + /* Get the BlockDriverState having the round robin token */
> + token = throttle_group_token(bs->throttle_state, i);
> +
> + /* If the ThrottleGroup is new set the current BlockDriverState as
> + * token
> + */
> + if (!token) {
> + throttle_group_set_token(bs->throttle_state, bs, i);
> + }
> +
> + }
> +
> + throttle_group_register_bs(bs->throttle_state, bs);
> +}
> +
> +static void bdrv_throttle_group_remove(BlockDriverState *bs)
> +{
> + BlockDriverState *token;
> + int i;
> +
> + for (i = 0; i < 2; i++) {
> + /* Get the BlockDriverState having the round robin token */
> + token = throttle_group_token(bs->throttle_state, i);
> + /* if this bs is the current token set the next bs as token */
> + if (token == bs) {
> + token = throttle_group_next_bs(token);
> + /* take care of the case where bs is the only bs of the group */
> + if (token == bs) {
> + token = NULL;
> + }
> + throttle_group_set_token(bs->throttle_state, token, i);
> + }
> + }
> +
> + /* remove the current bs from the list */
> + QLIST_REMOVE(bs, round_robin);
> +}
> +
> void bdrv_io_limits_disable(BlockDriverState *bs)
> {
> +
> + throttle_group_lock(bs->throttle_state);
> bs->io_limits_enabled = false;
> + throttle_group_unlock(bs->throttle_state);
>
> bdrv_start_throttled_reqs(bs);
>
> + throttle_group_lock(bs->throttle_state);
> + bdrv_throttle_group_remove(bs);
> + throttle_group_unlock(bs->throttle_state);
> +
> + throttle_group_unref(bs->throttle_state);
> + bs->throttle_state = NULL;
> +
> throttle_timers_destroy(&bs->throttle_timers);
> }
>
> static void bdrv_throttle_read_timer_cb(void *opaque)
> {
> BlockDriverState *bs = opaque;
> - throttle_timer_fired(&bs->throttle_state, false);
> +
> + throttle_group_lock(bs->throttle_state);
> + throttle_timer_fired(bs->throttle_state, false);
> + throttle_group_unlock(bs->throttle_state);
> +
> qemu_co_enter_next(&bs->throttled_reqs[0]);
> }
>
> static void bdrv_throttle_write_timer_cb(void *opaque)
> {
> BlockDriverState *bs = opaque;
> - throttle_timer_fired(&bs->throttle_state, true);
> +
> + throttle_group_lock(bs->throttle_state);
> + throttle_timer_fired(bs->throttle_state, true);
> + throttle_group_unlock(bs->throttle_state);
> +
> qemu_co_enter_next(&bs->throttled_reqs[1]);
> }
>
> /* should be called before bdrv_set_io_limits if a limit is set */
> -void bdrv_io_limits_enable(BlockDriverState *bs)
> +void bdrv_io_limits_enable(BlockDriverState *bs, const char *group)
Does this mean that after this series, all the throttle_states must be
contained inside its own throttle group? If so, we could embed ThrottleGroup
fields in ThrottleState.
It's weird when a function called throttle_group_compare takes a parameter of
ThrottleState pointer, and cast it back to ThrottleGroup with container_of.
Fam
^ permalink raw reply [flat|nested] 17+ messages in thread* Re: [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support
2014-10-08 6:53 ` Fam Zheng
@ 2014-10-08 11:05 ` Benoît Canet
2014-10-09 8:58 ` Fam Zheng
0 siblings, 1 reply; 17+ messages in thread
From: Benoît Canet @ 2014-10-08 11:05 UTC (permalink / raw)
To: Fam Zheng; +Cc: kwolf, stefanha, qemu-devel, Benoît Canet
On Wed, Oct 08, 2014 at 02:53:38PM +0800, Fam Zheng wrote:
>
> Does this mean that after this series, all the throttle_states must be
> contained inside its own throttle group? If so, we could embed ThrottleGroup
> fields in ThrottleState.
>
> It's weird when a function called throttle_group_compare takes a parameter of
> ThrottleState pointer, and cast it back to ThrottleGroup with container_of.
It's done like this to fullfill a design goal: the throttle should be reusable
without the groups and any reference to block related stuff.
So it's just a way to split the responsabilities.
Best regards
Benoît
Thanks for reviewing.
>
> Fam
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support
2014-10-08 11:05 ` Benoît Canet
@ 2014-10-09 8:58 ` Fam Zheng
2014-10-10 11:35 ` Benoît Canet
0 siblings, 1 reply; 17+ messages in thread
From: Fam Zheng @ 2014-10-09 8:58 UTC (permalink / raw)
To: Benoît Canet; +Cc: kwolf, qemu-devel, stefanha
On Wed, 10/08 11:05, Benoît Canet wrote:
> On Wed, Oct 08, 2014 at 02:53:38PM +0800, Fam Zheng wrote:
> >
> > Does this mean that after this series, all the throttle_states must be
> > contained inside its own throttle group? If so, we could embed ThrottleGroup
> > fields in ThrottleState.
> >
> > It's weird when a function called throttle_group_compare takes a parameter of
> > ThrottleState pointer, and cast it back to ThrottleGroup with container_of.
>
> It's done like this to fullfill a design goal: the throttle should be reusable
> without the groups and any reference to block related stuff.
> So it's just a way to split the responsabilities.
I see.
Having both ThrottleGroup and ThrottleState interfaces is more complicated than
just use ThrottleGroup, where a one-member group is exactly the same as
ThrottleState.
Fam
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support
2014-10-09 8:58 ` Fam Zheng
@ 2014-10-10 11:35 ` Benoît Canet
0 siblings, 0 replies; 17+ messages in thread
From: Benoît Canet @ 2014-10-10 11:35 UTC (permalink / raw)
To: Fam Zheng; +Cc: kwolf, stefanha, qemu-devel, Benoît Canet
On Thu, Oct 09, 2014 at 04:58:22PM +0800, Fam Zheng wrote:
> On Wed, 10/08 11:05, Benoît Canet wrote:
> > On Wed, Oct 08, 2014 at 02:53:38PM +0800, Fam Zheng wrote:
> > >
> > > Does this mean that after this series, all the throttle_states must be
> > > contained inside its own throttle group? If so, we could embed ThrottleGroup
> > > fields in ThrottleState.
> > >
> > > It's weird when a function called throttle_group_compare takes a parameter of
> > > ThrottleState pointer, and cast it back to ThrottleGroup with container_of.
> >
> > It's done like this to fullfill a design goal: the throttle should be reusable
> > without the groups and any reference to block related stuff.
> > So it's just a way to split the responsabilities.
>
> I see.
>
> Having both ThrottleGroup and ThrottleState interfaces is more complicated than
> just use ThrottleGroup, where a one-member group is exactly the same as
> ThrottleState.
Here my interest conflict between a short term strategy (comply and getting these
patches merged asap) and the technical advantage of keeping ThrottleState and
ThrottleGroup separated.
orthogonality
-------------
An advantage to keep ThrottleState and ThrottleGroup separated is that
the two roles of implementing the throttle itself and implementing the behavior
of a group are keep separated.
As a result each piece of code is simpler to write, review and test.
genericity
----------
When writing the initial throttle code I carefully designed it to be independant
of BlockDriverState.
As a result the throttle code lives in util/ and is easilly reusable into whatever
we want (a device model or network throttling).
It is mean, designed and written to be as generic as possible.
So yes merging ThrottleState and ThrottleGroup would result in the seemlingly nice
thing that one structure is simpler than two structure.
But it would also imply the fact that I really hate that this pesky
BlockDriverState structure would become tied to ThrottleState.
If we do this ThrottleState would move out of util/ to block/ and we would
have lost the ability to reuse this infrastructure. It would be a short term gain
and a long term loss.
Another fact is that the rationale "1 structure is simpler than 2" is not alway
relevant: look for BlockBackend that we are desesperately trying to move out of
BlockDriverState.
Best regards
Benoît
>
> Fam
^ permalink raw reply [flat|nested] 17+ messages in thread
* [Qemu-devel] [PATCH v1 8/8] throttle: Update throttle infrastructure copyright
2014-10-07 13:24 [Qemu-devel] [PATCH v1 0/8] Block Throttle Group Support Benoît Canet
` (6 preceding siblings ...)
2014-10-07 13:24 ` [Qemu-devel] [PATCH v1 7/8] throttle: Add throttle group support Benoît Canet
@ 2014-10-07 13:24 ` Benoît Canet
7 siblings, 0 replies; 17+ messages in thread
From: Benoît Canet @ 2014-10-07 13:24 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, famz, Benoît Canet, stefanha
Signed-off-by: Benoit Canet <benoit.canet@nodalink.com>
---
include/qemu/throttle.h | 4 ++--
tests/test-throttle.c | 4 ++--
util/throttle.c | 4 ++--
3 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index 3b9d1b8..8abd94d 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -1,10 +1,10 @@
/*
* QEMU throttling infrastructure
*
- * Copyright (C) Nodalink, SARL. 2013
+ * Copyright (C) Nodalink, EURL. 2013-2014
*
* Author:
- * Benoît Canet <benoit.canet@irqsave.net>
+ * Benoît Canet <benoit.canet@nodalink.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
diff --git a/tests/test-throttle.c b/tests/test-throttle.c
index ecb5504..0efd372 100644
--- a/tests/test-throttle.c
+++ b/tests/test-throttle.c
@@ -1,10 +1,10 @@
/*
* Throttle infrastructure tests
*
- * Copyright Nodalink, SARL. 2013
+ * Copyright Nodalink, EURL. 2013-2014
*
* Authors:
- * Benoît Canet <benoit.canet@irqsave.net>
+ * Benoît Canet <benoit.canet@nodalink.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.
diff --git a/util/throttle.c b/util/throttle.c
index 163b9d0..4884c08 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -1,10 +1,10 @@
/*
* QEMU throttling infrastructure
*
- * Copyright (C) Nodalink, SARL. 2013
+ * Copyright (C) Nodalink, EURL. 2013-2014
*
* Author:
- * Benoît Canet <benoit.canet@irqsave.net>
+ * Benoît Canet <benoit.canet@nodalink.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
--
2.1.1
^ permalink raw reply related [flat|nested] 17+ messages in thread