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 "qapi/error.h"
27 #include "qemu/throttle.h"
28 #include "qemu/timer.h"
29 #include "block/aio.h"
31 /* This function make a bucket leak
33 * @bkt: the bucket to make leak
34 * @delta_ns: the time delta
36 void throttle_leak_bucket(LeakyBucket
*bkt
, int64_t delta_ns
)
40 /* compute how much to leak */
41 leak
= (bkt
->avg
* (double) delta_ns
) / NANOSECONDS_PER_SECOND
;
43 /* make the bucket leak */
44 bkt
->level
= MAX(bkt
->level
- leak
, 0);
46 /* if we allow bursts for more than one second we also need to
47 * keep track of bkt->burst_level so the bkt->max goal per second
49 if (bkt
->burst_length
> 1) {
50 leak
= (bkt
->max
* (double) delta_ns
) / NANOSECONDS_PER_SECOND
;
51 bkt
->burst_level
= MAX(bkt
->burst_level
- leak
, 0);
55 /* Calculate the time delta since last leak and make proportionals leaks
57 * @now: the current timestamp in ns
59 static void throttle_do_leak(ThrottleState
*ts
, int64_t now
)
61 /* compute the time elapsed since the last leak */
62 int64_t delta_ns
= now
- ts
->previous_leak
;
65 ts
->previous_leak
= now
;
71 /* make each bucket leak */
72 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
73 throttle_leak_bucket(&ts
->cfg
.buckets
[i
], delta_ns
);
77 /* do the real job of computing the time to wait
79 * @limit: the throttling limit
80 * @extra: the number of operation to delay
81 * @ret: the time to wait in ns
83 static int64_t throttle_do_compute_wait(double limit
, double extra
)
85 double wait
= extra
* NANOSECONDS_PER_SECOND
;
90 /* This function compute the wait time in ns that a leaky bucket should trigger
92 * @bkt: the leaky bucket we operate on
93 * @ret: the resulting wait time in ns or 0 if the operation can go through
95 int64_t throttle_compute_wait(LeakyBucket
*bkt
)
97 double extra
; /* the number of extra units blocking the io */
98 double bucket_size
; /* I/O before throttling to bkt->avg */
99 double burst_bucket_size
; /* Before throttling to bkt->max */
106 /* If bkt->max is 0 we still want to allow short bursts of I/O
107 * from the guest, otherwise every other request will be throttled
108 * and performance will suffer considerably. */
109 bucket_size
= (double) bkt
->avg
/ 10;
110 burst_bucket_size
= 0;
112 /* If we have a burst limit then we have to wait until all I/O
113 * at burst rate has finished before throttling to bkt->avg */
114 bucket_size
= bkt
->max
* bkt
->burst_length
;
115 burst_bucket_size
= (double) bkt
->max
/ 10;
118 /* If the main bucket is full then we have to wait */
119 extra
= bkt
->level
- bucket_size
;
121 return throttle_do_compute_wait(bkt
->avg
, extra
);
124 /* If the main bucket is not full yet we still have to check the
125 * burst bucket in order to enforce the burst limit */
126 if (bkt
->burst_length
> 1) {
127 assert(bkt
->max
> 0); /* see throttle_is_valid() */
128 extra
= bkt
->burst_level
- burst_bucket_size
;
130 return throttle_do_compute_wait(bkt
->max
, extra
);
137 /* This function compute the time that must be waited while this IO
139 * @is_write: true if the current IO is a write, false if it's a read
142 static int64_t throttle_compute_wait_for(ThrottleState
*ts
,
145 BucketType to_check
[2][4] = { {THROTTLE_BPS_TOTAL
,
152 THROTTLE_OPS_WRITE
}, };
153 int64_t wait
, max_wait
= 0;
156 for (i
= 0; i
< 4; i
++) {
157 BucketType index
= to_check
[is_write
][i
];
158 wait
= throttle_compute_wait(&ts
->cfg
.buckets
[index
]);
159 if (wait
> max_wait
) {
167 /* compute the timer for this type of operation
169 * @is_write: the type of operation
170 * @now: the current clock timestamp
171 * @next_timestamp: the resulting timer
172 * @ret: true if a timer must be set
174 static bool throttle_compute_timer(ThrottleState
*ts
,
177 int64_t *next_timestamp
)
181 /* leak proportionally to the time elapsed */
182 throttle_do_leak(ts
, now
);
184 /* compute the wait time if any */
185 wait
= throttle_compute_wait_for(ts
, is_write
);
187 /* if the code must wait compute when the next timer should fire */
189 *next_timestamp
= now
+ wait
;
193 /* else no need to wait at all */
194 *next_timestamp
= now
;
198 /* Add timers to event loop */
199 void throttle_timers_attach_aio_context(ThrottleTimers
*tt
,
200 AioContext
*new_context
)
202 ThrottleDirection dir
;
204 for (dir
= THROTTLE_READ
; dir
< THROTTLE_MAX
; dir
++) {
205 if (tt
->timer_cb
[dir
]) {
207 aio_timer_new(new_context
, tt
->clock_type
, SCALE_NS
,
208 tt
->timer_cb
[dir
], tt
->timer_opaque
);
214 * Initialize the ThrottleConfig structure to a valid state
215 * @cfg: the config to initialize
217 void throttle_config_init(ThrottleConfig
*cfg
)
220 memset(cfg
, 0, sizeof(*cfg
));
221 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
222 cfg
->buckets
[i
].burst_length
= 1;
226 /* To be called first on the ThrottleState */
227 void throttle_init(ThrottleState
*ts
)
229 memset(ts
, 0, sizeof(ThrottleState
));
230 throttle_config_init(&ts
->cfg
);
233 /* To be called first on the ThrottleTimers */
234 void throttle_timers_init(ThrottleTimers
*tt
,
235 AioContext
*aio_context
,
236 QEMUClockType clock_type
,
237 QEMUTimerCB
*read_timer_cb
,
238 QEMUTimerCB
*write_timer_cb
,
241 assert(read_timer_cb
|| write_timer_cb
);
242 memset(tt
, 0, sizeof(ThrottleTimers
));
244 tt
->clock_type
= clock_type
;
245 tt
->timer_cb
[THROTTLE_READ
] = read_timer_cb
;
246 tt
->timer_cb
[THROTTLE_WRITE
] = write_timer_cb
;
247 tt
->timer_opaque
= timer_opaque
;
248 throttle_timers_attach_aio_context(tt
, aio_context
);
251 /* destroy a timer */
252 static void throttle_timer_destroy(QEMUTimer
**timer
)
254 if (*timer
== NULL
) {
262 /* Remove timers from event loop */
263 void throttle_timers_detach_aio_context(ThrottleTimers
*tt
)
265 ThrottleDirection dir
;
267 for (dir
= THROTTLE_READ
; dir
< THROTTLE_MAX
; dir
++) {
268 throttle_timer_destroy(&tt
->timers
[dir
]);
272 /* To be called last on the ThrottleTimers */
273 void throttle_timers_destroy(ThrottleTimers
*tt
)
275 throttle_timers_detach_aio_context(tt
);
278 /* is any throttling timer configured */
279 bool throttle_timers_are_initialized(ThrottleTimers
*tt
)
281 ThrottleDirection dir
;
283 for (dir
= THROTTLE_READ
; dir
< THROTTLE_MAX
; dir
++) {
284 if (tt
->timers
[dir
]) {
292 /* Does any throttling must be done
294 * @cfg: the throttling configuration to inspect
295 * @ret: true if throttling must be done else false
297 bool throttle_enabled(ThrottleConfig
*cfg
)
301 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
302 if (cfg
->buckets
[i
].avg
> 0) {
310 /* check if a throttling configuration is valid
311 * @cfg: the throttling configuration to inspect
312 * @ret: true if valid else false
313 * @errp: error object
315 bool throttle_is_valid(ThrottleConfig
*cfg
, Error
**errp
)
318 bool bps_flag
, ops_flag
;
319 bool bps_max_flag
, ops_max_flag
;
321 bps_flag
= cfg
->buckets
[THROTTLE_BPS_TOTAL
].avg
&&
322 (cfg
->buckets
[THROTTLE_BPS_READ
].avg
||
323 cfg
->buckets
[THROTTLE_BPS_WRITE
].avg
);
325 ops_flag
= cfg
->buckets
[THROTTLE_OPS_TOTAL
].avg
&&
326 (cfg
->buckets
[THROTTLE_OPS_READ
].avg
||
327 cfg
->buckets
[THROTTLE_OPS_WRITE
].avg
);
329 bps_max_flag
= cfg
->buckets
[THROTTLE_BPS_TOTAL
].max
&&
330 (cfg
->buckets
[THROTTLE_BPS_READ
].max
||
331 cfg
->buckets
[THROTTLE_BPS_WRITE
].max
);
333 ops_max_flag
= cfg
->buckets
[THROTTLE_OPS_TOTAL
].max
&&
334 (cfg
->buckets
[THROTTLE_OPS_READ
].max
||
335 cfg
->buckets
[THROTTLE_OPS_WRITE
].max
);
337 if (bps_flag
|| ops_flag
|| bps_max_flag
|| ops_max_flag
) {
338 error_setg(errp
, "bps/iops/max total values and read/write values"
339 " cannot be used at the same time");
344 !cfg
->buckets
[THROTTLE_OPS_TOTAL
].avg
&&
345 !cfg
->buckets
[THROTTLE_OPS_READ
].avg
&&
346 !cfg
->buckets
[THROTTLE_OPS_WRITE
].avg
) {
347 error_setg(errp
, "iops size requires an iops value to be set");
351 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
352 LeakyBucket
*bkt
= &cfg
->buckets
[i
];
353 if (bkt
->avg
> THROTTLE_VALUE_MAX
|| bkt
->max
> THROTTLE_VALUE_MAX
) {
354 error_setg(errp
, "bps/iops/max values must be within [0, %lld]",
359 if (!bkt
->burst_length
) {
360 error_setg(errp
, "the burst length cannot be 0");
364 if (bkt
->burst_length
> 1 && !bkt
->max
) {
365 error_setg(errp
, "burst length set without burst rate");
369 if (bkt
->max
&& bkt
->burst_length
> THROTTLE_VALUE_MAX
/ bkt
->max
) {
370 error_setg(errp
, "burst length too high for this burst rate");
374 if (bkt
->max
&& !bkt
->avg
) {
375 error_setg(errp
, "bps_max/iops_max require corresponding"
380 if (bkt
->max
&& bkt
->max
< bkt
->avg
) {
381 error_setg(errp
, "bps_max/iops_max cannot be lower than bps/iops");
389 /* Used to configure the throttle
391 * @ts: the throttle state we are working on
392 * @clock_type: the group's clock_type
393 * @cfg: the config to set
395 void throttle_config(ThrottleState
*ts
,
396 QEMUClockType clock_type
,
403 /* Zero bucket level */
404 for (i
= 0; i
< BUCKETS_COUNT
; i
++) {
405 ts
->cfg
.buckets
[i
].level
= 0;
406 ts
->cfg
.buckets
[i
].burst_level
= 0;
409 ts
->previous_leak
= qemu_clock_get_ns(clock_type
);
412 /* used to get config
414 * @ts: the throttle state we are working on
415 * @cfg: the config to write
417 void throttle_get_config(ThrottleState
*ts
, ThrottleConfig
*cfg
)
423 /* Schedule the read or write timer if needed
425 * NOTE: this function is not unit tested due to it's usage of timer_mod
427 * @tt: the timers structure
428 * @is_write: the type of operation (read/write)
429 * @ret: true if the timer has been scheduled else false
431 bool throttle_schedule_timer(ThrottleState
*ts
,
435 int64_t now
= qemu_clock_get_ns(tt
->clock_type
);
436 int64_t next_timestamp
;
440 timer
= is_write
? tt
->timers
[THROTTLE_WRITE
] : tt
->timers
[THROTTLE_READ
];
443 must_wait
= throttle_compute_timer(ts
,
448 /* request not throttled */
453 /* request throttled and timer pending -> do nothing */
454 if (timer_pending(timer
)) {
458 /* request throttled and timer not pending -> arm timer */
459 timer_mod(timer
, next_timestamp
);
463 /* do the accounting for this operation
465 * @is_write: the type of operation (read/write)
466 * @size: the size of the operation
468 void throttle_account(ThrottleState
*ts
, bool is_write
, uint64_t size
)
470 const BucketType bucket_types_size
[2][2] = {
471 { THROTTLE_BPS_TOTAL
, THROTTLE_BPS_READ
},
472 { THROTTLE_BPS_TOTAL
, THROTTLE_BPS_WRITE
}
474 const BucketType bucket_types_units
[2][2] = {
475 { THROTTLE_OPS_TOTAL
, THROTTLE_OPS_READ
},
476 { THROTTLE_OPS_TOTAL
, THROTTLE_OPS_WRITE
}
481 /* if cfg.op_size is defined and smaller than size we compute unit count */
482 if (ts
->cfg
.op_size
&& size
> ts
->cfg
.op_size
) {
483 units
= (double) size
/ ts
->cfg
.op_size
;
486 for (i
= 0; i
< 2; i
++) {
489 bkt
= &ts
->cfg
.buckets
[bucket_types_size
[is_write
][i
]];
491 if (bkt
->burst_length
> 1) {
492 bkt
->burst_level
+= size
;
495 bkt
= &ts
->cfg
.buckets
[bucket_types_units
[is_write
][i
]];
497 if (bkt
->burst_length
> 1) {
498 bkt
->burst_level
+= units
;
503 /* return a ThrottleConfig based on the options in a ThrottleLimits
505 * @arg: the ThrottleLimits object to read from
506 * @cfg: the ThrottleConfig to edit
507 * @errp: error object
509 void throttle_limits_to_config(ThrottleLimits
*arg
, ThrottleConfig
*cfg
,
512 if (arg
->has_bps_total
) {
513 cfg
->buckets
[THROTTLE_BPS_TOTAL
].avg
= arg
->bps_total
;
515 if (arg
->has_bps_read
) {
516 cfg
->buckets
[THROTTLE_BPS_READ
].avg
= arg
->bps_read
;
518 if (arg
->has_bps_write
) {
519 cfg
->buckets
[THROTTLE_BPS_WRITE
].avg
= arg
->bps_write
;
522 if (arg
->has_iops_total
) {
523 cfg
->buckets
[THROTTLE_OPS_TOTAL
].avg
= arg
->iops_total
;
525 if (arg
->has_iops_read
) {
526 cfg
->buckets
[THROTTLE_OPS_READ
].avg
= arg
->iops_read
;
528 if (arg
->has_iops_write
) {
529 cfg
->buckets
[THROTTLE_OPS_WRITE
].avg
= arg
->iops_write
;
532 if (arg
->has_bps_total_max
) {
533 cfg
->buckets
[THROTTLE_BPS_TOTAL
].max
= arg
->bps_total_max
;
535 if (arg
->has_bps_read_max
) {
536 cfg
->buckets
[THROTTLE_BPS_READ
].max
= arg
->bps_read_max
;
538 if (arg
->has_bps_write_max
) {
539 cfg
->buckets
[THROTTLE_BPS_WRITE
].max
= arg
->bps_write_max
;
541 if (arg
->has_iops_total_max
) {
542 cfg
->buckets
[THROTTLE_OPS_TOTAL
].max
= arg
->iops_total_max
;
544 if (arg
->has_iops_read_max
) {
545 cfg
->buckets
[THROTTLE_OPS_READ
].max
= arg
->iops_read_max
;
547 if (arg
->has_iops_write_max
) {
548 cfg
->buckets
[THROTTLE_OPS_WRITE
].max
= arg
->iops_write_max
;
551 if (arg
->has_bps_total_max_length
) {
552 if (arg
->bps_total_max_length
> UINT_MAX
) {
553 error_setg(errp
, "bps-total-max-length value must be in"
554 " the range [0, %u]", UINT_MAX
);
557 cfg
->buckets
[THROTTLE_BPS_TOTAL
].burst_length
= arg
->bps_total_max_length
;
559 if (arg
->has_bps_read_max_length
) {
560 if (arg
->bps_read_max_length
> UINT_MAX
) {
561 error_setg(errp
, "bps-read-max-length value must be in"
562 " the range [0, %u]", UINT_MAX
);
565 cfg
->buckets
[THROTTLE_BPS_READ
].burst_length
= arg
->bps_read_max_length
;
567 if (arg
->has_bps_write_max_length
) {
568 if (arg
->bps_write_max_length
> UINT_MAX
) {
569 error_setg(errp
, "bps-write-max-length value must be in"
570 " the range [0, %u]", UINT_MAX
);
573 cfg
->buckets
[THROTTLE_BPS_WRITE
].burst_length
= arg
->bps_write_max_length
;
575 if (arg
->has_iops_total_max_length
) {
576 if (arg
->iops_total_max_length
> UINT_MAX
) {
577 error_setg(errp
, "iops-total-max-length value must be in"
578 " the range [0, %u]", UINT_MAX
);
581 cfg
->buckets
[THROTTLE_OPS_TOTAL
].burst_length
= arg
->iops_total_max_length
;
583 if (arg
->has_iops_read_max_length
) {
584 if (arg
->iops_read_max_length
> UINT_MAX
) {
585 error_setg(errp
, "iops-read-max-length value must be in"
586 " the range [0, %u]", UINT_MAX
);
589 cfg
->buckets
[THROTTLE_OPS_READ
].burst_length
= arg
->iops_read_max_length
;
591 if (arg
->has_iops_write_max_length
) {
592 if (arg
->iops_write_max_length
> UINT_MAX
) {
593 error_setg(errp
, "iops-write-max-length value must be in"
594 " the range [0, %u]", UINT_MAX
);
597 cfg
->buckets
[THROTTLE_OPS_WRITE
].burst_length
= arg
->iops_write_max_length
;
600 if (arg
->has_iops_size
) {
601 cfg
->op_size
= arg
->iops_size
;
604 throttle_is_valid(cfg
, errp
);
607 /* write the options of a ThrottleConfig to a ThrottleLimits
609 * @cfg: the ThrottleConfig to read from
610 * @var: the ThrottleLimits to write to
612 void throttle_config_to_limits(ThrottleConfig
*cfg
, ThrottleLimits
*var
)
614 var
->bps_total
= cfg
->buckets
[THROTTLE_BPS_TOTAL
].avg
;
615 var
->bps_read
= cfg
->buckets
[THROTTLE_BPS_READ
].avg
;
616 var
->bps_write
= cfg
->buckets
[THROTTLE_BPS_WRITE
].avg
;
617 var
->iops_total
= cfg
->buckets
[THROTTLE_OPS_TOTAL
].avg
;
618 var
->iops_read
= cfg
->buckets
[THROTTLE_OPS_READ
].avg
;
619 var
->iops_write
= cfg
->buckets
[THROTTLE_OPS_WRITE
].avg
;
620 var
->bps_total_max
= cfg
->buckets
[THROTTLE_BPS_TOTAL
].max
;
621 var
->bps_read_max
= cfg
->buckets
[THROTTLE_BPS_READ
].max
;
622 var
->bps_write_max
= cfg
->buckets
[THROTTLE_BPS_WRITE
].max
;
623 var
->iops_total_max
= cfg
->buckets
[THROTTLE_OPS_TOTAL
].max
;
624 var
->iops_read_max
= cfg
->buckets
[THROTTLE_OPS_READ
].max
;
625 var
->iops_write_max
= cfg
->buckets
[THROTTLE_OPS_WRITE
].max
;
626 var
->bps_total_max_length
= cfg
->buckets
[THROTTLE_BPS_TOTAL
].burst_length
;
627 var
->bps_read_max_length
= cfg
->buckets
[THROTTLE_BPS_READ
].burst_length
;
628 var
->bps_write_max_length
= cfg
->buckets
[THROTTLE_BPS_WRITE
].burst_length
;
629 var
->iops_total_max_length
= cfg
->buckets
[THROTTLE_OPS_TOTAL
].burst_length
;
630 var
->iops_read_max_length
= cfg
->buckets
[THROTTLE_OPS_READ
].burst_length
;
631 var
->iops_write_max_length
= cfg
->buckets
[THROTTLE_OPS_WRITE
].burst_length
;
632 var
->iops_size
= cfg
->op_size
;
634 var
->has_bps_total
= true;
635 var
->has_bps_read
= true;
636 var
->has_bps_write
= true;
637 var
->has_iops_total
= true;
638 var
->has_iops_read
= true;
639 var
->has_iops_write
= true;
640 var
->has_bps_total_max
= true;
641 var
->has_bps_read_max
= true;
642 var
->has_bps_write_max
= true;
643 var
->has_iops_total_max
= true;
644 var
->has_iops_read_max
= true;
645 var
->has_iops_write_max
= true;
646 var
->has_bps_read_max_length
= true;
647 var
->has_bps_total_max_length
= true;
648 var
->has_bps_write_max_length
= true;
649 var
->has_iops_total_max_length
= true;
650 var
->has_iops_read_max_length
= true;
651 var
->has_iops_write_max_length
= true;
652 var
->has_iops_size
= true;