1
2
3
4
5
6
7 package atomic_test
8
9 import (
10 "runtime/internal/atomic"
11 "testing"
12 )
13
14 func TestAnd32(t *testing.T) {
15
16 x := uint32(0xffffffff)
17 for i := uint32(0); i < 32; i++ {
18 old := x
19 v := atomic.And32(&x, ^(1 << i))
20 if r := uint32(0xffffffff) << (i + 1); x != r || v != old {
21 t.Fatalf("clearing bit %#x: want %#x, got new %#x and old %#v", uint32(1<<i), r, x, v)
22 }
23 }
24
25
26 a := make([]uint32, 1<<12)
27 for i := range a {
28 a[i] = 0xffffffff
29 }
30
31
32 done := make(chan bool)
33 for i := 0; i < 32; i++ {
34 m := ^uint32(1 << i)
35 go func() {
36 for i := range a {
37 atomic.And(&a[i], m)
38 }
39 done <- true
40 }()
41 }
42 for i := 0; i < 32; i++ {
43 <-done
44 }
45
46
47 for i, v := range a {
48 if v != 0 {
49 t.Fatalf("a[%v] not cleared: want %#x, got %#x", i, uint32(0), v)
50 }
51 }
52 }
53
54 func TestAnd64(t *testing.T) {
55
56 x := uint64(0xffffffffffffffff)
57 for i := uint64(0); i < 64; i++ {
58 old := x
59 v := atomic.And64(&x, ^(1 << i))
60 if r := uint64(0xffffffffffffffff) << (i + 1); x != r || v != old {
61 t.Fatalf("clearing bit %#x: want %#x, got new %#x and old %#v", uint64(1<<i), r, x, v)
62 }
63 }
64
65
66 a := make([]uint64, 1<<12)
67 for i := range a {
68 a[i] = 0xffffffffffffffff
69 }
70
71
72 done := make(chan bool)
73 for i := 0; i < 64; i++ {
74 m := ^uint64(1 << i)
75 go func() {
76 for i := range a {
77 atomic.And64(&a[i], m)
78 }
79 done <- true
80 }()
81 }
82 for i := 0; i < 64; i++ {
83 <-done
84 }
85
86
87 for i, v := range a {
88 if v != 0 {
89 t.Fatalf("a[%v] not cleared: want %#x, got %#x", i, uint64(0), v)
90 }
91 }
92 }
93
94 func TestOr32(t *testing.T) {
95
96 x := uint32(0)
97 for i := uint32(0); i < 32; i++ {
98 old := x
99 v := atomic.Or32(&x, 1<<i)
100 if r := (uint32(1) << (i + 1)) - 1; x != r || v != old {
101 t.Fatalf("setting bit %#x: want %#x, got new %#x and old %#v", uint32(1<<i), r, x, v)
102 }
103 }
104
105
106 a := make([]uint32, 1<<12)
107
108
109 done := make(chan bool)
110 for i := 0; i < 32; i++ {
111 m := uint32(1 << i)
112 go func() {
113 for i := range a {
114 atomic.Or32(&a[i], m)
115 }
116 done <- true
117 }()
118 }
119 for i := 0; i < 32; i++ {
120 <-done
121 }
122
123
124 for i, v := range a {
125 if v != 0xffffffff {
126 t.Fatalf("a[%v] not fully set: want %#x, got %#x", i, uint32(0xffffffff), v)
127 }
128 }
129 }
130
131 func TestOr64(t *testing.T) {
132
133 x := uint64(0)
134 for i := uint64(0); i < 64; i++ {
135 old := x
136 v := atomic.Or64(&x, 1<<i)
137 if r := (uint64(1) << (i + 1)) - 1; x != r || v != old {
138 t.Fatalf("setting bit %#x: want %#x, got new %#x and old %#v", uint64(1<<i), r, x, v)
139 }
140 }
141
142
143 a := make([]uint64, 1<<12)
144
145
146 done := make(chan bool)
147 for i := 0; i < 64; i++ {
148 m := uint64(1 << i)
149 go func() {
150 for i := range a {
151 atomic.Or64(&a[i], m)
152 }
153 done <- true
154 }()
155 }
156 for i := 0; i < 64; i++ {
157 <-done
158 }
159
160
161 for i, v := range a {
162 if v != 0xffffffffffffffff {
163 t.Fatalf("a[%v] not fully set: want %#x, got %#x", i, uint64(0xffffffffffffffff), v)
164 }
165 }
166 }
167
168 func BenchmarkAnd32(b *testing.B) {
169 var x [128]uint32
170 sink = &x
171 for i := 0; i < b.N; i++ {
172 atomic.And32(&x[63], uint32(i))
173 }
174 }
175
176 func BenchmarkAnd32Parallel(b *testing.B) {
177 var x [128]uint32
178 sink = &x
179 b.RunParallel(func(pb *testing.PB) {
180 i := uint32(0)
181 for pb.Next() {
182 atomic.And32(&x[63], i)
183 i++
184 }
185 })
186 }
187
188 func BenchmarkAnd64(b *testing.B) {
189 var x [128]uint64
190 sink = &x
191 for i := 0; i < b.N; i++ {
192 atomic.And64(&x[63], uint64(i))
193 }
194 }
195
196 func BenchmarkAnd64Parallel(b *testing.B) {
197 var x [128]uint64
198 sink = &x
199 b.RunParallel(func(pb *testing.PB) {
200 i := uint64(0)
201 for pb.Next() {
202 atomic.And64(&x[63], i)
203 i++
204 }
205 })
206 }
207
208 func BenchmarkOr32(b *testing.B) {
209 var x [128]uint32
210 sink = &x
211 for i := 0; i < b.N; i++ {
212 atomic.Or32(&x[63], uint32(i))
213 }
214 }
215
216 func BenchmarkOr32Parallel(b *testing.B) {
217 var x [128]uint32
218 sink = &x
219 b.RunParallel(func(pb *testing.PB) {
220 i := uint32(0)
221 for pb.Next() {
222 atomic.Or32(&x[63], i)
223 i++
224 }
225 })
226 }
227
228 func BenchmarkOr64(b *testing.B) {
229 var x [128]uint64
230 sink = &x
231 for i := 0; i < b.N; i++ {
232 atomic.Or64(&x[63], uint64(i))
233 }
234 }
235
236 func BenchmarkOr64Parallel(b *testing.B) {
237 var x [128]uint64
238 sink = &x
239 b.RunParallel(func(pb *testing.PB) {
240 i := uint64(0)
241 for pb.Next() {
242 atomic.Or64(&x[63], i)
243 i++
244 }
245 })
246 }
247
View as plain text