1. Patchew
  2. linux
  3. View series

[PATCH] tools/memory-model: Add atomic_and()/or()/xor() and add_negative

Puranjay Mohan posted 1 patch 1 week, 4 days ago 
tools/memory-model/linux-kernel.def | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
[PATCH] tools/memory-model: Add atomic_and()/or()/xor() and add_negative
Posted by Puranjay Mohan 1 week, 4 days ago 
Pull-849[1] added the support of '&', '|', and '^' to the herd7 tool's
atomics operations.

Use these in linux-kernel.def to implement atomic_and()/or()/xor() with
all their ordering variants.

atomic_add_negative() is already available so add its acquire, release,
and relaxed ordering variants.

[1] https://github.com/herd/herdtools7/pull/849

Signed-off-by: Puranjay Mohan <puranjay@kernel.org>
---
 tools/memory-model/linux-kernel.def | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/tools/memory-model/linux-kernel.def b/tools/memory-model/linux-kernel.def
index 88a39601f525..d1f11930ec51 100644
--- a/tools/memory-model/linux-kernel.def
+++ b/tools/memory-model/linux-kernel.def
@@ -65,6 +65,9 @@ atomic_set_release(X,V) { smp_store_release(X,V); }
 
 atomic_add(V,X) { __atomic_op(X,+,V); }
 atomic_sub(V,X) { __atomic_op(X,-,V); }
+atomic_and(V,X) { __atomic_op(X,&,V); }
+atomic_or(V,X)  { __atomic_op(X,|,V); }
+atomic_xor(V,X) { __atomic_op(X,^,V); }
 atomic_inc(X)   { __atomic_op(X,+,1); }
 atomic_dec(X)   { __atomic_op(X,-,1); }
 
@@ -77,6 +80,21 @@ 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)
@@ -117,3 +135,6 @@ 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
-- 
2.40.1
Re: [PATCH] tools/memory-model: Add atomic_and()/or()/xor() and add_negative
Posted by Boqun Feng 1 week, 4 days ago 
On Wed, May 08, 2024 at 02:34:00PM +0000, Puranjay Mohan wrote:
> Pull-849[1] added the support of '&', '|', and '^' to the herd7 tool's
> atomics operations.
> 
> Use these in linux-kernel.def to implement atomic_and()/or()/xor() with
> all their ordering variants.
> 
> atomic_add_negative() is already available so add its acquire, release,
> and relaxed ordering variants.
> 
> [1] https://github.com/herd/herdtools7/pull/849

A newer version of herd is required for this feature, right? So please
also do a change in tools/memory-model/README "REQUIREMENTS" session
when the new version released.

Needless to say, this patch looks good to me.

Reviewed-by: Boqun Feng <boqun.feng@gmail.com>

Regards,
Boqun

> 
> Signed-off-by: Puranjay Mohan <puranjay@kernel.org>
> ---
>  tools/memory-model/linux-kernel.def | 21 +++++++++++++++++++++
>  1 file changed, 21 insertions(+)
> 
> diff --git a/tools/memory-model/linux-kernel.def b/tools/memory-model/linux-kernel.def
> index 88a39601f525..d1f11930ec51 100644
> --- a/tools/memory-model/linux-kernel.def
> +++ b/tools/memory-model/linux-kernel.def
> @@ -65,6 +65,9 @@ atomic_set_release(X,V) { smp_store_release(X,V); }
>  
>  atomic_add(V,X) { __atomic_op(X,+,V); }
>  atomic_sub(V,X) { __atomic_op(X,-,V); }
> +atomic_and(V,X) { __atomic_op(X,&,V); }
> +atomic_or(V,X)  { __atomic_op(X,|,V); }
> +atomic_xor(V,X) { __atomic_op(X,^,V); }
>  atomic_inc(X)   { __atomic_op(X,+,1); }
>  atomic_dec(X)   { __atomic_op(X,-,1); }
>  
> @@ -77,6 +80,21 @@ 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)
> @@ -117,3 +135,6 @@ 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
> -- 
> 2.40.1
>
Re: [PATCH] tools/memory-model: Add atomic_and()/or()/xor() and add_negative
Posted by Akira Yokosawa 1 week, 3 days ago 
On Wed, 8 May 2024 12:49:57 -0700, Boqun Feng wrote:
> On Wed, May 08, 2024 at 02:34:00PM +0000, Puranjay Mohan wrote:
>> Pull-849[1] added the support of '&', '|', and '^' to the herd7 tool's
>> atomics operations.
>>
>> Use these in linux-kernel.def to implement atomic_and()/or()/xor() with
>> all their ordering variants.
>>
>> atomic_add_negative() is already available so add its acquire, release,
>> and relaxed ordering variants.
>>
>> [1] https://github.com/herd/herdtools7/pull/849
> 
> A newer version of herd is required for this feature, right?

Yes, this requires building herd7 from latest source.

herdtools7 7.57 (released recently) happened before pull 849.

Luc, what is your plan on a next release (7.57.1?) ?

>                                                               So please
> also do a change in tools/memory-model/README "REQUIREMENTS" session
> when the new version released.

Puranjay, it would be great if you add some litmus tests which use
additional atomic primitives under tools/memory-model/litmus-tests/
as well.

        Thanks, Akira

> Boqun
> 
>>
>> Signed-off-by: Puranjay Mohan <puranjay@kernel.org>
>> ---
>>  tools/memory-model/linux-kernel.def | 21 +++++++++++++++++++++
>>  1 file changed, 21 insertions(+)
Re: [PATCH] tools/memory-model: Add atomic_and()/or()/xor() and add_negative
Posted by Paul E. McKenney 1 week, 3 days ago 
On Thu, May 09, 2024 at 06:59:17AM +0900, Akira Yokosawa wrote:
> On Wed, 8 May 2024 12:49:57 -0700, Boqun Feng wrote:
> > On Wed, May 08, 2024 at 02:34:00PM +0000, Puranjay Mohan wrote:
> >> Pull-849[1] added the support of '&', '|', and '^' to the herd7 tool's
> >> atomics operations.
> >>
> >> Use these in linux-kernel.def to implement atomic_and()/or()/xor() with
> >> all their ordering variants.
> >>
> >> atomic_add_negative() is already available so add its acquire, release,
> >> and relaxed ordering variants.
> >>
> >> [1] https://github.com/herd/herdtools7/pull/849
> > 
> > A newer version of herd is required for this feature, right?
> 
> Yes, this requires building herd7 from latest source.
> 
> herdtools7 7.57 (released recently) happened before pull 849.
> 
> Luc, what is your plan on a next release (7.57.1?) ?
> 
> >                                                               So please
> > also do a change in tools/memory-model/README "REQUIREMENTS" session
> > when the new version released.
> 
> Puranjay, it would be great if you add some litmus tests which use
> additional atomic primitives under tools/memory-model/litmus-tests/
> as well.

Thank you for checking, Akira!  I need to hold off sending this upstream
until there is a herdtools7 release that supports it.  So not the merge
window that is likely to open this weekend.  ;-)

							Thanx, Paul

>         Thanks, Akira
> 
> > Boqun
> > 
> >>
> >> Signed-off-by: Puranjay Mohan <puranjay@kernel.org>
> >> ---
> >>  tools/memory-model/linux-kernel.def | 21 +++++++++++++++++++++
> >>  1 file changed, 21 insertions(+)
>
Re: [PATCH] tools/memory-model: Add atomic_and()/or()/xor() and add_negative
Posted by Andrea Parri 1 week, 4 days ago 
On Wed, May 08, 2024 at 02:34:00PM +0000, Puranjay Mohan wrote:
> Pull-849[1] added the support of '&', '|', and '^' to the herd7 tool's
> atomics operations.
> 
> Use these in linux-kernel.def to implement atomic_and()/or()/xor() with
> all their ordering variants.
> 
> atomic_add_negative() is already available so add its acquire, release,
> and relaxed ordering variants.
> 
> [1] https://github.com/herd/herdtools7/pull/849
> 
> Signed-off-by: Puranjay Mohan <puranjay@kernel.org>

Acked-by: Andrea Parri <parri.andrea@gmail.com>

Thanks,
  Andrea
Re: [PATCH] tools/memory-model: Add atomic_and()/or()/xor() and add_negative
Posted by Paul E. McKenney 1 week, 4 days ago 
On Wed, May 08, 2024 at 05:28:22PM +0200, Andrea Parri wrote:
> On Wed, May 08, 2024 at 02:34:00PM +0000, Puranjay Mohan wrote:
> > Pull-849[1] added the support of '&', '|', and '^' to the herd7 tool's
> > atomics operations.
> > 
> > Use these in linux-kernel.def to implement atomic_and()/or()/xor() with
> > all their ordering variants.
> > 
> > atomic_add_negative() is already available so add its acquire, release,
> > and relaxed ordering variants.
> > 
> > [1] https://github.com/herd/herdtools7/pull/849
> > 
> > Signed-off-by: Puranjay Mohan <puranjay@kernel.org>
> 
> Acked-by: Andrea Parri <parri.andrea@gmail.com>

Queued for review and testing, and thank you both!

							Thanx, Paul

Patchew 2.1-devel-0870f84

© 2016 - 2024 Red Hat, Inc.