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 <stdint.h> 8 #include <string.h> 9 10 #include "testing/gtest/include/gtest/gtest.h" 11 12 template <class AtomicType> 13 static 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 85 template <class AtomicType> 86 static 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 // Verify that CAS will *not* change "value" if it doesn't match the 93 // expected number. CAS will always return the actual value of the 94 // variable from before any change. 95 AtomicType fail = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 2); 96 EXPECT_EQ(1, value); 97 EXPECT_EQ(1, fail); 98 99 // Use test value that has non-zero bits in both halves, more for testing 100 // 64-bit implementation on 32-bit platforms. 101 const AtomicType k_test_val = (static_cast<uint64_t>(1) << 102 (NUM_BITS(AtomicType) - 2)) + 11; 103 value = k_test_val; 104 prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 5); 105 EXPECT_EQ(k_test_val, value); 106 EXPECT_EQ(k_test_val, prev); 107 108 value = k_test_val; 109 prev = base::subtle::NoBarrier_CompareAndSwap(&value, k_test_val, 5); 110 EXPECT_EQ(5, value); 111 EXPECT_EQ(k_test_val, prev); 112 } 113 114 115 template <class AtomicType> 116 static void TestAtomicExchange() { 117 AtomicType value = 0; 118 AtomicType new_value = base::subtle::NoBarrier_AtomicExchange(&value, 1); 119 EXPECT_EQ(1, value); 120 EXPECT_EQ(0, new_value); 121 122 // Use test value that has non-zero bits in both halves, more for testing 123 // 64-bit implementation on 32-bit platforms. 124 const AtomicType k_test_val = (static_cast<uint64_t>(1) << 125 (NUM_BITS(AtomicType) - 2)) + 11; 126 value = k_test_val; 127 new_value = base::subtle::NoBarrier_AtomicExchange(&value, k_test_val); 128 EXPECT_EQ(k_test_val, value); 129 EXPECT_EQ(k_test_val, new_value); 130 131 value = k_test_val; 132 new_value = base::subtle::NoBarrier_AtomicExchange(&value, 5); 133 EXPECT_EQ(5, value); 134 EXPECT_EQ(k_test_val, new_value); 135 } 136 137 138 template <class AtomicType> 139 static void TestAtomicIncrementBounds() { 140 // Test at rollover boundary between int_max and int_min 141 AtomicType test_val = (static_cast<uint64_t>(1) << 142 (NUM_BITS(AtomicType) - 1)); 143 AtomicType value = -1 ^ test_val; 144 AtomicType new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1); 145 EXPECT_EQ(test_val, value); 146 EXPECT_EQ(value, new_value); 147 148 base::subtle::NoBarrier_AtomicIncrement(&value, -1); 149 EXPECT_EQ(-1 ^ test_val, value); 150 151 // Test at 32-bit boundary for 64-bit atomic type. 152 test_val = static_cast<uint64_t>(1) << (NUM_BITS(AtomicType) / 2); 153 value = test_val - 1; 154 new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1); 155 EXPECT_EQ(test_val, value); 156 EXPECT_EQ(value, new_value); 157 158 base::subtle::NoBarrier_AtomicIncrement(&value, -1); 159 EXPECT_EQ(test_val - 1, value); 160 } 161 162 // Return an AtomicType with the value 0xa5a5a5.. 163 template <class AtomicType> 164 static AtomicType TestFillValue() { 165 AtomicType val = 0; 166 memset(&val, 0xa5, sizeof(AtomicType)); 167 return val; 168 } 169 170 // This is a simple sanity check that values are correct. Not testing 171 // atomicity 172 template <class AtomicType> 173 static void TestStore() { 174 const AtomicType kVal1 = TestFillValue<AtomicType>(); 175 const AtomicType kVal2 = static_cast<AtomicType>(-1); 176 177 AtomicType value; 178 179 base::subtle::NoBarrier_Store(&value, kVal1); 180 EXPECT_EQ(kVal1, value); 181 base::subtle::NoBarrier_Store(&value, kVal2); 182 EXPECT_EQ(kVal2, value); 183 184 base::subtle::Acquire_Store(&value, kVal1); 185 EXPECT_EQ(kVal1, value); 186 base::subtle::Acquire_Store(&value, kVal2); 187 EXPECT_EQ(kVal2, value); 188 189 base::subtle::Release_Store(&value, kVal1); 190 EXPECT_EQ(kVal1, value); 191 base::subtle::Release_Store(&value, kVal2); 192 EXPECT_EQ(kVal2, value); 193 } 194 195 // This is a simple sanity check that values are correct. Not testing 196 // atomicity 197 template <class AtomicType> 198 static void TestLoad() { 199 const AtomicType kVal1 = TestFillValue<AtomicType>(); 200 const AtomicType kVal2 = static_cast<AtomicType>(-1); 201 202 AtomicType value; 203 204 value = kVal1; 205 EXPECT_EQ(kVal1, base::subtle::NoBarrier_Load(&value)); 206 value = kVal2; 207 EXPECT_EQ(kVal2, base::subtle::NoBarrier_Load(&value)); 208 209 value = kVal1; 210 EXPECT_EQ(kVal1, base::subtle::Acquire_Load(&value)); 211 value = kVal2; 212 EXPECT_EQ(kVal2, base::subtle::Acquire_Load(&value)); 213 214 value = kVal1; 215 EXPECT_EQ(kVal1, base::subtle::Release_Load(&value)); 216 value = kVal2; 217 EXPECT_EQ(kVal2, base::subtle::Release_Load(&value)); 218 } 219 220 TEST(AtomicOpsTest, Inc) { 221 TestAtomicIncrement<base::subtle::Atomic32>(); 222 TestAtomicIncrement<base::subtle::AtomicWord>(); 223 } 224 225 TEST(AtomicOpsTest, CompareAndSwap) { 226 TestCompareAndSwap<base::subtle::Atomic32>(); 227 TestCompareAndSwap<base::subtle::AtomicWord>(); 228 } 229 230 TEST(AtomicOpsTest, Exchange) { 231 TestAtomicExchange<base::subtle::Atomic32>(); 232 TestAtomicExchange<base::subtle::AtomicWord>(); 233 } 234 235 TEST(AtomicOpsTest, IncrementBounds) { 236 TestAtomicIncrementBounds<base::subtle::Atomic32>(); 237 TestAtomicIncrementBounds<base::subtle::AtomicWord>(); 238 } 239 240 TEST(AtomicOpsTest, Store) { 241 TestStore<base::subtle::Atomic32>(); 242 TestStore<base::subtle::AtomicWord>(); 243 } 244 245 TEST(AtomicOpsTest, Load) { 246 TestLoad<base::subtle::Atomic32>(); 247 TestLoad<base::subtle::AtomicWord>(); 248 } 249
