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