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 0298d75c9b759daa886fb0157a22e5b5bf1331f4..9dd8b60ae435ba808e59b87bb052c70decff48e1 100644 (file)
--- a/src/runtime/internal/atomic/atomic_andor_test.go
+++ b/src/runtime/internal/atomic/atomic_andor_test.go
@@ -1,4 +1,5 @@
-// +build wasm
+//go:build 386 || amd64 || arm || arm64 || ppc64 || ppc64le || riscv64 || wasm
+
 //
 // Copyright 2023 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -9,8 +10,8 @@
 package atomic_test
 
 import (
-       "testing"
        "runtime/internal/atomic"
+       "testing"
 )
 
 func TestAnd32(t *testing.T) {
@@ -167,3 +168,82 @@ 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++
+               }
+       })
+}