atomicops_unittest.cc 7.39 KB
Newer Older
gejun's avatar
gejun committed
1 2 3 4
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5
#include "butil/atomicops.h"
gejun's avatar
gejun committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include <stdint.h>
#include <string.h>

#include <gtest/gtest.h>

template <class AtomicType>
static void TestAtomicIncrement() {
  // For now, we just test single threaded execution

  // use a guard value to make sure the NoBarrier_AtomicIncrement doesn't go
  // outside the expected address bounds.  This is in particular to
  // test that some future change to the asm code doesn't cause the
  // 32-bit NoBarrier_AtomicIncrement doesn't do the wrong thing on 64-bit
  // machines.
  struct {
    AtomicType prev_word;
    AtomicType count;
    AtomicType next_word;
  } s;

  AtomicType prev_word_value, next_word_value;
  memset(&prev_word_value, 0xFF, sizeof(AtomicType));
  memset(&next_word_value, 0xEE, sizeof(AtomicType));

  s.prev_word = prev_word_value;
  s.count = 0;
  s.next_word = next_word_value;

35
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, 1), 1);
gejun's avatar
gejun committed
36 37 38 39
  EXPECT_EQ(s.count, 1);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

40
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, 2), 3);
gejun's avatar
gejun committed
41 42 43 44
  EXPECT_EQ(s.count, 3);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

45
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, 3), 6);
gejun's avatar
gejun committed
46 47 48 49
  EXPECT_EQ(s.count, 6);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

50
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, -3), 3);
gejun's avatar
gejun committed
51 52 53 54
  EXPECT_EQ(s.count, 3);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

55
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, -2), 1);
gejun's avatar
gejun committed
56 57 58 59
  EXPECT_EQ(s.count, 1);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

60
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, -1), 0);
gejun's avatar
gejun committed
61 62 63 64
  EXPECT_EQ(s.count, 0);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

65
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, -1), -1);
gejun's avatar
gejun committed
66 67 68 69
  EXPECT_EQ(s.count, -1);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

70
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, -4), -5);
gejun's avatar
gejun committed
71 72 73 74
  EXPECT_EQ(s.count, -5);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);

75
  EXPECT_EQ(butil::subtle::NoBarrier_AtomicIncrement(&s.count, 5), 0);
gejun's avatar
gejun committed
76 77 78 79 80 81 82 83 84 85 86 87
  EXPECT_EQ(s.count, 0);
  EXPECT_EQ(s.prev_word, prev_word_value);
  EXPECT_EQ(s.next_word, next_word_value);
}


#define NUM_BITS(T) (sizeof(T) * 8)


template <class AtomicType>
static void TestCompareAndSwap() {
  AtomicType value = 0;
88
  AtomicType prev = butil::subtle::NoBarrier_CompareAndSwap(&value, 0, 1);
gejun's avatar
gejun committed
89 90 91 92 93 94 95 96
  EXPECT_EQ(1, value);
  EXPECT_EQ(0, prev);

  // Use test value that has non-zero bits in both halves, more for testing
  // 64-bit implementation on 32-bit platforms.
  const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
                                 (NUM_BITS(AtomicType) - 2)) + 11;
  value = k_test_val;
97
  prev = butil::subtle::NoBarrier_CompareAndSwap(&value, 0, 5);
gejun's avatar
gejun committed
98 99 100 101
  EXPECT_EQ(k_test_val, value);
  EXPECT_EQ(k_test_val, prev);

  value = k_test_val;
102
  prev = butil::subtle::NoBarrier_CompareAndSwap(&value, k_test_val, 5);
gejun's avatar
gejun committed
103 104 105 106 107 108 109 110
  EXPECT_EQ(5, value);
  EXPECT_EQ(k_test_val, prev);
}


template <class AtomicType>
static void TestAtomicExchange() {
  AtomicType value = 0;
111
  AtomicType new_value = butil::subtle::NoBarrier_AtomicExchange(&value, 1);
gejun's avatar
gejun committed
112 113 114 115 116 117 118 119
  EXPECT_EQ(1, value);
  EXPECT_EQ(0, new_value);

  // Use test value that has non-zero bits in both halves, more for testing
  // 64-bit implementation on 32-bit platforms.
  const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
                                 (NUM_BITS(AtomicType) - 2)) + 11;
  value = k_test_val;
120
  new_value = butil::subtle::NoBarrier_AtomicExchange(&value, k_test_val);
gejun's avatar
gejun committed
121 122 123 124
  EXPECT_EQ(k_test_val, value);
  EXPECT_EQ(k_test_val, new_value);

  value = k_test_val;
125
  new_value = butil::subtle::NoBarrier_AtomicExchange(&value, 5);
gejun's avatar
gejun committed
126 127 128 129 130 131 132 133 134 135 136
  EXPECT_EQ(5, value);
  EXPECT_EQ(k_test_val, new_value);
}


template <class AtomicType>
static void TestAtomicIncrementBounds() {
  // Test at rollover boundary between int_max and int_min
  AtomicType test_val = (static_cast<uint64_t>(1) <<
                         (NUM_BITS(AtomicType) - 1));
  AtomicType value = -1 ^ test_val;
137
  AtomicType new_value = butil::subtle::NoBarrier_AtomicIncrement(&value, 1);
gejun's avatar
gejun committed
138 139 140
  EXPECT_EQ(test_val, value);
  EXPECT_EQ(value, new_value);

141
  butil::subtle::NoBarrier_AtomicIncrement(&value, -1);
gejun's avatar
gejun committed
142 143 144 145 146
  EXPECT_EQ(-1 ^ test_val, value);

  // Test at 32-bit boundary for 64-bit atomic type.
  test_val = static_cast<uint64_t>(1) << (NUM_BITS(AtomicType) / 2);
  value = test_val - 1;
147
  new_value = butil::subtle::NoBarrier_AtomicIncrement(&value, 1);
gejun's avatar
gejun committed
148 149 150
  EXPECT_EQ(test_val, value);
  EXPECT_EQ(value, new_value);

151
  butil::subtle::NoBarrier_AtomicIncrement(&value, -1);
gejun's avatar
gejun committed
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
  EXPECT_EQ(test_val - 1, value);
}

// Return an AtomicType with the value 0xa5a5a5..
template <class AtomicType>
static AtomicType TestFillValue() {
  AtomicType val = 0;
  memset(&val, 0xa5, sizeof(AtomicType));
  return val;
}

// This is a simple sanity check that values are correct. Not testing
// atomicity
template <class AtomicType>
static void TestStore() {
  const AtomicType kVal1 = TestFillValue<AtomicType>();
  const AtomicType kVal2 = static_cast<AtomicType>(-1);

  AtomicType value;

172
  butil::subtle::NoBarrier_Store(&value, kVal1);
gejun's avatar
gejun committed
173
  EXPECT_EQ(kVal1, value);
174
  butil::subtle::NoBarrier_Store(&value, kVal2);
gejun's avatar
gejun committed
175 176
  EXPECT_EQ(kVal2, value);

177
  butil::subtle::Acquire_Store(&value, kVal1);
gejun's avatar
gejun committed
178
  EXPECT_EQ(kVal1, value);
179
  butil::subtle::Acquire_Store(&value, kVal2);
gejun's avatar
gejun committed
180 181
  EXPECT_EQ(kVal2, value);

182
  butil::subtle::Release_Store(&value, kVal1);
gejun's avatar
gejun committed
183
  EXPECT_EQ(kVal1, value);
184
  butil::subtle::Release_Store(&value, kVal2);
gejun's avatar
gejun committed
185 186 187 188 189 190 191 192 193 194 195 196 197
  EXPECT_EQ(kVal2, value);
}

// This is a simple sanity check that values are correct. Not testing
// atomicity
template <class AtomicType>
static void TestLoad() {
  const AtomicType kVal1 = TestFillValue<AtomicType>();
  const AtomicType kVal2 = static_cast<AtomicType>(-1);

  AtomicType value;

  value = kVal1;
198
  EXPECT_EQ(kVal1, butil::subtle::NoBarrier_Load(&value));
gejun's avatar
gejun committed
199
  value = kVal2;
200
  EXPECT_EQ(kVal2, butil::subtle::NoBarrier_Load(&value));
gejun's avatar
gejun committed
201 202

  value = kVal1;
203
  EXPECT_EQ(kVal1, butil::subtle::Acquire_Load(&value));
gejun's avatar
gejun committed
204
  value = kVal2;
205
  EXPECT_EQ(kVal2, butil::subtle::Acquire_Load(&value));
gejun's avatar
gejun committed
206 207

  value = kVal1;
208
  EXPECT_EQ(kVal1, butil::subtle::Release_Load(&value));
gejun's avatar
gejun committed
209
  value = kVal2;
210
  EXPECT_EQ(kVal2, butil::subtle::Release_Load(&value));
gejun's avatar
gejun committed
211 212 213
}

TEST(AtomicOpsTest, Inc) {
214 215
  TestAtomicIncrement<butil::subtle::Atomic32>();
  TestAtomicIncrement<butil::subtle::AtomicWord>();
gejun's avatar
gejun committed
216 217 218
}

TEST(AtomicOpsTest, CompareAndSwap) {
219 220
  TestCompareAndSwap<butil::subtle::Atomic32>();
  TestCompareAndSwap<butil::subtle::AtomicWord>();
gejun's avatar
gejun committed
221 222 223
}

TEST(AtomicOpsTest, Exchange) {
224 225
  TestAtomicExchange<butil::subtle::Atomic32>();
  TestAtomicExchange<butil::subtle::AtomicWord>();
gejun's avatar
gejun committed
226 227 228
}

TEST(AtomicOpsTest, IncrementBounds) {
229 230
  TestAtomicIncrementBounds<butil::subtle::Atomic32>();
  TestAtomicIncrementBounds<butil::subtle::AtomicWord>();
gejun's avatar
gejun committed
231 232 233
}

TEST(AtomicOpsTest, Store) {
234 235
  TestStore<butil::subtle::Atomic32>();
  TestStore<butil::subtle::AtomicWord>();
gejun's avatar
gejun committed
236 237 238
}

TEST(AtomicOpsTest, Load) {
239 240
  TestLoad<butil::subtle::Atomic32>();
  TestLoad<butil::subtle::AtomicWord>();
gejun's avatar
gejun committed
241
}