atomicops_unittest.cc 7.4 KB

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