runtime/internal/atomic: add arm/arm64 operators for And/Or

[gostls13.git] / src / runtime / internal / atomic / atomic_andor_test.go

diff --git a/src/runtime/internal/atomic/atomic_andor_test.go b/src/runtime/internal/atomic/atomic_andor_test.go
index 03c2c754f33d48c2053decffbe30eade2a48d1ea..9dd8b60ae435ba808e59b87bb052c70decff48e1 100644 (file)
--- a/src/runtime/internal/atomic/atomic_andor_test.go
+++ b/src/runtime/internal/atomic/atomic_andor_test.go
@@ -1,4 +1,4 @@
-//go:build wasm || ppc64 || ppc64le
+//go:build 386 || amd64 || arm || arm64 || ppc64 || ppc64le || riscv64 || wasm
 
 //
 // Copyright 2023 The Go Authors. All rights reserved.
@@ -167,3 +167,83 @@ func TestOr64(t *testing.T) {
                }
        }
 }
+
+func BenchmarkAnd32(b *testing.B) {
+       var x [128]uint32 // give x its own cache line
+       sink = &x
+       for i := 0; i < b.N; i++ {
+               atomic.And32(&x[63], uint32(i))
+       }
+}
+
+func BenchmarkAnd32Parallel(b *testing.B) {
+       var x [128]uint32 // give x its own cache line
+       sink = &x
+       b.RunParallel(func(pb *testing.PB) {
+               i := uint32(0)
+               for pb.Next() {
+                       atomic.And32(&x[63], i)
+                       i++
+               }
+       })
+}
+
+func BenchmarkAnd64(b *testing.B) {
+       var x [128]uint64 // give x its own cache line
+       sink = &x
+       for i := 0; i < b.N; i++ {
+               atomic.And64(&x[63], uint64(i))
+       }
+}
+
+func BenchmarkAnd64Parallel(b *testing.B) {
+       var x [128]uint64 // give x its own cache line
+       sink = &x
+       b.RunParallel(func(pb *testing.PB) {
+               i := uint64(0)
+               for pb.Next() {
+                       atomic.And64(&x[63], i)
+                       i++
+               }
+       })
+}
+
+func BenchmarkOr32(b *testing.B) {
+       var x [128]uint32 // give x its own cache line
+       sink = &x
+       for i := 0; i < b.N; i++ {
+               atomic.Or32(&x[63], uint32(i))
+       }
+}
+
+func BenchmarkOr32Parallel(b *testing.B) {
+       var x [128]uint32 // give x its own cache line
+       sink = &x
+       b.RunParallel(func(pb *testing.PB) {
+               i := uint32(0)
+               for pb.Next() {
+                       atomic.Or32(&x[63], i)
+                       i++
+               }
+       })
+}
+
+func BenchmarkOr64(b *testing.B) {
+       var x [128]uint64 // give x its own cache line
+       sink = &x
+       for i := 0; i < b.N; i++ {
+               atomic.Or64(&x[63], uint64(i))
+       }
+}
+
+func BenchmarkOr64Parallel(b *testing.B) {
+       var x [128]uint64 // give x its own cache line
+       sink = &x
+       b.RunParallel(func(pb *testing.PB) {
+               i := uint64(0)
+               for pb.Next() {
+                       atomic.Or64(&x[63], i)
+                       i++
+               }
+       })
+}