include/qemu/ratelimit.h

   1 /*
   2  * Ratelimiting calculations
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  10  * See the COPYING.LIB file in the top-level directory.
  11  *
  12  */
  13
  14 #ifndef QEMU_RATELIMIT_H
  15 #define QEMU_RATELIMIT_H
  16
  17 #include "qemu/lockable.h"
  18 #include "qemu/timer.h"
  19
  20 typedef struct {
  21     QemuMutex lock;
  22     int64_t slice_start_time;
  23     int64_t slice_end_time;
  24     uint64_t slice_quota;
  25     uint64_t slice_ns;
  26     uint64_t dispatched;
  27 } RateLimit;
  28
  29 /** Calculate and return delay for next request in ns
  30  *
  31  * Record that we sent @n data units (where @n matches the scale chosen
  32  * during ratelimit_set_speed). If we may send more data units
  33  * in the current time slice, return 0 (i.e. no delay). Otherwise
  34  * return the amount of time (in ns) until the start of the next time
  35  * slice that will permit sending the next chunk of data.
  36  *
  37  * Recording sent data units even after exceeding the quota is
  38  * permitted; the time slice will be extended accordingly.
  39  */
  40 static inline int64_t ratelimit_calculate_delay(RateLimit *limit, uint64_t n)
  41 {
  42     int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
  43     double delay_slices;
  44
  45     QEMU_LOCK_GUARD(&limit->lock);
  46     if (!limit->slice_quota) {
  47         /* Throttling disabled.  */
  48         return 0;
  49     }
  50     assert(limit->slice_ns);
  51
  52     if (limit->slice_end_time < now) {
  53         /* Previous, possibly extended, time slice finished; reset the
  54          * accounting. */
  55         limit->slice_start_time = now;
  56         limit->slice_end_time = now + limit->slice_ns;
  57         limit->dispatched = 0;
  58     }
  59
  60     limit->dispatched += n;
  61     if (limit->dispatched < limit->slice_quota) {
  62         /* We may send further data within the current time slice, no
  63          * need to delay the next request. */
  64         return 0;
  65     }
  66
  67     /* Quota exceeded. Wait based on the excess amount and then start a new
  68      * slice. */
  69     delay_slices = (double)limit->dispatched / limit->slice_quota;
  70     limit->slice_end_time = limit->slice_start_time +
  71         (uint64_t)(delay_slices * limit->slice_ns);
  72     return limit->slice_end_time - now;
  73 }
  74
  75 static inline void ratelimit_init(RateLimit *limit)
  76 {
  77     qemu_mutex_init(&limit->lock);
  78 }
  79
  80 static inline void ratelimit_destroy(RateLimit *limit)
  81 {
  82     qemu_mutex_destroy(&limit->lock);
  83 }
  84
  85 static inline void ratelimit_set_speed(RateLimit *limit, uint64_t speed,
  86                                        uint64_t slice_ns)
  87 {
  88     QEMU_LOCK_GUARD(&limit->lock);
  89     limit->slice_ns = slice_ns;
  90     if (speed == 0) {
  91         limit->slice_quota = 0;
  92     } else {
  93         limit->slice_quota = MAX(((double)speed * slice_ns) / 1000000000ULL, 1);
  94     }
  95 }
  96
  97 #endif