2 * QEMU throttling infrastructure
4 * Copyright (C) Nodalink, EURL. 2013-2014
5 * Copyright (C) Igalia, S.L. 2015
8 * BenoƮt Canet <benoit.canet@nodalink.com>
9 * Alberto Garcia <berto@igalia.com>
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 or
14 * (at your option) version 3 of the License.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, see <http://www.gnu.org/licenses/>.
25 #include "qemu/osdep.h"
26 #include "qemu/throttle.h"
27 #include "qemu/timer.h"
28 #include "block/aio.h"
30 /* This function make a bucket leak
32 * @bkt: the bucket to make leak
33 * @delta_ns: the time delta
35 void throttle_leak_bucket(LeakyBucket
*bkt
, int64_t delta_ns
)
39 /* compute how much to leak */
40 leak
= (bkt
->avg
* (double) delta_ns
) / NANOSECONDS_PER_SECOND
;
42 /* make the bucket leak */
43 bkt
->level
= MAX(bkt
->level
- leak
, 0);
46 /* Calculate the time delta since last leak and make proportionals leaks
48 * @now: the current timestamp in ns
50 static void throttle_do_leak(ThrottleState
*ts
, int64_t now
)
52 /* compute the time elapsed since the last leak */
53 int64_t delta_ns
= now
- ts
->previous_leak
;
56 ts
->previous_leak
= now
;
62 /* make each bucket leak */
63 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
64 throttle_leak_bucket(&ts
->cfg
.buckets
[i
], delta_ns
);
68 /* do the real job of computing the time to wait
70 * @limit: the throttling limit
71 * @extra: the number of operation to delay
72 * @ret: the time to wait in ns
74 static int64_t throttle_do_compute_wait(double limit
, double extra
)
76 double wait
= extra
* NANOSECONDS_PER_SECOND
;
81 /* This function compute the wait time in ns that a leaky bucket should trigger
83 * @bkt: the leaky bucket we operate on
84 * @ret: the resulting wait time in ns or 0 if the operation can go through
86 int64_t throttle_compute_wait(LeakyBucket
*bkt
)
88 double extra
; /* the number of extra units blocking the io */
94 extra
= bkt
->level
- bkt
->max
;
100 return throttle_do_compute_wait(bkt
->avg
, extra
);
103 /* This function compute the time that must be waited while this IO
105 * @is_write: true if the current IO is a write, false if it's a read
108 static int64_t throttle_compute_wait_for(ThrottleState
*ts
,
111 BucketType to_check
[2][4] = { {THROTTLE_BPS_TOTAL
,
118 THROTTLE_OPS_WRITE
}, };
119 int64_t wait
, max_wait
= 0;
122 for (i
= 0; i
< 4; i
++) {
123 BucketType index
= to_check
[is_write
][i
];
124 wait
= throttle_compute_wait(&ts
->cfg
.buckets
[index
]);
125 if (wait
> max_wait
) {
133 /* compute the timer for this type of operation
135 * @is_write: the type of operation
136 * @now: the current clock timestamp
137 * @next_timestamp: the resulting timer
138 * @ret: true if a timer must be set
140 bool throttle_compute_timer(ThrottleState
*ts
,
143 int64_t *next_timestamp
)
147 /* leak proportionally to the time elapsed */
148 throttle_do_leak(ts
, now
);
150 /* compute the wait time if any */
151 wait
= throttle_compute_wait_for(ts
, is_write
);
153 /* if the code must wait compute when the next timer should fire */
155 *next_timestamp
= now
+ wait
;
159 /* else no need to wait at all */
160 *next_timestamp
= now
;
164 /* Add timers to event loop */
165 void throttle_timers_attach_aio_context(ThrottleTimers
*tt
,
166 AioContext
*new_context
)
168 tt
->timers
[0] = aio_timer_new(new_context
, tt
->clock_type
, SCALE_NS
,
169 tt
->read_timer_cb
, tt
->timer_opaque
);
170 tt
->timers
[1] = aio_timer_new(new_context
, tt
->clock_type
, SCALE_NS
,
171 tt
->write_timer_cb
, tt
->timer_opaque
);
174 /* To be called first on the ThrottleState */
175 void throttle_init(ThrottleState
*ts
)
177 memset(ts
, 0, sizeof(ThrottleState
));
180 /* To be called first on the ThrottleTimers */
181 void throttle_timers_init(ThrottleTimers
*tt
,
182 AioContext
*aio_context
,
183 QEMUClockType clock_type
,
184 QEMUTimerCB
*read_timer_cb
,
185 QEMUTimerCB
*write_timer_cb
,
188 memset(tt
, 0, sizeof(ThrottleTimers
));
190 tt
->clock_type
= clock_type
;
191 tt
->read_timer_cb
= read_timer_cb
;
192 tt
->write_timer_cb
= write_timer_cb
;
193 tt
->timer_opaque
= timer_opaque
;
194 throttle_timers_attach_aio_context(tt
, aio_context
);
197 /* destroy a timer */
198 static void throttle_timer_destroy(QEMUTimer
**timer
)
200 assert(*timer
!= NULL
);
207 /* Remove timers from event loop */
208 void throttle_timers_detach_aio_context(ThrottleTimers
*tt
)
212 for (i
= 0; i
< 2; i
++) {
213 throttle_timer_destroy(&tt
->timers
[i
]);
217 /* To be called last on the ThrottleTimers */
218 void throttle_timers_destroy(ThrottleTimers
*tt
)
220 throttle_timers_detach_aio_context(tt
);
223 /* is any throttling timer configured */
224 bool throttle_timers_are_initialized(ThrottleTimers
*tt
)
233 /* Does any throttling must be done
235 * @cfg: the throttling configuration to inspect
236 * @ret: true if throttling must be done else false
238 bool throttle_enabled(ThrottleConfig
*cfg
)
242 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
243 if (cfg
->buckets
[i
].avg
> 0) {
251 /* return true if any two throttling parameters conflicts
253 * @cfg: the throttling configuration to inspect
254 * @ret: true if any conflict detected else false
256 bool throttle_conflicting(ThrottleConfig
*cfg
)
258 bool bps_flag
, ops_flag
;
259 bool bps_max_flag
, ops_max_flag
;
261 bps_flag
= cfg
->buckets
[THROTTLE_BPS_TOTAL
].avg
&&
262 (cfg
->buckets
[THROTTLE_BPS_READ
].avg
||
263 cfg
->buckets
[THROTTLE_BPS_WRITE
].avg
);
265 ops_flag
= cfg
->buckets
[THROTTLE_OPS_TOTAL
].avg
&&
266 (cfg
->buckets
[THROTTLE_OPS_READ
].avg
||
267 cfg
->buckets
[THROTTLE_OPS_WRITE
].avg
);
269 bps_max_flag
= cfg
->buckets
[THROTTLE_BPS_TOTAL
].max
&&
270 (cfg
->buckets
[THROTTLE_BPS_READ
].max
||
271 cfg
->buckets
[THROTTLE_BPS_WRITE
].max
);
273 ops_max_flag
= cfg
->buckets
[THROTTLE_OPS_TOTAL
].max
&&
274 (cfg
->buckets
[THROTTLE_OPS_READ
].max
||
275 cfg
->buckets
[THROTTLE_OPS_WRITE
].max
);
277 return bps_flag
|| ops_flag
|| bps_max_flag
|| ops_max_flag
;
280 /* check if a throttling configuration is valid
281 * @cfg: the throttling configuration to inspect
282 * @ret: true if valid else false
284 bool throttle_is_valid(ThrottleConfig
*cfg
)
288 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
289 if (cfg
->buckets
[i
].avg
< 0 ||
290 cfg
->buckets
[i
].max
< 0 ||
291 cfg
->buckets
[i
].avg
> THROTTLE_VALUE_MAX
||
292 cfg
->buckets
[i
].max
> THROTTLE_VALUE_MAX
) {
300 /* check if bps_max/iops_max is used without bps/iops
301 * @cfg: the throttling configuration to inspect
303 bool throttle_max_is_missing_limit(ThrottleConfig
*cfg
)
307 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
308 if (cfg
->buckets
[i
].max
&& !cfg
->buckets
[i
].avg
) {
315 /* fix bucket parameters */
316 static void throttle_fix_bucket(LeakyBucket
*bkt
)
320 /* zero bucket level */
323 /* The following is done to cope with the Linux CFQ block scheduler
324 * which regroup reads and writes by block of 100ms in the guest.
325 * When they are two process one making reads and one making writes cfq
326 * make a pattern looking like the following:
327 * WWWWWWWWWWWRRRRRRRRRRRRRRWWWWWWWWWWWWWwRRRRRRRRRRRRRRRRR
328 * Having a max burst value of 100ms of the average will help smooth the
332 if (bkt
->avg
&& !bkt
->max
) {
337 /* take care of canceling a timer */
338 static void throttle_cancel_timer(QEMUTimer
*timer
)
340 assert(timer
!= NULL
);
345 /* Used to configure the throttle
347 * @ts: the throttle state we are working on
348 * @tt: the throttle timers we use in this aio context
349 * @cfg: the config to set
351 void throttle_config(ThrottleState
*ts
,
359 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
360 throttle_fix_bucket(&ts
->cfg
.buckets
[i
]);
363 ts
->previous_leak
= qemu_clock_get_ns(tt
->clock_type
);
365 for (i
= 0; i
< 2; i
++) {
366 throttle_cancel_timer(tt
->timers
[i
]);
370 /* used to get config
372 * @ts: the throttle state we are working on
373 * @cfg: the config to write
375 void throttle_get_config(ThrottleState
*ts
, ThrottleConfig
*cfg
)
381 /* Schedule the read or write timer if needed
383 * NOTE: this function is not unit tested due to it's usage of timer_mod
385 * @tt: the timers structure
386 * @is_write: the type of operation (read/write)
387 * @ret: true if the timer has been scheduled else false
389 bool throttle_schedule_timer(ThrottleState
*ts
,
393 int64_t now
= qemu_clock_get_ns(tt
->clock_type
);
394 int64_t next_timestamp
;
397 must_wait
= throttle_compute_timer(ts
,
402 /* request not throttled */
407 /* request throttled and timer pending -> do nothing */
408 if (timer_pending(tt
->timers
[is_write
])) {
412 /* request throttled and timer not pending -> arm timer */
413 timer_mod(tt
->timers
[is_write
], next_timestamp
);
417 /* do the accounting for this operation
419 * @is_write: the type of operation (read/write)
420 * @size: the size of the operation
422 void throttle_account(ThrottleState
*ts
, bool is_write
, uint64_t size
)
426 /* if cfg.op_size is defined and smaller than size we compute unit count */
427 if (ts
->cfg
.op_size
&& size
> ts
->cfg
.op_size
) {
428 units
= (double) size
/ ts
->cfg
.op_size
;
431 ts
->cfg
.buckets
[THROTTLE_BPS_TOTAL
].level
+= size
;
432 ts
->cfg
.buckets
[THROTTLE_OPS_TOTAL
].level
+= units
;
435 ts
->cfg
.buckets
[THROTTLE_BPS_WRITE
].level
+= size
;
436 ts
->cfg
.buckets
[THROTTLE_OPS_WRITE
].level
+= units
;
438 ts
->cfg
.buckets
[THROTTLE_BPS_READ
].level
+= size
;
439 ts
->cfg
.buckets
[THROTTLE_OPS_READ
].level
+= units
;