mirror of
https://github.com/torvalds/linux
synced 2024-07-21 18:51:47 +00:00
9ba7d3b3b8
As reported by Viktor, plain accesses in LKMM are weaker than accesses to registers: the latter carry dependencies but the former do not. This is exemplified in the following snippet: int r = READ_ONCE(*x); WRITE_ONCE(*y, r); Here a data dependency links the READ_ONCE() to the WRITE_ONCE(), preserving their order, because the model treats r as a register. If r is turned into a memory location accessed by plain accesses, however, the link is broken and the order between READ_ONCE() and WRITE_ONCE() is no longer preserved. This is too conservative, since any optimizations on plain accesses that might break dependencies are also possible on registers; it also contradicts the intuitive notion of "dependency" as the data stored by the WRITE_ONCE() does depend on the data read by the READ_ONCE(), independently of whether r is a register or a memory location. This is resolved by redefining all dependencies to include dependencies carried by memory accesses; a dependency is said to be carried by memory accesses (in the model: carry-dep) from one load to another load if the initial load is followed by an arbitrarily long sequence alternating between stores and loads of the same thread, where the data of each store depends on the previous load, and is read by the next load. Any dependency linking the final load in the sequence to another access also links the initial load in the sequence to that access. More deep details can be found in this LKML discussion: https://lore.kernel.org/lkml/d86295788ad14a02874ab030ddb8a6f8@huawei.com/ Reported-by: Viktor Vafeiadis <viktor@mpi-sws.org> Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huawei.com> Reviewed-by: Alan Stern <stern@rowland.harvard.edu> Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
32 lines
628 B
Plaintext
32 lines
628 B
Plaintext
C dep+plain
|
|
|
|
(*
|
|
* Result: Never
|
|
*
|
|
* This litmus test demonstrates that in LKMM, plain accesses
|
|
* carry dependencies much like accesses to registers:
|
|
* The data stored to *z1 and *z2 by P0() originates from P0()'s
|
|
* READ_ONCE(), and therefore using that data to compute the
|
|
* conditional of P0()'s if-statement creates a control dependency
|
|
* from that READ_ONCE() to P0()'s WRITE_ONCE().
|
|
*)
|
|
|
|
{}
|
|
|
|
P0(int *x, int *y, int *z1, int *z2)
|
|
{
|
|
int a = READ_ONCE(*x);
|
|
*z1 = a;
|
|
*z2 = *z1;
|
|
if (*z2 == 1)
|
|
WRITE_ONCE(*y, 1);
|
|
}
|
|
|
|
P1(int *x, int *y)
|
|
{
|
|
int r = smp_load_acquire(y);
|
|
smp_store_release(x, r);
|
|
}
|
|
|
|
exists (x=1 /\ y=1)
|