Continuous Leaky Bucket Throttling
v11 cover Continuous Leaky Bucket Throttling
This patchset implement continous leaky bucket throttling.
It use two requests queue to enable to do silly unbalanced throttling like block_set_io_throttle 0 0 0 0 6000 1
It use two timer to get the timer callbacks and the throttle.c code simple
v11:
Reapplied Eric's reviewed by (they are precious)
v10:
Rebased on top of Eric latest patch (merged in qemu-trivial-next)
v9:
Apply Reviewed-By by Eric
Rebased on top of "qmp: fix integer usage in examples" by Eric (Please apply it
first)
v8:
rearm timer only when it's not pending [Stefan] Schedule next request right after accouting it [Stefan]
v7:
honor max values if specified [Paolo] s/cfg/Linux CFQ/ [Stefan]
revert throttle_get_config to it's old prototype [Stefan] s/size/@size/ [Stefan]
s/acccount/account/ [Stefan]
remove tracked_request_end uneeded hunk [Stefan] Spaces before (json-int)s [Stefan]
*** BLURB HERE ***
Benoît Canet (5):
throttle: Add a new throttling API implementing continuous leaky
bucket.
throttle: Add units tests
block: Enable the new throttling code in the block layer.
block: Add support for throttling burst max in QMP and the command
line.
block: Add iops_size to do the iops accounting for a given io size.
block.c | 338 +++++++++---------------------- block/qapi.c | 50 +++-- blockdev.c | 205 ++++++++++++++----- hmp.c | 36 +++- include/block/block.h | 1 - include/block/block_int.h | 32 +-- include/qemu/throttle.h | 103 ++++++++++ qapi-schema.json | 40 +++- qemu-options.hx | 4 +- qmp-commands.hx | 32 ++- tests/Makefile | 2 + tests/test-throttle.c | 481 +++++++++++++++++++++++++++++++++++++++++++++ util/Makefile.objs | 1 + util/throttle.c | 396 +++++++++++++++++++++++++++++++++++++ 14 files changed, 1383 insertions(+), 338 deletions(-) create mode 100644 include/qemu/throttle.h create mode 100644 tests/test-throttle.c create mode 100644 util/throttle.c
Signature · 1 line
1.7.10.4
PATCH v11 1/5 throttle: Add a new throttling API implementing continuous leaky bucket.
Implement the continuous leaky bucket algorithm devised on IRC as a separate module.
--- include/qemu/throttle.h | 103 ++++++++++++ util/Makefile.objs | 1 + util/throttle.c | 396 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 500 insertions(+) create mode 100644 include/qemu/throttle.h create mode 100644 util/throttle.c
include/qemu/throttle.h new file +103 -0
@@ -0,0 +1,103 @@ +/* +* QEMU throttling infrastructure +* +* Copyright (C) Nodalink, SARL. 2013 +* +* Author: +* Benoît Canet <[email protected]> +* +* 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_H +#define THROTTLE_H + +#include <stdint.h> +#include "qemu-common.h" +#include "qemu/timer.h" + +#define NANOSECONDS_PER_SECOND 1000000000.0 + +typedef enum { +THROTTLE_BPS_TOTAL , +THROTTLE_BPS_READ , +THROTTLE_BPS_WRITE , +THROTTLE_OPS_TOTAL , +THROTTLE_OPS_READ , +THROTTLE_OPS_WRITE , +BUCKETS_COUNT , +}BucketType ; + +typedef struct LeakyBucket { +double avg;/* average goal in units per second */ +double max;/* leaky bucket max burst in units */ +double level;/* bucket level in units */ +}LeakyBucket ; + +/* The following structure is used to configure a ThrottleState +* It contains a bit of state: the bucket field of the LeakyBucket structure. +* However it allows to keep the code clean and the bucket field is reset to +* zero at the right time. +*/ +typedef struct ThrottleConfig { +LeakyBucket buckets[BUCKETS_COUNT ];/* leaky buckets */ +uint64_t op_size;/* size of an operation in bytes */ +}ThrottleConfig ; + +typedef struct ThrottleState { +ThrottleConfig cfg;/* configuration */ +int64_t previous_leak;/* timestamp of the last leak done */ +QEMUTimer * timers[2 ];/* timers used to do the throttling */ +QEMUClockType clock_type;/* the clock used */ +}ThrottleState ; + +/* operations on single leaky buckets */ +void throttle_leak_bucket (LeakyBucket *bkt,int64_t delta); + +int64_t throttle_compute_wait (LeakyBucket *bkt); + +/* expose timer computation function for unit tests */ +bool throttle_compute_timer (ThrottleState *ts, +bool is_write, +int64_t now, +int64_t *next_timestamp); + +/* init/destroy cycle */ +void throttle_init (ThrottleState *ts, +QEMUClockType clock_type, +void (read_timer )(void *), +void (write_timer )(void *), +void *timer_opaque); + +void throttle_destroy (ThrottleState *ts); + +bool throttle_have_timer (ThrottleState *ts); + +/* configuration */ +bool throttle_enabled (ThrottleConfig *cfg); + +bool throttle_conflicting (ThrottleConfig *cfg); + +bool throttle_is_valid (ThrottleConfig *cfg); + +void throttle_config (ThrottleState *ts,ThrottleConfig *cfg); + +void throttle_get_config (ThrottleState *ts,ThrottleConfig *cfg); + +/* usage */ +bool throttle_schedule_timer (ThrottleState *ts,bool is_write); + +void throttle_account (ThrottleState *ts,bool is_write,uint64_t size); + +#endif
util/Makefile.objs +1 -0
@@ -11,3 +11,4 @@ util-obj-y += iov.o aes.o qemu-config.o qemu-sockets.o uri.o notify.o util-obj-y += qemu-option.o qemu-progress.o util-obj-y += hexdump.o util-obj-y += crc32c.o +util-obj-y += throttle.o
util/throttle.c new file +396 -0
396 lines not on this page · raw message
Signature · 1 line
1.7.10.4
Re: [Qemu-devel] [PATCH V11 1/5] throttle: Add a new throttling API implementing continuous leaky bucket.
Quoted 509 lines · Benoît Canet
Implement the continuous leaky bucket algorithm devised on IRC as a separate module.
Signed-off-by Benoit Canet <[email protected]>--- include/qemu/throttle.h | 103 ++++++++++++ util/Makefile.objs | 1 + util/throttle.c | 396 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 500 insertions(+) create mode 100644 include/qemu/throttle.h create mode 100644 util/throttle.cinclude/qemu/throttle.h new file +103
-0@@ -0,0 +1,103 @@ +/* +* QEMU throttling infrastructure +* +* Copyright (C) Nodalink, SARL. 2013 +* +* Author: +* Benoît Canet <[email protected]> +* +* 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_H +#define THROTTLE_H + +#include <stdint.h> +#include "qemu-common.h" +#include "qemu/timer.h" + +#define NANOSECONDS_PER_SECOND 1000000000.0 + +typedef enum { +THROTTLE_BPS_TOTAL , +THROTTLE_BPS_READ , +THROTTLE_BPS_WRITE , +THROTTLE_OPS_TOTAL , +THROTTLE_OPS_READ , +THROTTLE_OPS_WRITE , +BUCKETS_COUNT , +}BucketType ; + +typedef struct LeakyBucket { +double avg;/* average goal in units per second */ +double max;/* leaky bucket max burst in units */ +double level;/* bucket level in units */ +}LeakyBucket ; + +/* The following structure is used to configure a ThrottleState +* It contains a bit of state: the bucket field of the LeakyBucket structure. +* However it allows to keep the code clean and the bucket field is reset to +* zero at the right time. +*/ +typedef struct ThrottleConfig { +LeakyBucket buckets[BUCKETS_COUNT ];/* leaky buckets */ +uint64_t op_size;/* size of an operation in bytes */ +}ThrottleConfig ; + +typedef struct ThrottleState { +ThrottleConfig cfg;/* configuration */ +int64_t previous_leak;/* timestamp of the last leak done */ +QEMUTimer * timers[2 ];/* timers used to do the throttling */ +QEMUClockType clock_type;/* the clock used */ +}ThrottleState ; + +/* operations on single leaky buckets */ +void throttle_leak_bucket (LeakyBucket *bkt,int64_t delta); + +int64_t throttle_compute_wait (LeakyBucket *bkt); + +/* expose timer computation function for unit tests */ +bool throttle_compute_timer (ThrottleState *ts, +bool is_write, +int64_t now, +int64_t *next_timestamp); + +/* init/destroy cycle */ +void throttle_init (ThrottleState *ts, +QEMUClockType clock_type, +void (read_timer )(void *), +void (write_timer )(void *), +void *timer_opaque); + +void throttle_destroy (ThrottleState *ts); + +bool throttle_have_timer (ThrottleState *ts); + +/* configuration */ +bool throttle_enabled (ThrottleConfig *cfg); + +bool throttle_conflicting (ThrottleConfig *cfg); + +bool throttle_is_valid (ThrottleConfig *cfg); + +void throttle_config (ThrottleState *ts,ThrottleConfig *cfg); + +void throttle_get_config (ThrottleState *ts,ThrottleConfig *cfg); + +/* usage */ +bool throttle_schedule_timer (ThrottleState *ts,bool is_write); + +void throttle_account (ThrottleState *ts,bool is_write,uint64_t size); + +#endif util/Makefile.objs +1
-0@@ -11,3 +11,4 @@ util-obj-y += iov.o aes.o qemu-config.o qemu-sockets.o uri.o notify.o util-obj-y += qemu-option.o qemu-progress.o util-obj-y += hexdump.o util-obj-y += crc32c.o +util-obj-y += throttle.outil/throttle.c new file +373
-0@@ -0,0 +1,396 @@ +/* +* QEMU throttling infrastructure +* +* Copyright (C) Nodalink, SARL. 2013 +* +* Author: +* Benoît Canet <[email protected]> +* +* 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 "qemu/throttle.h" +#include "qemu/timer.h" + +/* This function make a bucket leak +* +* @bkt: the bucket to make leak +* @delta_ns: the time delta +*/ +void throttle_leak_bucket (LeakyBucket *bkt,int64_t delta_ns) +{ +double leak; + +/* compute how much to leak */ + leak = (bkt->avg * (double ) delta_ns) /NANOSECONDS_PER_SECOND ; + +/* make the bucket leak */ + bkt->level =MAX (bkt->level - leak,0 ); +} + +/* Calculate the time delta since last leak and make proportionals leaks +* +* @now: the current timestamp in ns +*/ +static void throttle_do_leak (ThrottleState *ts,int64_t now) +{ +/* compute the time elapsed since the last leak */ +int64_t delta_ns = now - ts->previous_leak; +int i; + + ts->previous_leak = now; + +if (delta_ns <=0 ) { +return ; + } + +/* make each bucket leak */ +for (i =0 ; i <BUCKETS_COUNT ; i++) { +throttle_leak_bucket (&ts->cfg.buckets[i], delta_ns); + } +} + +/* do the real job of computing the time to wait +* +* @limit: the throttling limit +* @extra: the number of operation to delay +* @ret: the time to wait in ns +*/ +static int64_t throttle_do_compute_wait (double limit,double extra) +{ +double wait = extra *NANOSECONDS_PER_SECOND ; + wait /= limit; +return wait; +} + +/* This function compute the wait time in ns that a leaky bucket should trigger +* +* @bkt: the leaky bucket we operate on +* @ret: the resulting wait time in ns or 0 if the operation can go through +*/ +int64_t throttle_compute_wait (LeakyBucket *bkt) +{ +double extra;/* the number of extra units blocking the io */ + +if (!bkt->avg) { +return 0 ; + } + + extra = bkt->level - bkt->max; + +if (extra <=0 ) { +return 0 ; + } + +return throttle_do_compute_wait (bkt->avg, extra); +} + +/* This function compute the time that must be waited while this IO +* +* @is_write: true if the current IO is a write, false if it's a read +* @ret: time to wait +*/ +static int64_t throttle_compute_wait_for (ThrottleState *ts, +bool is_write) +{ +BucketType to_check[2 ][4 ] = { {THROTTLE_BPS_TOTAL , +THROTTLE_OPS_TOTAL , +THROTTLE_BPS_READ , +THROTTLE_OPS_READ }, + {THROTTLE_BPS_TOTAL , +THROTTLE_OPS_TOTAL , +THROTTLE_BPS_WRITE , +THROTTLE_OPS_WRITE }, }; +int64_t wait, max_wait =0 ; +int i; + +for (i =0 ; i <4 ; i++) { +BucketType index = to_check[is_write][i]; + wait =throttle_compute_wait (&ts->cfg.buckets[index]); +if (wait > max_wait) { + max_wait = wait; + } + } + +return max_wait; +} + +/* compute the timer for this type of operation +* +* @is_write: the type of operation +* @now: the current clock timestamp +* @next_timestamp: the resulting timer +* @ret: true if a timer must be set +*/ +bool throttle_compute_timer (ThrottleState *ts, +bool is_write, +int64_t now, +int64_t *next_timestamp) +{ +int64_t wait; + +/* leak proportionally to the time elapsed */ +throttle_do_leak (ts, now); + +/* compute the wait time if any */ + wait =throttle_compute_wait_for (ts, is_write); + +/* if the code must wait compute when the next timer should fire */ +if (wait) { + *next_timestamp = now + wait; +return true; + } + +/* else no need to wait at all */ + *next_timestamp = now; +return false; +} + +/* To be called first on the ThrottleState */ +void throttle_init (ThrottleState *ts, +QEMUClockType clock_type, +QEMUTimerCB *read_timer_cb, +QEMUTimerCB *write_timer_cb, +void *timer_opaque) +{ +memset (ts,0 ,sizeof (ThrottleState)); + + ts->clock_type = clock_type; + ts->timers[0 ] =timer_new_ns (clock_type, read_timer_cb, timer_opaque); + ts->timers[1 ] =timer_new_ns (clock_type, write_timer_cb, timer_opaque); +} + +/* destroy a timer */ +static void throttle_timer_destroy (QEMUTimer **timer) +{ +assert (*timer !=NULL ); + +timer_del (*timer); +timer_free (*timer); + *timer =NULL ; +} + +/* To be called last on the ThrottleState */ +void throttle_destroy (ThrottleState *ts) +{ +int i; + +for (i =0 ; i <2 ; i++) { +throttle_timer_destroy (&ts->timers[i]); + } +} + +/* is any throttling timer configured */ +bool throttle_have_timer (ThrottleState *ts) +{ +if (ts->timers[0 ]) { +return true; + } + +return false; +} + +/* Does any throttling must be done +* +* @cfg: the throttling configuration to inspect +* @ret: true if throttling must be done else false +*/ +bool throttle_enabled (ThrottleConfig *cfg) +{ +int i; + +for (i =0 ; i <BUCKETS_COUNT ; i++) { +if (cfg->buckets[i].avg >0 ) { +return true; + } + } + +return false; +} + +/* return true if any two throttling parameters conflicts +* +* @cfg: the throttling configuration to inspect +* @ret: true if any conflict detected else false +*/ +bool throttle_conflicting (ThrottleConfig *cfg) +{ +bool bps_flag, ops_flag; +bool bps_max_flag, ops_max_flag; + + bps_flag = cfg->buckets[THROTTLE_BPS_TOTAL ].avg && + (cfg->buckets[THROTTLE_BPS_READ ].avg || + cfg->buckets[THROTTLE_BPS_WRITE ].avg); + + ops_flag = cfg->buckets[THROTTLE_OPS_TOTAL ].avg && + (cfg->buckets[THROTTLE_OPS_READ ].avg || + cfg->buckets[THROTTLE_OPS_WRITE ].avg); + + bps_max_flag = cfg->buckets[THROTTLE_BPS_TOTAL ].max && + (cfg->buckets[THROTTLE_BPS_READ ].max || + cfg->buckets[THROTTLE_BPS_WRITE ].max); + + ops_max_flag = cfg->buckets[THROTTLE_OPS_TOTAL ].max && + (cfg->buckets[THROTTLE_OPS_READ ].max || + cfg->buckets[THROTTLE_OPS_WRITE ].max); + +return bps_flag || ops_flag || bps_max_flag || ops_max_flag; +} + +/* check if a throttling configuration is valid +* @cfg: the throttling configuration to inspect +* @ret: true if valid else false +*/ +bool throttle_is_valid (ThrottleConfig *cfg) +{ +bool invalid = false; +int i; + +for (i =0 ; i <BUCKETS_COUNT ; i++) { +if (cfg->buckets[i].avg <0 ) { + invalid = true; + } + } + +for (i =0 ; i <BUCKETS_COUNT ; i++) { +if (cfg->buckets[i].max <0 ) { + invalid = true; + } + } + +return !invalid; +} + +/* fix bucket parameters */ +static void throttle_fix_bucket (LeakyBucket *bkt) +{ +double min; + +/* zero bucket level */ + bkt->level =0 ; + +/* The following is done to cope with the Linux CFQ block scheduler +* which regroup reads and writes by block of 100ms in the guest. +* When they are two process one making reads and one making writes cfq +* make a pattern looking like the following: +* WWWWWWWWWWWRRRRRRRRRRRRRRWWWWWWWWWWWWWwRRRRRRRRRRRRRRRRR +* Having a max burst value of 100ms of the average will help smooth the +* throttling +*/ + min = bkt->avg /10 ; +if (bkt->avg && !bkt->max) { + bkt->max = min; + } +} + +/* take care of canceling a timer */ +static void throttle_cancel_timer (QEMUTimer *timer) +{ +assert (timer !=NULL ); + +timer_del (timer); +} + +/* Used to configure the throttle +* +* @ts: the throttle state we are working on +* @cfg: the config to set +*/ +void throttle_config (ThrottleState *ts,ThrottleConfig *cfg) +{ +int i; + + ts->cfg = *cfg; + +for (i =0 ; i <BUCKETS_COUNT ; i++) { +throttle_fix_bucket (&ts->cfg.buckets[i]); + } + + ts->previous_leak =qemu_clock_get_ns (ts->clock_type); + +for (i =0 ; i <2 ; i++) { +throttle_cancel_timer (ts->timers[i]); + } +} + +/* used to get config +* +* @ts: the throttle state we are working on +* @cfg: the config to write +*/ +void throttle_get_config (ThrottleState *ts,ThrottleConfig *cfg) +{ + *cfg = ts->cfg; +} + + +/* Schedule the read or write timer if needed +* +* NOTE: this function is not unit tested due to it's usage of timer_mod +* +* @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) +{ +int64_t now =qemu_clock_get_ns (ts->clock_type); +int64_t next_timestamp; +bool must_wait; + + must_wait =throttle_compute_timer (ts, + is_write, + now, + &next_timestamp); + +/* request not throttled */ +if (!must_wait) { +return false; + } + +/* request throttled and timer pending -> do nothing */ +if (timer_pending (ts->timers[is_write])) { +return true; + } + +/* request throttled and timer not pending -> arm timer */ +timer_mod (ts->timers[is_write], next_timestamp); +return true; +} + +/* do the accounting for this operation +* +* @is_write: the type of operation (read/write)
util/throttle.c line 383
Quoted 10 lines
util/throttle.c new file +10
-0+* @size: the size of the operation +*/ +void throttle_account (ThrottleState *ts,bool is_write,uint64_t size) +{ +double units =1.0 ; + +/* if cfg.op_size is not defined we will account exactly 1 operation */ +if (ts->cfg.op_size) { + units = (double ) size / ts->cfg.op_size; + }
If op_size is non-zero, iops limits are merely a fixed proportion of bps limits, which means the lower set of the two is applied and the higher skipped. I understand the amazon uses op_size like accounting for big IO requests, but we don't do it condionally on io size or anything here, so that once user sets op_size, it simply kicks either bps_{,rd,wr} or iops_{,rd,wr} out the game, is that true?
Fam
Quoted 17 lines
util/throttle.c new file +13
-0+ + ts->cfg.buckets[THROTTLE_BPS_TOTAL ].level += size; + ts->cfg.buckets[THROTTLE_OPS_TOTAL ].level += units; + +if (is_write) { + ts->cfg.buckets[THROTTLE_BPS_WRITE ].level += size; + ts->cfg.buckets[THROTTLE_OPS_WRITE ].level += units; + }else { + ts->cfg.buckets[THROTTLE_BPS_READ ].level += size; + ts->cfg.buckets[THROTTLE_OPS_READ ].level += units; + } +} +Signature · 1 line
1.7.10.4
Re: [Qemu-devel] [PATCH V11 1/5] throttle: Add a new throttling API implementing continuous leaky bucket.
Quoted 6 lines
If
op_sizeis non-zero, iops limits are merely a fixed proportion of bps limits, which means the lower set of the two is applied and the higher skipped. I understand the amazon usesop_sizelike accounting for big IO requests, but we don't do it condionally on io size or anything here, so that once user setsop_size, it simply kicks either bps_{,rd,wr} or iops_{,rd,wr} out the game, is that true?
It will combine with iops_{,rd,wr}.
Best regards
Benoît
Re: [Qemu-devel] [PATCH V11 1/5] throttle: Add a new throttling API implementing continuous leaky bucket.
Il 02/09/2013 12:16, Benoît Canet ha scritto:
Quoted 7 lines
Quoted 6 lines
If
op_sizeis non-zero, iops limits are merely a fixed proportion of bpsQuoted 5 lines
limits, which means the lower set of the two is applied and the higher skipped. I understand the amazon uses
op_sizelike accounting for big IO requests, but we don't do it condionally on io size or anything here, so that once user setsop_size, it simply kicks either bps_{,rd,wr} or iops_{,rd,wr} out the game, is that true?It will combine with iops_{,rd,wr}.
I think what Fam asked is this:
what is the difference between bps=524288 and iops=1/op_size=524288?
And I think the answer should be that bs=524288 will allow many requests up to 524288 bytes, while with iops all requests should be rounded up to the op_size.
However, I think this is not what the code is doing right now, isn't it?
Paolo
Re: [Qemu-devel] [PATCH V11 1/5] throttle: Add a new throttling API implementing continuous leaky bucket.
Quoted 1 line
However, I think this is not what the code is doing right now, isn't it?
Hi Paolo,
I changed the code so it trigger only if the request size is bigger than op_size.
Best regards
Benoît
PATCH v11 2/5 throttle: Add units tests
In reply to Benoît Canet--- tests/Makefile | 2 + tests/test-throttle.c | 481 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 483 insertions(+) create mode 100644 tests/test-throttle.c
tests/Makefile +2 -0
@@ -29,6 +29,7 @@ check-unit-y += tests/test-visitor-serialization$(EXESUF) check-unit-y += tests/test-iov$(EXESUF) gcov-files-test-iov-y = util/iov.c check-unit-y += tests/test-aio$(EXESUF) +check-unit-y += tests/test-throttle$(EXESUF) gcov-files-test-aio-$(CONFIG_WIN32) = aio-win32.c gcov-files-test-aio-$(CONFIG_POSIX) = aio-posix.c check-unit-y += tests/test-thread-pool$(EXESUF)
@@ -117,6 +118,7 @@ tests/check-qfloat$(EXESUF): tests/check-qfloat.o libqemuutil.a tests/check-qjson$(EXESUF): tests/check-qjson.o libqemuutil.a libqemustub.a tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(block-obj-y) libqemuutil.a libqemustub.a tests/test-aio$(EXESUF): tests/test-aio.o $(block-obj-y) libqemuutil.a libqemustub.a +tests/test-throttle$(EXESUF): tests/test-throttle.o $(block-obj-y) libqemuutil.a libqemustub.a tests/test-thread-pool$(EXESUF): tests/test-thread-pool.o $(block-obj-y) libqemuutil.a libqemustub.a tests/test-iov$(EXESUF): tests/test-iov.o libqemuutil.a tests/test-hbitmap$(EXESUF): tests/test-hbitmap.o libqemuutil.a libqemustub.a
tests/test-throttle.c new file +481 -0
481 lines not on this page · raw message
Signature · 1 line
1.7.10.4
PATCH v11 3/5 block: Enable the new throttling code in the block layer.
In reply to Benoît Canet--- block.c | 338 +++++++++++++-------------------------------- block/qapi.c | 21 ++- blockdev.c | 100 ++++++++------ include/block/block.h | 1 - include/block/block_int.h | 32 +---- 5 files changed, 164 insertions(+), 328 deletions(-)
block.c +95 -243
@@ -86,13 +86,6 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque); static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,int64_t sector_num,int nb_sectors); -static bool bdrv_exceed_bps_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,double elapsed_time,uint64_t *wait); -static bool bdrv_exceed_iops_limits (BlockDriverState *bs,bool is_write, -double elapsed_time,uint64_t *wait); -static bool bdrv_exceed_io_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,int64_t *wait); - static QTAILQ_HEAD(, BlockDriverState) bdrv_states =QTAILQ_HEAD_INITIALIZER (bdrv_states);
@@ -123,69 +116,101 @@ int is_windows_drive(const char *filename)#endif /* throttling disk I/O limits */ -void bdrv_io_limits_disable (BlockDriverState *bs) +void bdrv_set_io_limits (BlockDriverState *bs, +ThrottleConfig *cfg) { - bs->io_limits_enabled = false; +int i; -do {}while (qemu_co_enter_next (&bs->throttled_reqs)); +throttle_config (&bs->throttle_state, cfg); -if (bs->block_timer) { -timer_del (bs->block_timer); -timer_free (bs->block_timer); - bs->block_timer =NULL ; +for (i =0 ; i <2 ; i++) { +qemu_co_enter_next (&bs->throttled_reqs[i]); } +} + +/* this function drain all the throttled IOs */ +static bool bdrv_start_throttled_reqs (BlockDriverState *bs) +{ +bool drained = false; +bool enabled = bs->io_limits_enabled; +int i; + + bs->io_limits_enabled = false; + +for (i =0 ; i <2 ; i++) { +while (qemu_co_enter_next (&bs->throttled_reqs[i])) { + drained = true; + } + } + + bs->io_limits_enabled = enabled; - bs->slice_start =0 ; - bs->slice_end =0 ; +return drained; } -static void bdrv_block_timer (void *opaque) +void bdrv_io_limits_disable (BlockDriverState *bs) { -BlockDriverState *bs = opaque; + bs->io_limits_enabled = false; -qemu_co_enter_next (&bs->throttled_reqs); +bdrv_start_throttled_reqs (bs); + +throttle_destroy (&bs->throttle_state); } -void bdrv_io_limits_enable (BlockDriverState *bs) +static void bdrv_throttle_read_timer_cb (void *opaque) { - bs->block_timer =timer_new_ns (QEMU_CLOCK_VIRTUAL , bdrv_block_timer, bs); - bs->io_limits_enabled = true; +BlockDriverState *bs = opaque; +qemu_co_enter_next (&bs->throttled_reqs[0 ]); } -bool bdrv_io_limits_enabled (BlockDriverState *bs) +static void bdrv_throttle_write_timer_cb (void *opaque) { -BlockIOLimit *io_limits = &bs->io_limits; -return io_limits->bps[BLOCK_IO_LIMIT_READ ] - || io_limits->bps[BLOCK_IO_LIMIT_WRITE ] - || io_limits->bps[BLOCK_IO_LIMIT_TOTAL ] - || io_limits->iops[BLOCK_IO_LIMIT_READ ] - || io_limits->iops[BLOCK_IO_LIMIT_WRITE ] - || io_limits->iops[BLOCK_IO_LIMIT_TOTAL ]; +BlockDriverState *bs = opaque; +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) +{ +assert (!bs->io_limits_enabled); +throttle_init (&bs->throttle_state, +QEMU_CLOCK_VIRTUAL , + bdrv_throttle_read_timer_cb, + bdrv_throttle_write_timer_cb, + bs); + bs->io_limits_enabled = true; +} + +/* This function makes an IO wait if needed +* +* @nb_sectors: the number of sectors of the IO +* @is_write: is the IO a write +*/ static void bdrv_io_limits_intercept (BlockDriverState *bs, -bool is_write,int nb_sectors) +int nb_sectors, +bool is_write) { -int64_t wait_time =-1 ; +/* does this io must wait */ +bool must_wait =throttle_schedule_timer (&bs->throttle_state, is_write); -if (!qemu_co_queue_empty (&bs->throttled_reqs)) { -qemu_co_queue_wait (&bs->throttled_reqs); +/* 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])) { +qemu_co_queue_wait (&bs->throttled_reqs[is_write]); } -/* In fact, we hope to keep each request's timing, in FIFO mode. The next -* throttled requests will not be dequeued until the current request is -* allowed to be serviced. So if the current request still exceeds the -* limits, it will be inserted to the head. All requests followed it will -* be still in throttled_reqs queue. -*/ +/* the IO will be executed, do the accounting */ +throttle_account (&bs->throttle_state, + is_write, + nb_sectors *BDRV_SECTOR_SIZE ); -while (bdrv_exceed_io_limits (bs, nb_sectors, is_write, &wait_time)) { -timer_mod (bs->block_timer, - wait_time +qemu_clock_get_ns (QEMU_CLOCK_VIRTUAL )); -qemu_co_queue_wait_insert_head (&bs->throttled_reqs); +/* if the next request must wait -> do nothing */ +if (throttle_schedule_timer (&bs->throttle_state, is_write)) { +return ; } -qemu_co_queue_next (&bs->throttled_reqs); +/* else queue next request for execution */ +qemu_co_queue_next (&bs->throttled_reqs[is_write]); }/* check if the path starts with "<protocol>:" */
@@ -305,7 +330,8 @@ BlockDriverState *bdrv_new(const char *device_name)bdrv_iostatus_disable (bs);notifier_list_init (&bs->close_notifiers);notifier_with_return_list_init (&bs->before_write_notifiers); -qemu_co_queue_init (&bs->throttled_reqs); +qemu_co_queue_init (&bs->throttled_reqs[0 ]); +qemu_co_queue_init (&bs->throttled_reqs[1 ]);return bs; }
@@ -1113,11 +1139,6 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,bdrv_dev_change_media_cb (bs, true); } -/* throttling disk I/O limits */ -if (bs->io_limits_enabled) { -bdrv_io_limits_enable (bs); - } -return 0 ; unlink_and_fail:
@@ -1436,7 +1457,10 @@ static bool bdrv_requests_pending(BlockDriverState *bs)if (!QLIST_EMPTY (&bs->tracked_requests)) {return true; } -if (!qemu_co_queue_empty (&bs->throttled_reqs)) { +if (!qemu_co_queue_empty (&bs->throttled_reqs[0 ])) { +return true; + } +if (!qemu_co_queue_empty (&bs->throttled_reqs[1 ])) {return true; }if (bs->file &&bdrv_requests_pending (bs->file)) {
@@ -1482,7 +1506,7 @@ void bdrv_drain_all(void)* a busy wait. */ QTAILQ_FOREACH(bs, &bdrv_states, list) { -while (qemu_co_enter_next (&bs->throttled_reqs)) { +if (bdrv_start_throttled_reqs (bs)) { busy = true; } }
@@ -1524,13 +1548,12 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, bs_dest->enable_write_cache = bs_src->enable_write_cache; -/* i/o timing parameters */ - bs_dest->slice_start = bs_src->slice_start; - bs_dest->slice_end = bs_src->slice_end; - bs_dest->slice_submitted = bs_src->slice_submitted; - bs_dest->io_limits = bs_src->io_limits; - bs_dest->throttled_reqs = bs_src->throttled_reqs; - bs_dest->block_timer = bs_src->block_timer; +/* i/o throttled req */ +memcpy (&bs_dest->throttle_state, + &bs_src->throttle_state, +sizeof (ThrottleState)); + 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 */
@@ -1577,7 +1600,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)assert (bs_new->dev ==NULL );assert (bs_new->in_use ==0 );assert (bs_new->io_limits_enabled == false); -assert (bs_new->block_timer ==NULL ); +assert (!throttle_have_timer (&bs_new->throttle_state)); tmp = *bs_new; *bs_new = *bs_old;
@@ -1596,7 +1619,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)assert (bs_new->job ==NULL );assert (bs_new->in_use ==0 );assert (bs_new->io_limits_enabled == false); -assert (bs_new->block_timer ==NULL ); +assert (!throttle_have_timer (&bs_new->throttle_state));bdrv_rebind (bs_new);bdrv_rebind (bs_old);
@@ -2539,11 +2562,6 @@ static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,return -EIO ; } -/* throttling disk read I/O */ -if (bs->io_limits_enabled) { -bdrv_io_limits_intercept (bs, false, nb_sectors); - } -if (bs->copy_on_read) { flags |=BDRV_REQ_COPY_ON_READ ; }
@@ -2555,6 +2573,11 @@ static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,wait_for_overlapping_requests (bs, sector_num, nb_sectors); } +/* throttling disk I/O */ +if (bs->io_limits_enabled) { +bdrv_io_limits_intercept (bs, nb_sectors, false); + } +tracked_request_begin (&req, bs, sector_num, nb_sectors, false);if (flags &BDRV_REQ_COPY_ON_READ ) {
@@ -2680,15 +2703,15 @@ static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,return -EIO ; } -/* throttling disk write I/O */ -if (bs->io_limits_enabled) { -bdrv_io_limits_intercept (bs, true, nb_sectors); - } -if (bs->copy_on_read_in_flight) {wait_for_overlapping_requests (bs, sector_num, nb_sectors); } +/* throttling disk I/O */ +if (bs->io_limits_enabled) { +bdrv_io_limits_intercept (bs, nb_sectors, true); + } +tracked_request_begin (&req, bs, sector_num, nb_sectors, true); ret =notifier_with_return_list_notify (&bs->before_write_notifiers, &req);
@@ -2806,14 +2829,6 @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) *nb_sectors_ptr = length; } -/* throttling disk io limits */ -void bdrv_set_io_limits (BlockDriverState *bs, -BlockIOLimit *io_limits) -{ - bs->io_limits = *io_limits; - bs->io_limits_enabled =bdrv_io_limits_enabled (bs); -} -void bdrv_set_on_error (BlockDriverState *bs,BlockdevOnError on_read_error,BlockdevOnError on_write_error) {
@@ -3623,169 +3638,6 @@ void bdrv_aio_cancel(BlockDriverAIOCB *acb) acb->aiocb_info->cancel (acb); } -/* block I/O throttling */ -static bool bdrv_exceed_bps_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,double elapsed_time,uint64_t *wait) -{ -uint64_t bps_limit =0 ; -uint64_t extension; -double bytes_limit, bytes_base, bytes_res; -double slice_time, wait_time; - -if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]) { - bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]; - }else if (bs->io_limits.bps[is_write]) { - bps_limit = bs->io_limits.bps[is_write]; - }else { -if (wait) { - *wait =0 ; - } - -return false; - } - - slice_time = bs->slice_end - bs->slice_start; - slice_time /= (NANOSECONDS_PER_SECOND ); - bytes_limit = bps_limit * slice_time; - bytes_base = bs->slice_submitted.bytes[is_write]; -if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]) { - bytes_base += bs->slice_submitted.bytes[!is_write]; - } - -/* bytes_base: the bytes of data which have been read/written; and -* it is obtained from the history statistic info. -* bytes_res: the remaining bytes of data which need to be read/written. -* (bytes_base + bytes_res) / bps_limit: used to calcuate -* the total time for completing reading/writting all data. -*/ - bytes_res = (unsigned ) nb_sectors *BDRV_SECTOR_SIZE ; - -if (bytes_base + bytes_res <= bytes_limit) { -if (wait) { - *wait =0 ; - } - -return false; - } - -/* Calc approx time to dispatch */ - wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time; - -/* When the I/O rate at runtime exceeds the limits, -* bs->slice_end need to be extended in order that the current statistic -* info can be kept until the timer fire, so it is increased and tuned -* based on the result of experiment. -*/ - extension = wait_time *NANOSECONDS_PER_SECOND ; - extension =DIV_ROUND_UP (extension,BLOCK_IO_SLICE_TIME ) * -BLOCK_IO_SLICE_TIME ; - bs->slice_end += extension; -if (wait) { - *wait = wait_time *NANOSECONDS_PER_SECOND ; - } - -return true; -} - -static bool bdrv_exceed_iops_limits (BlockDriverState *bs,bool is_write, -double elapsed_time,uint64_t *wait) -{ -uint64_t iops_limit =0 ; -double ios_limit, ios_base; -double slice_time, wait_time; - -if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]) { - iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]; - }else if (bs->io_limits.iops[is_write]) { - iops_limit = bs->io_limits.iops[is_write]; - }else { -if (wait) { - *wait =0 ; - } - -return false; - } - - slice_time = bs->slice_end - bs->slice_start; - slice_time /= (NANOSECONDS_PER_SECOND ); - ios_limit = iops_limit * slice_time; - ios_base = bs->slice_submitted.ios[is_write]; -if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]) { - ios_base += bs->slice_submitted.ios[!is_write]; - } - -if (ios_base +1 <= ios_limit) { -if (wait) { - *wait =0 ; - } - -return false; - } - -/* Calc approx time to dispatch, in seconds */ - wait_time = (ios_base +1 ) / iops_limit; -if (wait_time > elapsed_time) { - wait_time = wait_time - elapsed_time; - }else { - wait_time =0 ; - } - -/* Exceeded current slice, extend it by another slice time */ - bs->slice_end +=BLOCK_IO_SLICE_TIME ; -if (wait) { - *wait = wait_time *NANOSECONDS_PER_SECOND ; - } - -return true; -} - -static bool bdrv_exceed_io_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,int64_t *wait) -{ -int64_t now, max_wait; -uint64_t bps_wait =0 , iops_wait =0 ; -double elapsed_time; -int bps_ret, iops_ret; - - now =qemu_clock_get_ns (QEMU_CLOCK_VIRTUAL ); -if (now > bs->slice_end) { - bs->slice_start = now; - bs->slice_end = now +BLOCK_IO_SLICE_TIME ; -memset (&bs->slice_submitted,0 ,sizeof (bs->slice_submitted)); - } - - elapsed_time = now - bs->slice_start; - elapsed_time /= (NANOSECONDS_PER_SECOND ); - - bps_ret =bdrv_exceed_bps_limits (bs, nb_sectors, - is_write, elapsed_time, &bps_wait); - iops_ret =bdrv_exceed_iops_limits (bs, is_write, - elapsed_time, &iops_wait); -if (bps_ret || iops_ret) { - max_wait = bps_wait > iops_wait ? bps_wait : iops_wait; -if (wait) { - *wait = max_wait; - } - - now =qemu_clock_get_ns (QEMU_CLOCK_VIRTUAL ); -if (bs->slice_end < now + max_wait) { - bs->slice_end = now + max_wait; - } - -return true; - } - -if (wait) { - *wait =0 ; - } - - bs->slice_submitted.bytes[is_write] += (int64_t )nb_sectors * -BDRV_SECTOR_SIZE ; - bs->slice_submitted.ios[is_write]++; - -return false; -} -/**************************************************************/ /* async block device emulation */
block/qapi.c +9 -12
@@ -223,18 +223,15 @@ void bdrv_query_info(BlockDriverState *bs, info->inserted->backing_file_depth =bdrv_get_backing_file_depth (bs);if (bs->io_limits_enabled) { - info->inserted->bps = - bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]; - info->inserted->bps_rd = - bs->io_limits.bps[BLOCK_IO_LIMIT_READ ]; - info->inserted->bps_wr = - bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE ]; - info->inserted->iops = - bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]; - info->inserted->iops_rd = - bs->io_limits.iops[BLOCK_IO_LIMIT_READ ]; - info->inserted->iops_wr = - bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE ]; +ThrottleConfig cfg; +throttle_get_config (&bs->throttle_state, &cfg); + info->inserted->bps = cfg.buckets[THROTTLE_BPS_TOTAL ].avg; + info->inserted->bps_rd = cfg.buckets[THROTTLE_BPS_READ ].avg; + info->inserted->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE ].avg; + + info->inserted->iops = cfg.buckets[THROTTLE_OPS_TOTAL ].avg; + info->inserted->iops_rd = cfg.buckets[THROTTLE_OPS_READ ].avg; + info->inserted->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE ].avg; } bs0 = bs;
blockdev.c +54 -46
154 lines not on this page · raw message
include/block/block.h +0 -1
@@ -107,7 +107,6 @@ void bdrv_info_stats(Monitor *mon, QObject **ret_data);/* disk I/O throttling */ void bdrv_io_limits_enable (BlockDriverState *bs);void bdrv_io_limits_disable (BlockDriverState *bs); -bool bdrv_io_limits_enabled (BlockDriverState *bs);void bdrv_init (void );void bdrv_init_with_whitelist (void );
include/block/block_int.h +6 -26
@@ -35,18 +35,12 @@#include "qemu/hbitmap.h" #include "block/snapshot.h" #include "qemu/main-loop.h" +#include "qemu/throttle.h" #define BLOCK_FLAG_ENCRYPT 1#define BLOCK_FLAG_COMPAT6 4#define BLOCK_FLAG_LAZY_REFCOUNTS 8 -#define BLOCK_IO_LIMIT_READ 0 -#define BLOCK_IO_LIMIT_WRITE 1 -#define BLOCK_IO_LIMIT_TOTAL 2 - -#define BLOCK_IO_SLICE_TIME 100000000 -#define NANOSECONDS_PER_SECOND 1000000000.0 -#define BLOCK_OPT_SIZE "size"#define BLOCK_OPT_ENCRYPT "encryption"#define BLOCK_OPT_COMPAT6 "compat6"
@@ -70,17 +64,6 @@ typedef struct BdrvTrackedRequest {CoQueue wait_queue;/* coroutines blocked on this request */ } BdrvTrackedRequest; - -typedef struct BlockIOLimit { -int64_t bps[3 ]; -int64_t iops[3 ]; -}BlockIOLimit ; - -typedef struct BlockIOBaseValue { -uint64_t bytes[2 ]; -uint64_t ios[2 ]; -}BlockIOBaseValue ; -struct BlockDriver {const char *format_name;int instance_size;
@@ -264,13 +247,9 @@ struct BlockDriverState {/* number of in-flight copy-on-read requests */ unsigned int copy_on_read_in_flight; -/* the time for latest disk I/O */ -int64_t slice_start; -int64_t slice_end; -BlockIOLimit io_limits; -BlockIOBaseValue slice_submitted; -CoQueue throttled_reqs; -QEMUTimer *block_timer; +/* I/O throttling */ +ThrottleState throttle_state; +CoQueue throttled_reqs[2 ];bool io_limits_enabled;/* I/O stats (display with "info blockstats"). */
@@ -312,7 +291,8 @@ struct BlockDriverState {int get_tmp_filename (char *filename,int size);void bdrv_set_io_limits (BlockDriverState *bs, -BlockIOLimit *io_limits); +ThrottleConfig *cfg); +/** * bdrv_add_before_write_notifier:
Signature · 1 line
1.7.10.4
Re: [Qemu-devel] [PATCH V11 3/5] block: Enable the new throttling code in the block layer.
Quoted 42 lines · Benoît Canet
Signed-off-by Benoit Canet <[email protected]>--- block.c | 338 +++++++++++++-------------------------------- block/qapi.c | 21 ++- blockdev.c | 100 ++++++++------ include/block/block.h | 1 - include/block/block_int.h | 32 +---- 5 files changed, 164 insertions(+), 328 deletions(-)block.c +4
-11@@ -86,13 +86,6 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque); static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,int64_t sector_num,int nb_sectors); -static bool bdrv_exceed_bps_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,double elapsed_time,uint64_t *wait); -static bool bdrv_exceed_iops_limits (BlockDriverState *bs,bool is_write, -double elapsed_time,uint64_t *wait); -static bool bdrv_exceed_io_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,int64_t *wait); - static QTAILQ_HEAD(, BlockDriverState) bdrv_states =QTAILQ_HEAD_INITIALIZER (bdrv_states);@@ -123,69 +116,101 @@ int is_windows_drive(const char *filename)#endif /* throttling disk I/O limits */ -void bdrv_io_limits_disable (BlockDriverState *bs) +void bdrv_set_io_limits (BlockDriverState *bs, +ThrottleConfig *cfg) { - bs->io_limits_enabled = false; +int i; -do {}while (qemu_co_enter_next (&bs->throttled_reqs)); +throttle_config (&bs->throttle_state, cfg); -if (bs->block_timer) {
block.c int is_windows_drive(const char *filename) · line 132
Quoted 10 lines
block.c +6
-3-timer_del (bs->block_timer); -timer_free (bs->block_timer); - bs->block_timer =NULL ; +for (i =0 ; i <2 ; i++) { +qemu_co_enter_next (&bs->throttled_reqs[i]); } +} + +/* this function drain all the throttled IOs */ +static bool bdrv_start_throttled_reqs (BlockDriverState *bs)
This function is to drain the throttled reqs, but named start_throttled_reqs, why?
Quoted 475 lines
block.c +85
-229+{ +bool drained = false; +bool enabled = bs->io_limits_enabled; +int i; + + bs->io_limits_enabled = false; + +for (i =0 ; i <2 ; i++) { +while (qemu_co_enter_next (&bs->throttled_reqs[i])) { + drained = true; + } + } + + bs->io_limits_enabled = enabled; - bs->slice_start =0 ; - bs->slice_end =0 ; +return drained; } -static void bdrv_block_timer (void *opaque) +void bdrv_io_limits_disable (BlockDriverState *bs) { -BlockDriverState *bs = opaque; + bs->io_limits_enabled = false; -qemu_co_enter_next (&bs->throttled_reqs); +bdrv_start_throttled_reqs (bs); + +throttle_destroy (&bs->throttle_state); } -void bdrv_io_limits_enable (BlockDriverState *bs) +static void bdrv_throttle_read_timer_cb (void *opaque) { - bs->block_timer =timer_new_ns (QEMU_CLOCK_VIRTUAL , bdrv_block_timer, bs); - bs->io_limits_enabled = true; +BlockDriverState *bs = opaque; +qemu_co_enter_next (&bs->throttled_reqs[0 ]); } -bool bdrv_io_limits_enabled (BlockDriverState *bs) +static void bdrv_throttle_write_timer_cb (void *opaque) { -BlockIOLimit *io_limits = &bs->io_limits; -return io_limits->bps[BLOCK_IO_LIMIT_READ ] - || io_limits->bps[BLOCK_IO_LIMIT_WRITE ] - || io_limits->bps[BLOCK_IO_LIMIT_TOTAL ] - || io_limits->iops[BLOCK_IO_LIMIT_READ ] - || io_limits->iops[BLOCK_IO_LIMIT_WRITE ] - || io_limits->iops[BLOCK_IO_LIMIT_TOTAL ]; +BlockDriverState *bs = opaque; +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) +{ +assert (!bs->io_limits_enabled); +throttle_init (&bs->throttle_state, +QEMU_CLOCK_VIRTUAL , + bdrv_throttle_read_timer_cb, + bdrv_throttle_write_timer_cb, + bs); + bs->io_limits_enabled = true; +} + +/* This function makes an IO wait if needed +* +* @nb_sectors: the number of sectors of the IO +* @is_write: is the IO a write +*/ static void bdrv_io_limits_intercept (BlockDriverState *bs, -bool is_write,int nb_sectors) +int nb_sectors, +bool is_write) { -int64_t wait_time =-1 ; +/* does this io must wait */ +bool must_wait =throttle_schedule_timer (&bs->throttle_state, is_write); -if (!qemu_co_queue_empty (&bs->throttled_reqs)) { -qemu_co_queue_wait (&bs->throttled_reqs); +/* 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])) { +qemu_co_queue_wait (&bs->throttled_reqs[is_write]); } -/* In fact, we hope to keep each request's timing, in FIFO mode. The next -* throttled requests will not be dequeued until the current request is -* allowed to be serviced. So if the current request still exceeds the -* limits, it will be inserted to the head. All requests followed it will -* be still in throttled_reqs queue. -*/ +/* the IO will be executed, do the accounting */ +throttle_account (&bs->throttle_state, + is_write, + nb_sectors *BDRV_SECTOR_SIZE ); -while (bdrv_exceed_io_limits (bs, nb_sectors, is_write, &wait_time)) { -timer_mod (bs->block_timer, - wait_time +qemu_clock_get_ns (QEMU_CLOCK_VIRTUAL )); -qemu_co_queue_wait_insert_head (&bs->throttled_reqs); +/* if the next request must wait -> do nothing */ +if (throttle_schedule_timer (&bs->throttle_state, is_write)) { +return ; } -qemu_co_queue_next (&bs->throttled_reqs); +/* else queue next request for execution */ +qemu_co_queue_next (&bs->throttled_reqs[is_write]); }/* check if the path starts with "<protocol>:" */ @@ -305,7 +330,8 @@ BlockDriverState *bdrv_new(const char *device_name)bdrv_iostatus_disable (bs);notifier_list_init (&bs->close_notifiers);notifier_with_return_list_init (&bs->before_write_notifiers); -qemu_co_queue_init (&bs->throttled_reqs); +qemu_co_queue_init (&bs->throttled_reqs[0 ]); +qemu_co_queue_init (&bs->throttled_reqs[1 ]);return bs; }@@ -1113,11 +1139,6 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,bdrv_dev_change_media_cb (bs, true); } -/* throttling disk I/O limits */ -if (bs->io_limits_enabled) { -bdrv_io_limits_enable (bs); - } -return 0 ; unlink_and_fail:@@ -1436,7 +1457,10 @@ static bool bdrv_requests_pending(BlockDriverState *bs)if (!QLIST_EMPTY (&bs->tracked_requests)) {return true; } -if (!qemu_co_queue_empty (&bs->throttled_reqs)) { +if (!qemu_co_queue_empty (&bs->throttled_reqs[0 ])) { +return true; + } +if (!qemu_co_queue_empty (&bs->throttled_reqs[1 ])) {return true; }if (bs->file &&bdrv_requests_pending (bs->file)) {@@ -1482,7 +1506,7 @@ void bdrv_drain_all(void)* a busy wait. */ QTAILQ_FOREACH(bs, &bdrv_states, list) { -while (qemu_co_enter_next (&bs->throttled_reqs)) { +if (bdrv_start_throttled_reqs (bs)) { busy = true; } }@@ -1524,13 +1548,12 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, bs_dest->enable_write_cache = bs_src->enable_write_cache; -/* i/o timing parameters */ - bs_dest->slice_start = bs_src->slice_start; - bs_dest->slice_end = bs_src->slice_end; - bs_dest->slice_submitted = bs_src->slice_submitted; - bs_dest->io_limits = bs_src->io_limits; - bs_dest->throttled_reqs = bs_src->throttled_reqs; - bs_dest->block_timer = bs_src->block_timer; +/* i/o throttled req */ +memcpy (&bs_dest->throttle_state, + &bs_src->throttle_state, +sizeof (ThrottleState)); + 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 */ @@ -1577,7 +1600,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)assert (bs_new->dev ==NULL );assert (bs_new->in_use ==0 );assert (bs_new->io_limits_enabled == false); -assert (bs_new->block_timer ==NULL ); +assert (!throttle_have_timer (&bs_new->throttle_state)); tmp = *bs_new; *bs_new = *bs_old;@@ -1596,7 +1619,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)assert (bs_new->job ==NULL );assert (bs_new->in_use ==0 );assert (bs_new->io_limits_enabled == false); -assert (bs_new->block_timer ==NULL ); +assert (!throttle_have_timer (&bs_new->throttle_state));bdrv_rebind (bs_new);bdrv_rebind (bs_old);@@ -2539,11 +2562,6 @@ static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,return -EIO ; } -/* throttling disk read I/O */ -if (bs->io_limits_enabled) { -bdrv_io_limits_intercept (bs, false, nb_sectors); - } -if (bs->copy_on_read) { flags |=BDRV_REQ_COPY_ON_READ ; }@@ -2555,6 +2573,11 @@ static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,wait_for_overlapping_requests (bs, sector_num, nb_sectors); } +/* throttling disk I/O */ +if (bs->io_limits_enabled) { +bdrv_io_limits_intercept (bs, nb_sectors, false); + } +tracked_request_begin (&req, bs, sector_num, nb_sectors, false);if (flags &BDRV_REQ_COPY_ON_READ ) {@@ -2680,15 +2703,15 @@ static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,return -EIO ; } -/* throttling disk write I/O */ -if (bs->io_limits_enabled) { -bdrv_io_limits_intercept (bs, true, nb_sectors); - } -if (bs->copy_on_read_in_flight) {wait_for_overlapping_requests (bs, sector_num, nb_sectors); } +/* throttling disk I/O */ +if (bs->io_limits_enabled) { +bdrv_io_limits_intercept (bs, nb_sectors, true); + } +tracked_request_begin (&req, bs, sector_num, nb_sectors, true); ret =notifier_with_return_list_notify (&bs->before_write_notifiers, &req);@@ -2806,14 +2829,6 @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) *nb_sectors_ptr = length; } -/* throttling disk io limits */ -void bdrv_set_io_limits (BlockDriverState *bs, -BlockIOLimit *io_limits) -{ - bs->io_limits = *io_limits; - bs->io_limits_enabled =bdrv_io_limits_enabled (bs); -} -void bdrv_set_on_error (BlockDriverState *bs,BlockdevOnError on_read_error,BlockdevOnError on_write_error) {@@ -3623,169 +3638,6 @@ void bdrv_aio_cancel(BlockDriverAIOCB *acb) acb->aiocb_info->cancel (acb); } -/* block I/O throttling */ -static bool bdrv_exceed_bps_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,double elapsed_time,uint64_t *wait) -{ -uint64_t bps_limit =0 ; -uint64_t extension; -double bytes_limit, bytes_base, bytes_res; -double slice_time, wait_time; - -if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]) { - bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]; - }else if (bs->io_limits.bps[is_write]) { - bps_limit = bs->io_limits.bps[is_write]; - }else { -if (wait) { - *wait =0 ; - } - -return false; - } - - slice_time = bs->slice_end - bs->slice_start; - slice_time /= (NANOSECONDS_PER_SECOND ); - bytes_limit = bps_limit * slice_time; - bytes_base = bs->slice_submitted.bytes[is_write]; -if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]) { - bytes_base += bs->slice_submitted.bytes[!is_write]; - } - -/* bytes_base: the bytes of data which have been read/written; and -* it is obtained from the history statistic info. -* bytes_res: the remaining bytes of data which need to be read/written. -* (bytes_base + bytes_res) / bps_limit: used to calcuate -* the total time for completing reading/writting all data. -*/ - bytes_res = (unsigned ) nb_sectors *BDRV_SECTOR_SIZE ; - -if (bytes_base + bytes_res <= bytes_limit) { -if (wait) { - *wait =0 ; - } - -return false; - } - -/* Calc approx time to dispatch */ - wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time; - -/* When the I/O rate at runtime exceeds the limits, -* bs->slice_end need to be extended in order that the current statistic -* info can be kept until the timer fire, so it is increased and tuned -* based on the result of experiment. -*/ - extension = wait_time *NANOSECONDS_PER_SECOND ; - extension =DIV_ROUND_UP (extension,BLOCK_IO_SLICE_TIME ) * -BLOCK_IO_SLICE_TIME ; - bs->slice_end += extension; -if (wait) { - *wait = wait_time *NANOSECONDS_PER_SECOND ; - } - -return true; -} - -static bool bdrv_exceed_iops_limits (BlockDriverState *bs,bool is_write, -double elapsed_time,uint64_t *wait) -{ -uint64_t iops_limit =0 ; -double ios_limit, ios_base; -double slice_time, wait_time; - -if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]) { - iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]; - }else if (bs->io_limits.iops[is_write]) { - iops_limit = bs->io_limits.iops[is_write]; - }else { -if (wait) { - *wait =0 ; - } - -return false; - } - - slice_time = bs->slice_end - bs->slice_start; - slice_time /= (NANOSECONDS_PER_SECOND ); - ios_limit = iops_limit * slice_time; - ios_base = bs->slice_submitted.ios[is_write]; -if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]) { - ios_base += bs->slice_submitted.ios[!is_write]; - } - -if (ios_base +1 <= ios_limit) { -if (wait) { - *wait =0 ; - } - -return false; - } - -/* Calc approx time to dispatch, in seconds */ - wait_time = (ios_base +1 ) / iops_limit; -if (wait_time > elapsed_time) { - wait_time = wait_time - elapsed_time; - }else { - wait_time =0 ; - } - -/* Exceeded current slice, extend it by another slice time */ - bs->slice_end +=BLOCK_IO_SLICE_TIME ; -if (wait) { - *wait = wait_time *NANOSECONDS_PER_SECOND ; - } - -return true; -} - -static bool bdrv_exceed_io_limits (BlockDriverState *bs,int nb_sectors, -bool is_write,int64_t *wait) -{ -int64_t now, max_wait; -uint64_t bps_wait =0 , iops_wait =0 ; -double elapsed_time; -int bps_ret, iops_ret; - - now =qemu_clock_get_ns (QEMU_CLOCK_VIRTUAL ); -if (now > bs->slice_end) { - bs->slice_start = now; - bs->slice_end = now +BLOCK_IO_SLICE_TIME ; -memset (&bs->slice_submitted,0 ,sizeof (bs->slice_submitted)); - } - - elapsed_time = now - bs->slice_start; - elapsed_time /= (NANOSECONDS_PER_SECOND ); - - bps_ret =bdrv_exceed_bps_limits (bs, nb_sectors, - is_write, elapsed_time, &bps_wait); - iops_ret =bdrv_exceed_iops_limits (bs, is_write, - elapsed_time, &iops_wait); -if (bps_ret || iops_ret) { - max_wait = bps_wait > iops_wait ? bps_wait : iops_wait; -if (wait) { - *wait = max_wait; - } - - now =qemu_clock_get_ns (QEMU_CLOCK_VIRTUAL ); -if (bs->slice_end < now + max_wait) { - bs->slice_end = now + max_wait; - } - -return true; - } - -if (wait) { - *wait =0 ; - } - - bs->slice_submitted.bytes[is_write] += (int64_t )nb_sectors * -BDRV_SECTOR_SIZE ; - bs->slice_submitted.ios[is_write]++; - -return false; -} -/**************************************************************/ /* async block device emulation */ block/qapi.c +9
-12@@ -223,18 +223,15 @@ void bdrv_query_info(BlockDriverState *bs, info->inserted->backing_file_depth =bdrv_get_backing_file_depth (bs);if (bs->io_limits_enabled) { - info->inserted->bps = - bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL ]; - info->inserted->bps_rd = - bs->io_limits.bps[BLOCK_IO_LIMIT_READ ]; - info->inserted->bps_wr = - bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE ]; - info->inserted->iops = - bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]; - info->inserted->iops_rd = - bs->io_limits.iops[BLOCK_IO_LIMIT_READ ]; - info->inserted->iops_wr = - bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE ]; +ThrottleConfig cfg; +throttle_get_config (&bs->throttle_state, &cfg); + info->inserted->bps = cfg.buckets[THROTTLE_BPS_TOTAL ].avg; + info->inserted->bps_rd = cfg.buckets[THROTTLE_BPS_READ ].avg; + info->inserted->bps_wr = cfg.buckets[THROTTLE_BPS_WRITE ].avg; + + info->inserted->iops = cfg.buckets[THROTTLE_OPS_TOTAL ].avg; + info->inserted->iops_rd = cfg.buckets[THROTTLE_OPS_READ ].avg; + info->inserted->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE ].avg; } bs0 = bs;blockdev.c +1
-7@@ -281,32 +281,16 @@ static int parse_block_error_action(const char *buf, bool is_read) } } -static bool do_check_io_limits (BlockIOLimit *io_limits,Error **errp) +static bool check_throttle_config (ThrottleConfig *cfg,Error **errp) { -bool bps_flag; -bool iops_flag; - -assert (io_limits); - - bps_flag = (io_limits->bps[BLOCK_IO_LIMIT_TOTAL ] !=0 )
blockdev.c static int parse_block_error_action(const char *buf, bool is_read) · line 288
Quoted 10 lines
blockdev.c +2
-7- && ((io_limits->bps[BLOCK_IO_LIMIT_READ ] !=0 ) - || (io_limits->bps[BLOCK_IO_LIMIT_WRITE ] !=0 )); - iops_flag = (io_limits->iops[BLOCK_IO_LIMIT_TOTAL ] !=0 ) - && ((io_limits->iops[BLOCK_IO_LIMIT_READ ] !=0 ) - || (io_limits->iops[BLOCK_IO_LIMIT_WRITE ] !=0 )); -if (bps_flag || iops_flag) { -error_setg (errp,"bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) " +if (throttle_conflicting (cfg)) { +error_setg (errp,"bps/iops/max total values and read/write values" "cannot be used at the same time" );
The string is concatenated as:
"bps/iops/max total values and read/write valuescannot be used at the same time"
Missing space at here: ^
Quoted 222 lines
blockdev.c +51
-32return false; } -if (io_limits->bps[BLOCK_IO_LIMIT_TOTAL ] <0 || - io_limits->bps[BLOCK_IO_LIMIT_WRITE ] <0 || - io_limits->bps[BLOCK_IO_LIMIT_READ ] <0 || - io_limits->iops[BLOCK_IO_LIMIT_TOTAL ] <0 || - io_limits->iops[BLOCK_IO_LIMIT_WRITE ] <0 || - io_limits->iops[BLOCK_IO_LIMIT_READ ] <0 ) { -error_setg (errp,"bps and iops values must be 0 or greater" ); +if (!throttle_is_valid (cfg)) { +error_setg (errp,"bps/iops/maxs values must be 0 or greater" );return false; }@@ -331,7 +315,7 @@ static DriveInfo *blockdev_init(QemuOpts *all_opts,int on_read_error, on_write_error;const char *devaddr;DriveInfo *dinfo; -BlockIOLimit io_limits; +ThrottleConfig cfg;int snapshot =0 ;bool copy_on_read;int ret;@@ -497,20 +481,31 @@ static DriveInfo *blockdev_init(QemuOpts *all_opts, }/* disk I/O throttling */ - io_limits.bps[BLOCK_IO_LIMIT_TOTAL ] = +memset (&cfg,0 ,sizeof (cfg)); + cfg.buckets[THROTTLE_BPS_TOTAL ].avg =qemu_opt_get_number (opts,"throttling.bps-total" ,0 ); - io_limits.bps[BLOCK_IO_LIMIT_READ ] = + cfg.buckets[THROTTLE_BPS_READ ].avg =qemu_opt_get_number (opts,"throttling.bps-read" ,0 ); - io_limits.bps[BLOCK_IO_LIMIT_WRITE ] = + cfg.buckets[THROTTLE_BPS_WRITE ].avg =qemu_opt_get_number (opts,"throttling.bps-write" ,0 ); - io_limits.iops[BLOCK_IO_LIMIT_TOTAL ] = + cfg.buckets[THROTTLE_OPS_TOTAL ].avg =qemu_opt_get_number (opts,"throttling.iops-total" ,0 ); - io_limits.iops[BLOCK_IO_LIMIT_READ ] = + cfg.buckets[THROTTLE_OPS_READ ].avg =qemu_opt_get_number (opts,"throttling.iops-read" ,0 ); - io_limits.iops[BLOCK_IO_LIMIT_WRITE ] = + cfg.buckets[THROTTLE_OPS_WRITE ].avg =qemu_opt_get_number (opts,"throttling.iops-write" ,0 ); -if (!do_check_io_limits (&io_limits, &error)) { + cfg.buckets[THROTTLE_BPS_TOTAL ].max =0 ; + cfg.buckets[THROTTLE_BPS_READ ].max =0 ; + cfg.buckets[THROTTLE_BPS_WRITE ].max =0 ; + + cfg.buckets[THROTTLE_OPS_TOTAL ].max =0 ; + cfg.buckets[THROTTLE_OPS_READ ].max =0 ; + cfg.buckets[THROTTLE_OPS_WRITE ].max =0 ; + + cfg.op_size =0 ; + +if (!check_throttle_config (&cfg, &error)) {error_report ("%s" ,error_get_pretty (error));error_free (error);return NULL ;@@ -637,7 +632,10 @@ static DriveInfo *blockdev_init(QemuOpts *all_opts,bdrv_set_on_error (dinfo->bdrv, on_read_error, on_write_error);/* disk I/O throttling */ -bdrv_set_io_limits (dinfo->bdrv, &io_limits); +if (throttle_enabled (&cfg)) { +bdrv_io_limits_enable (dinfo->bdrv); +bdrv_set_io_limits (dinfo->bdrv, &cfg); + }switch (type) {case IF_IDE :@@ -1271,7 +1269,7 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, int64_t bps_wr, int64_t iops, int64_t iops_rd, int64_t iops_wr, Error **errp) { - BlockIOLimit io_limits; + ThrottleConfig cfg;BlockDriverState *bs; bs =bdrv_find (device);@@ -1280,27 +1278,37 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,return ; } - io_limits.bps[BLOCK_IO_LIMIT_TOTAL ] = bps; - io_limits.bps[BLOCK_IO_LIMIT_READ ] = bps_rd; - io_limits.bps[BLOCK_IO_LIMIT_WRITE ] = bps_wr; - io_limits.iops[BLOCK_IO_LIMIT_TOTAL ]= iops; - io_limits.iops[BLOCK_IO_LIMIT_READ ] = iops_rd; - io_limits.iops[BLOCK_IO_LIMIT_WRITE ]= iops_wr; +memset (&cfg,0 ,sizeof (cfg)); + cfg.buckets[THROTTLE_BPS_TOTAL ].avg = bps; + cfg.buckets[THROTTLE_BPS_READ ].avg = bps_rd; + cfg.buckets[THROTTLE_BPS_WRITE ].avg = bps_wr; + + cfg.buckets[THROTTLE_OPS_TOTAL ].avg = iops; + cfg.buckets[THROTTLE_OPS_READ ].avg = iops_rd; + cfg.buckets[THROTTLE_OPS_WRITE ].avg = iops_wr; + + cfg.buckets[THROTTLE_BPS_TOTAL ].max =0 ; + cfg.buckets[THROTTLE_BPS_READ ].max =0 ; + cfg.buckets[THROTTLE_BPS_WRITE ].max =0 ; + + cfg.buckets[THROTTLE_OPS_TOTAL ].max =0 ; + cfg.buckets[THROTTLE_OPS_READ ].max =0 ; + cfg.buckets[THROTTLE_OPS_WRITE ].max =0 ; -if (!do_check_io_limits (&io_limits, errp)) { + cfg.op_size =0 ; + +if (!check_throttle_config (&cfg, errp)) {return ; } - bs->io_limits = io_limits; - -if (!bs->io_limits_enabled &&bdrv_io_limits_enabled (bs)) { +if (!bs->io_limits_enabled &&throttle_enabled (&cfg)) {bdrv_io_limits_enable (bs); - }else if (bs->io_limits_enabled && !bdrv_io_limits_enabled (bs)) { + }else if (bs->io_limits_enabled && !throttle_enabled (&cfg)) {bdrv_io_limits_disable (bs); - }else { -if (bs->block_timer) { -timer_mod (bs->block_timer,qemu_clock_get_ns (QEMU_CLOCK_VIRTUAL )); - } + } + +if (bs->io_limits_enabled) { +bdrv_set_io_limits (bs, &cfg); } }include/block/block.h +0
-1@@ -107,7 +107,6 @@ void bdrv_info_stats(Monitor *mon, QObject **ret_data);/* disk I/O throttling */ void bdrv_io_limits_enable (BlockDriverState *bs);void bdrv_io_limits_disable (BlockDriverState *bs); -bool bdrv_io_limits_enabled (BlockDriverState *bs);void bdrv_init (void );void bdrv_init_with_whitelist (void );include/block/block_int.h +6
-26@@ -35,18 +35,12 @@#include "qemu/hbitmap.h" #include "block/snapshot.h" #include "qemu/main-loop.h" +#include "qemu/throttle.h" #define BLOCK_FLAG_ENCRYPT 1#define BLOCK_FLAG_COMPAT6 4#define BLOCK_FLAG_LAZY_REFCOUNTS 8 -#define BLOCK_IO_LIMIT_READ 0 -#define BLOCK_IO_LIMIT_WRITE 1 -#define BLOCK_IO_LIMIT_TOTAL 2 - -#define BLOCK_IO_SLICE_TIME 100000000 -#define NANOSECONDS_PER_SECOND 1000000000.0 -#define BLOCK_OPT_SIZE "size"#define BLOCK_OPT_ENCRYPT "encryption"#define BLOCK_OPT_COMPAT6 "compat6"@@ -70,17 +64,6 @@ typedef struct BdrvTrackedRequest {CoQueue wait_queue;/* coroutines blocked on this request */ } BdrvTrackedRequest; - -typedef struct BlockIOLimit { -int64_t bps[3 ]; -int64_t iops[3 ]; -}BlockIOLimit ; - -typedef struct BlockIOBaseValue { -uint64_t bytes[2 ]; -uint64_t ios[2 ]; -}BlockIOBaseValue ; -struct BlockDriver {const char *format_name;int instance_size;@@ -264,13 +247,9 @@ struct BlockDriverState {/* number of in-flight copy-on-read requests */ unsigned int copy_on_read_in_flight; -/* the time for latest disk I/O */ -int64_t slice_start; -int64_t slice_end; -BlockIOLimit io_limits; -BlockIOBaseValue slice_submitted; -CoQueue throttled_reqs; -QEMUTimer *block_timer; +/* I/O throttling */ +ThrottleState throttle_state; +CoQueue throttled_reqs[2 ];bool io_limits_enabled;/* I/O stats (display with "info blockstats"). */ @@ -312,7 +291,8 @@ struct BlockDriverState {int get_tmp_filename (char *filename,int size);void bdrv_set_io_limits (BlockDriverState *bs, -BlockIOLimit *io_limits); +ThrottleConfig *cfg); +/** * bdrv_add_before_write_notifier: Signature · 1 line
1.7.10.4
Re: [Qemu-devel] [PATCH V11 3/5] block: Enable the new throttling code in the block layer.
Quoted 5 lines
block.c int is_windows_drive(const char *filename) · line 132
Quoted 2 lines
block.c +2
-0+/* this function drain all the throttled IOs */ +static bool bdrv_start_throttled_reqs (BlockDriverState *bs)This function is to drain the throttled reqs, but named
start_throttled_reqs, why?
I took the name Stefan gave me.
Best regards
Benoît
PATCH v11 4/5 block: Add support for throttling burst max in QMP and the command line.
In reply to Benoît CanetThe max parameter of the leaky bucket throttling algorithm can be used to allow the guest to do bursts.
The max value is a pool of I/O that the guest can use without being throttled at all. Throttling is triggered once this pool is empty.
--- block/qapi.c | 26 ++++++++++++ blockdev.c | 118 ++++++++++++++++++++++++++++++++++++++++++++++-------- hmp.c | 32 +++++++++++++-- qapi-schema.json | 34 +++++++++++++++- qemu-options.hx | 4 +- qmp-commands.hx | 28 ++++++++++++- 6 files changed, 218 insertions(+), 24 deletions(-)
block/qapi.c +26 -0
@@ -232,6 +232,32 @@ void bdrv_query_info(BlockDriverState *bs, info->inserted->iops = cfg.buckets[THROTTLE_OPS_TOTAL ].avg; info->inserted->iops_rd = cfg.buckets[THROTTLE_OPS_READ ].avg; info->inserted->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE ].avg; + + info->inserted->has_bps_max = + cfg.buckets[THROTTLE_BPS_TOTAL ].max; + info->inserted->bps_max = + cfg.buckets[THROTTLE_BPS_TOTAL ].max; + info->inserted->has_bps_rd_max = + cfg.buckets[THROTTLE_BPS_READ ].max; + info->inserted->bps_rd_max = + cfg.buckets[THROTTLE_BPS_READ ].max; + info->inserted->has_bps_wr_max = + cfg.buckets[THROTTLE_BPS_WRITE ].max; + info->inserted->bps_wr_max = + cfg.buckets[THROTTLE_BPS_WRITE ].max; + + info->inserted->has_iops_max = + cfg.buckets[THROTTLE_OPS_TOTAL ].max; + info->inserted->iops_max = + cfg.buckets[THROTTLE_OPS_TOTAL ].max; + info->inserted->has_iops_rd_max = + cfg.buckets[THROTTLE_OPS_READ ].max; + info->inserted->iops_rd_max = + cfg.buckets[THROTTLE_OPS_READ ].max; + info->inserted->has_iops_wr_max = + cfg.buckets[THROTTLE_OPS_WRITE ].max; + info->inserted->iops_wr_max = + cfg.buckets[THROTTLE_OPS_WRITE ].max; } bs0 = bs;
blockdev.c +102 -16
154 lines not on this page · raw message
hmp.c +29 -3
@@ -344,14 +344,28 @@ void hmp_info_block(Monitor *mon, const QDict *qdict) {monitor_printf (mon," I/O throttling: bps=%" PRId64" bps_rd=%" PRId64" bps_wr=%" PRId64 +" bps_max=%" PRId64 +" bps_rd_max=%" PRId64 +" bps_wr_max=%" PRId64" iops=%" PRId64" iops_rd=%" PRId64 -" iops_wr=%" PRId64"\n" , +" iops_wr=%" PRId64 +" iops_max=%" PRId64 +" iops_rd_max=%" PRId64 +" iops_wr_max=%" PRId64"\n" , info->value->inserted->bps, info->value->inserted->bps_rd, info->value->inserted->bps_wr, + info->value->inserted->bps_max, + info->value->inserted->bps_rd_max, + info->value->inserted->bps_wr_max, info->value->inserted->iops, info->value->inserted->iops_rd, - info->value->inserted->iops_wr); + info->value->inserted->iops_wr, + info->value->inserted->iops_max, + info->value->inserted->iops_rd_max, + info->value->inserted->iops_wr_max); + } else { +monitor_printf (mon," [not inserted]" ); }if (verbose) {
@@ -1098,7 +1112,19 @@ void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)qdict_get_int (qdict,"bps_wr" ),qdict_get_int (qdict,"iops" ),qdict_get_int (qdict,"iops_rd" ), - qdict_get_int(qdict, "iops_wr"), &err); +qdict_get_int (qdict,"iops_wr" ), + false,/* no burst max via HMP */ +0 , + false, +0 , + false, +0 , + false, +0 , + false, +0 , + false, + 0, &err);hmp_handle_error (mon, &err); }
qapi-schema.json +32 -2
@@ -785,6 +785,18 @@ # # @image: the info of image used (since: 1.6) # +# @bps_max: #optional total max in bytes (Since 1.7) +# +# @bps_rd_max: #optional read max in bytes (Since 1.7) +# +# @bps_wr_max: #optional write max in bytes (Since 1.7) +# +# @iops_max: #optional total I/O operations max (Since 1.7) +# +# @iops_rd_max: #optional read I/O operations max (Since 1.7) +# +# @iops_wr_max: #optional write I/O operations max (Since 1.7) +# # Since: 0.14.0 # # Notes: This interface is only found in @BlockInfo.
@@ -795,7 +807,10 @@ 'encrypted': 'bool', 'encryption_key_missing': 'bool', 'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int', 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int', - 'image': 'ImageInfo' } } + 'image': 'ImageInfo', + '*bps_max': 'int', '*bps_rd_max': 'int', + '*bps_wr_max': 'int', '*iops_max': 'int', + '*iops_rd_max': 'int', '*iops_wr_max': 'int' }} ## # @BlockDeviceIoStatus:
@@ -2174,6 +2189,18 @@ # # @iops_wr: write I/O operations per second # +# @bps_max: #optional total max in bytes (Since 1.7) +# +# @bps_rd_max: #optional read max in bytes (Since 1.7) +# +# @bps_wr_max: #optional write max in bytes (Since 1.7) +# +# @iops_max: #optional total I/O operations max (Since 1.7) +# +# @iops_rd_max: #optional read I/O operations max (Since 1.7) +# +# @iops_wr_max: #optional write I/O operations max (Since 1.7) +# # Returns: Nothing on success # If @device is not a valid block device, DeviceNotFound #
@@ -2181,7 +2208,10 @@ ## { 'command': 'block_set_io_throttle', 'data': { 'device': 'str', 'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int', - 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int' } } + 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int', + '*bps_max': 'int', '*bps_rd_max': 'int', + '*bps_wr_max': 'int', '*iops_max': 'int', + '*iops_rd_max': 'int', '*iops_wr_max': 'int' }} ## # @block-stream:
qemu-options.hx +3 -1
@@ -409,7 +409,9 @@ DEF("drive", HAS_ARG, QEMU_OPTION_drive, " [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n" " [,serial=s][,addr=A][,id=name][,aio=threads|native]\n" " [,readonly=on|off][,copy-on-read=on|off]\n" - " [[,bps=b]|[[,bps_rd=r][,bps_wr=w]]][[,iops=i]|[[,iops_rd=r][,iops_wr=w]]\n" + " [[,bps=b]|[[,bps_rd=r][,bps_wr=w]]][[,iops=i]|[[,iops_rd=r]\n" + " [,iops_wr=w][,bps_max=bm]|[[,bps_rd_max=rm][,bps_wr_max=wm]]]\n" + " [[,iops_max=im]|[[,iops_rd_max=irm][,iops_wr_max=iwm]]\n" " use 'file' as a drive image\n", QEMU_ARCH_ALL) STEXI @item -drive @var{option}[,@var{option}[,@var{option}[,...]]]
qmp-commands.hx +26 -2
@@ -1389,7 +1389,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", + .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?", .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle, },
@@ -1408,6 +1408,12 @@ Arguments: - "iops": total I/O operations per second (json-int) - "iops_rd": read I/O operations per second (json-int) - "iops_wr": write I/O operations per second (json-int) +- "bps_max": total max in bytes (json-int) +- "bps_rd_max": read max in bytes (json-int) +- "bps_wr_max": write max in bytes (json-int) +- "iops_max": total I/O operations max (json-int) +- "iops_rd_max": read I/O operations max (json-int) +- "iops_wr_max": write I/O operations max (json-int) Example:
@@ -1417,7 +1423,13 @@ Example: "bps_wr": 0, "iops": 0, "iops_rd": 0, - "iops_wr": 0 } } + "iops_wr": 0, + "bps_max": 8000000, + "bps_rd_max": 0, + "bps_wr_max": 0, + "iops_max": 0, + "iops_rd_max": 0, + "iops_wr_max": 0 } } <- { "return": {} } EQMP
@@ -1758,6 +1770,12 @@ Each json-object contain the following: - "iops": limit total I/O operations per second (json-int) - "iops_rd": limit read operations per second (json-int) - "iops_wr": limit write operations per second (json-int) + - "bps_max": total max in bytes (json-int) + - "bps_rd_max": read max in bytes (json-int) + - "bps_wr_max": write max in bytes (json-int) + - "iops_max": total I/O operations max (json-int) + - "iops_rd_max": read I/O operations max (json-int) + - "iops_wr_max": write I/O operations max (json-int) - "image": the detail of the image, it is a json-object containing the following: - "filename": image file name (json-string)
@@ -1827,6 +1845,12 @@ Example: "iops":1000000, "iops_rd":0, "iops_wr":0, + "bps_max": 8000000, + "bps_rd_max": 0, + "bps_wr_max": 0, + "iops_max": 0, + "iops_rd_max": 0, + "iops_wr_max": 0, "image":{ "filename":"disks/test.qcow2", "format":"qcow2",
Signature · 1 line
1.7.10.4
Re: [Qemu-devel] [PATCH V11 4/5] block: Add support for throttling burst max in QMP and the command line.
Quoted 4 lines · Benoît Canet
The max parameter of the leaky bucket throttling algorithm can be used to allow the guest to do bursts.
The max value is a pool of I/O that the guest can use without being throttled at all. Throttling is triggered once this pool is empty.
It would be good to putting this description in comment and/or document strings (e.g. help text) to make it easier for both users and developers to understand how is this "max" used, because it's hard to fully understand from "total max in bytes" or "total max in bytes".
Quoted 293 lines
Signed-off-by Benoit Canet <[email protected]>Reviewed-by Eric Blake <[email protected]>--- block/qapi.c | 26 ++++++++++++ blockdev.c | 118 ++++++++++++++++++++++++++++++++++++++++++++++-------- hmp.c | 32 +++++++++++++-- qapi-schema.json | 34 +++++++++++++++- qemu-options.hx | 4 +- qmp-commands.hx | 28 ++++++++++++- 6 files changed, 218 insertions(+), 24 deletions(-)block/qapi.c +26
-0@@ -232,6 +232,32 @@ void bdrv_query_info(BlockDriverState *bs, info->inserted->iops = cfg.buckets[THROTTLE_OPS_TOTAL ].avg; info->inserted->iops_rd = cfg.buckets[THROTTLE_OPS_READ ].avg; info->inserted->iops_wr = cfg.buckets[THROTTLE_OPS_WRITE ].avg; + + info->inserted->has_bps_max = + cfg.buckets[THROTTLE_BPS_TOTAL ].max; + info->inserted->bps_max = + cfg.buckets[THROTTLE_BPS_TOTAL ].max; + info->inserted->has_bps_rd_max = + cfg.buckets[THROTTLE_BPS_READ ].max; + info->inserted->bps_rd_max = + cfg.buckets[THROTTLE_BPS_READ ].max; + info->inserted->has_bps_wr_max = + cfg.buckets[THROTTLE_BPS_WRITE ].max; + info->inserted->bps_wr_max = + cfg.buckets[THROTTLE_BPS_WRITE ].max; + + info->inserted->has_iops_max = + cfg.buckets[THROTTLE_OPS_TOTAL ].max; + info->inserted->iops_max = + cfg.buckets[THROTTLE_OPS_TOTAL ].max; + info->inserted->has_iops_rd_max = + cfg.buckets[THROTTLE_OPS_READ ].max; + info->inserted->iops_rd_max = + cfg.buckets[THROTTLE_OPS_READ ].max; + info->inserted->has_iops_wr_max = + cfg.buckets[THROTTLE_OPS_WRITE ].max; + info->inserted->iops_wr_max = + cfg.buckets[THROTTLE_OPS_WRITE ].max; } bs0 = bs;blockdev.c +102
-16@@ -495,13 +495,18 @@ static DriveInfo *blockdev_init(QemuOpts *all_opts, cfg.buckets[THROTTLE_OPS_WRITE ].avg =qemu_opt_get_number (opts,"throttling.iops-write" ,0 ); - cfg.buckets[THROTTLE_BPS_TOTAL ].max =0 ; - cfg.buckets[THROTTLE_BPS_READ ].max =0 ; - cfg.buckets[THROTTLE_BPS_WRITE ].max =0 ; - - cfg.buckets[THROTTLE_OPS_TOTAL ].max =0 ; - cfg.buckets[THROTTLE_OPS_READ ].max =0 ; - cfg.buckets[THROTTLE_OPS_WRITE ].max =0 ; + cfg.buckets[THROTTLE_BPS_TOTAL ].max = +qemu_opt_get_number (opts,"throttling.bps-total-max" ,0 ); + cfg.buckets[THROTTLE_BPS_READ ].max = +qemu_opt_get_number (opts,"throttling.bps-read-max" ,0 ); + cfg.buckets[THROTTLE_BPS_WRITE ].max = +qemu_opt_get_number (opts,"throttling.bps-write-max" ,0 ); + cfg.buckets[THROTTLE_OPS_TOTAL ].max = +qemu_opt_get_number (opts,"throttling.iops-total-max" ,0 ); + cfg.buckets[THROTTLE_OPS_READ ].max = +qemu_opt_get_number (opts,"throttling.iops-read-max" ,0 ); + cfg.buckets[THROTTLE_OPS_WRITE ].max = +qemu_opt_get_number (opts,"throttling.iops-write-max" ,0 ); cfg.op_size =0 ;@@ -782,6 +787,14 @@ DriveInfo *drive_init(QemuOpts *all_opts, BlockInterfaceType block_default_type)qemu_opt_rename (all_opts,"bps_rd" ,"throttling.bps-read" );qemu_opt_rename (all_opts,"bps_wr" ,"throttling.bps-write" ); +qemu_opt_rename (all_opts,"iops_max" ,"throttling.iops-total-max" ); +qemu_opt_rename (all_opts,"iops_rd_max" ,"throttling.iops-read-max" ); +qemu_opt_rename (all_opts,"iops_wr_max" ,"throttling.iops-write-max" ); + +qemu_opt_rename (all_opts,"bps_max" ,"throttling.bps-total-max" ); +qemu_opt_rename (all_opts,"bps_rd_max" ,"throttling.bps-read-max" ); +qemu_opt_rename (all_opts,"bps_wr_max" ,"throttling.bps-write-max" ); +qemu_opt_rename (all_opts,"readonly" ,"read-only" ); value =qemu_opt_get (all_opts,"cache" );@@ -1266,8 +1279,22 @@ void qmp_change_blockdev(const char *device, const char *filename,/* throttling disk I/O limits */ void qmp_block_set_io_throttle (const char *device,int64_t bps,int64_t bps_rd, -int64_t bps_wr,int64_t iops,int64_t iops_rd, -int64_t iops_wr,Error **errp) +int64_t bps_wr, +int64_t iops, +int64_t iops_rd, +int64_t iops_wr, +bool has_bps_max, +int64_t bps_max, +bool has_bps_rd_max, +int64_t bps_rd_max, +bool has_bps_wr_max, +int64_t bps_wr_max, +bool has_iops_max, +int64_t iops_max, +bool has_iops_rd_max, +int64_t iops_rd_max, +bool has_iops_wr_max, +int64_t iops_wr_max,Error **errp) {ThrottleConfig cfg;BlockDriverState *bs;@@ -1287,13 +1314,24 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, cfg.buckets[THROTTLE_OPS_READ ].avg = iops_rd; cfg.buckets[THROTTLE_OPS_WRITE ].avg = iops_wr; - cfg.buckets[THROTTLE_BPS_TOTAL ].max =0 ; - cfg.buckets[THROTTLE_BPS_READ ].max =0 ; - cfg.buckets[THROTTLE_BPS_WRITE ].max =0 ; - - cfg.buckets[THROTTLE_OPS_TOTAL ].max =0 ; - cfg.buckets[THROTTLE_OPS_READ ].max =0 ; - cfg.buckets[THROTTLE_OPS_WRITE ].max =0 ; +if (has_bps_max) { + cfg.buckets[THROTTLE_BPS_TOTAL ].max = bps_max; + } +if (has_bps_rd_max) { + cfg.buckets[THROTTLE_BPS_READ ].max = bps_rd_max; + } +if (has_bps_wr_max) { + cfg.buckets[THROTTLE_BPS_WRITE ].max = bps_wr_max; + } +if (has_iops_max) { + cfg.buckets[THROTTLE_OPS_TOTAL ].max = iops_max; + } +if (has_iops_rd_max) { + cfg.buckets[THROTTLE_OPS_READ ].max = iops_rd_max; + } +if (has_iops_wr_max) { + cfg.buckets[THROTTLE_OPS_WRITE ].max = iops_wr_max; + } cfg.op_size =0 ;@@ -1997,6 +2035,30 @@ QemuOptsList qemu_common_drive_opts = { .type = QEMU_OPT_NUMBER, .help = "limit write bytes per second", },{ + .name = "throttling.iops-total-max", + .type = QEMU_OPT_NUMBER, + .help = "I/O operations burst", + },{ + .name = "throttling.iops-read-max", + .type = QEMU_OPT_NUMBER, + .help = "I/O operations read burst", + },{ + .name = "throttling.iops-write-max", + .type = QEMU_OPT_NUMBER, + .help = "I/O operations write burst", + },{ + .name = "throttling.bps-total-max", + .type = QEMU_OPT_NUMBER, + .help = "total bytes burst", + },{ + .name = "throttling.bps-read-max", + .type = QEMU_OPT_NUMBER, + .help = "total bytes read burst", + },{ + .name = "throttling.bps-write-max", + .type = QEMU_OPT_NUMBER, + .help = "total bytes write burst", + },{ .name = "copy-on-read", .type = QEMU_OPT_BOOL, .help = "copy read data from backing file into image file",@@ -2119,6 +2181,30 @@ QemuOptsList qemu_old_drive_opts = { .type = QEMU_OPT_NUMBER, .help = "limit write bytes per second", },{ + .name = "iops_max", + .type = QEMU_OPT_NUMBER, + .help = "I/O operations burst", + },{ + .name = "iops_rd_max", + .type = QEMU_OPT_NUMBER, + .help = "I/O operations read burst", + },{ + .name = "iops_wr_max", + .type = QEMU_OPT_NUMBER, + .help = "I/O operations write burst", + },{ + .name = "bps_max", + .type = QEMU_OPT_NUMBER, + .help = "total bytes burst", + },{ + .name = "bps_rd_max", + .type = QEMU_OPT_NUMBER, + .help = "total bytes read burst", + },{ + .name = "bps_wr_max", + .type = QEMU_OPT_NUMBER, + .help = "total bytes write burst", + },{ .name = "copy-on-read", .type = QEMU_OPT_BOOL, .help = "copy read data from backing file into image file",hmp.c +29
-3@@ -344,14 +344,28 @@ void hmp_info_block(Monitor *mon, const QDict *qdict) {monitor_printf (mon," I/O throttling: bps=%" PRId64" bps_rd=%" PRId64" bps_wr=%" PRId64 +" bps_max=%" PRId64 +" bps_rd_max=%" PRId64 +" bps_wr_max=%" PRId64" iops=%" PRId64" iops_rd=%" PRId64 -" iops_wr=%" PRId64"\n" , +" iops_wr=%" PRId64 +" iops_max=%" PRId64 +" iops_rd_max=%" PRId64 +" iops_wr_max=%" PRId64"\n" , info->value->inserted->bps, info->value->inserted->bps_rd, info->value->inserted->bps_wr, + info->value->inserted->bps_max, + info->value->inserted->bps_rd_max, + info->value->inserted->bps_wr_max, info->value->inserted->iops, info->value->inserted->iops_rd, - info->value->inserted->iops_wr); + info->value->inserted->iops_wr, + info->value->inserted->iops_max, + info->value->inserted->iops_rd_max, + info->value->inserted->iops_wr_max); + } else { +monitor_printf (mon," [not inserted]" ); }if (verbose) {@@ -1098,7 +1112,19 @@ void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)qdict_get_int (qdict,"bps_wr" ),qdict_get_int (qdict,"iops" ),qdict_get_int (qdict,"iops_rd" ), - qdict_get_int(qdict, "iops_wr"), &err); +qdict_get_int (qdict,"iops_wr" ), + false,/* no burst max via HMP */ +0 , + false, +0 , + false, +0 , + false, +0 , + false, +0 , + false, + 0, &err);hmp_handle_error (mon, &err); }qapi-schema.json +12
-0@@ -785,6 +785,18 @@ # # @image: the info of image used (since: 1.6) # +# @bps_max: #optional total max in bytes (Since 1.7) +# +# @bps_rd_max: #optional read max in bytes (Since 1.7) +# +# @bps_wr_max: #optional write max in bytes (Since 1.7) +# +# @iops_max: #optional total I/O operations max (Since 1.7) +# +# @iops_rd_max: #optional read I/O operations max (Since 1.7) +# +# @iops_wr_max: #optional write I/O operations max (Since 1.7) +# # Since: 0.14.0 # # Notes: This interface is only found in @BlockInfo.
qapi-schema.json line 813
Quoted 8 lines
qapi-schema.json +4
-1@@ -795,7 +807,10 @@ 'encrypted': 'bool', 'encryption_key_missing': 'bool', 'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int', 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int', - 'image': 'ImageInfo' } } + 'image': 'ImageInfo', + '*bps_max': 'int', '*bps_rd_max': 'int', + '*bps_wr_max': 'int', '*iops_max': 'int', + '*iops_rd_max': 'int', '*iops_wr_max': 'int' }}
Please be consistent with brace spaceing: s/}}/} }/
Quoted 23 lines
qapi-schema.json +12
-0## # @BlockDeviceIoStatus:@@ -2174,6 +2189,18 @@ # # @iops_wr: write I/O operations per second # +# @bps_max: #optional total max in bytes (Since 1.7) +# +# @bps_rd_max: #optional read max in bytes (Since 1.7) +# +# @bps_wr_max: #optional write max in bytes (Since 1.7) +# +# @iops_max: #optional total I/O operations max (Since 1.7) +# +# @iops_rd_max: #optional read I/O operations max (Since 1.7) +# +# @iops_wr_max: #optional write I/O operations max (Since 1.7) +# # Returns: Nothing on success # If @device is not a valid block device, DeviceNotFound #
qapi-schema.json line 2214
Quoted 8 lines
qapi-schema.json +4
-1@@ -2181,7 +2208,10 @@ ## { 'command': 'block_set_io_throttle', 'data': { 'device': 'str', 'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int', - 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int' } } + 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int', + '*bps_max': 'int', '*bps_rd_max': 'int', + '*bps_wr_max': 'int', '*iops_max': 'int', + '*iops_rd_max': 'int', '*iops_wr_max': 'int' }}
Please be consistent with brace spaceing: s/}}/} }/
Quoted 8 lines
qapi-schema.json +0
-0## # @block-stream:qemu-options.hx +0
-0
qemu-options.hx DEF("drive", HAS_ARG, QEMU_OPTION_drive, · line 414
Quoted 7 lines
qemu-options.hx +3
-1@@ -409,7 +409,9 @@ DEF("drive", HAS_ARG, QEMU_OPTION_drive, " [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n" " [,serial=s][,addr=A][,id=name][,aio=threads|native]\n" " [,readonly=on|off][,copy-on-read=on|off]\n" - " [[,bps=b]|[[,bps_rd=r][,bps_wr=w]]][[,iops=i]|[[,iops_rd=r][,iops_wr=w]]\n" + " [[,bps=b]|[[,bps_rd=r][,bps_wr=w]]][[,iops=i]|[[,iops_rd=r]\n" + " [,iops_wr=w][,bps_max=bm]|[[,bps_rd_max=rm][,bps_wr_max=wm]]]\n" + " [[,iops_max=im]|[[,iops_rd_max=irm][,iops_wr_max=iwm]]\n"
The brackets don't match here, let's expand and indent it to see what's here:
[
[,bps=b]
|
[
[,bps_rd=r]
[,bps_wr=w]
]
]
[
[,iops=i]
|
[
[,iops_rd=r]
[,iops_wr=w]
[,bps_max=bm]
|
[
[,bps_rd_max=rm]
[,bps_wr_max=wm]
]
]
[
[,iops_max=im]
|
[
[,iops_rd_max=irm]
[,iops_wr_max=iwm]
]\n"Mismatch here, right? And I think you wanted to move bps_max* group to outmost.
qmp-commands.hx EQMP · line 1392
Quoted 13 lines
qemu-options.hx +0
-0" use 'file' as a drive image\n", QEMU_ARCH_ALL) STEXI @item -drive @var{option}[,@var{option}[,@var{option}[,...]]]qmp-commands.hx +1
-1@@ -1389,7 +1389,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", + .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?",
Too long, wrap this line?
Quoted 18 lines
qmp-commands.hx +6
-0.mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle, },@@ -1408,6 +1408,12 @@ Arguments: - "iops": total I/O operations per second (json-int) - "iops_rd": read I/O operations per second (json-int) - "iops_wr": write I/O operations per second (json-int) +- "bps_max": total max in bytes (json-int) +- "bps_rd_max": read max in bytes (json-int) +- "bps_wr_max": write max in bytes (json-int) +- "iops_max": total I/O operations max (json-int) +- "iops_rd_max": read I/O operations max (json-int) +- "iops_wr_max": write I/O operations max (json-int) Example:@@ -1417,7 +1423,13 @@ Example: "bps_wr": 0,
qmp-commands.hx Example: · line 1432
Quoted 10 lines
qmp-commands.hx +7
-1"iops": 0, "iops_rd": 0, - "iops_wr": 0 } } + "iops_wr": 0, + "bps_max": 8000000, + "bps_rd_max": 0, + "bps_wr_max": 0, + "iops_max": 0, + "iops_rd_max": 0, + "iops_wr_max": 0 } }
OK, good brace spacing.
Quoted 33 lines
qmp-commands.hx +12
-0<- { "return": {} } EQMP@@ -1758,6 +1770,12 @@ Each json-object contain the following: - "iops": limit total I/O operations per second (json-int) - "iops_rd": limit read operations per second (json-int) - "iops_wr": limit write operations per second (json-int) + - "bps_max": total max in bytes (json-int) + - "bps_rd_max": read max in bytes (json-int) + - "bps_wr_max": write max in bytes (json-int) + - "iops_max": total I/O operations max (json-int) + - "iops_rd_max": read I/O operations max (json-int) + - "iops_wr_max": write I/O operations max (json-int) - "image": the detail of the image, it is a json-object containing the following: - "filename": image file name (json-string)@@ -1827,6 +1845,12 @@ Example: "iops":1000000, "iops_rd":0, "iops_wr":0, + "bps_max": 8000000, + "bps_rd_max": 0, + "bps_wr_max": 0, + "iops_max": 0, + "iops_rd_max": 0, + "iops_wr_max": 0, "image":{ "filename":"disks/test.qcow2", "format":"qcow2",Signature · 1 line
1.7.10.4
Re: [Qemu-devel] [PATCH V11 4/5] block: Add support for throttling burst max in QMP and the command line.
Quoted 5 lines
qmp-commands.hx EQMP · line 1392
Quoted 3 lines
.name = "
block_set_io_throttle",qmp-commands.hx +1
-1- .args_type = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr: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?",Too long, wrap this line?
I am afraid it would mess with QMP code generation.
Best regards
Benoît
PATCH v11 5/5 block: Add iops_size to do the iops accounting for a given io size.
In reply to Benoît CanetThis feature can be used in case where users are avoiding the iops limit by doing jumbo I/Os hammering the storage backend.
--- block/qapi.c | 3 +++ blockdev.c | 21 ++++++++++++++++++--- hmp.c | 8 ++++++-- qapi-schema.json | 10 ++++++++-- qemu-options.hx | 2 +- qmp-commands.hx | 8 ++++++-- 6 files changed, 42 insertions(+), 10 deletions(-)
block/qapi.c +3 -0
@@ -258,6 +258,9 @@ void bdrv_query_info(BlockDriverState *bs, cfg.buckets[THROTTLE_OPS_WRITE ].max; info->inserted->iops_wr_max = cfg.buckets[THROTTLE_OPS_WRITE ].max; + + info->inserted->has_iops_size = cfg.op_size; + info->inserted->iops_size = cfg.op_size; } bs0 = bs;
blockdev.c +18 -3
@@ -508,7 +508,7 @@ static DriveInfo *blockdev_init(QemuOpts *all_opts, cfg.buckets[THROTTLE_OPS_WRITE ].max =qemu_opt_get_number (opts,"throttling.iops-write-max" ,0 ); - cfg.op_size =0 ; + cfg.op_size =qemu_opt_get_number (opts,"throttling.iops-size" ,0 );if (!check_throttle_config (&cfg, &error)) {error_report ("%s" ,error_get_pretty (error));
@@ -795,6 +795,9 @@ DriveInfo *drive_init(QemuOpts *all_opts, BlockInterfaceType block_default_type)qemu_opt_rename (all_opts,"bps_rd_max" ,"throttling.bps-read-max" );qemu_opt_rename (all_opts,"bps_wr_max" ,"throttling.bps-write-max" ); +qemu_opt_rename (all_opts, +"iops_size" ,"throttling.iops-size" ); +qemu_opt_rename (all_opts,"readonly" ,"read-only" ); value =qemu_opt_get (all_opts,"cache" );
@@ -1294,7 +1297,9 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,bool has_iops_rd_max, int64_t iops_rd_max, bool has_iops_wr_max, - int64_t iops_wr_max, Error **errp) + int64_t iops_wr_max, + bool has_iops_size, + int64_t iops_size, Error **errp) { ThrottleConfig cfg;BlockDriverState *bs;
@@ -1333,7 +1338,9 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, cfg.buckets[THROTTLE_OPS_WRITE ].max = iops_wr_max; } - cfg.op_size =0 ; +if (has_iops_size) { + cfg.op_size = iops_size; + }if (!check_throttle_config (&cfg, errp)) {return ;
@@ -2059,6 +2066,10 @@ QemuOptsList qemu_common_drive_opts = { .type = QEMU_OPT_NUMBER, .help = "total bytes write burst", },{ + .name = "throttling.iops-size", + .type = QEMU_OPT_NUMBER, + .help = "when limiting by iops max size of an I/O in bytes", + },{ .name = "copy-on-read", .type = QEMU_OPT_BOOL, .help = "copy read data from backing file into image file",
@@ -2205,6 +2216,10 @@ QemuOptsList qemu_old_drive_opts = { .type = QEMU_OPT_NUMBER, .help = "total bytes write burst", },{ + .name = "iops_size", + .type = QEMU_OPT_NUMBER, + .help = "when limiting by iops max size of an I/O in bytes", + },{ .name = "copy-on-read", .type = QEMU_OPT_BOOL, .help = "copy read data from backing file into image file",
hmp.c +6 -2
@@ -351,7 +351,8 @@ void hmp_info_block(Monitor *mon, const QDict *qdict)" iops_wr=%" PRId64" iops_max=%" PRId64" iops_rd_max=%" PRId64 -" iops_wr_max=%" PRId64"\n" , +" iops_wr_max=%" PRId64 +" iops_size=%" PRId64"\n" , info->value->inserted->bps, info->value->inserted->bps_rd, info->value->inserted->bps_wr,
@@ -363,7 +364,8 @@ void hmp_info_block(Monitor *mon, const QDict *qdict) info->value->inserted->iops_wr, info->value->inserted->iops_max, info->value->inserted->iops_rd_max, - info->value->inserted->iops_wr_max); + info->value->inserted->iops_wr_max, + info->value->inserted->iops_size); }else {monitor_printf (mon," [not inserted]" ); }
@@ -1124,6 +1126,8 @@ void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict) false,0 , false, +0 , + false,/* No default I/O size */ 0, &err);hmp_handle_error (mon, &err); }
qapi-schema.json +8 -2
@@ -797,6 +797,8 @@ # # @iops_wr_max: #optional write I/O operations max (Since 1.7) # +# @iops_size: #optional an I/O size in bytes (Since 1.7) +# # Since: 0.14.0 # # Notes: This interface is only found in @BlockInfo.
@@ -810,7 +812,8 @@ 'image': 'ImageInfo', '*bps_max': 'int', '*bps_rd_max': 'int', '*bps_wr_max': 'int', '*iops_max': 'int', - '*iops_rd_max': 'int', '*iops_wr_max': 'int' }} + '*iops_rd_max': 'int', '*iops_wr_max': 'int', + '*iops_size': 'int' } } ## # @BlockDeviceIoStatus:
@@ -2201,6 +2204,8 @@ # # @iops_wr_max: #optional write I/O operations max (Since 1.7) # +# @iops_size: #optional an I/O size in bytes (Since 1.7) +# # Returns: Nothing on success # If @device is not a valid block device, DeviceNotFound #
@@ -2211,7 +2216,8 @@ 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int', '*bps_max': 'int', '*bps_rd_max': 'int', '*bps_wr_max': 'int', '*iops_max': 'int', - '*iops_rd_max': 'int', '*iops_wr_max': 'int' }} + '*iops_rd_max': 'int', '*iops_wr_max': 'int', + '*iops_size': 'int' }} ## # @block-stream:
qemu-options.hx +1 -1
@@ -411,7 +411,7 @@ DEF("drive", HAS_ARG, QEMU_OPTION_drive, " [,readonly=on|off][,copy-on-read=on|off]\n" " [[,bps=b]|[[,bps_rd=r][,bps_wr=w]]][[,iops=i]|[[,iops_rd=r]\n" " [,iops_wr=w][,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_max=im]|[[,iops_rd_max=irm][,iops_wr_max=iwm][,iops_size=is]]\n" " use 'file' as a drive image\n", QEMU_ARCH_ALL) STEXI @item -drive @var{option}[,@var{option}[,@var{option}[,...]]]
qmp-commands.hx +6 -2
@@ -1389,7 +1389,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?", + .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?", .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle, },
@@ -1414,6 +1414,7 @@ Arguments: - "iops_max": total I/O operations max (json-int) - "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) Example:
@@ -1429,7 +1430,8 @@ Example: "bps_wr_max": 0, "iops_max": 0, "iops_rd_max": 0, - "iops_wr_max": 0 } } + "iops_wr_max": 0, + "iops_size": 0 } } <- { "return": {} } EQMP
@@ -1776,6 +1778,7 @@ Each json-object contain the following: - "iops_max": total I/O operations max (json-int) - "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 when limiting by iops (json-int) - "image": the detail of the image, it is a json-object containing the following: - "filename": image file name (json-string)
@@ -1851,6 +1854,7 @@ Example: "iops_max": 0, "iops_rd_max": 0, "iops_wr_max": 0, + "iops_size": 0, "image":{ "filename":"disks/test.qcow2", "format":"qcow2",
Signature · 1 line
1.7.10.4