Rename "NoBarrier" memory operations to "Relaxed".

test/cctest/test-atomicops.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 26 matching lines @@
 #define CHECK_EQU(v1, v2) \
   CHECK_EQ(static_cast<int64_t>(v1), static_cast<int64_t>(v2))
 
 #define NUM_BITS(T) (sizeof(T) * 8)
 
 
 template <class AtomicType>
 static void TestAtomicIncrement() {
   // For now, we just test the single-threaded execution.
 
-  // Use a guard value to make sure that NoBarrier_AtomicIncrement doesn't
+  // Use a guard value to make sure that Relaxed_AtomicIncrement doesn't
   // go outside the expected address bounds.  This is to test that the
-  // 32-bit NoBarrier_AtomicIncrement doesn't do the wrong thing on 64-bit
+  // 32-bit Relaxed_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;
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, 1), 1);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, 1), 1);
   CHECK_EQU(s.count, 1);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, 2), 3);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, 2), 3);
   CHECK_EQU(s.count, 3);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, 3), 6);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, 3), 6);
   CHECK_EQU(s.count, 6);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, -3), 3);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, -3), 3);
   CHECK_EQU(s.count, 3);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, -2), 1);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, -2), 1);
   CHECK_EQU(s.count, 1);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, -1), 0);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, -1), 0);
   CHECK_EQU(s.count, 0);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, -1), -1);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, -1), -1);
   CHECK_EQU(s.count, -1);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, -4), -5);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, -4), -5);
   CHECK_EQU(s.count, -5);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 
-  CHECK_EQU(NoBarrier_AtomicIncrement(&s.count, 5), 0);
+  CHECK_EQU(Relaxed_AtomicIncrement(&s.count, 5), 0);
   CHECK_EQU(s.count, 0);
   CHECK_EQU(s.prev_word, prev_word_value);
   CHECK_EQU(s.next_word, next_word_value);
 }
 
 
 template <class AtomicType>
 static void TestCompareAndSwap() {
   AtomicType value = 0;
-  AtomicType prev = NoBarrier_CompareAndSwap(&value, 0, 1);
+  AtomicType prev = Relaxed_CompareAndSwap(&value, 0, 1);
   CHECK_EQU(1, value);
   CHECK_EQU(0, prev);
 
   // Use a test value that has non-zero bits in both halves, for testing
   // the 64-bit implementation on 32-bit platforms.
   const AtomicType k_test_val =
       (static_cast<AtomicType>(1) << (NUM_BITS(AtomicType) - 2)) + 11;
   value = k_test_val;
-  prev = NoBarrier_CompareAndSwap(&value, 0, 5);
+  prev = Relaxed_CompareAndSwap(&value, 0, 5);
   CHECK_EQU(k_test_val, value);
   CHECK_EQU(k_test_val, prev);
 
   value = k_test_val;
-  prev = NoBarrier_CompareAndSwap(&value, k_test_val, 5);
+  prev = Relaxed_CompareAndSwap(&value, k_test_val, 5);
   CHECK_EQU(5, value);
   CHECK_EQU(k_test_val, prev);
 }
 
 
 template <class AtomicType>
 static void TestAtomicExchange() {
   AtomicType value = 0;
-  AtomicType new_value = NoBarrier_AtomicExchange(&value, 1);
+  AtomicType new_value = Relaxed_AtomicExchange(&value, 1);
   CHECK_EQU(1, value);
   CHECK_EQU(0, new_value);
 
   // Use a test value that has non-zero bits in both halves, for testing
   // the 64-bit implementation on 32-bit platforms.
   const AtomicType k_test_val =
       (static_cast<AtomicType>(1) << (NUM_BITS(AtomicType) - 2)) + 11;
   value = k_test_val;
-  new_value = NoBarrier_AtomicExchange(&value, k_test_val);
+  new_value = Relaxed_AtomicExchange(&value, k_test_val);
   CHECK_EQU(k_test_val, value);
   CHECK_EQU(k_test_val, new_value);
 
   value = k_test_val;
-  new_value = NoBarrier_AtomicExchange(&value, 5);
+  new_value = Relaxed_AtomicExchange(&value, 5);
   CHECK_EQU(5, value);
   CHECK_EQU(k_test_val, new_value);
 }
 
 
 template <class AtomicType>
 static void TestAtomicIncrementBounds() {
   // Test at 32-bit boundary for 64-bit atomic type.
   AtomicType test_val = static_cast<AtomicType>(1)
                         << (NUM_BITS(AtomicType) / 2);
   AtomicType value = test_val - 1;
-  AtomicType new_value = NoBarrier_AtomicIncrement(&value, 1);
+  AtomicType new_value = Relaxed_AtomicIncrement(&value, 1);
   CHECK_EQU(test_val, value);
   CHECK_EQU(value, new_value);
 
-  NoBarrier_AtomicIncrement(&value, -1);
+  Relaxed_AtomicIncrement(&value, -1);
   CHECK_EQU(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 to ensure 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;
 
-  NoBarrier_Store(&value, kVal1);
+  Relaxed_Store(&value, kVal1);
   CHECK_EQU(kVal1, value);
-  NoBarrier_Store(&value, kVal2);
+  Relaxed_Store(&value, kVal2);
   CHECK_EQU(kVal2, value);
 
   Release_Store(&value, kVal1);
   CHECK_EQU(kVal1, value);
   Release_Store(&value, kVal2);
   CHECK_EQU(kVal2, value);
 }
 
 
 // Merge this test with TestStore as soon as we have Atomic8 acquire
 // and release stores.
 static void TestStoreAtomic8() {
   const Atomic8 kVal1 = TestFillValue<Atomic8>();
   const Atomic8 kVal2 = static_cast<Atomic8>(-1);
 
   Atomic8 value;
 
-  NoBarrier_Store(&value, kVal1);
+  Relaxed_Store(&value, kVal1);
   CHECK_EQU(kVal1, value);
-  NoBarrier_Store(&value, kVal2);
+  Relaxed_Store(&value, kVal2);
   CHECK_EQU(kVal2, value);
 }
 
 
 // This is a simple sanity check to ensure 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;
-  CHECK_EQU(kVal1, NoBarrier_Load(&value));
+  CHECK_EQU(kVal1, Relaxed_Load(&value));
   value = kVal2;
-  CHECK_EQU(kVal2, NoBarrier_Load(&value));
+  CHECK_EQU(kVal2, Relaxed_Load(&value));
 
   value = kVal1;
   CHECK_EQU(kVal1, Acquire_Load(&value));
   value = kVal2;
   CHECK_EQU(kVal2, Acquire_Load(&value));
 }
 
 
 // Merge this test with TestLoad as soon as we have Atomic8 acquire
 // and release loads.
 static void TestLoadAtomic8() {
   const Atomic8 kVal1 = TestFillValue<Atomic8>();
   const Atomic8 kVal2 = static_cast<Atomic8>(-1);
 
   Atomic8 value;
 
   value = kVal1;
-  CHECK_EQU(kVal1, NoBarrier_Load(&value));
+  CHECK_EQU(kVal1, Relaxed_Load(&value));
   value = kVal2;
-  CHECK_EQU(kVal2, NoBarrier_Load(&value));
+  CHECK_EQU(kVal2, Relaxed_Load(&value));
 }
 
 
 TEST(AtomicIncrement) {
   TestAtomicIncrement<Atomic32>();
   TestAtomicIncrement<AtomicWord>();
 }
 
 
 TEST(CompareAndSwap) {
@@ skipping 19 matching lines @@
   TestStore<Atomic32>();
   TestStore<AtomicWord>();
 }
 
 
 TEST(Load) {
   TestLoadAtomic8();
   TestLoad<Atomic32>();
   TestLoad<AtomicWord>();
 }