xref: /openbmc/qemu/docs/devel/migration/dirty-limit.rst (revision 4c6f8a79)

Dirty limit
===========

The dirty limit, short for dirty page rate upper limit, is a new capability
introduced in the 8.1 QEMU release that uses a new algorithm based on the KVM
dirty ring to throttle down the guest during live migration.

The algorithm framework is as follows:

::

  ------------------------------------------------------------------------------
  main   --------------> throttle thread ------------> PREPARE(1) <--------
  thread  \                                                |              |
           \                                               |              |
            \                                              V              |
             -\                                        CALCULATE(2)       |
               \                                           |              |
                \                                          |              |
                 \                                         V              |
                  \                                    SET PENALTY(3) -----
                   -\                                      |
                     \                                     |
                      \                                    V
                       -> virtual CPU thread -------> ACCEPT PENALTY(4)
  ------------------------------------------------------------------------------

When the qmp command qmp_set_vcpu_dirty_limit is called for the first time,
the QEMU main thread starts the throttle thread. The throttle thread, once
launched, executes the loop, which consists of three steps:

  - PREPARE (1)

     The entire work of PREPARE (1) is preparation for the second stage,
     CALCULATE(2), as the name implies. It involves preparing the dirty
     page rate value and the corresponding upper limit of the VM:
     The dirty page rate is calculated via the KVM dirty ring mechanism,
     which tells QEMU how many dirty pages a virtual CPU has had since the
     last KVM_EXIT_DIRTY_RING_FULL exception; The dirty page rate upper
     limit is specified by caller, therefore fetch it directly.

  - CALCULATE (2)

     Calculate a suitable sleep period for each virtual CPU, which will be
     used to determine the penalty for the target virtual CPU. The
     computation must be done carefully in order to reduce the dirty page
     rate progressively down to the upper limit without oscillation. To
     achieve this, two strategies are provided: the first is to add or
     subtract sleep time based on the ratio of the current dirty page rate
     to the limit, which is used when the current dirty page rate is far
     from the limit; the second is to add or subtract a fixed time when
     the current dirty page rate is close to the limit.

  - SET PENALTY (3)

     Set the sleep time for each virtual CPU that should be penalized based
     on the results of the calculation supplied by step CALCULATE (2).

After completing the three above stages, the throttle thread loops back
to step PREPARE (1) until the dirty limit is reached.

On the other hand, each virtual CPU thread reads the sleep duration and
sleeps in the path of the KVM_EXIT_DIRTY_RING_FULL exception handler, that
is ACCEPT PENALTY (4). Virtual CPUs tied with writing processes will
obviously exit to the path and get penalized, whereas virtual CPUs involved
with read processes will not.

In summary, thanks to the KVM dirty ring technology, the dirty limit
algorithm will restrict virtual CPUs as needed to keep their dirty page
rate inside the limit. This leads to more steady reading performance during
live migration and can aid in improving large guest responsiveness.