1 // Copyright 2011 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/atomicops.h"
6
7 #include <stdint.h>
8 #include <string.h>
9 #include <type_traits>
10
11 #include "testing/gtest/include/gtest/gtest.h"
12
13 template <class AtomicType>
TestAtomicIncrement()14 static void TestAtomicIncrement() {
15 // For now, we just test single threaded execution
16
17 // use a guard value to make sure the NoBarrier_AtomicIncrement doesn't go
18 // outside the expected address bounds. This is in particular to
19 // test that some future change to the asm code doesn't cause the
20 // 32-bit NoBarrier_AtomicIncrement doesn't do the wrong thing on 64-bit
21 // machines.
22 struct {
23 AtomicType prev_word;
24 AtomicType count;
25 AtomicType next_word;
26 } s;
27
28 AtomicType prev_word_value, next_word_value;
29 memset(&prev_word_value, 0xFF, sizeof(AtomicType));
30 memset(&next_word_value, 0xEE, sizeof(AtomicType));
31
32 s.prev_word = prev_word_value;
33 s.count = 0;
34 s.next_word = next_word_value;
35
36 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 1), 1);
37 EXPECT_EQ(s.count, 1);
38 EXPECT_EQ(s.prev_word, prev_word_value);
39 EXPECT_EQ(s.next_word, next_word_value);
40
41 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 2), 3);
42 EXPECT_EQ(s.count, 3);
43 EXPECT_EQ(s.prev_word, prev_word_value);
44 EXPECT_EQ(s.next_word, next_word_value);
45
46 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 3), 6);
47 EXPECT_EQ(s.count, 6);
48 EXPECT_EQ(s.prev_word, prev_word_value);
49 EXPECT_EQ(s.next_word, next_word_value);
50
51 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -3), 3);
52 EXPECT_EQ(s.count, 3);
53 EXPECT_EQ(s.prev_word, prev_word_value);
54 EXPECT_EQ(s.next_word, next_word_value);
55
56 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -2), 1);
57 EXPECT_EQ(s.count, 1);
58 EXPECT_EQ(s.prev_word, prev_word_value);
59 EXPECT_EQ(s.next_word, next_word_value);
60
61 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -1), 0);
62 EXPECT_EQ(s.count, 0);
63 EXPECT_EQ(s.prev_word, prev_word_value);
64 EXPECT_EQ(s.next_word, next_word_value);
65
66 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -1), -1);
67 EXPECT_EQ(s.count, -1);
68 EXPECT_EQ(s.prev_word, prev_word_value);
69 EXPECT_EQ(s.next_word, next_word_value);
70
71 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -4), -5);
72 EXPECT_EQ(s.count, -5);
73 EXPECT_EQ(s.prev_word, prev_word_value);
74 EXPECT_EQ(s.next_word, next_word_value);
75
76 EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 5), 0);
77 EXPECT_EQ(s.count, 0);
78 EXPECT_EQ(s.prev_word, prev_word_value);
79 EXPECT_EQ(s.next_word, next_word_value);
80 }
81
82
83 #define NUM_BITS(T) (sizeof(T) * 8)
84
85
86 template <class AtomicType>
TestCompareAndSwap()87 static void TestCompareAndSwap() {
88 AtomicType value = 0;
89 AtomicType prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 1);
90 EXPECT_EQ(1, value);
91 EXPECT_EQ(0, prev);
92
93 // Verify that CAS will *not* change "value" if it doesn't match the
94 // expected number. CAS will always return the actual value of the
95 // variable from before any change.
96 AtomicType fail = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 2);
97 EXPECT_EQ(1, value);
98 EXPECT_EQ(1, fail);
99
100 // Use test value that has non-zero bits in both halves, more for testing
101 // 64-bit implementation on 32-bit platforms.
102 const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
103 (NUM_BITS(AtomicType) - 2)) + 11;
104 value = k_test_val;
105 prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 5);
106 EXPECT_EQ(k_test_val, value);
107 EXPECT_EQ(k_test_val, prev);
108
109 value = k_test_val;
110 prev = base::subtle::NoBarrier_CompareAndSwap(&value, k_test_val, 5);
111 EXPECT_EQ(5, value);
112 EXPECT_EQ(k_test_val, prev);
113 }
114
115
116 template <class AtomicType>
TestAtomicExchange()117 static void TestAtomicExchange() {
118 AtomicType value = 0;
119 AtomicType new_value = base::subtle::NoBarrier_AtomicExchange(&value, 1);
120 EXPECT_EQ(1, value);
121 EXPECT_EQ(0, new_value);
122
123 // Use test value that has non-zero bits in both halves, more for testing
124 // 64-bit implementation on 32-bit platforms.
125 const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
126 (NUM_BITS(AtomicType) - 2)) + 11;
127 value = k_test_val;
128 new_value = base::subtle::NoBarrier_AtomicExchange(&value, k_test_val);
129 EXPECT_EQ(k_test_val, value);
130 EXPECT_EQ(k_test_val, new_value);
131
132 value = k_test_val;
133 new_value = base::subtle::NoBarrier_AtomicExchange(&value, 5);
134 EXPECT_EQ(5, value);
135 EXPECT_EQ(k_test_val, new_value);
136 }
137
138
139 template <class AtomicType>
TestAtomicIncrementBounds()140 static void TestAtomicIncrementBounds() {
141 // Test at rollover boundary between int_max and int_min
142 AtomicType test_val = (static_cast<uint64_t>(1) <<
143 (NUM_BITS(AtomicType) - 1));
144 AtomicType value = -1 ^ test_val;
145 AtomicType new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1);
146 EXPECT_EQ(test_val, value);
147 EXPECT_EQ(value, new_value);
148
149 base::subtle::NoBarrier_AtomicIncrement(&value, -1);
150 EXPECT_EQ(-1 ^ test_val, value);
151
152 // Test at 32-bit boundary for 64-bit atomic type.
153 test_val = static_cast<uint64_t>(1) << (NUM_BITS(AtomicType) / 2);
154 value = test_val - 1;
155 new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1);
156 EXPECT_EQ(test_val, value);
157 EXPECT_EQ(value, new_value);
158
159 base::subtle::NoBarrier_AtomicIncrement(&value, -1);
160 EXPECT_EQ(test_val - 1, value);
161 }
162
163 // Return an AtomicType with the value 0xa5a5a5..
164 template <class AtomicType>
TestFillValue()165 static AtomicType TestFillValue() {
166 AtomicType val = 0;
167 memset(&val, 0xa5, sizeof(AtomicType));
168 return val;
169 }
170
171 // This is a simple sanity check that values are correct. Not testing
172 // atomicity
173 template <class AtomicType>
TestStore()174 static void TestStore() {
175 const AtomicType kVal1 = TestFillValue<AtomicType>();
176 const AtomicType kVal2 = static_cast<AtomicType>(-1);
177
178 AtomicType value;
179
180 if constexpr (std::is_same_v<AtomicType, base::subtle::Atomic32>) {
181 base::subtle::NoBarrier_Store(&value, kVal1);
182 EXPECT_EQ(kVal1, value);
183 base::subtle::NoBarrier_Store(&value, kVal2);
184 EXPECT_EQ(kVal2, value);
185 }
186
187 base::subtle::Release_Store(&value, kVal1);
188 EXPECT_EQ(kVal1, value);
189 base::subtle::Release_Store(&value, kVal2);
190 EXPECT_EQ(kVal2, value);
191 }
192
193 // This is a simple sanity check that values are correct. Not testing
194 // atomicity
195 template <class AtomicType>
TestLoad()196 static void TestLoad() {
197 const AtomicType kVal1 = TestFillValue<AtomicType>();
198 const AtomicType kVal2 = static_cast<AtomicType>(-1);
199
200 AtomicType value;
201
202 value = kVal1;
203 EXPECT_EQ(kVal1, base::subtle::NoBarrier_Load(&value));
204 value = kVal2;
205 EXPECT_EQ(kVal2, base::subtle::NoBarrier_Load(&value));
206
207 value = kVal1;
208 EXPECT_EQ(kVal1, base::subtle::Acquire_Load(&value));
209 value = kVal2;
210 EXPECT_EQ(kVal2, base::subtle::Acquire_Load(&value));
211 }
212
TEST(AtomicOpsTest,Inc)213 TEST(AtomicOpsTest, Inc) {
214 TestAtomicIncrement<base::subtle::Atomic32>();
215 TestAtomicIncrement<base::subtle::AtomicWord>();
216 }
217
TEST(AtomicOpsTest,CompareAndSwap)218 TEST(AtomicOpsTest, CompareAndSwap) {
219 TestCompareAndSwap<base::subtle::Atomic32>();
220 TestCompareAndSwap<base::subtle::AtomicWord>();
221 }
222
TEST(AtomicOpsTest,Exchange)223 TEST(AtomicOpsTest, Exchange) {
224 TestAtomicExchange<base::subtle::Atomic32>();
225 TestAtomicExchange<base::subtle::AtomicWord>();
226 }
227
TEST(AtomicOpsTest,IncrementBounds)228 TEST(AtomicOpsTest, IncrementBounds) {
229 TestAtomicIncrementBounds<base::subtle::Atomic32>();
230 TestAtomicIncrementBounds<base::subtle::AtomicWord>();
231 }
232
TEST(AtomicOpsTest,Store)233 TEST(AtomicOpsTest, Store) {
234 TestStore<base::subtle::Atomic32>();
235 TestStore<base::subtle::AtomicWord>();
236 }
237
TEST(AtomicOpsTest,Load)238 TEST(AtomicOpsTest, Load) {
239 TestLoad<base::subtle::Atomic32>();
240 TestLoad<base::subtle::AtomicWord>();
241 }
242