1 /* Copyright (c) 2006, Google Inc. 2 * All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 * 30 * --- 31 * Author: Sanjay Ghemawat 32 */ 33 34 #include <stdio.h> 35 #include "base/logging.h" 36 #include "base/atomicops.h" 37 38 #define GG_ULONGLONG(x) static_cast<uint64>(x) 39 40 template <class AtomicType> 41 static void TestAtomicIncrement() { 42 // For now, we just test single threaded execution 43 44 // use a guard value to make sure the NoBarrier_AtomicIncrement doesn't go 45 // outside the expected address bounds. This is in particular to 46 // test that some future change to the asm code doesn't cause the 47 // 32-bit NoBarrier_AtomicIncrement doesn't do the wrong thing on 64-bit 48 // machines. 49 struct { 50 AtomicType prev_word; 51 AtomicType count; 52 AtomicType next_word; 53 } s; 54 55 AtomicType prev_word_value, next_word_value; 56 memset(&prev_word_value, 0xFF, sizeof(AtomicType)); 57 memset(&next_word_value, 0xEE, sizeof(AtomicType)); 58 59 s.prev_word = prev_word_value; 60 s.count = 0; 61 s.next_word = next_word_value; 62 63 ASSERT_EQ(1, base::subtle::NoBarrier_AtomicIncrement(&s.count, 1)); 64 ASSERT_EQ(1, s.count); 65 ASSERT_EQ(prev_word_value, s.prev_word); 66 ASSERT_EQ(next_word_value, s.next_word); 67 68 ASSERT_EQ(3, base::subtle::NoBarrier_AtomicIncrement(&s.count, 2)); 69 ASSERT_EQ(3, s.count); 70 ASSERT_EQ(prev_word_value, s.prev_word); 71 ASSERT_EQ(next_word_value, s.next_word); 72 73 ASSERT_EQ(6, base::subtle::NoBarrier_AtomicIncrement(&s.count, 3)); 74 ASSERT_EQ(6, s.count); 75 ASSERT_EQ(prev_word_value, s.prev_word); 76 ASSERT_EQ(next_word_value, s.next_word); 77 78 ASSERT_EQ(3, base::subtle::NoBarrier_AtomicIncrement(&s.count, -3)); 79 ASSERT_EQ(3, s.count); 80 ASSERT_EQ(prev_word_value, s.prev_word); 81 ASSERT_EQ(next_word_value, s.next_word); 82 83 ASSERT_EQ(1, base::subtle::NoBarrier_AtomicIncrement(&s.count, -2)); 84 ASSERT_EQ(1, s.count); 85 ASSERT_EQ(prev_word_value, s.prev_word); 86 ASSERT_EQ(next_word_value, s.next_word); 87 88 ASSERT_EQ(0, base::subtle::NoBarrier_AtomicIncrement(&s.count, -1)); 89 ASSERT_EQ(0, s.count); 90 ASSERT_EQ(prev_word_value, s.prev_word); 91 ASSERT_EQ(next_word_value, s.next_word); 92 93 ASSERT_EQ(-1, base::subtle::NoBarrier_AtomicIncrement(&s.count, -1)); 94 ASSERT_EQ(-1, s.count); 95 ASSERT_EQ(prev_word_value, s.prev_word); 96 ASSERT_EQ(next_word_value, s.next_word); 97 98 ASSERT_EQ(-5, base::subtle::NoBarrier_AtomicIncrement(&s.count, -4)); 99 ASSERT_EQ(-5, s.count); 100 ASSERT_EQ(prev_word_value, s.prev_word); 101 ASSERT_EQ(next_word_value, s.next_word); 102 103 ASSERT_EQ(0, base::subtle::NoBarrier_AtomicIncrement(&s.count, 5)); 104 ASSERT_EQ(0, s.count); 105 ASSERT_EQ(prev_word_value, s.prev_word); 106 ASSERT_EQ(next_word_value, s.next_word); 107 } 108 109 110 #define NUM_BITS(T) (sizeof(T) * 8) 111 112 113 template <class AtomicType> 114 static void TestCompareAndSwap() { 115 AtomicType value = 0; 116 AtomicType prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 1); 117 ASSERT_EQ(1, value); 118 ASSERT_EQ(0, prev); 119 120 // Use test value that has non-zero bits in both halves, more for testing 121 // 64-bit implementation on 32-bit platforms. 122 const AtomicType k_test_val = (GG_ULONGLONG(1) << 123 (NUM_BITS(AtomicType) - 2)) + 11; 124 value = k_test_val; 125 prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 5); 126 ASSERT_EQ(k_test_val, value); 127 ASSERT_EQ(k_test_val, prev); 128 129 value = k_test_val; 130 prev = base::subtle::NoBarrier_CompareAndSwap(&value, k_test_val, 5); 131 ASSERT_EQ(5, value); 132 ASSERT_EQ(k_test_val, prev); 133 } 134 135 136 template <class AtomicType> 137 static void TestAtomicExchange() { 138 AtomicType value = 0; 139 AtomicType new_value = base::subtle::NoBarrier_AtomicExchange(&value, 1); 140 ASSERT_EQ(1, value); 141 ASSERT_EQ(0, new_value); 142 143 // Use test value that has non-zero bits in both halves, more for testing 144 // 64-bit implementation on 32-bit platforms. 145 const AtomicType k_test_val = (GG_ULONGLONG(1) << 146 (NUM_BITS(AtomicType) - 2)) + 11; 147 value = k_test_val; 148 new_value = base::subtle::NoBarrier_AtomicExchange(&value, k_test_val); 149 ASSERT_EQ(k_test_val, value); 150 ASSERT_EQ(k_test_val, new_value); 151 152 value = k_test_val; 153 new_value = base::subtle::NoBarrier_AtomicExchange(&value, 5); 154 ASSERT_EQ(5, value); 155 ASSERT_EQ(k_test_val, new_value); 156 } 157 158 159 template <class AtomicType> 160 static void TestAtomicIncrementBounds() { 161 // Test increment at the half-width boundary of the atomic type. 162 // It is primarily for testing at the 32-bit boundary for 64-bit atomic type. 163 AtomicType test_val = GG_ULONGLONG(1) << (NUM_BITS(AtomicType) / 2); 164 AtomicType value = test_val - 1; 165 AtomicType new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1); 166 ASSERT_EQ(test_val, value); 167 ASSERT_EQ(value, new_value); 168 169 base::subtle::NoBarrier_AtomicIncrement(&value, -1); 170 ASSERT_EQ(test_val - 1, value); 171 } 172 173 // This is a simple sanity check that values are correct. Not testing 174 // atomicity 175 template <class AtomicType> 176 static void TestStore() { 177 const AtomicType kVal1 = static_cast<AtomicType>(0xa5a5a5a5a5a5a5a5LL); 178 const AtomicType kVal2 = static_cast<AtomicType>(-1); 179 180 AtomicType value; 181 182 base::subtle::NoBarrier_Store(&value, kVal1); 183 ASSERT_EQ(kVal1, value); 184 base::subtle::NoBarrier_Store(&value, kVal2); 185 ASSERT_EQ(kVal2, value); 186 187 base::subtle::Acquire_Store(&value, kVal1); 188 ASSERT_EQ(kVal1, value); 189 base::subtle::Acquire_Store(&value, kVal2); 190 ASSERT_EQ(kVal2, value); 191 192 base::subtle::Release_Store(&value, kVal1); 193 ASSERT_EQ(kVal1, value); 194 base::subtle::Release_Store(&value, kVal2); 195 ASSERT_EQ(kVal2, value); 196 } 197 198 // This is a simple sanity check that values are correct. Not testing 199 // atomicity 200 template <class AtomicType> 201 static void TestLoad() { 202 const AtomicType kVal1 = static_cast<AtomicType>(0xa5a5a5a5a5a5a5a5LL); 203 const AtomicType kVal2 = static_cast<AtomicType>(-1); 204 205 AtomicType value; 206 207 value = kVal1; 208 ASSERT_EQ(kVal1, base::subtle::NoBarrier_Load(&value)); 209 value = kVal2; 210 ASSERT_EQ(kVal2, base::subtle::NoBarrier_Load(&value)); 211 212 value = kVal1; 213 ASSERT_EQ(kVal1, base::subtle::Acquire_Load(&value)); 214 value = kVal2; 215 ASSERT_EQ(kVal2, base::subtle::Acquire_Load(&value)); 216 217 value = kVal1; 218 ASSERT_EQ(kVal1, base::subtle::Release_Load(&value)); 219 value = kVal2; 220 ASSERT_EQ(kVal2, base::subtle::Release_Load(&value)); 221 } 222 223 template <class AtomicType> 224 static void TestAtomicOps() { 225 TestCompareAndSwap<AtomicType>(); 226 TestAtomicExchange<AtomicType>(); 227 TestAtomicIncrementBounds<AtomicType>(); 228 TestStore<AtomicType>(); 229 TestLoad<AtomicType>(); 230 } 231 232 int main(int argc, char** argv) { 233 TestAtomicIncrement<AtomicWord>(); 234 TestAtomicIncrement<Atomic32>(); 235 236 TestAtomicOps<AtomicWord>(); 237 TestAtomicOps<Atomic32>(); 238 239 // I've commented the Atomic64 tests out for now, because Atomic64 240 // doesn't work on x86 systems that are not compiled to support mmx 241 // registers. Since I want this project to be as portable as 242 // possible -- that is, not to assume we've compiled for mmx or even 243 // that the processor supports it -- and we don't actually use 244 // Atomic64 anywhere, I've commented it out of the test for now. 245 // (Luckily, if we ever do use Atomic64 by accident, we'll get told 246 // via a compiler error rather than some obscure runtime failure, so 247 // this course of action is safe.) 248 // If we ever *do* want to enable this, try adding -msse (or -mmmx?) 249 // to the CXXFLAGS in Makefile.am. 250 #if 0 and defined(BASE_HAS_ATOMIC64) 251 TestAtomicIncrement<base::subtle::Atomic64>(); 252 TestAtomicOps<base::subtle::Atomic64>(); 253 #endif 254 255 printf("PASS\n"); 256 return 0; 257 } 258
