async: fix hangs on weakly-ordered architectures
cover async: fix hangs on weakly-ordered architectures
ARM machines and other weakly-ordered architectures have been suffering for a long time from hangs in qemu-img and qemu-io. For QEMU binaries these are mitigated by the timers that sooner or later fire in the main loop, but these will not happen for the tools and probably not with I/O threads either.
The fix is in patch 5. Patch 1-3 are docs updates that explain the bug, and patch 4 is a bugfix exposed by the new patch.
Paolo
Paolo Bonzini (5):
atomics: convert to reStructuredText
atomics: update documentation
rcu: do not mention atomic_mb_read/set in documentation
aio-wait: delegate polling of main AioContext if BQL not held
async: use explicit memory barriers
docs/devel/atomics.rst | 501 +++++++++++++++++++++++++++++++++++++++ docs/devel/atomics.txt | 403 ------------------------------- docs/devel/index.rst | 1 + docs/devel/rcu.txt | 4 +- include/block/aio-wait.h | 22 ++ include/block/aio.h | 29 +-- util/aio-posix.c | 16 +- util/aio-win32.c | 17 +- util/async.c | 16 +- 9 files changed, 576 insertions(+), 433 deletions(-) create mode 100644 docs/devel/atomics.rst delete mode 100644 docs/devel/atomics.txt
Signature · 1 line
2.18.2
PATCH 1/5 atomics: convert to reStructuredText
No attempts to fix or update the text; these are left for the next patch in the series.
--- docs/devel/atomics.rst | 446 +++++++++++++++++++++++++++++++++++++++++ docs/devel/atomics.txt | 403 ------------------------------------- docs/devel/index.rst | 1 + 3 files changed, 447 insertions(+), 403 deletions(-) create mode 100644 docs/devel/atomics.rst delete mode 100644 docs/devel/atomics.txt
docs/devel/atomics.rst new file +446 -0
@@ -0,0 +1,446 @@ +========================= +Atomic operations in QEMU +========================= + +CPUs perform independent memory operations effectively in random order. +but this can be a problem for CPU-CPU interaction (including interactions +between QEMU and the guest). Multi-threaded programs use various tools +to instruct the compiler and the CPU to restrict the order to something +that is consistent with the expectations of the programmer. + +The most basic tool is locking. Mutexes, condition variables and +semaphores are used in QEMU, and should be the default approach to +synchronization. Anything else is considerably harder, but it's +also justified more often than one would like. The two tools that +are provided by ``qemu/atomic.h`` are memory barriers and atomic operations. + +Macros defined by ``qemu/atomic.h`` fall in three camps: + +- compiler barriers: ``barrier()``; + +- weak atomic access and manual memory barriers: ``atomic_read()``, + ``atomic_set()``, ``smp_rmb()``, ``smp_wmb()``, ``smp_mb()``, ``smp_mb_acquire()``, + ``smp_mb_release()``, ``smp_read_barrier_depends()``; + +- sequentially consistent atomic access: everything else. + + +Compiler memory barrier +======================= + +``barrier()`` prevents the compiler from moving the memory accesses either +side of it to the other side. The compiler barrier has no direct effect +on the CPU, which may then reorder things however it wishes. + +``barrier()`` is mostly used within ``qemu/atomic.h`` itself. On some +architectures, CPU guarantees are strong enough that blocking compiler +optimizations already ensures the correct order of execution. In this +case, ``qemu/atomic.h`` will reduce stronger memory barriers to simple +compiler barriers. + +Still, ``barrier()`` can be useful when writing code that can be interrupted +by signal handlers. + + +Sequentially consistent atomic access +===================================== + +Most of the operations in the ``qemu/atomic.h`` header ensure *sequential +consistency*, where "the result of any execution is the same as if the +operations of all the processors were executed in some sequential order, +and the operations of each individual processor appear in this sequence +in the order specified by its program". + +``qemu/atomic.h`` provides the following set of atomic read-modify-write +operations:: + + void atomic_inc(ptr) + void atomic_dec(ptr) + void atomic_add(ptr, val) + void atomic_sub(ptr, val) + void atomic_and(ptr, val) + void atomic_or(ptr, val) + + typeof(*ptr) atomic_fetch_inc(ptr) + typeof(*ptr) atomic_fetch_dec(ptr) + typeof(*ptr) atomic_fetch_add(ptr, val) + typeof(*ptr) atomic_fetch_sub(ptr, val) + typeof(*ptr) atomic_fetch_and(ptr, val) + typeof(*ptr) atomic_fetch_or(ptr, val) + typeof(*ptr) atomic_fetch_xor(ptr, val) + typeof(*ptr) atomic_fetch_inc_nonzero(ptr) + typeof(*ptr) atomic_xchg(ptr, val) + typeof(*ptr) atomic_cmpxchg(ptr, old, new) + +all of which return the old value of ``*ptr``. These operations are +polymorphic; they operate on any type that is as wide as a pointer. + +Similar operations return the new value of ``*ptr``:: + + typeof(*ptr) atomic_inc_fetch(ptr) + typeof(*ptr) atomic_dec_fetch(ptr) + typeof(*ptr) atomic_add_fetch(ptr, val) + typeof(*ptr) atomic_sub_fetch(ptr, val) + typeof(*ptr) atomic_and_fetch(ptr, val) + typeof(*ptr) atomic_or_fetch(ptr, val) + typeof(*ptr) atomic_xor_fetch(ptr, val) + +Sequentially consistent loads and stores can be done using:: + + atomic_fetch_add(ptr, 0) for loads + atomic_xchg(ptr, val) for stores + +However, they are quite expensive on some platforms, notably POWER and +Arm. Therefore, qemu/atomic.h provides two primitives with slightly +weaker constraints:: + + typeof(*ptr) atomic_mb_read(ptr) + void atomic_mb_set(ptr, val) + +The semantics of these primitives map to Java volatile variables, +and are strongly related to memory barriers as used in the Linux +kernel (see below). + +As long as you use atomic_mb_read and atomic_mb_set, accesses cannot +be reordered with each other, and it is also not possible to reorder +"normal" accesses around them. + +However, and this is the important difference between +atomic_mb_read/atomic_mb_set and sequential consistency, it is important +for both threads to access the same volatile variable. It is not the +case that everything visible to thread A when it writes volatile field f +becomes visible to thread B after it reads volatile field g. The store +and load have to "match" (i.e., be performed on the same volatile +field) to achieve the right semantics. + + +These operations operate on any type that is as wide as an int or smaller. + + +Weak atomic access and manual memory barriers +============================================= + +Compared to sequentially consistent atomic access, programming with +weaker consistency models can be considerably more complicated. +In general, if the algorithm you are writing includes both writes +and reads on the same side, it is generally simpler to use sequentially +consistent primitives. + +When using this model, variables are accessed with: + +- ``atomic_read()`` and ``atomic_set()``; these prevent the compiler from + optimizing accesses out of existence and creating unsolicited + accesses, but do not otherwise impose any ordering on loads and + stores: both the compiler and the processor are free to reorder + them. + +- ``atomic_load_acquire()``, which guarantees the LOAD to appear to + happen, with respect to the other components of the system, + before all the LOAD or STORE operations specified afterwards. + Operations coming before ``atomic_load_acquire()`` can still be + reordered after it. + +- ``atomic_store_release()``, which guarantees the STORE to appear to + happen, with respect to the other components of the system, + after all the LOAD or STORE operations specified afterwards. + Operations coming after ``atomic_store_release()`` can still be + reordered after it. + +Restrictions to the ordering of accesses can also be specified +using the memory barrier macros: ``smp_rmb()``, ``smp_wmb()``, ``smp_mb()``, +``smp_mb_acquire()``, ``smp_mb_release()``, ``smp_read_barrier_depends()``. + +Memory barriers control the order of references to shared memory. +They come in six kinds: + +- ``smp_rmb()`` guarantees that all the LOAD operations specified before + the barrier will appear to happen before all the LOAD operations + specified after the barrier with respect to the other components of + the system. + + In other words, ``smp_rmb()`` puts a partial ordering on loads, but is not + required to have any effect on stores. + +- ``smp_wmb()`` guarantees that all the STORE operations specified before + the barrier will appear to happen before all the STORE operations + specified after the barrier with respect to the other components of + the system. + + In other words, ``smp_wmb()`` puts a partial ordering on stores, but is not + required to have any effect on loads. + +- ``smp_mb_acquire()`` guarantees that all the LOAD operations specified before + the barrier will appear to happen before all the LOAD or STORE operations + specified after the barrier with respect to the other components of + the system. + +- ``smp_mb_release()`` guarantees that all the STORE operations specified *after* + the barrier will appear to happen after all the LOAD or STORE operations + specified *before* the barrier with respect to the other components of + the system. + +- ``smp_mb()`` guarantees that all the LOAD and STORE operations specified + before the barrier will appear to happen before all the LOAD and + STORE operations specified after the barrier with respect to the other + components of the system. + + ``smp_mb()`` puts a partial ordering on both loads and stores. It is + stronger than both a read and a write memory barrier; it implies both + ``smp_mb_acquire()`` and ``smp_mb_release()``, but it also prevents STOREs + coming before the barrier from overtaking LOADs coming after the + barrier and vice versa. + +- ``smp_read_barrier_depends()`` is a weaker kind of read barrier. On + most processors, whenever two loads are performed such that the + second depends on the result of the first (e.g., the first load + retrieves the address to which the second load will be directed), + the processor will guarantee that the first LOAD will appear to happen + before the second with respect to the other components of the system. + However, this is not always true---for example, it was not true on + Alpha processors. Whenever this kind of access happens to shared + memory (that is not protected by a lock), a read barrier is needed, + and ``smp_read_barrier_depends()`` can be used instead of ``smp_rmb()``. + + Note that the first load really has to have a _data_ dependency and not + a control dependency. If the address for the second load is dependent + on the first load, but the dependency is through a conditional rather + than actually loading the address itself, then it's a _control_ + dependency and a full read barrier or better is required. + + +This is the set of barriers that is required *between* two ``atomic_read()`` +and ``atomic_set()`` operations to achieve sequential consistency: + + +----------------+-------------------------------------------------------+ + | | 2nd operation | + | +------------------+-----------------+------------------+ + | 1st operation | (after last) | atomic_read | atomic_set | + +----------------+------------------+-----------------+------------------+ + | (before first) | .. | none | smp_mb_release() | + +----------------+------------------+-----------------+------------------+ + | atomic_read | smp_mb_acquire() | smp_rmb() [1]_ | [2]_ | + +----------------+------------------+-----------------+------------------+ + | atomic_set | none | smp_mb() [3]_ | smp_wmb() | + +----------------+------------------+-----------------+------------------+ + + .. [1] Or smp_read_barrier_depends(). + + .. [2] This requires a load-store barrier. This is achieved by + either smp_mb_acquire() or smp_mb_release(). + + .. [3] This requires a store-load barrier. On most machines, the only + way to achieve this is a full barrier. + + +You can see that the two possible definitions of ``atomic_mb_read()`` +and ``atomic_mb_set()`` are the following: + + 1) | atomic_mb_read(p) = atomic_read(p); smp_mb_acquire() + | atomic_mb_set(p, v) = smp_mb_release(); atomic_set(p, v); smp_mb() + + 2) | atomic_mb_read(p) = smp_mb() atomic_read(p); smp_mb_acquire() + | atomic_mb_set(p, v) = smp_mb_release(); atomic_set(p, v); + +Usually the former is used, because ``smp_mb()`` is expensive and a program +normally has more reads than writes. Therefore it makes more sense to +make ``atomic_mb_set()`` the more expensive operation. + +There are two common cases in which atomic_mb_read and atomic_mb_set +generate too many memory barriers, and thus it can be useful to manually +place barriers, or use atomic_load_acquire/atomic_store_release instead: + +- when a data structure has one thread that is always a writer + and one thread that is always a reader, manual placement of + memory barriers makes the write side faster. Furthermore, + correctness is easy to check for in this case using the "pairing" + trick that is explained below: + + +----------------------------------------------------------------------+ + | thread 1 | + +-----------------------------------+----------------------------------+ + | before | after | + +===================================+==================================+ + | :: | :: | + | | | + | (other writes) | | + | atomic_mb_set(&a, x) | atomic_store_release(&a, x) | + | atomic_mb_set(&b, y) | atomic_store_release(&b, y) | + +-----------------------------------+----------------------------------+ + + +----------------------------------------------------------------------+ + | thread 2 | + +-----------------------------------+----------------------------------+ + | before | after | + +===================================+==================================+ + | :: | :: | + | | | + | y = atomic_mb_read(&b) | y = atomic_load_acquire(&b) | + | x = atomic_mb_read(&a) | x = atomic_load_acquire(&a) | + | (other reads) | | + +-----------------------------------+----------------------------------+ + + Note that the barrier between the stores in thread 1, and between + the loads in thread 2, has been optimized here to a write or a + read memory barrier respectively. On some architectures, notably + ARMv7, smp_mb_acquire and smp_mb_release are just as expensive as + smp_mb, but smp_rmb and/or smp_wmb are more efficient. + +- sometimes, a thread is accessing many variables that are otherwise + unrelated to each other (for example because, apart from the current + thread, exactly one other thread will read or write each of these + variables). In this case, it is possible to "hoist" the implicit + barriers provided by ``atomic_mb_read()`` and ``atomic_mb_set()`` outside + a loop. For example, the above definition ``atomic_mb_read()`` gives + the following transformation: + + +-----------------------------------+----------------------------------+ + | before | after | + +===================================+==================================+ + | :: | :: | + | | | + | n = 0; | n = 0; | + | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | + | n += atomic_mb_read(&a[i]); | n += atomic_read(&a[i]); | + | | smp_mb_acquire(); | + +-----------------------------------+----------------------------------+ + + Similarly, atomic_mb_set() can be transformed as follows: + + +-----------------------------------+----------------------------------+ + | before | after | + +===================================+==================================+ + | :: | :: | + | | | + | | smp_mb_release(); | + | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | + | atomic_mb_set(&a[i], false); | atomic_set(&a[i], false); | + | | smp_mb(); | + +-----------------------------------+----------------------------------+ + + + The other thread can still use ``atomic_mb_read()``/``atomic_mb_set()``. + +The two tricks can be combined. In this case, splitting a loop in +two lets you hoist the barriers out of the loops _and_ eliminate the +expensive ``smp_mb()``: + + +-----------------------------------+----------------------------------+ + | before | after | + +===================================+==================================+ + | :: | :: | + | | | + | | smp_mb_release(); | + | for (i = 0; i < 10; i++) { | for (i = 0; i < 10; i++) | + | atomic_mb_set(&a[i], false); | atomic_set(&a[i], false); | + | atomic_mb_set(&b[i], false); | smb_wmb(); | + | } | for (i = 0; i < 10; i++) | + | | atomic_set(&a[i], false); | + | | smp_mb(); | + +-----------------------------------+----------------------------------+ + + +Memory barrier pairing +---------------------- + +A useful rule of thumb is that memory barriers should always, or almost +always, be paired with another barrier. In the case of QEMU, however, +note that the other barrier may actually be in a driver that runs in +the guest! + +For the purposes of pairing, ``smp_read_barrier_depends()`` and ``smp_rmb()`` +both count as read barriers. A read barrier shall pair with a write +barrier or a full barrier; a write barrier shall pair with a read +barrier or a full barrier. A full barrier can pair with anything. +For example: + + +--------------------+------------------------------+ + | thread 1 | thread 2 | + +====================+==============================+ + | :: | :: | + | | | + | a = 1; | | + | smp_wmb(); | | + | b = 2; | x = b; | + | | smp_rmb(); | + | | y = a; | + +--------------------+------------------------------+ + +Note that the "writing" thread is accessing the variables in the +opposite order as the "reading" thread. This is expected: stores +before the write barrier will normally match the loads after the +read barrier, and vice versa. The same is true for more than 2 +access and for data dependency barriers: + + +----------------------+------------------------------+ + | thread 1 | thread 2 | + +======================+==============================+ + | :: | :: | + | | | + | b[2] = 1; | | + | smp_wmb(); | | + | x->i = 2; | | + | smp_wmb(); | | + | a = x; | x = a; | + | | smp_read_barrier_depends(); | + | | y = x->i; | + | | smp_read_barrier_depends(); | + | | z = b[y]; | + +----------------------+------------------------------+ + +``smp_wmb()`` also pairs with ``atomic_mb_read()`` and ``smp_mb_acquire()``. +and ``smp_rmb()`` also pairs with ``atomic_mb_set()`` and ``smp_mb_release()``. + + +Comparison with Linux kernel memory barriers +============================================ + +Here is a list of differences between Linux kernel atomic operations +and memory barriers, and the equivalents in QEMU: + +- atomic operations in Linux are always on a 32-bit int type and + use a boxed ``atomic_t`` type; atomic operations in QEMU are polymorphic + and use normal C types. + +- Originally, ``atomic_read`` and ``atomic_set`` in Linux gave no guarantee + at all. Linux 4.1 updated them to implement volatile + semantics via ``ACCESS_ONCE`` (or the more recent ``READ``/``WRITE_ONCE``). + + QEMU's ``atomic_read`` and ``atomic_set`` implement C11 atomic relaxed + semantics if the compiler supports it, and volatile semantics otherwise. + Both semantics prevent the compiler from doing certain transformations; + the difference is that atomic accesses are guaranteed to be atomic, + while volatile accesses aren't. Thus, in the volatile case we just cross + our fingers hoping that the compiler will generate atomic accesses, + since we assume the variables passed are machine-word sized and + properly aligned. + + No barriers are implied by ``atomic_read`` and ``atomic_set`` in either Linux + or QEMU. + +- atomic read-modify-write operations in Linux are of three kinds: + + ===================== ========================================= + ``atomic_OP`` returns void + ``atomic_OP_return`` returns new value of the variable + ``atomic_fetch_OP`` returns the old value of the variable + ``atomic_cmpxchg`` returns the old value of the variable + ===================== ========================================= + + In QEMU, the second kind does not exist. Currently Linux has + atomic_fetch_or only. QEMU provides and, or, inc, dec, add, sub. + +- different atomic read-modify-write operations in Linux imply + a different set of memory barriers; in QEMU, all of them enforce + sequential consistency, which means they imply full memory barriers + before and after the operation. + +- Linux does not have an equivalent of ``atomic_mb_set()``. In particular, + note that ``smp_store_mb()`` is a little weaker than ``atomic_mb_set()``. + ``atomic_mb_read()`` compiles to the same instructions as Linux's + ``smp_load_acquire()``, but this should be treated as an implementation + detail. + +Sources +======= + +- ``Documentation/memory-barriers.txt`` from the Linux kernel
docs/devel/atomics.txt deleted +0 -403
403 lines not on this page · raw message
docs/devel/index.rst +1 -0
@@ -17,6 +17,7 @@ Contents: loads-stores memory migration + atomics stable-process testing decodetree
Signature · 1 line
2.18.2
Re: [PATCH 1/5] atomics: convert to reStructuredText
Quoted 4 lines · Paolo Bonzini
No attempts to fix or update the text; these are left for the next patch in the series.
Signed-off-by Paolo Bonzini <[email protected]>
Signature · 1 line
Alex Bennée
PATCH 2/5 atomics: update documentation
In reply to Paolo BonziniSome of the constraints on operand sizes have been relaxed, so adjust the documentation.
Deprecate atomic_mb_read and atomic_mb_set; it is not really possible to use them correctly because they do not interoperate with sequentially-consistent RMW operations.
Finally, extend the memory barrier pairing section to cover acquire and release semantics in general, roughly based on the KVM Forum 2016 talk, "<atomic.h> weapons".
--- docs/devel/atomics.rst | 467 +++++++++++++++++++++++------------------ 1 file changed, 261 insertions(+), 206 deletions(-)
docs/devel/atomics.rst +261 -206
@@ -11,10 +11,15 @@ that is consistent with the expectations of the programmer. The most basic tool is locking. Mutexes, condition variables and semaphores are used in QEMU, and should be the default approach to synchronization. Anything else is considerably harder, but it's -also justified more often than one would like. The two tools that -are provided by ``qemu/atomic.h`` are memory barriers and atomic operations. +also justified more often than one would like; +the most performance-critical parts of QEMU in particular require +a very low level approach to concurrency, involving memory barriers +and atomic operations. The semantics of concurrent memory accesses are governed +by the C11 memory model. -Macros defined by ``qemu/atomic.h`` fall in three camps: +QEMU provides a header, ``qemu/atomic.h``, which wraps C11 atomics to +provide better portability and a less verbose syntax. ``qemu/atomic.h`` +provides macros that fall in three camps: - compiler barriers: ``barrier()``;
@@ -24,13 +29,21 @@ Macros defined by ``qemu/atomic.h`` fall in three camps: - sequentially consistent atomic access: everything else. +In general, use of ``qemu/atomic.h`` should be wrapped with more easily +used data structures (e.g. the lock-free singly-linked list operations +``QSLIST_INSERT_HEAD_ATOMIC`` and ``QSLIST_MOVE_ATOMIC``) or synchronization +primitives (such as RCU, ``QemuEvent`` or ``QemuLockCnt``). Bare use of +atomic operations and memory barriers should be limited to inter-thread +checking of flags and documented thoroughly. + + Compiler memory barrier ======================= -``barrier()`` prevents the compiler from moving the memory accesses either -side of it to the other side. The compiler barrier has no direct effect -on the CPU, which may then reorder things however it wishes. +``barrier()`` prevents the compiler from moving the memory accesses on +either side of it to the other side. The compiler barrier has no direct +effect on the CPU, which may then reorder things however it wishes. ``barrier()`` is mostly used within ``qemu/atomic.h`` itself. On some architectures, CPU guarantees are strong enough that blocking compiler
@@ -73,7 +86,8 @@ operations:: typeof(*ptr) atomic_cmpxchg(ptr, old, new) all of which return the old value of ``*ptr``. These operations are -polymorphic; they operate on any type that is as wide as a pointer. +polymorphic; they operate on any type that is as wide as a pointer or +smaller. Similar operations return the new value of ``*ptr``::
@@ -85,36 +99,28 @@ Similar operations return the new value of ``*ptr``:: typeof(*ptr) atomic_or_fetch(ptr, val) typeof(*ptr) atomic_xor_fetch(ptr, val) -Sequentially consistent loads and stores can be done using:: - - atomic_fetch_add(ptr, 0) for loads - atomic_xchg(ptr, val) for stores - -However, they are quite expensive on some platforms, notably POWER and -Arm. Therefore, qemu/atomic.h provides two primitives with slightly -weaker constraints:: +``qemu/atomic.h`` also provides loads and stores that cannot be reordered +with each other:: typeof(*ptr) atomic_mb_read(ptr) void atomic_mb_set(ptr, val) -The semantics of these primitives map to Java volatile variables, -and are strongly related to memory barriers as used in the Linux -kernel (see below). +However these do not provide sequential consistency and, in particular, +they do not participate in the total ordering enforced by +sequentially-consistent operations. For this reason they are deprecated. +They should instead be replaced with any of the following (ordered from +easiest to hardest): -As long as you use atomic_mb_read and atomic_mb_set, accesses cannot -be reordered with each other, and it is also not possible to reorder -"normal" accesses around them. +- accesses inside a mutex or spinlock -However, and this is the important difference between -atomic_mb_read/atomic_mb_set and sequential consistency, it is important -for both threads to access the same volatile variable. It is not the -case that everything visible to thread A when it writes volatile field f -becomes visible to thread B after it reads volatile field g. The store -and load have to "match" (i.e., be performed on the same volatile -field) to achieve the right semantics. +- lightweight synchronization primitives such as ``QemuEvent`` +- RCU operations (``atomic_rcu_read``, ``atomic_rcu_set``) when publishing + or accessing a new version of a data structure -These operations operate on any type that is as wide as an int or smaller. +- other atomic accesses: ``atomic_read`` and ``atomic_load_acquire`` for + loads, ``atomic_set`` and ``atomic_store_release`` for stores, ``smp_mb`` + to forbid reordering subsequent loads before a store. Weak atomic access and manual memory barriers
@@ -122,9 +128,24 @@ Weak atomic access and manual memory barriers Compared to sequentially consistent atomic access, programming with weaker consistency models can be considerably more complicated. -In general, if the algorithm you are writing includes both writes -and reads on the same side, it is generally simpler to use sequentially -consistent primitives. +The only guarantees that you can rely upon in this case are: + +- atomic accesses will not cause data races (and hence undefined behavior); + ordinary accesses instead cause data races if they are concurrent with + other accesses and at least one access is a write. In order to ensure this, + the compiler will not optimize accesses out of existence, create unsolicited + accesses, or perform other similar optimzations. + +- acquire operations will appear to happen, with respect to the other + components of the system, before all the LOAD or STORE operations + specified afterwards. + +- release operations will appear to happen, with respect to the other + components of the system, after all the LOAD or STORE operations + specified afterwards. + +- release operations will *synchronize with* acquire operations; + see :ref:`acqrel` for a detailed explanation. When using this model, variables are accessed with:
@@ -208,168 +229,182 @@ They come in six kinds: dependency and a full read barrier or better is required. -This is the set of barriers that is required *between* two ``atomic_read()`` -and ``atomic_set()`` operations to achieve sequential consistency: - - +----------------+-------------------------------------------------------+ - | | 2nd operation | - | +------------------+-----------------+------------------+ - | 1st operation | (after last) | atomic_read | atomic_set | - +----------------+------------------+-----------------+------------------+ - | (before first) | .. | none | smp_mb_release() | - +----------------+------------------+-----------------+------------------+ - | atomic_read | smp_mb_acquire() | smp_rmb() [1]_ | [2]_ | - +----------------+------------------+-----------------+------------------+ - | atomic_set | none | smp_mb() [3]_ | smp_wmb() | - +----------------+------------------+-----------------+------------------+ - - .. [1] Or smp_read_barrier_depends(). - - .. [2] This requires a load-store barrier. This is achieved by - either smp_mb_acquire() or smp_mb_release(). - - .. [3] This requires a store-load barrier. On most machines, the only - way to achieve this is a full barrier. - - -You can see that the two possible definitions of ``atomic_mb_read()`` -and ``atomic_mb_set()`` are the following: - - 1) | atomic_mb_read(p) = atomic_read(p); smp_mb_acquire() - | atomic_mb_set(p, v) = smp_mb_release(); atomic_set(p, v); smp_mb() - - 2) | atomic_mb_read(p) = smp_mb() atomic_read(p); smp_mb_acquire() - | atomic_mb_set(p, v) = smp_mb_release(); atomic_set(p, v); - -Usually the former is used, because ``smp_mb()`` is expensive and a program -normally has more reads than writes. Therefore it makes more sense to -make ``atomic_mb_set()`` the more expensive operation. - -There are two common cases in which atomic_mb_read and atomic_mb_set -generate too many memory barriers, and thus it can be useful to manually -place barriers, or use atomic_load_acquire/atomic_store_release instead: - -- when a data structure has one thread that is always a writer - and one thread that is always a reader, manual placement of - memory barriers makes the write side faster. Furthermore, - correctness is easy to check for in this case using the "pairing" - trick that is explained below: - - +----------------------------------------------------------------------+ - | thread 1 | - +-----------------------------------+----------------------------------+ - | before | after | - +===================================+==================================+ - | :: | :: | - | | | - | (other writes) | | - | atomic_mb_set(&a, x) | atomic_store_release(&a, x) | - | atomic_mb_set(&b, y) | atomic_store_release(&b, y) | - +-----------------------------------+----------------------------------+ - - +----------------------------------------------------------------------+ - | thread 2 | - +-----------------------------------+----------------------------------+ - | before | after | - +===================================+==================================+ - | :: | :: | - | | | - | y = atomic_mb_read(&b) | y = atomic_load_acquire(&b) | - | x = atomic_mb_read(&a) | x = atomic_load_acquire(&a) | - | (other reads) | | - +-----------------------------------+----------------------------------+ - - Note that the barrier between the stores in thread 1, and between - the loads in thread 2, has been optimized here to a write or a - read memory barrier respectively. On some architectures, notably - ARMv7, smp_mb_acquire and smp_mb_release are just as expensive as - smp_mb, but smp_rmb and/or smp_wmb are more efficient. - -- sometimes, a thread is accessing many variables that are otherwise - unrelated to each other (for example because, apart from the current - thread, exactly one other thread will read or write each of these - variables). In this case, it is possible to "hoist" the implicit - barriers provided by ``atomic_mb_read()`` and ``atomic_mb_set()`` outside - a loop. For example, the above definition ``atomic_mb_read()`` gives - the following transformation: - - +-----------------------------------+----------------------------------+ - | before | after | - +===================================+==================================+ - | :: | :: | - | | | - | n = 0; | n = 0; | - | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | - | n += atomic_mb_read(&a[i]); | n += atomic_read(&a[i]); | - | | smp_mb_acquire(); | - +-----------------------------------+----------------------------------+ - - Similarly, atomic_mb_set() can be transformed as follows: - - +-----------------------------------+----------------------------------+ - | before | after | - +===================================+==================================+ - | :: | :: | - | | | - | | smp_mb_release(); | - | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | - | atomic_mb_set(&a[i], false); | atomic_set(&a[i], false); | - | | smp_mb(); | - +-----------------------------------+----------------------------------+ - - - The other thread can still use ``atomic_mb_read()``/``atomic_mb_set()``. - -The two tricks can be combined. In this case, splitting a loop in -two lets you hoist the barriers out of the loops _and_ eliminate the -expensive ``smp_mb()``: - - +-----------------------------------+----------------------------------+ - | before | after | - +===================================+==================================+ - | :: | :: | - | | | - | | smp_mb_release(); | - | for (i = 0; i < 10; i++) { | for (i = 0; i < 10; i++) | - | atomic_mb_set(&a[i], false); | atomic_set(&a[i], false); | - | atomic_mb_set(&b[i], false); | smb_wmb(); | - | } | for (i = 0; i < 10; i++) | - | | atomic_set(&a[i], false); | - | | smp_mb(); | - +-----------------------------------+----------------------------------+ - - -Memory barrier pairing ----------------------- - -A useful rule of thumb is that memory barriers should always, or almost -always, be paired with another barrier. In the case of QEMU, however, -note that the other barrier may actually be in a driver that runs in -the guest! - -For the purposes of pairing, ``smp_read_barrier_depends()`` and ``smp_rmb()`` -both count as read barriers. A read barrier shall pair with a write -barrier or a full barrier; a write barrier shall pair with a read -barrier or a full barrier. A full barrier can pair with anything. -For example: - - +--------------------+------------------------------+ - | thread 1 | thread 2 | - +====================+==============================+ - | :: | :: | - | | | - | a = 1; | | - | smp_wmb(); | | - | b = 2; | x = b; | - | | smp_rmb(); | - | | y = a; | - +--------------------+------------------------------+ +Memory barriers and ``atomic_load_acquire``/``atomic_store_release`` are +mostly used when a data structure has one thread that is always a writer +and one thread that is always a reader: + + +----------------------------------+----------------------------------+ + | thread 1 | thread 2 | + +==================================+==================================+ + | :: | :: | + | | | + | atomic_store_release(&a, x); | y = atomic_load_acquire(&b); | + | atomic_store_release(&b, y); | x = atomic_load_acquire(&a); | + +----------------------------------+----------------------------------+ + +In this case, correctness is easy to check for in this case using the +"pairing" trick that is explained below. + +Sometimes, a thread is accessing many variables that are otherwise +unrelated to each other (for example because, apart from the current +thread, exactly one other thread will read or write each of these +variables). In this case, it is possible to "hoist" the barriers +outside a loop. For example: + + +------------------------------------------+----------------------------------+ + | before | after | + +==========================================+==================================+ + | :: | :: | + | | | + | n = 0; | n = 0; | + | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | + | n += atomic_load_acquire(&a[i]); | n += atomic_read(&a[i]); | + | | smp_mb_acquire(); | + +------------------------------------------+----------------------------------+ + | :: | :: | + | | | + | | smp_mb_release(); | + | for (i = 0; i < 10; i++) | for (i = 0; i < 10; i++) | + | atomic_store_release(&a[i], false); | atomic_set(&a[i], false); | + +------------------------------------------+----------------------------------+ + +Splitting a loop can also be useful to reduce the number of barriers: + + +------------------------------------------+----------------------------------+ + | before | after | + +==========================================+==================================+ + | :: | :: | + | | | + | n = 0; | smp_mb_release(); | + | for (i = 0; i < 10; i++) { | for (i = 0; i < 10; i++) | + | atomic_store_release(&a[i], false); | atomic_set(&a[i], false); | + | smp_mb(); | smb_mb(); | + | n += atomic_read(&b[i]); | n = 0; | + | } | for (i = 0; i < 10; i++) | + | | n += atomic_read(&b[i]); | + +------------------------------------------+----------------------------------+ + +In this case, a ``smp_mb_release()`` is also replaced with a (possibly cheaper, and clearer +as well) ``smp_wmb()``: + + +------------------------------------------+----------------------------------+ + | before | after | + +==========================================+==================================+ + | :: | :: | + | | | + | | smp_mb_release(); | + | for (i = 0; i < 10; i++) { | for (i = 0; i < 10; i++) | + | atomic_store_release(&a[i], false); | atomic_set(&a[i], false); | + | atomic_store_release(&b[i], false); | smb_wmb(); | + | } | for (i = 0; i < 10; i++) | + | | atomic_set(&b[i], false); | + +------------------------------------------+----------------------------------+ + + +.. _acqrel: + +Acquire/release pairing and the *synchronizes-with* relation +------------------------------------------------------------ + +Atomic operations other than ``atomic_set()`` and ``atomic_read()`` have +either *acquire* or *release* semantics. This has two effects: + +- within a thread, they are ordered either after previous operations (for + acquire) or before subsequent operations (for release). + +- if a release operation in one thread *synchronizes with* an acquire operation in another + thread, the ordering constraints propagates from the first to the + second thread. That is, everything before the release operation in the + first thread is guaranteed to *happen before* everything after the + acquire operation in the second thread. + +The concept of acquire and release semantics is not exclusive to atomic +operations; almost all higher-level synchronization primitives also have +acquire or release semantics. For example: + +- ``pthread_mutex_lock`` has acquire semantics, ``pthread_mutex_unlock`` has + release semantics and synchronizes with a ``pthread_mutex_lock`` for the + same mutex. + +- ``pthread_cond_broadcast`` has release semantics, ``pthread_cond_wait`` has + both release semantics (for loads and stores before the wait) and acquire + semantics (for loads and stores after the wakeup) + +- ``pthread_create`` has release semantics and synchronizes with the start + of the new thread; ``pthread_join`` has acquire semantics and synchronizes + with the exiting of the thread. + +- ``qemu_event_set`` has release semantics, ``qemu_event_wait`` has + acquire semantics + +For example, in the following example there are no atomic accesses, but still +thread 2 is relying on the *synchronizes-with* relation between ``pthread_exit`` +(release) and ``pthread_join`` (acquire): + + +----------------------+-------------------------------+ + | thread 1 | thread 2 | + +======================+===============================+ + | :: | :: | + | | | + | *a = 1; | | + | pthread_exit(a); | pthread_join(thread1, &a); | + | | x = *a; | + +----------------------+-------------------------------+ + +As a result, a useful rule of thumb is that atomic operations other than +``atomic_set()`` and ``atomic_read()`` will almost always be paired with another +operation of the opposite kind: an acquire operation will pair with +a release operation and vice versa. In the case of QEMU, however, note +that the other barrier may actually be in a driver that runs in the guest! + +``smp_read_barrier_depends()``, ``smp_rmb()``, ``smp_mb_acquire()``, +``atomic_load_acquire()`` and ``atomic_rcu_read()`` all count +as acquire operations. ``smp_wmb()``, ``smp_mb_release()``, +``atomic_store_release()`` and ``atomic_rcu_set()`` all count as release +operations. ``smp_mb()`` counts as both acquire and release, therefore +it can pair with any other atomic operation. Here is an example: + + +----------------------+------------------------------+ + | thread 1 | thread 2 | + +======================+==============================+ + | :: | :: | + | | | + | atomic_set(&a, 1); | | + | smp_wmb(); | | + | atomic_set(&b, 2); | x = atomic_read(&b); | + | | smp_rmb(); | + | | y = atomic_read(&a); | + +----------------------+------------------------------+ + +Note that a load-store pair only counts if the two operations access the +same variable: that is, a store-release on a variable ``x`` *synchronizes +with* a load-acquire on a variable ``x``, while a release barrier +synchronizes with any acquire operation. The following example shows +correct synchronization: + + +--------------------------------+--------------------------------+ + | thread 1 | thread 2 | + +================================+================================+ + | :: | :: | + | | | + | atomic_set(&a, 1); | | + | atomic_store_release(&b, 2); | x = atomic_load_acquire(&b); | + | | y = atomic_read(&a); | + +--------------------------------+--------------------------------+ + +Acquire and release semantics of higher-level synchronization primitives +can also be relied upon for the purpose of pairing memory barriers or +acquire/release operations. Note that the "writing" thread is accessing the variables in the opposite order as the "reading" thread. This is expected: stores -before the write barrier will normally match the loads after the -read barrier, and vice versa. The same is true for more than 2 -access and for data dependency barriers: +before a release operation or write barrier will normally match the loads +after the acquire operation or read barrier, and vice versa. The same +was true in the ``pthread_exit``/``pthread_join`` example above. + +Finally, this more complex example has more than two accesses and data +dependency barriers. It also does not use atomic accesses whenever there +cannot be a data race: +----------------------+------------------------------+ | thread 1 | thread 2 |
@@ -380,17 +415,13 @@ access and for data dependency barriers: | smp_wmb(); | | | x->i = 2; | | | smp_wmb(); | | - | a = x; | x = a; | + | atomic_set(&a, x); | x = atomic_read(&a); | | | smp_read_barrier_depends(); | | | y = x->i; | | | smp_read_barrier_depends(); | | | z = b[y]; | +----------------------+------------------------------+ -``smp_wmb()`` also pairs with ``atomic_mb_read()`` and ``smp_mb_acquire()``. -and ``smp_rmb()`` also pairs with ``atomic_mb_set()`` and ``smp_mb_release()``. - - Comparison with Linux kernel memory barriers ============================================
@@ -426,19 +457,43 @@ and memory barriers, and the equivalents in QEMU: ``atomic_cmpxchg`` returns the old value of the variable ===================== ========================================= - In QEMU, the second kind does not exist. Currently Linux has - atomic_fetch_or only. QEMU provides and, or, inc, dec, add, sub. + In QEMU, the second kind is named ``atomic_OP_fetch``. - different atomic read-modify-write operations in Linux imply a different set of memory barriers; in QEMU, all of them enforce - sequential consistency, which means they imply full memory barriers - before and after the operation. - -- Linux does not have an equivalent of ``atomic_mb_set()``. In particular, - note that ``smp_store_mb()`` is a little weaker than ``atomic_mb_set()``. - ``atomic_mb_read()`` compiles to the same instructions as Linux's - ``smp_load_acquire()``, but this should be treated as an implementation - detail. + sequential consistency. + +- in QEMU, ``atomic_read()`` and ``atomic_set()`` do not participate in + the total ordering enforced by sequentially-consistent operations. + This is because QEMU uses the C11 memory model. The following example + is correct in Linux but not in QEMU: + + +----------------------------------+--------------------------------+ + | Linux (correct) | QEMU (incorrect) | + +==================================+================================+ + | :: | :: | + | | | + | a = atomic_fetch_add(&x, 2); | a = atomic_fetch_add(&x, 2); | + | b = READ_ONCE(&y); | b = atomic_read(&y); | + +----------------------------------+--------------------------------+ + + because the read of ``y`` can be moved (by either the processor or the + compiler) before the write of ``x``. + + Fixing this requires an ``smp_mb()`` memory barrier between the write + of ``x`` and the read of ``y``. In the common case where only one thread + writes ``x``, it is also possible to write it like this: + + +--------------------------------+ + | QEMU (correct) | + +================================+ + | :: | + | | + | a = atomic_read(&x); | + | atomic_set(&x, a + 2); | + | smp_mb(); | + | b = atomic_read(&y); | + +--------------------------------+ Sources =======
Signature · 1 line
2.18.2
Re: [PATCH 2/5] atomics: update documentation
docs/devel/atomics.rst Weak atomic access and manual memory barriers · line 145
Quoted 3 lines · Paolo Bonzini
+- release operations will appear to happen, with respect to the other
docs/devel/atomics.rst +2
-0+ components of the system, after all the LOAD or STORE operations + specified afterwards.
"specified before", not after for release.
Otherwise,
r~
Re: [PATCH 2/5] atomics: update documentation
Quoted 5 lines · Richard Henderson
docs/devel/atomics.rst Weak atomic access and manual memory barriers · line 145
Quoted 3 lines · Paolo Bonzini
+- release operations will appear to happen, with respect to the other
docs/devel/atomics.rst +2
-0+ components of the system, after all the LOAD or STORE operations + specified afterwards."specified before", not after for release.
Not the only one such pasto (e.g. "operations coming after ``atomic_store_release()`` can still be reordered before it", the text said "after"). I have fixed all of them.
Paolo
PATCH 3/5 rcu: do not mention atomic_mb_read/set in documentation
In reply to Paolo Bonzini--- docs/devel/rcu.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
docs/devel/rcu.txt +2 -2
@@ -132,7 +132,7 @@ The core RCU API is small: typeof(*p) atomic_rcu_read(p); - atomic_rcu_read() is similar to atomic_mb_read(), but it makes + atomic_rcu_read() is similar to atomic_load_acquire(), but it makes some assumptions on the code that calls it. This allows a more optimized implementation.
@@ -154,7 +154,7 @@ The core RCU API is small: void atomic_rcu_set(p, typeof(*p) v); - atomic_rcu_set() is also similar to atomic_mb_set(), and it also + atomic_rcu_set() is similar to atomic_store_release(), though it also makes assumptions on the code that calls it in order to allow a more optimized implementation.
Signature · 1 line
2.18.2
Re: [PATCH 3/5] rcu: do not mention atomic_mb_read/set in documentation
Quoted 4 lines · Paolo Bonzini
Signed-off-by Paolo Bonzini <[email protected]>--- docs/devel/rcu.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
r~
PATCH 4/5 aio-wait: delegate polling of main AioContext if BQL not held
In reply to Paolo BonziniAny thread that is not a iothread returns NULL for qemu_get_current_aio_context(). As a result, it would also return true for in_aio_context_home_thread(qemu_get_aio_context()), causing AIO_WAIT_WHILE to invoke aio_poll() directly. This is incorrect
if the BQL is not held, because aio_poll() does not expect to
run concurrently from multiple threads, and it can actually
happen when savevm writes to the vmstate file from the
migration thread.
Therefore, restrict in_aio_context_home_thread to return true for the main AioContext only if the BQL is held.
The function is moved to aio-wait.h because it is mostly used there and to avoid a circular reference between main-loop.h and block/aio.h.
--- include/block/aio-wait.h | 22 ++++++++++++++++++++++ include/block/aio.h | 29 ++++++++++------------------- 2 files changed, 32 insertions(+), 19 deletions(-)
include/block/aio-wait.h +22 -0
@@ -26,6 +26,7 @@#define QEMU_AIO_WAIT_H #include "block/aio.h" +#include "qemu/main-loop.h" /** * AioWait:
@@ -124,4 +125,25 @@ void aio_wait_kick(void);*/ void aio_wait_bh_oneshot (AioContext *ctx,QEMUBHFunc *cb,void *opaque); +/** +* in_aio_context_home_thread: +* @ctx: the aio context +* +* Return whether we are running in the thread that normally runs @ctx. Note +* that acquiring/releasing ctx does not affect the outcome, each AioContext +* still only has one home thread that is responsible for running it. +*/ +static inline bool in_aio_context_home_thread (AioContext *ctx) +{ +if (ctx ==qemu_get_current_aio_context ()) { +return true; + } + +if (ctx ==qemu_get_aio_context ()) { +return qemu_mutex_iothread_locked (); + }else { +return false; + } +} +#endif /* QEMU_AIO_WAIT_H */
include/block/aio.h +10 -19
@@ -133,12 +133,16 @@ struct AioContext {AioHandlerList deleted_aio_handlers;/* Used to avoid unnecessary event_notifier_set calls in aio_notify; -* accessed with atomic primitives. If this field is 0, everything -* (file descriptors, bottom halves, timers) will be re-evaluated -* before the next blocking poll(), thus the event_notifier_set call -* can be skipped. If it is non-zero, you may need to wake up a -* concurrent aio_poll or the glib main event loop, making -* event_notifier_set necessary. +* only written from the AioContext home thread, or under the BQL in +* the case of the main AioContext. However, it is read from any +* thread so it is still accessed with atomic primitives. +* +* If this field is 0, everything (file descriptors, bottom halves, +* timers) will be re-evaluated before the next blocking poll() or +* io_uring wait; therefore, the event_notifier_set call can be +* skipped. If it is non-zero, you may need to wake up a concurrent +* aio_poll or the glib main event loop, making event_notifier_set +* necessary. * * Bit 0 is reserved for GSource usage of the AioContext, and is 1 * between a call to aio_ctx_prepare and the next call to aio_ctx_check.
@@ -681,19 +685,6 @@ void aio_co_enter(AioContext *ctx, struct Coroutine *co);*/ AioContext *qemu_get_current_aio_context (void ); -/** -* in_aio_context_home_thread: -* @ctx: the aio context -* -* Return whether we are running in the thread that normally runs @ctx. Note -* that acquiring/releasing ctx does not affect the outcome, each AioContext -* still only has one home thread that is responsible for running it. -*/ -static inline bool in_aio_context_home_thread (AioContext *ctx) -{ -return ctx ==qemu_get_current_aio_context (); -} -/** * aio_context_setup: * @ctx: the aio context
Signature · 1 line
2.18.2
PATCH 5/5 async: use explicit memory barriers
In reply to Paolo BonziniWhen using C11 atomics, non-seqcst reads and writes do not participate in the total order of seqcst operations. In util/async.c and util/aio-posix.c, in particular, the pattern that we use
write ctx->notify_me write bh->scheduled
read bh->scheduled read ctx->notify_me
if !bh->scheduled, sleep if ctx->notify_me, notifyneeds to use seqcst operations for both the write and the read. In general this is something that we do not want, because there can be many sources that are polled in addition to bottom halves. The alternative is to place a seqcst memory barrier between the write and the read. This also comes with a disadvantage, in that the memory barrier is implicit on strongly-ordered architectures and it wastes a few dozen clock cycles.
Fortunately, ctx->notify_me is never written concurrently by two threads, so we can assert that and relax the writes to ctx->notify_me. The resulting solution works and performs well on both aarch64 and x86.
Note that the atomic_set/atomic_read combination is not an atomic read-modify-write, and therefore it is even weaker than C11 ATOMIC_RELAXED; on x86, ATOMIC_RELAXED compiles to a locked operation.
--- util/aio-posix.c | 16 ++++++++++++++-- util/aio-win32.c | 17 ++++++++++++++--- util/async.c | 16 ++++++++++++---- 3 files changed, 40 insertions(+), 9 deletions(-)
util/aio-posix.c +14 -2
@@ -559,6 +559,11 @@ bool aio_poll(AioContext *ctx, bool blocking)int64_t timeout;int64_t start =0 ; +/* +* There cannot be two concurrent aio_poll calls for the same AioContext (or +* an aio_poll concurrent with a GSource prepare/check/dispatch callback). +* We rely on this below to avoid slow locked accesses to ctx->notify_me. +*/ assert (in_aio_context_home_thread (ctx));/* aio_notify can avoid the expensive event_notifier_set if
@@ -569,7 +574,13 @@ bool aio_poll(AioContext *ctx, bool blocking)* so disable the optimization now. */ if (blocking) { -atomic_add (&ctx->notify_me,2 ); +atomic_set (&ctx->notify_me,atomic_read (&ctx->notify_me) +2 ); +/* +* Write ctx->notify_me before computing the timeout +* (reading bottom half flags, etc.). Pairs with +* smp_mb in aio_notify(). +*/ +smp_mb (); }qemu_lockcnt_inc (&ctx->list_lock);
@@ -590,7 +601,8 @@ bool aio_poll(AioContext *ctx, bool blocking) }if (blocking) { -atomic_sub (&ctx->notify_me,2 ); +/* Finish the poll before clearing the flag. */ +atomic_store_release (&ctx->notify_me,atomic_read (&ctx->notify_me) -2 );aio_notify_accept (ctx); }
util/aio-win32.c +14 -3
@@ -321,6 +321,12 @@ bool aio_poll(AioContext *ctx, bool blocking)int count;int timeout; +/* +* There cannot be two concurrent aio_poll calls for the same AioContext (or +* an aio_poll concurrent with a GSource prepare/check/dispatch callback). +* We rely on this below to avoid slow locked accesses to ctx->notify_me. +*/ +assert (in_aio_context_home_thread (ctx)); progress = false;/* aio_notify can avoid the expensive event_notifier_set if
@@ -331,7 +337,13 @@ bool aio_poll(AioContext *ctx, bool blocking)* so disable the optimization now. */ if (blocking) { -atomic_add (&ctx->notify_me,2 ); +atomic_set (&ctx->notify_me,atomic_read (&ctx->notify_me) +2 ); +/* +* Write ctx->notify_me before computing the timeout +* (reading bottom half flags, etc.). Pairs with +* smp_mb in aio_notify(). +*/ +smp_mb (); }qemu_lockcnt_inc (&ctx->list_lock);
@@ -364,8 +376,7 @@ bool aio_poll(AioContext *ctx, bool blocking) ret =WaitForMultipleObjects (count, events, FALSE, timeout);if (blocking) {assert (first); -assert (in_aio_context_home_thread (ctx)); -atomic_sub (&ctx->notify_me,2 ); +atomic_store_release (&ctx->notify_me,atomic_read (&ctx->notify_me) -2 );aio_notify_accept (ctx); }
util/async.c +12 -4
@@ -249,7 +249,14 @@ aio_ctx_prepare(GSource *source, gint *timeout) {AioContext *ctx = (AioContext *) source; -atomic_or (&ctx->notify_me,1 ); +atomic_set (&ctx->notify_me,atomic_read (&ctx->notify_me) |1 ); + +/* +* Write ctx->notify_me before computing the timeout +* (reading bottom half flags, etc.). Pairs with +* smp_mb in aio_notify(). +*/ +smp_mb ();/* We assume there is no timeout already supplied */ *timeout =qemu_timeout_ns_to_ms (aio_compute_timeout (ctx));
@@ -268,7 +275,8 @@ aio_ctx_check(GSource *source)QEMUBH *bh;BHListSlice *s; -atomic_and (&ctx->notify_me, ~1 ); +/* Finish computing the timeout before clearing the flag. */ +atomic_store_release (&ctx->notify_me,atomic_read (&ctx->notify_me) & ~1 );aio_notify_accept (ctx); QSLIST_FOREACH_RCU(bh, &ctx->bh_list, next) {
@@ -411,10 +419,10 @@ LuringState *aio_get_linux_io_uring(AioContext *ctx)void aio_notify (AioContext *ctx) {/* Write e.g. bh->scheduled before reading ctx->notify_me. Pairs -* with atomic_or in aio_ctx_prepare or atomic_add in aio_poll. +* with smp_mb in aio_ctx_prepare or aio_poll. */ smp_mb (); -if (ctx->notify_me) { +if (atomic_read (&ctx->notify_me)) {event_notifier_set (&ctx->notifier);atomic_mb_set (&ctx->notified, true); }
Signature · 1 line
2.18.2
Re: [PATCH 5/5] async: use explicit memory barriers
Quoted 149 lines · Paolo Bonzini
When using C11 atomics, non-seqcst reads and writes do not participate in the total order of seqcst operations. In
util/async.candutil/aio-posix.c, in particular, the pattern that we usewrite ctx->notify_me write bh->scheduled read bh->scheduled read ctx->notify_me if !bh->scheduled, sleep if ctx->notify_me, notifyneeds to use seqcst operations for both the write and the read. In general this is something that we do not want, because there can be many sources that are polled in addition to bottom halves. The alternative is to place a seqcst memory barrier between the write and the read. This also comes with a disadvantage, in that the memory barrier is implicit on strongly-ordered architectures and it wastes a few dozen clock cycles.
Fortunately,
ctx->notify_meis never written concurrently by two threads, so we can assert that and relax the writes toctx->notify_me. The resulting solution works and performs well on both aarch64 and x86.Note that the atomic_set/atomic_read combination is not an atomic read-modify-write, and therefore it is even weaker than C11
ATOMIC_RELAXED; on x86,ATOMIC_RELAXEDcompiles to a locked operation.Analyzed-by Ying Fang <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>--- util/aio-posix.c | 16 ++++++++++++++-- util/aio-win32.c | 17 ++++++++++++++--- util/async.c | 16 ++++++++++++---- 3 files changed, 40 insertions(+), 9 deletions(-)util/aio-posix.c +14
-2@@ -559,6 +559,11 @@ bool aio_poll(AioContext *ctx, bool blocking)int64_t timeout;int64_t start =0 ; +/* +* There cannot be two concurrent aio_poll calls for the same AioContext (or +* an aio_poll concurrent with a GSource prepare/check/dispatch callback). +* We rely on this below to avoid slow locked accesses to ctx->notify_me. +*/ assert (in_aio_context_home_thread (ctx));/* aio_notify can avoid the expensive event_notifier_set if @@ -569,7 +574,13 @@ bool aio_poll(AioContext *ctx, bool blocking)* so disable the optimization now. */ if (blocking) { -atomic_add (&ctx->notify_me,2 ); +atomic_set (&ctx->notify_me,atomic_read (&ctx->notify_me) +2 ); +/* +* Write ctx->notify_me before computing the timeout +* (reading bottom half flags, etc.). Pairs with +* smp_mb in aio_notify(). +*/ +smp_mb (); }qemu_lockcnt_inc (&ctx->list_lock);@@ -590,7 +601,8 @@ bool aio_poll(AioContext *ctx, bool blocking) }if (blocking) { -atomic_sub (&ctx->notify_me,2 ); +/* Finish the poll before clearing the flag. */ +atomic_store_release (&ctx->notify_me,atomic_read (&ctx->notify_me) -2 );aio_notify_accept (ctx); }util/aio-win32.c +14
-3@@ -321,6 +321,12 @@ bool aio_poll(AioContext *ctx, bool blocking)int count;int timeout; +/* +* There cannot be two concurrent aio_poll calls for the same AioContext (or +* an aio_poll concurrent with a GSource prepare/check/dispatch callback). +* We rely on this below to avoid slow locked accesses to ctx->notify_me. +*/ +assert (in_aio_context_home_thread (ctx)); progress = false;/* aio_notify can avoid the expensive event_notifier_set if @@ -331,7 +337,13 @@ bool aio_poll(AioContext *ctx, bool blocking)* so disable the optimization now. */ if (blocking) { -atomic_add (&ctx->notify_me,2 ); +atomic_set (&ctx->notify_me,atomic_read (&ctx->notify_me) +2 ); +/* +* Write ctx->notify_me before computing the timeout +* (reading bottom half flags, etc.). Pairs with +* smp_mb in aio_notify(). +*/ +smp_mb (); }qemu_lockcnt_inc (&ctx->list_lock);@@ -364,8 +376,7 @@ bool aio_poll(AioContext *ctx, bool blocking) ret =WaitForMultipleObjects (count, events, FALSE, timeout);if (blocking) {assert (first); -assert (in_aio_context_home_thread (ctx)); -atomic_sub (&ctx->notify_me,2 ); +atomic_store_release (&ctx->notify_me,atomic_read (&ctx->notify_me) -2 );aio_notify_accept (ctx); }util/async.c +10
-2@@ -249,7 +249,14 @@ aio_ctx_prepare(GSource *source, gint *timeout) {AioContext *ctx = (AioContext *) source; -atomic_or (&ctx->notify_me,1 ); +atomic_set (&ctx->notify_me,atomic_read (&ctx->notify_me) |1 ); + +/* +* Write ctx->notify_me before computing the timeout +* (reading bottom half flags, etc.). Pairs with +* smp_mb in aio_notify(). +*/ +smp_mb ();/* We assume there is no timeout already supplied */ *timeout =qemu_timeout_ns_to_ms (aio_compute_timeout (ctx));@@ -268,7 +275,8 @@ aio_ctx_check(GSource *source)QEMUBH *bh;BHListSlice *s; -atomic_and (&ctx->notify_me, ~1 ); +/* Finish computing the timeout before clearing the flag. */ +atomic_store_release (&ctx->notify_me,atomic_read (&ctx->notify_me) & ~1 );aio_notify_accept (ctx); QSLIST_FOREACH_RCU(bh, &ctx->bh_list, next) {@@ -411,10 +419,10 @@ LuringState *aio_get_linux_io_uring(AioContext *ctx)void aio_notify (AioContext *ctx) {
util/async.c LuringState *aio_get_linux_io_uring(AioContext *ctx) · line 428
Quoted 10 lines
util/async.c +2
-2/* Write e.g. bh->scheduled before reading ctx->notify_me. Pairs -* with atomic_or in aio_ctx_prepare or atomic_add in aio_poll. +* with smp_mb in aio_ctx_prepare or aio_poll. */ smp_mb (); -if (ctx->notify_me) { +if (atomic_read (&ctx->notify_me)) {event_notifier_set (&ctx->notifier);atomic_mb_set (&ctx->notified, true); }
Quoted 5 lines · Paolo Bonzini
ARM machines and other weakly-ordered architectures have been suffering for a long time from hangs in qemu-img and qemu-io. For QEMU binaries these are mitigated by the timers that sooner or later fire in the main loop, but these will not happen for the tools and probably not with I/O threads either.
yes, we occasionally see qemu main thread hangs and VM stuck in in-shutdown state on aarch64 platform. So this could happen with I/O threads.
Quoted 26 lines
The fix is in patch 5. Patch 1-3 are docs updates that explain the bug, and patch 4 is a bugfix exposed by the new patch.
Paolo
Paolo Bonzini (5):
atomics: convert to reStructuredText
atomics: update documentation
rcu: do not mention atomic_mb_read/set in documentation
aio-wait: delegate polling of main AioContext if BQL not held
async: use explicit memory barriersdocs/devel/atomics.rst | 501 +++++++++++++++++++++++++++++++++++++++ docs/devel/atomics.txt | 403 ------------------------------- docs/devel/index.rst | 1 + docs/devel/rcu.txt | 4 +- include/block/aio-wait.h | 22 ++ include/block/aio.h | 29 +-- util/aio-posix.c | 16 +- util/aio-win32.c | 17 +- util/async.c | 16 +- 9 files changed, 576 insertions(+), 433 deletions(-)create mode 100644
docs/devel/atomics.rst
delete mode 100644docs/devel/atomics.txt
Quoted 9 lines · Ying Fang
Quoted 5 lines · Paolo Bonzini
ARM machines and other weakly-ordered architectures have been suffering for a long time from hangs in qemu-img and qemu-io. For QEMU binaries these are mitigated by the timers that sooner or later fire in the main loop, but these will not happen for the tools and probably not with I/O threads either.
yes, we occasionally see qemu main thread hangs and VM stuck in in-shutdown state on aarch64 platform. So this could happen with I/O threads.
Thanks for confirming! Have you managed to test the final version of the patches? It would be great to include test results.
Paolo
Quoted 8 lines · Paolo Bonzini
Quoted 7 lines · Ying Fang
Quoted 5 lines · Paolo Bonzini
ARM machines and other weakly-ordered architectures have been suffering for a long time from hangs in qemu-img and qemu-io. For QEMU binaries these are mitigated by the timers that sooner or later fire in the main loop, but these will not happen for the tools and probably not with I/O threads either.
Quoted 5 lines
Quoted 2 lines
yes, we occasionally see qemu main thread hangs and VM stuck in in-shutdown state on aarch64 platform. So this could happen with I/O threads.
Thanks for confirming! Have you managed to test the final version of the patches? It would be great to include test results.
Yes, I did the test with your latest patches on both aarch64 and x86 platform.Test results show that the hang has been fixed. Thanks.
Quoted 5 lines
Paolo
Stefan Hajnoczi
AppliedQuoted 18 lines · Paolo Bonzini
ARM machines and other weakly-ordered architectures have been suffering for a long time from hangs in qemu-img and qemu-io. For QEMU binaries these are mitigated by the timers that sooner or later fire in the main loop, but these will not happen for the tools and probably not with I/O threads either.
The fix is in patch 5. Patch 1-3 are docs updates that explain the bug, and patch 4 is a bugfix exposed by the new patch.
Paolo
Paolo Bonzini (5):
atomics: convert to reStructuredText
atomics: update documentation
rcu: do not mention atomic_mb_read/set in documentation
aio-wait: delegate polling of main AioContext if BQL not held
async: use explicit memory barriers
Quoted 12 lines
docs/devel/atomics.rst | 501 +++++++++++++++++++++++++++++++++++++++ docs/devel/atomics.txt | 403 ------------------------------- docs/devel/index.rst | 1 + docs/devel/rcu.txt | 4 +- include/block/aio-wait.h | 22 ++ include/block/aio.h | 29 +-- util/aio-posix.c | 16 +- util/aio-win32.c | 17 +- util/async.c | 16 +- 9 files changed, 576 insertions(+), 433 deletions(-) create mode 100644 docs/devel/atomics.rst delete mode 100644 docs/devel/atomics.txt
Applied patches 4 and 5 to my block branch.
Stefan