Re: [PATCH] docs: Document the throttle block filter

[Kevin Wolf <kwolf@redhat.com>]

Am 21.09.2020 um 19:30 hat Alberto Garcia geschrieben:
> This filter was added back in 2017 for QEMU 2.11 but it was never
> properly documented, so let's explain how it works and add a couple of
> examples.
> 
> Signed-off-by: Alberto Garcia <berto@igalia.com>
> ---
>  docs/throttle.txt | 107 +++++++++++++++++++++++++++++++++++++++++++++-
>  1 file changed, 106 insertions(+), 1 deletion(-)
> 
> diff --git a/docs/throttle.txt b/docs/throttle.txt
> index cd4e109d39..c06d1b9662 100644
> --- a/docs/throttle.txt
> +++ b/docs/throttle.txt
> @@ -1,6 +1,6 @@
>  The QEMU throttling infrastructure
>  ==================================
> -Copyright (C) 2016 Igalia, S.L.
> +Copyright (C) 2016,2020 Igalia, S.L.
>  Author: Alberto Garcia <berto@igalia.com>
>  
>  This work is licensed under the terms of the GNU GPL, version 2 or
> @@ -253,3 +253,108 @@ up. After those 60 seconds the bucket will have leaked 60 x 100 =
>  
>  Also, due to the way the algorithm works, longer burst can be done at
>  a lower I/O rate, e.g. 1000 IOPS during 120 seconds.
> +
> +
> +The 'throttle' block filter
> +---------------------------
> +Since QEMU 2.11 it is possible to configure the I/O limits using a
> +'throttle' block filter. This filter uses the exact same throttling
> +infrastructure described above but can be used anywhere in the node
> +graph, allowing for more flexibility.
> +
> +The user can create an arbitrary number of filters and each one of
> +them must be assigned to a group that contains the actual I/O limits.
> +Different filters can use the same group so the limits are shared as
> +described earlier in "Applying I/O limits to groups of disks".
> +
> +A group can be created using the object-add QMP function:
> +
> +   { "execute": "object-add",
> +     "arguments": {
> +       "qom-type": "throttle-group",
> +       "id": "group0",
> +       "props": {
> +         "limits" : {
> +           "iops-total": 1000
> +           "bps-write": 2097152
> +         }
> +       }
> +     }
> +   }
> +
> +throttle-group has a 'limits' property (of type ThrottleLimits as
> +defined in qapi/block-core.json) which can be set on creation or later
> +with 'qom-set'.
> +
> +A throttle-group can also be created with the -object command line
> +option but at the moment there is no way to pass a 'limits' parameter
> +that contains a ThrottleLimits structure. The solution is to set the
> +individual values directly, like in this example:
> +
> +   -object throttle-group,id=group0,x-iops-total=1000,x-bps-write=2097152
> +
> +Note however that this not stable API (hence the 'x-' prefixes) and
> +can change or disappear in the future.

Should we use a stronger wording here, like "will disappear when -object
gains support for structured options and enables use of 'limits'"?

> +Once we have a throttle-group we can use the throttle block filter,
> +where the 'file' property must be set to the block device that we want
> +to filter:
> +
> +   { "execute": "blockdev-add",
> +     "arguments": {
> +        "options":  {
> +           "driver": "qcow2",
> +           "node-name": "disk0",
> +           "file": {
> +              "driver": "file",
> +              "filename": "/path/to/disk.qcow2"
> +           }
> +        }
> +     }
> +   }
> +
> +   { "execute": "blockdev-add",
> +     "arguments": {
> +        "driver": "throttle",
> +        "node-name": "throttle0",
> +        "throttle-group": "group0",
> +        "file": "disk0"
> +     }
> +   }
> +
> +A similar setup can also be done with the command line, for example:
> +
> +   -drive driver=throttle,throttle-group=group0,
> +          file.driver=qcow2,file.file.filename=/path/to/disk.qcow2
> +
> +The scenario described so far is very simple but the throttle block
> +filter allows for more complex configurations. For example, let's say
> +that we have three different drives and we want to set I/O limits for
> +each one of them and an additional set of limits for the combined I/O
> +of all three drives.
> +
> +First we would define all throttle groups, one for each one of the
> +drives and one that would apply to all of them:
> +
> +   -object throttle-group,id=limits0,x-iops-total=2000
> +   -object throttle-group,id=limits1,x-iops-total=2500
> +   -object throttle-group,id=limits2,x-iops-total=3000
> +   -object throttle-group,id=limits012,x-iops-total=4000
> +
> +Now we can define the drives, and for each one of them we use two
> +chained throttle filters: the drive's own filter and the combined
> +filter.
> +
> +   -drive driver=throttle,throttle-group=limits012,
> +          file.driver=throttle,file.throttle-group=limits0
> +          file.file.driver=qcow2,file.file.file.filename=/path/to/disk0.qcow2
> +   -drive driver=throttle,throttle-group=limits012,
> +          file.driver=throttle,file.throttle-group=limits1
> +          file.file.driver=qcow2,file.file.file.filename=/path/to/disk1.qcow2
> +   -drive driver=throttle,throttle-group=limits012,
> +          file.driver=throttle,file.throttle-group=limits2
> +          file.file.driver=qcow2,file.file.file.filename=/path/to/disk2.qcow2
> +
> +In this example the individual drives have IOPS limits of 2000, 2500
> +and 3000 respectively but the total combined I/O can never exceed 4000
> +IOPS.

Reviewed-by: Kevin Wolf <kwolf@redhat.com>

Depending on whether you want to change the sentence about the unstable
interface, I'll wait for v2 or merge this one.

Kevin