* [RFC][PATCH 0/4] tools/memory-model: Define more of LKMM in tools/memory-model
@ 2024-05-27 15:22 Jonas Oberhauser
2024-05-27 15:22 ` [RFC][PATCH 1/4] tools/memory-model: Legitimize current use of tags in LKMM macros Jonas Oberhauser
` (3 more replies)
0 siblings, 4 replies; 12+ messages in thread
From: Jonas Oberhauser @ 2024-05-27 15:22 UTC (permalink / raw)
To: paulmck
Cc: stern, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells,
j.alglave, luc.maranget, akiyks, dlustig, joel, urezki,
quic_neeraju, frederic, linux-kernel, Jonas Oberhauser
Currently, the effect of several tag on operations is defined only in
the herd7 tool's OCaml code as syntax transformations, while the effect
of all other tags is defined in tools/memory-model.
This asymmetry means that two seemingly analogous definitions in
tools/memory-model behave quite differently because the generated
representation is sometimes modified by hardcoded behavior in herd7.
It also makes it hard to see that the behavior of the formalization
matches the intuition described in explanation.txt without delving into
the implementation of herd7.
Furthermore, this hardcoded behavior is hard to maintain inside herd7 and
other tools implementing WMM, and has caused several bugs and confusions
with the tool maintainers, e.g.:
https://github.com/MPI-SWS/genmc/issues/22
https://github.com/herd/herdtools7/issues/384#issuecomment-1132859904
https://github.com/hernanponcedeleon/Dat3M/issues/254
It also means that potential future extensions of LKMM with new tags may
not work without changing internals of the herd7 tool.
In this patch series, we first emulate the effect of herd7 transformations
in tools/memory-model through explicit rules in .cat and .bell files that
reference the transformed tags.
These transformations do not have any immediate effect with the current
herd7 implementation, because they apply after the syntax transformations
have already modified those tags.
In a second step, we then distinguish between syntactic tags (that are
placed by the programmer on operations, e.g., an 'ACQUIRE tag on both the
read and write of an xchg_acquire() operation) and sets of events (that
would be defined after the (emulated) transformations, e.g., an Acquire
set that includes only on the read of the xchg_acquire(), but "has been
removed" from the write).
This second step is incompatible with the current herd7 implementation,
since herd7 uses hardcoded tag names to decide what to do with LKMM;
therefore, the newly introduced syntactic tags will be ignored or
processed incorrectly by herd7.
Have fun,
jonas
Jonas Oberhauser (4):
tools/memory-model: Legitimize current use of tags in LKMM macros
tools/memory-model: Define applicable tags on operation in tools/...
tools/memory-model: Define effect of Mb tags on RMWs in tools/...
tools/memory-model: Distinguish between syntactic and semantic tags
tools/memory-model/linux-kernel.bell | 28 +++--
tools/memory-model/linux-kernel.cat | 9 ++
tools/memory-model/linux-kernel.def | 176 +++++++++++++--------------
3 files changed, 115 insertions(+), 98 deletions(-)
--
2.34.1
^ permalink raw reply [flat|nested] 12+ messages in thread* [RFC][PATCH 1/4] tools/memory-model: Legitimize current use of tags in LKMM macros 2024-05-27 15:22 [RFC][PATCH 0/4] tools/memory-model: Define more of LKMM in tools/memory-model Jonas Oberhauser @ 2024-05-27 15:22 ` Jonas Oberhauser 2024-05-27 15:58 ` Alan Stern 2024-05-27 15:22 ` [RFC][PATCH 2/4] tools/memory-model: Define applicable tags on operation in tools/ Jonas Oberhauser ` (2 subsequent siblings) 3 siblings, 1 reply; 12+ messages in thread From: Jonas Oberhauser @ 2024-05-27 15:22 UTC (permalink / raw) To: paulmck Cc: stern, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel, Jonas Oberhauser The current macros in linux-kernel.def reference instructions such as __xchg{mb} or __cmpxchg{acquire}, which are invalid combinations of tags and instructions according to the declarations in linux-kernel.bell. This works with current herd7 because herd7 removes these tags anyways and does not actually enforce validity of combinations at all. If a future herd7 version no longer applies these hardcoded transformations, then all currently invalid combinations will actually appear on some instruction. We therefore adjust the declarations to make the resulting combinations valid, by adding the 'mb tag to the set of Accesses and allowing all Accesses to appear on all read, write, and RMW instructions. Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> --- tools/memory-model/linux-kernel.bell | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/tools/memory-model/linux-kernel.bell b/tools/memory-model/linux-kernel.bell index ce068700939c..1b2444cdf8d1 100644 --- a/tools/memory-model/linux-kernel.bell +++ b/tools/memory-model/linux-kernel.bell @@ -16,10 +16,11 @@ enum Accesses = 'once (*READ_ONCE,WRITE_ONCE*) || 'release (*smp_store_release*) || 'acquire (*smp_load_acquire*) || - 'noreturn (* R of non-return RMW *) -instructions R[{'once,'acquire,'noreturn}] -instructions W[{'once,'release}] -instructions RMW[{'once,'acquire,'release}] + 'noreturn (* R of non-return RMW *) || + 'mb (*xchg(),compare_exchange(),...*) +instructions R[Accesses] +instructions W[Accesses] +instructions RMW[Accesses] enum Barriers = 'wmb (*smp_wmb*) || 'rmb (*smp_rmb*) || -- 2.34.1 ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC][PATCH 1/4] tools/memory-model: Legitimize current use of tags in LKMM macros 2024-05-27 15:22 ` [RFC][PATCH 1/4] tools/memory-model: Legitimize current use of tags in LKMM macros Jonas Oberhauser @ 2024-05-27 15:58 ` Alan Stern 0 siblings, 0 replies; 12+ messages in thread From: Alan Stern @ 2024-05-27 15:58 UTC (permalink / raw) To: Jonas Oberhauser Cc: paulmck, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel On Mon, May 27, 2024 at 05:22:50PM +0200, Jonas Oberhauser wrote: > The current macros in linux-kernel.def reference instructions such as > __xchg{mb} or __cmpxchg{acquire}, which are invalid combinations of tags > and instructions according to the declarations in linux-kernel.bell. > This works with current herd7 because herd7 removes these tags anyways > and does not actually enforce validity of combinations at all. > > If a future herd7 version no longer applies these hardcoded > transformations, then all currently invalid combinations will actually > appear on some instruction. > > We therefore adjust the declarations to make the resulting combinations > valid, by adding the 'mb tag to the set of Accesses and allowing all > Accesses to appear on all read, write, and RMW instructions. > > Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> > --- > tools/memory-model/linux-kernel.bell | 9 +++++---- > 1 file changed, 5 insertions(+), 4 deletions(-) > > diff --git a/tools/memory-model/linux-kernel.bell b/tools/memory-model/linux-kernel.bell > index ce068700939c..1b2444cdf8d1 100644 > --- a/tools/memory-model/linux-kernel.bell > +++ b/tools/memory-model/linux-kernel.bell > @@ -16,10 +16,11 @@ > enum Accesses = 'once (*READ_ONCE,WRITE_ONCE*) || > 'release (*smp_store_release*) || > 'acquire (*smp_load_acquire*) || > - 'noreturn (* R of non-return RMW *) > -instructions R[{'once,'acquire,'noreturn}] > -instructions W[{'once,'release}] > -instructions RMW[{'once,'acquire,'release}] > + 'noreturn (* R of non-return RMW *) || > + 'mb (*xchg(),compare_exchange(),...*) It would be better to write cmpxchg() instead of compare_exchange(). Alan > +instructions R[Accesses] > +instructions W[Accesses] > +instructions RMW[Accesses] > > enum Barriers = 'wmb (*smp_wmb*) || > 'rmb (*smp_rmb*) || > -- > 2.34.1 > ^ permalink raw reply [flat|nested] 12+ messages in thread
* [RFC][PATCH 2/4] tools/memory-model: Define applicable tags on operation in tools/... 2024-05-27 15:22 [RFC][PATCH 0/4] tools/memory-model: Define more of LKMM in tools/memory-model Jonas Oberhauser 2024-05-27 15:22 ` [RFC][PATCH 1/4] tools/memory-model: Legitimize current use of tags in LKMM macros Jonas Oberhauser @ 2024-05-27 15:22 ` Jonas Oberhauser 2024-05-27 15:59 ` Alan Stern 2024-05-27 15:22 ` [RFC][PATCH 3/4] tools/memory-model: Define effect of Mb tags on RMWs " Jonas Oberhauser 2024-05-27 15:22 ` [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags Jonas Oberhauser 3 siblings, 1 reply; 12+ messages in thread From: Jonas Oberhauser @ 2024-05-27 15:22 UTC (permalink / raw) To: paulmck Cc: stern, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel, Jonas Oberhauser Herd7 transforms reads, writes, and read-modify-writes by eliminating 'acquire tags from writes, 'release tags from reads, and 'acquire, 'release, and 'mb tags from failed read-modify-writes. We emulate this behavior by redefining Acquire, Release, and Mb sets in linux-kernel.bell to explicitly exclude those combinations. Herd7 furthermore adds 'noreturn tag to certain reads. Currently herd7 does not allow specifying the 'noreturn tag manually, but such manual declaration (e.g., through a syntax __atomic_op{noreturn}) would add invalid 'noreturn tags to writes; in preparation, we already also exclude this combination. Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> --- tools/memory-model/linux-kernel.bell | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/tools/memory-model/linux-kernel.bell b/tools/memory-model/linux-kernel.bell index 1b2444cdf8d1..08fa1ccb1328 100644 --- a/tools/memory-model/linux-kernel.bell +++ b/tools/memory-model/linux-kernel.bell @@ -36,6 +36,13 @@ enum Barriers = 'wmb (*smp_wmb*) || 'after-srcu-read-unlock (*smp_mb__after_srcu_read_unlock*) instructions F[Barriers] +(* Remove impossible tags, such as Acquire on a store or failed RMW *) +let FailedRMW = RMW \ (domain(rmw) | range(rmw)) +let Acquire = Acquire \ W \ FailedRMW +let Release = Release \ R \ FailedRMW +let Mb = Mb \ FailedRMW +let Noreturn = Noreturn \ W + (* SRCU *) enum SRCU = 'srcu-lock || 'srcu-unlock || 'sync-srcu instructions SRCU[SRCU] @@ -82,4 +89,4 @@ let Plain = M \ Marked let carry-dep = (data ; [~ Srcu-unlock] ; rfi)* let addr = carry-dep ; addr let ctrl = carry-dep ; ctrl -let data = carry-dep ; data +let data = carry-dep ; data \ No newline at end of file -- 2.34.1 ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC][PATCH 2/4] tools/memory-model: Define applicable tags on operation in tools/... 2024-05-27 15:22 ` [RFC][PATCH 2/4] tools/memory-model: Define applicable tags on operation in tools/ Jonas Oberhauser @ 2024-05-27 15:59 ` Alan Stern 0 siblings, 0 replies; 12+ messages in thread From: Alan Stern @ 2024-05-27 15:59 UTC (permalink / raw) To: Jonas Oberhauser Cc: paulmck, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel On Mon, May 27, 2024 at 05:22:51PM +0200, Jonas Oberhauser wrote: > Herd7 transforms reads, writes, and read-modify-writes by eliminating > 'acquire tags from writes, 'release tags from reads, and 'acquire, > 'release, and 'mb tags from failed read-modify-writes. We emulate this > behavior by redefining Acquire, Release, and Mb sets in linux-kernel.bell > to explicitly exclude those combinations. > > Herd7 furthermore adds 'noreturn tag to certain reads. Currently herd7 > does not allow specifying the 'noreturn tag manually, but such manual > declaration (e.g., through a syntax __atomic_op{noreturn}) would add > invalid 'noreturn tags to writes; in preparation, we already also exclude > this combination. > > Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> > --- > tools/memory-model/linux-kernel.bell | 9 ++++++++- > 1 file changed, 8 insertions(+), 1 deletion(-) > > diff --git a/tools/memory-model/linux-kernel.bell b/tools/memory-model/linux-kernel.bell > index 1b2444cdf8d1..08fa1ccb1328 100644 > --- a/tools/memory-model/linux-kernel.bell > +++ b/tools/memory-model/linux-kernel.bell > @@ -36,6 +36,13 @@ enum Barriers = 'wmb (*smp_wmb*) || > 'after-srcu-read-unlock (*smp_mb__after_srcu_read_unlock*) > instructions F[Barriers] > > +(* Remove impossible tags, such as Acquire on a store or failed RMW *) > +let FailedRMW = RMW \ (domain(rmw) | range(rmw)) > +let Acquire = Acquire \ W \ FailedRMW > +let Release = Release \ R \ FailedRMW > +let Mb = Mb \ FailedRMW > +let Noreturn = Noreturn \ W > + > (* SRCU *) > enum SRCU = 'srcu-lock || 'srcu-unlock || 'sync-srcu > instructions SRCU[SRCU] > @@ -82,4 +89,4 @@ let Plain = M \ Marked > let carry-dep = (data ; [~ Srcu-unlock] ; rfi)* > let addr = carry-dep ; addr > let ctrl = carry-dep ; ctrl > -let data = carry-dep ; data > +let data = carry-dep ; data > \ No newline at end of file It looks like the final newline was accidentally deleted. Alan ^ permalink raw reply [flat|nested] 12+ messages in thread
* [RFC][PATCH 3/4] tools/memory-model: Define effect of Mb tags on RMWs in tools/... 2024-05-27 15:22 [RFC][PATCH 0/4] tools/memory-model: Define more of LKMM in tools/memory-model Jonas Oberhauser 2024-05-27 15:22 ` [RFC][PATCH 1/4] tools/memory-model: Legitimize current use of tags in LKMM macros Jonas Oberhauser 2024-05-27 15:22 ` [RFC][PATCH 2/4] tools/memory-model: Define applicable tags on operation in tools/ Jonas Oberhauser @ 2024-05-27 15:22 ` Jonas Oberhauser 2024-05-27 16:04 ` Alan Stern 2024-05-27 15:22 ` [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags Jonas Oberhauser 3 siblings, 1 reply; 12+ messages in thread From: Jonas Oberhauser @ 2024-05-27 15:22 UTC (permalink / raw) To: paulmck Cc: stern, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel, Jonas Oberhauser, Viktor Vafeiadis Herd7 transforms successful RMW with Mb tags by inserting smp_mb() fences around them. We emulate this by considering imaginary po-edges before the RMW read and before the RMW write, and extending the smp_mb() ordering rule, which currently only applies to real po edges that would be found around a really inserted smp_mb(), also to cases of the only imagined po edges. Reported-by: Viktor Vafeiadis <viktor@mpi-sws.org> Suggested-by: Alan Stern <stern@rowland.harvard.edu> Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> --- tools/memory-model/linux-kernel.cat | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tools/memory-model/linux-kernel.cat b/tools/memory-model/linux-kernel.cat index adf3c4f41229..3a6e9677abe4 100644 --- a/tools/memory-model/linux-kernel.cat +++ b/tools/memory-model/linux-kernel.cat @@ -34,6 +34,15 @@ let R4rmb = R \ Noreturn (* Reads for which rmb works *) let rmb = [R4rmb] ; fencerel(Rmb) ; [R4rmb] let wmb = [W] ; fencerel(Wmb) ; [W] let mb = ([M] ; fencerel(Mb) ; [M]) | + (* full-barrier RMWs (successful cmpxchg(), xchg(), etc.) act as + * though there were enclosed by smp_mb(). + * The effect of these virtual smp_mb() is formalized by adding + * Mb tags to the read and write of the operation, and providing + * the same ordering as though there were additional po edges + * between the Mb tag and the read resp. write. + *) + ([M] ; po ; [Mb] ; (* po ; *) [R]) | + ([W] ; (* po ; *) [Mb] ; po ; [M]) | ([M] ; fencerel(Before-atomic) ; [RMW] ; po? ; [M]) | ([M] ; po? ; [RMW] ; fencerel(After-atomic) ; [M]) | ([M] ; po? ; [LKW] ; fencerel(After-spinlock) ; [M]) | -- 2.34.1 ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC][PATCH 3/4] tools/memory-model: Define effect of Mb tags on RMWs in tools/... 2024-05-27 15:22 ` [RFC][PATCH 3/4] tools/memory-model: Define effect of Mb tags on RMWs " Jonas Oberhauser @ 2024-05-27 16:04 ` Alan Stern 0 siblings, 0 replies; 12+ messages in thread From: Alan Stern @ 2024-05-27 16:04 UTC (permalink / raw) To: Jonas Oberhauser Cc: paulmck, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel, Viktor Vafeiadis On Mon, May 27, 2024 at 05:22:52PM +0200, Jonas Oberhauser wrote: > Herd7 transforms successful RMW with Mb tags by inserting smp_mb() fences > around them. We emulate this by considering imaginary po-edges before the > RMW read and before the RMW write, and extending the smp_mb() ordering > rule, which currently only applies to real po edges that would be found > around a really inserted smp_mb(), also to cases of the only imagined po > edges. > > Reported-by: Viktor Vafeiadis <viktor@mpi-sws.org> > Suggested-by: Alan Stern <stern@rowland.harvard.edu> > Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> > --- > tools/memory-model/linux-kernel.cat | 9 +++++++++ > 1 file changed, 9 insertions(+) > > diff --git a/tools/memory-model/linux-kernel.cat b/tools/memory-model/linux-kernel.cat > index adf3c4f41229..3a6e9677abe4 100644 > --- a/tools/memory-model/linux-kernel.cat > +++ b/tools/memory-model/linux-kernel.cat > @@ -34,6 +34,15 @@ let R4rmb = R \ Noreturn (* Reads for which rmb works *) > let rmb = [R4rmb] ; fencerel(Rmb) ; [R4rmb] > let wmb = [W] ; fencerel(Wmb) ; [W] > let mb = ([M] ; fencerel(Mb) ; [M]) | > + (* full-barrier RMWs (successful cmpxchg(), xchg(), etc.) act as > + * though there were enclosed by smp_mb(). > + * The effect of these virtual smp_mb() is formalized by adding > + * Mb tags to the read and write of the operation, and providing > + * the same ordering as though there were additional po edges > + * between the Mb tag and the read resp. write. > + *) This file's style calls for multiline comments to start with "(*" on a line by themselves. > + ([M] ; po ; [Mb] ; (* po ; *) [R]) | > + ([W] ; (* po ; *) [Mb] ; po ; [M]) | Can't these be written as: ([M] ; po ; [Mb & R]) | ([Mb & W] ; po ; [M]) | ? I think this would be easier to understand, even though it doesn't correspond as directly to the comment. Alan > ([M] ; fencerel(Before-atomic) ; [RMW] ; po? ; [M]) | > ([M] ; po? ; [RMW] ; fencerel(After-atomic) ; [M]) | > ([M] ; po? ; [LKW] ; fencerel(After-spinlock) ; [M]) | > -- > 2.34.1 > ^ permalink raw reply [flat|nested] 12+ messages in thread
* [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags 2024-05-27 15:22 [RFC][PATCH 0/4] tools/memory-model: Define more of LKMM in tools/memory-model Jonas Oberhauser ` (2 preceding siblings ...) 2024-05-27 15:22 ` [RFC][PATCH 3/4] tools/memory-model: Define effect of Mb tags on RMWs " Jonas Oberhauser @ 2024-05-27 15:22 ` Jonas Oberhauser 2024-05-27 16:06 ` Alan Stern 3 siblings, 1 reply; 12+ messages in thread From: Jonas Oberhauser @ 2024-05-27 15:22 UTC (permalink / raw) To: paulmck Cc: stern, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel, Jonas Oberhauser Not all tags that are always there syntactically also provide semantic membership in the corresponding set. For example, an 'acquire tag on a write does not imply that the write is finally in the Acquire set and provides acquire ordering. To distinguish in those cases between the syntactic tags and actual sets, we capitalize the former, so 'ACQUIRE tags may be present on both reads and writes, but only reads will appear in the Acquire set. For tags where the two concepts are the same we do not use specific capitalization to make this distinction. Reported-by: Boqun Feng <boqun.feng@gmail.com> Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> --- tools/memory-model/linux-kernel.bell | 22 ++-- tools/memory-model/linux-kernel.def | 176 +++++++++++++-------------- 2 files changed, 99 insertions(+), 99 deletions(-) diff --git a/tools/memory-model/linux-kernel.bell b/tools/memory-model/linux-kernel.bell index 08fa1ccb1328..045d94a8eabf 100644 --- a/tools/memory-model/linux-kernel.bell +++ b/tools/memory-model/linux-kernel.bell @@ -13,18 +13,18 @@ "Linux-kernel memory consistency model" -enum Accesses = 'once (*READ_ONCE,WRITE_ONCE*) || - 'release (*smp_store_release*) || - 'acquire (*smp_load_acquire*) || - 'noreturn (* R of non-return RMW *) || - 'mb (*xchg(),compare_exchange(),...*) +enum Accesses = 'ONCE (*READ_ONCE,WRITE_ONCE*) || + 'RELEASE (*smp_store_release*) || + 'ACQUIRE (*smp_load_acquire*) || + 'NORETURN (* R of non-return RMW *) || + 'MB (*xchg(),compare_exchange(),...*) instructions R[Accesses] instructions W[Accesses] instructions RMW[Accesses] enum Barriers = 'wmb (*smp_wmb*) || 'rmb (*smp_rmb*) || - 'mb (*smp_mb*) || + 'MB (*smp_mb*) || 'barrier (*barrier*) || 'rcu-lock (*rcu_read_lock*) || 'rcu-unlock (*rcu_read_unlock*) || @@ -38,10 +38,10 @@ instructions F[Barriers] (* Remove impossible tags, such as Acquire on a store or failed RMW *) let FailedRMW = RMW \ (domain(rmw) | range(rmw)) -let Acquire = Acquire \ W \ FailedRMW -let Release = Release \ R \ FailedRMW -let Mb = Mb \ FailedRMW -let Noreturn = Noreturn \ W +let Acquire = ACQUIRE \ W \ FailedRMW +let Release = RELEASE \ R \ FailedRMW +let Mb = MB \ FailedRMW +let Noreturn = NORETURN \ W (* SRCU *) enum SRCU = 'srcu-lock || 'srcu-unlock || 'sync-srcu @@ -81,7 +81,7 @@ flag ~empty rcu-rscs & (po ; [Sync-srcu] ; po) as invalid-sleep flag ~empty different-values(srcu-rscs) as srcu-bad-value-match (* Compute marked and plain memory accesses *) -let Marked = (~M) | IW | Once | Release | Acquire | domain(rmw) | range(rmw) | +let Marked = (~M) | IW | ONCE | RELEASE | ACQUIRE | MB | domain(rmw) | range(rmw) | LKR | LKW | UL | LF | RL | RU | Srcu-lock | Srcu-unlock let Plain = M \ Marked diff --git a/tools/memory-model/linux-kernel.def b/tools/memory-model/linux-kernel.def index a12b96c547b7..001366ff3fb4 100644 --- a/tools/memory-model/linux-kernel.def +++ b/tools/memory-model/linux-kernel.def @@ -6,18 +6,18 @@ // which appeared in ASPLOS 2018. // ONCE -READ_ONCE(X) __load{once}(X) -WRITE_ONCE(X,V) { __store{once}(X,V); } +READ_ONCE(X) __load{ONCE}(X) +WRITE_ONCE(X,V) { __store{ONCE}(X,V); } // Release Acquire and friends -smp_store_release(X,V) { __store{release}(*X,V); } -smp_load_acquire(X) __load{acquire}(*X) -rcu_assign_pointer(X,V) { __store{release}(X,V); } -rcu_dereference(X) __load{once}(X) -smp_store_mb(X,V) { __store{once}(X,V); __fence{mb}; } +smp_store_release(X,V) { __store{RELEASE}(*X,V); } +smp_load_acquire(X) __load{ACQUIRE}(*X) +rcu_assign_pointer(X,V) { __store{RELEASE}(X,V); } +rcu_dereference(X) __load{ONCE}(X) +smp_store_mb(X,V) { __store{ONCE}(X,V); __fence{MB}; } // Fences -smp_mb() { __fence{mb}; } +smp_mb() { __fence{MB}; } smp_rmb() { __fence{rmb}; } smp_wmb() { __fence{wmb}; } smp_mb__before_atomic() { __fence{before-atomic}; } @@ -28,14 +28,14 @@ smp_mb__after_srcu_read_unlock() { __fence{after-srcu-read-unlock}; } barrier() { __fence{barrier}; } // Exchange -xchg(X,V) __xchg{mb}(X,V) -xchg_relaxed(X,V) __xchg{once}(X,V) -xchg_release(X,V) __xchg{release}(X,V) -xchg_acquire(X,V) __xchg{acquire}(X,V) -cmpxchg(X,V,W) __cmpxchg{mb}(X,V,W) -cmpxchg_relaxed(X,V,W) __cmpxchg{once}(X,V,W) -cmpxchg_acquire(X,V,W) __cmpxchg{acquire}(X,V,W) -cmpxchg_release(X,V,W) __cmpxchg{release}(X,V,W) +xchg(X,V) __xchg{MB}(X,V) +xchg_relaxed(X,V) __xchg{ONCE}(X,V) +xchg_release(X,V) __xchg{RELEASE}(X,V) +xchg_acquire(X,V) __xchg{ACQUIRE}(X,V) +cmpxchg(X,V,W) __cmpxchg{MB}(X,V,W) +cmpxchg_relaxed(X,V,W) __cmpxchg{ONCE}(X,V,W) +cmpxchg_acquire(X,V,W) __cmpxchg{ACQUIRE}(X,V,W) +cmpxchg_release(X,V,W) __cmpxchg{RELEASE}(X,V,W) // Spinlocks spin_lock(X) { __lock(X); } @@ -72,75 +72,75 @@ atomic_inc(X) { __atomic_op(X,+,1); } atomic_dec(X) { __atomic_op(X,-,1); } atomic_andnot(V,X) { __atomic_op(X,&~,V); } -atomic_add_return(V,X) __atomic_op_return{mb}(X,+,V) -atomic_add_return_relaxed(V,X) __atomic_op_return{once}(X,+,V) -atomic_add_return_acquire(V,X) __atomic_op_return{acquire}(X,+,V) -atomic_add_return_release(V,X) __atomic_op_return{release}(X,+,V) -atomic_fetch_add(V,X) __atomic_fetch_op{mb}(X,+,V) -atomic_fetch_add_relaxed(V,X) __atomic_fetch_op{once}(X,+,V) -atomic_fetch_add_acquire(V,X) __atomic_fetch_op{acquire}(X,+,V) -atomic_fetch_add_release(V,X) __atomic_fetch_op{release}(X,+,V) - -atomic_fetch_and(V,X) __atomic_fetch_op{mb}(X,&,V) -atomic_fetch_and_relaxed(V,X) __atomic_fetch_op{once}(X,&,V) -atomic_fetch_and_acquire(V,X) __atomic_fetch_op{acquire}(X,&,V) -atomic_fetch_and_release(V,X) __atomic_fetch_op{release}(X,&,V) - -atomic_fetch_or(V,X) __atomic_fetch_op{mb}(X,|,V) -atomic_fetch_or_relaxed(V,X) __atomic_fetch_op{once}(X,|,V) -atomic_fetch_or_acquire(V,X) __atomic_fetch_op{acquire}(X,|,V) -atomic_fetch_or_release(V,X) __atomic_fetch_op{release}(X,|,V) - -atomic_fetch_xor(V,X) __atomic_fetch_op{mb}(X,^,V) -atomic_fetch_xor_relaxed(V,X) __atomic_fetch_op{once}(X,^,V) -atomic_fetch_xor_acquire(V,X) __atomic_fetch_op{acquire}(X,^,V) -atomic_fetch_xor_release(V,X) __atomic_fetch_op{release}(X,^,V) - -atomic_inc_return(X) __atomic_op_return{mb}(X,+,1) -atomic_inc_return_relaxed(X) __atomic_op_return{once}(X,+,1) -atomic_inc_return_acquire(X) __atomic_op_return{acquire}(X,+,1) -atomic_inc_return_release(X) __atomic_op_return{release}(X,+,1) -atomic_fetch_inc(X) __atomic_fetch_op{mb}(X,+,1) -atomic_fetch_inc_relaxed(X) __atomic_fetch_op{once}(X,+,1) -atomic_fetch_inc_acquire(X) __atomic_fetch_op{acquire}(X,+,1) -atomic_fetch_inc_release(X) __atomic_fetch_op{release}(X,+,1) - -atomic_sub_return(V,X) __atomic_op_return{mb}(X,-,V) -atomic_sub_return_relaxed(V,X) __atomic_op_return{once}(X,-,V) -atomic_sub_return_acquire(V,X) __atomic_op_return{acquire}(X,-,V) -atomic_sub_return_release(V,X) __atomic_op_return{release}(X,-,V) -atomic_fetch_sub(V,X) __atomic_fetch_op{mb}(X,-,V) -atomic_fetch_sub_relaxed(V,X) __atomic_fetch_op{once}(X,-,V) -atomic_fetch_sub_acquire(V,X) __atomic_fetch_op{acquire}(X,-,V) -atomic_fetch_sub_release(V,X) __atomic_fetch_op{release}(X,-,V) - -atomic_dec_return(X) __atomic_op_return{mb}(X,-,1) -atomic_dec_return_relaxed(X) __atomic_op_return{once}(X,-,1) -atomic_dec_return_acquire(X) __atomic_op_return{acquire}(X,-,1) -atomic_dec_return_release(X) __atomic_op_return{release}(X,-,1) -atomic_fetch_dec(X) __atomic_fetch_op{mb}(X,-,1) -atomic_fetch_dec_relaxed(X) __atomic_fetch_op{once}(X,-,1) -atomic_fetch_dec_acquire(X) __atomic_fetch_op{acquire}(X,-,1) -atomic_fetch_dec_release(X) __atomic_fetch_op{release}(X,-,1) - -atomic_xchg(X,V) __xchg{mb}(X,V) -atomic_xchg_relaxed(X,V) __xchg{once}(X,V) -atomic_xchg_release(X,V) __xchg{release}(X,V) -atomic_xchg_acquire(X,V) __xchg{acquire}(X,V) -atomic_cmpxchg(X,V,W) __cmpxchg{mb}(X,V,W) -atomic_cmpxchg_relaxed(X,V,W) __cmpxchg{once}(X,V,W) -atomic_cmpxchg_acquire(X,V,W) __cmpxchg{acquire}(X,V,W) -atomic_cmpxchg_release(X,V,W) __cmpxchg{release}(X,V,W) - -atomic_sub_and_test(V,X) __atomic_op_return{mb}(X,-,V) == 0 -atomic_dec_and_test(X) __atomic_op_return{mb}(X,-,1) == 0 -atomic_inc_and_test(X) __atomic_op_return{mb}(X,+,1) == 0 -atomic_add_negative(V,X) __atomic_op_return{mb}(X,+,V) < 0 -atomic_add_negative_relaxed(V,X) __atomic_op_return{once}(X,+,V) < 0 -atomic_add_negative_acquire(V,X) __atomic_op_return{acquire}(X,+,V) < 0 -atomic_add_negative_release(V,X) __atomic_op_return{release}(X,+,V) < 0 - -atomic_fetch_andnot(V,X) __atomic_fetch_op{mb}(X,&~,V) -atomic_fetch_andnot_acquire(V,X) __atomic_fetch_op{acquire}(X,&~,V) -atomic_fetch_andnot_release(V,X) __atomic_fetch_op{release}(X,&~,V) -atomic_fetch_andnot_relaxed(V,X) __atomic_fetch_op{once}(X,&~,V) +atomic_add_return(V,X) __atomic_op_return{MB}(X,+,V) +atomic_add_return_relaxed(V,X) __atomic_op_return{ONCE}(X,+,V) +atomic_add_return_acquire(V,X) __atomic_op_return{ACQUIRE}(X,+,V) +atomic_add_return_release(V,X) __atomic_op_return{RELEASE}(X,+,V) +atomic_fetch_add(V,X) __atomic_fetch_op{MB}(X,+,V) +atomic_fetch_add_relaxed(V,X) __atomic_fetch_op{ONCE}(X,+,V) +atomic_fetch_add_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,+,V) +atomic_fetch_add_release(V,X) __atomic_fetch_op{RELEASE}(X,+,V) + +atomic_fetch_and(V,X) __atomic_fetch_op{MB}(X,&,V) +atomic_fetch_and_relaxed(V,X) __atomic_fetch_op{ONCE}(X,&,V) +atomic_fetch_and_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,&,V) +atomic_fetch_and_release(V,X) __atomic_fetch_op{RELEASE}(X,&,V) + +atomic_fetch_or(V,X) __atomic_fetch_op{MB}(X,|,V) +atomic_fetch_or_relaxed(V,X) __atomic_fetch_op{ONCE}(X,|,V) +atomic_fetch_or_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,|,V) +atomic_fetch_or_release(V,X) __atomic_fetch_op{RELEASE}(X,|,V) + +atomic_fetch_xor(V,X) __atomic_fetch_op{MB}(X,^,V) +atomic_fetch_xor_relaxed(V,X) __atomic_fetch_op{ONCE}(X,^,V) +atomic_fetch_xor_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,^,V) +atomic_fetch_xor_release(V,X) __atomic_fetch_op{RELEASE}(X,^,V) + +atomic_inc_return(X) __atomic_op_return{MB}(X,+,1) +atomic_inc_return_relaxed(X) __atomic_op_return{ONCE}(X,+,1) +atomic_inc_return_acquire(X) __atomic_op_return{ACQUIRE}(X,+,1) +atomic_inc_return_release(X) __atomic_op_return{RELEASE}(X,+,1) +atomic_fetch_inc(X) __atomic_fetch_op{MB}(X,+,1) +atomic_fetch_inc_relaxed(X) __atomic_fetch_op{ONCE}(X,+,1) +atomic_fetch_inc_acquire(X) __atomic_fetch_op{ACQUIRE}(X,+,1) +atomic_fetch_inc_release(X) __atomic_fetch_op{RELEASE}(X,+,1) + +atomic_sub_return(V,X) __atomic_op_return{MB}(X,-,V) +atomic_sub_return_relaxed(V,X) __atomic_op_return{ONCE}(X,-,V) +atomic_sub_return_acquire(V,X) __atomic_op_return{ACQUIRE}(X,-,V) +atomic_sub_return_release(V,X) __atomic_op_return{RELEASE}(X,-,V) +atomic_fetch_sub(V,X) __atomic_fetch_op{MB}(X,-,V) +atomic_fetch_sub_relaxed(V,X) __atomic_fetch_op{ONCE}(X,-,V) +atomic_fetch_sub_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,-,V) +atomic_fetch_sub_release(V,X) __atomic_fetch_op{RELEASE}(X,-,V) + +atomic_dec_return(X) __atomic_op_return{MB}(X,-,1) +atomic_dec_return_relaxed(X) __atomic_op_return{ONCE}(X,-,1) +atomic_dec_return_acquire(X) __atomic_op_return{ACQUIRE}(X,-,1) +atomic_dec_return_release(X) __atomic_op_return{RELEASE}(X,-,1) +atomic_fetch_dec(X) __atomic_fetch_op{MB}(X,-,1) +atomic_fetch_dec_relaxed(X) __atomic_fetch_op{ONCE}(X,-,1) +atomic_fetch_dec_acquire(X) __atomic_fetch_op{ACQUIRE}(X,-,1) +atomic_fetch_dec_release(X) __atomic_fetch_op{RELEASE}(X,-,1) + +atomic_xchg(X,V) __xchg{MB}(X,V) +atomic_xchg_relaxed(X,V) __xchg{ONCE}(X,V) +atomic_xchg_release(X,V) __xchg{RELEASE}(X,V) +atomic_xchg_acquire(X,V) __xchg{ACQUIRE}(X,V) +atomic_cmpxchg(X,V,W) __cmpxchg{MB}(X,V,W) +atomic_cmpxchg_relaxed(X,V,W) __cmpxchg{ONCE}(X,V,W) +atomic_cmpxchg_acquire(X,V,W) __cmpxchg{ACQUIRE}(X,V,W) +atomic_cmpxchg_release(X,V,W) __cmpxchg{RELEASE}(X,V,W) + +atomic_sub_and_test(V,X) __atomic_op_return{MB}(X,-,V) == 0 +atomic_dec_and_test(X) __atomic_op_return{MB}(X,-,1) == 0 +atomic_inc_and_test(X) __atomic_op_return{MB}(X,+,1) == 0 +atomic_add_negative(V,X) __atomic_op_return{MB}(X,+,V) < 0 +atomic_add_negative_relaxed(V,X) __atomic_op_return{ONCE}(X,+,V) < 0 +atomic_add_negative_acquire(V,X) __atomic_op_return{ACQUIRE}(X,+,V) < 0 +atomic_add_negative_release(V,X) __atomic_op_return{RELEASE}(X,+,V) < 0 + +atomic_fetch_andnot(V,X) __atomic_fetch_op{MB}(X,&~,V) +atomic_fetch_andnot_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,&~,V) +atomic_fetch_andnot_release(V,X) __atomic_fetch_op{RELEASE}(X,&~,V) +atomic_fetch_andnot_relaxed(V,X) __atomic_fetch_op{ONCE}(X,&~,V) -- 2.34.1 ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags 2024-05-27 15:22 ` [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags Jonas Oberhauser @ 2024-05-27 16:06 ` Alan Stern 2024-05-28 12:49 ` Jonas Oberhauser 0 siblings, 1 reply; 12+ messages in thread From: Alan Stern @ 2024-05-27 16:06 UTC (permalink / raw) To: Jonas Oberhauser Cc: paulmck, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel On Mon, May 27, 2024 at 05:22:53PM +0200, Jonas Oberhauser wrote: > Not all tags that are always there syntactically also provide semantic > membership in the corresponding set. For example, an 'acquire tag on a > write does not imply that the write is finally in the Acquire set and > provides acquire ordering. > > To distinguish in those cases between the syntactic tags and actual > sets, we capitalize the former, so 'ACQUIRE tags may be present on both > reads and writes, but only reads will appear in the Acquire set. > > For tags where the two concepts are the same we do not use specific > capitalization to make this distinction. > > Reported-by: Boqun Feng <boqun.feng@gmail.com> > Signed-off-by: Jonas Oberhauser <jonas.oberhauser@huaweicloud.com> > --- > tools/memory-model/linux-kernel.bell | 22 ++-- > tools/memory-model/linux-kernel.def | 176 +++++++++++++-------------- > 2 files changed, 99 insertions(+), 99 deletions(-) > > diff --git a/tools/memory-model/linux-kernel.bell b/tools/memory-model/linux-kernel.bell > index 08fa1ccb1328..045d94a8eabf 100644 > --- a/tools/memory-model/linux-kernel.bell > +++ b/tools/memory-model/linux-kernel.bell > @@ -13,18 +13,18 @@ > > "Linux-kernel memory consistency model" > > -enum Accesses = 'once (*READ_ONCE,WRITE_ONCE*) || > - 'release (*smp_store_release*) || > - 'acquire (*smp_load_acquire*) || > - 'noreturn (* R of non-return RMW *) || > - 'mb (*xchg(),compare_exchange(),...*) > +enum Accesses = 'ONCE (*READ_ONCE,WRITE_ONCE*) || > + 'RELEASE (*smp_store_release*) || > + 'ACQUIRE (*smp_load_acquire*) || > + 'NORETURN (* R of non-return RMW *) || > + 'MB (*xchg(),compare_exchange(),...*) > instructions R[Accesses] > instructions W[Accesses] > instructions RMW[Accesses] > > enum Barriers = 'wmb (*smp_wmb*) || > 'rmb (*smp_rmb*) || > - 'mb (*smp_mb*) || > + 'MB (*smp_mb*) || > 'barrier (*barrier*) || > 'rcu-lock (*rcu_read_lock*) || > 'rcu-unlock (*rcu_read_unlock*) || > @@ -38,10 +38,10 @@ instructions F[Barriers] > > (* Remove impossible tags, such as Acquire on a store or failed RMW *) > let FailedRMW = RMW \ (domain(rmw) | range(rmw)) > -let Acquire = Acquire \ W \ FailedRMW > -let Release = Release \ R \ FailedRMW > -let Mb = Mb \ FailedRMW > -let Noreturn = Noreturn \ W > +let Acquire = ACQUIRE \ W \ FailedRMW > +let Release = RELEASE \ R \ FailedRMW > +let Mb = MB \ FailedRMW > +let Noreturn = NORETURN \ W > > (* SRCU *) > enum SRCU = 'srcu-lock || 'srcu-unlock || 'sync-srcu > @@ -81,7 +81,7 @@ flag ~empty rcu-rscs & (po ; [Sync-srcu] ; po) as invalid-sleep > flag ~empty different-values(srcu-rscs) as srcu-bad-value-match > > (* Compute marked and plain memory accesses *) > -let Marked = (~M) | IW | Once | Release | Acquire | domain(rmw) | range(rmw) | > +let Marked = (~M) | IW | ONCE | RELEASE | ACQUIRE | MB | domain(rmw) | range(rmw) | The new MB term isn't needed, because MB tags on memory accesses are filtered out unless the access also belongs to domain(rmw) | range(rmw). Alan ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags 2024-05-27 16:06 ` Alan Stern @ 2024-05-28 12:49 ` Jonas Oberhauser 2024-05-28 14:01 ` Alan Stern 0 siblings, 1 reply; 12+ messages in thread From: Jonas Oberhauser @ 2024-05-28 12:49 UTC (permalink / raw) To: Alan Stern Cc: paulmck, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel >> +let Mb = MB \ FailedRMW >> >> (* Compute marked and plain memory accesses *) >> -let Marked = (~M) | IW | Once | Release | Acquire | domain(rmw) | range(rmw) | >> +let Marked = (~M) | IW | ONCE | RELEASE | ACQUIRE | MB | domain(rmw) | range(rmw) | > > The new MB term isn't needed, because MB tags on memory accesses are > filtered out unless the access also belongs to domain(rmw) | range(rmw). > > Alan Thanks for all the notes. I think on this one is needed though under the assumption that herd7 would no longer know internally to replace the MB with ONCE in case of failure. best wishes, jonas ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags 2024-05-28 12:49 ` Jonas Oberhauser @ 2024-05-28 14:01 ` Alan Stern 2024-05-28 14:45 ` Jonas Oberhauser 0 siblings, 1 reply; 12+ messages in thread From: Alan Stern @ 2024-05-28 14:01 UTC (permalink / raw) To: Jonas Oberhauser Cc: paulmck, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel On Tue, May 28, 2024 at 02:49:38PM +0200, Jonas Oberhauser wrote: > > > +let Mb = MB \ FailedRMW > > > >> (* Compute marked and plain memory accesses *) > > > -let Marked = (~M) | IW | Once | Release | Acquire | domain(rmw) | range(rmw) | > > > +let Marked = (~M) | IW | ONCE | RELEASE | ACQUIRE | MB | domain(rmw) | range(rmw) | > > > > The new MB term isn't needed, because MB tags on memory accesses are > > filtered out unless the access also belongs to domain(rmw) | range(rmw). > > > > Alan > > > Thanks for all the notes. > I think on this one is needed though under the assumption that herd7 would > no longer know internally to replace the MB with ONCE in case > of failure. And I was wrong because failed RMW instructions are filtered out of Mb, not out of MB. Hmmm, this raises another question: Shouldn't the R event for a failed cmpxchg_release count as marked? At the moment it's not clear how such events will be tagged. Perhaps the best thing to do is add RMW to this list, which would make domain(rmw) and range(rmw) unnecessary. And then we probably don't need to keep MB -- unless smp_store_mb()'s definition ever gets reduced to __store{MB}(X,V). Alan ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags 2024-05-28 14:01 ` Alan Stern @ 2024-05-28 14:45 ` Jonas Oberhauser 0 siblings, 0 replies; 12+ messages in thread From: Jonas Oberhauser @ 2024-05-28 14:45 UTC (permalink / raw) To: Alan Stern Cc: paulmck, parri.andrea, will, peterz, boqun.feng, npiggin, dhowells, j.alglave, luc.maranget, akiyks, dlustig, joel, urezki, quic_neeraju, frederic, linux-kernel Am 5/28/2024 um 4:01 PM schrieb Alan Stern: > On Tue, May 28, 2024 at 02:49:38PM +0200, Jonas Oberhauser wrote: >>>> +let Mb = MB \ FailedRMW >>>>>> (* Compute marked and plain memory accesses *) >>>> -let Marked = (~M) | IW | Once | Release | Acquire | domain(rmw) | range(rmw) | >>>> +let Marked = (~M) | IW | ONCE | RELEASE | ACQUIRE | MB | domain(rmw) | range(rmw) | >>> >>> The new MB term isn't needed, because MB tags on memory accesses are >>> filtered out unless the access also belongs to domain(rmw) | range(rmw). >>> >>> Alan >> >> >> Thanks for all the notes. >> I think on this one is needed though under the assumption that herd7 would >> no longer know internally to replace the MB with ONCE in case >> of failure. > Hmmm, this raises another question: Shouldn't the R event for a failed > cmpxchg_release count as marked? Yes. > At the moment it's not clear how such > events will be tagged. If by "at the moment" you mean the current herd7, then (as mentioned in the cover letter) this patch does not work at all with the current herd7 because IIUC in fact ACQUIRE and RELEASE tags will be replaced by Once in all cases (so smp_store_release would be a store Once ...). However, in a hypothetical version of herd7 which just leaves all the syntactic tags intact, we would get R & RMW & RELEASE, which would not be in the Release set (by nature of failing and being a read) but would be Marked (by nature of having a syntactic RELEASE tag). > Perhaps the best thing to do is add RMW to > this list, which would make domain(rmw) and range(rmw) unnecessary. That's also a good idea. > And then we probably don't need to keep MB That's correct, although as a failsafe I would probably keep it anyways - it doesn't harm, but it may prevent a gotcha. Have fun, jonas ^ permalink raw reply [flat|nested] 12+ messages in thread
end of thread, other threads:[~2024-05-28 14:46 UTC | newest] Thread overview: 12+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2024-05-27 15:22 [RFC][PATCH 0/4] tools/memory-model: Define more of LKMM in tools/memory-model Jonas Oberhauser 2024-05-27 15:22 ` [RFC][PATCH 1/4] tools/memory-model: Legitimize current use of tags in LKMM macros Jonas Oberhauser 2024-05-27 15:58 ` Alan Stern 2024-05-27 15:22 ` [RFC][PATCH 2/4] tools/memory-model: Define applicable tags on operation in tools/ Jonas Oberhauser 2024-05-27 15:59 ` Alan Stern 2024-05-27 15:22 ` [RFC][PATCH 3/4] tools/memory-model: Define effect of Mb tags on RMWs " Jonas Oberhauser 2024-05-27 16:04 ` Alan Stern 2024-05-27 15:22 ` [RFC][PATCH 4/4] tools/memory-model: Distinguish between syntactic and semantic tags Jonas Oberhauser 2024-05-27 16:06 ` Alan Stern 2024-05-28 12:49 ` Jonas Oberhauser 2024-05-28 14:01 ` Alan Stern 2024-05-28 14:45 ` Jonas Oberhauser
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®