tests/stdatomic_test.cpp

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18 // Fool stdatomic.h into not using <atomic>.
  19 #undef _USING_LIBCXX
  20 #include <stdatomic.h>
  21 #include <pthread.h>
  22 #include <stdint.h>
  23
  24 TEST(stdatomic, LOCK_FREE) {
  25   ASSERT_TRUE(ATOMIC_BOOL_LOCK_FREE);
  26   ASSERT_TRUE(ATOMIC_CHAR16_T_LOCK_FREE);
  27   ASSERT_TRUE(ATOMIC_CHAR32_T_LOCK_FREE);
  28   ASSERT_TRUE(ATOMIC_CHAR_LOCK_FREE);
  29   ASSERT_TRUE(ATOMIC_INT_LOCK_FREE);
  30   ASSERT_TRUE(ATOMIC_LLONG_LOCK_FREE);
  31   ASSERT_TRUE(ATOMIC_LONG_LOCK_FREE);
  32   ASSERT_TRUE(ATOMIC_POINTER_LOCK_FREE);
  33   ASSERT_TRUE(ATOMIC_SHORT_LOCK_FREE);
  34   ASSERT_TRUE(ATOMIC_WCHAR_T_LOCK_FREE);
  35 }
  36
  37 TEST(stdatomic, init) {
  38   atomic_int v = ATOMIC_VAR_INIT(123);
  39   ASSERT_EQ(123, atomic_load(&v));
  40
  41   atomic_init(&v, 456);
  42   ASSERT_EQ(456, atomic_load(&v));
  43
  44   atomic_flag f = ATOMIC_FLAG_INIT;
  45   ASSERT_FALSE(atomic_flag_test_and_set(&f));
  46 }
  47
  48 TEST(stdatomic, atomic_thread_fence) {
  49   atomic_thread_fence(memory_order_relaxed);
  50   atomic_thread_fence(memory_order_consume);
  51   atomic_thread_fence(memory_order_acquire);
  52   atomic_thread_fence(memory_order_release);
  53   atomic_thread_fence(memory_order_acq_rel);
  54   atomic_thread_fence(memory_order_seq_cst);
  55 }
  56
  57 TEST(stdatomic, atomic_signal_fence) {
  58   atomic_signal_fence(memory_order_relaxed);
  59   atomic_signal_fence(memory_order_consume);
  60   atomic_signal_fence(memory_order_acquire);
  61   atomic_signal_fence(memory_order_release);
  62   atomic_signal_fence(memory_order_acq_rel);
  63   atomic_signal_fence(memory_order_seq_cst);
  64 }
  65
  66 TEST(stdatomic, atomic_is_lock_free) {
  67   atomic_char small;
  68   ASSERT_TRUE(atomic_is_lock_free(&small));
  69 #if defined(__clang__) || __GNUC_PREREQ(4, 7)
  70   // Otherwise stdatomic.h doesn't handle this.
  71   atomic_intmax_t big;
  72   // atomic_intmax_t(size = 64) is not lock free on mips32.
  73 #if defined(__mips__) && !defined(__LP64__)
  74   ASSERT_FALSE(atomic_is_lock_free(&big));
  75 #else
  76   ASSERT_TRUE(atomic_is_lock_free(&big));
  77 #endif
  78 #endif
  79 }
  80
  81 TEST(stdatomic, atomic_flag) {
  82   atomic_flag f = ATOMIC_FLAG_INIT;
  83   ASSERT_FALSE(atomic_flag_test_and_set(&f));
  84   ASSERT_TRUE(atomic_flag_test_and_set(&f));
  85
  86   atomic_flag_clear(&f);
  87
  88   ASSERT_FALSE(atomic_flag_test_and_set_explicit(&f, memory_order_relaxed));
  89   ASSERT_TRUE(atomic_flag_test_and_set_explicit(&f, memory_order_relaxed));
  90
  91   atomic_flag_clear_explicit(&f, memory_order_relaxed);
  92   ASSERT_FALSE(atomic_flag_test_and_set_explicit(&f, memory_order_relaxed));
  93 }
  94
  95 TEST(stdatomic, atomic_store) {
  96   atomic_int i;
  97   atomic_store(&i, 123);
  98   ASSERT_EQ(123, atomic_load(&i));
  99   atomic_store_explicit(&i, 123, memory_order_relaxed);
 100   ASSERT_EQ(123, atomic_load_explicit(&i, memory_order_relaxed));
 101 }
 102
 103 TEST(stdatomic, atomic_exchange) {
 104   atomic_int i;
 105   atomic_store(&i, 123);
 106   ASSERT_EQ(123, atomic_exchange(&i, 456));
 107   ASSERT_EQ(456, atomic_exchange_explicit(&i, 123, memory_order_relaxed));
 108 }
 109
 110 TEST(stdatomic, atomic_compare_exchange) {
 111   atomic_int i;
 112   int expected;
 113
 114   atomic_store(&i, 123);
 115   expected = 123;
 116   ASSERT_TRUE(atomic_compare_exchange_strong(&i, &expected, 456));
 117   ASSERT_FALSE(atomic_compare_exchange_strong(&i, &expected, 456));
 118   ASSERT_EQ(456, expected);
 119
 120   atomic_store(&i, 123);
 121   expected = 123;
 122   ASSERT_TRUE(atomic_compare_exchange_strong_explicit(&i, &expected, 456, memory_order_relaxed, memory_order_relaxed));
 123   ASSERT_FALSE(atomic_compare_exchange_strong_explicit(&i, &expected, 456, memory_order_relaxed, memory_order_relaxed));
 124   ASSERT_EQ(456, expected);
 125
 126   atomic_store(&i, 123);
 127   expected = 123;
 128   ASSERT_TRUE(atomic_compare_exchange_weak(&i, &expected, 456));
 129   ASSERT_FALSE(atomic_compare_exchange_weak(&i, &expected, 456));
 130   ASSERT_EQ(456, expected);
 131
 132   atomic_store(&i, 123);
 133   expected = 123;
 134   ASSERT_TRUE(atomic_compare_exchange_weak_explicit(&i, &expected, 456, memory_order_relaxed, memory_order_relaxed));
 135   ASSERT_FALSE(atomic_compare_exchange_weak_explicit(&i, &expected, 456, memory_order_relaxed, memory_order_relaxed));
 136   ASSERT_EQ(456, expected);
 137 }
 138
 139 TEST(stdatomic, atomic_fetch_add) {
 140   atomic_int i = ATOMIC_VAR_INIT(123);
 141   ASSERT_EQ(123, atomic_fetch_add(&i, 1));
 142   ASSERT_EQ(124, atomic_fetch_add_explicit(&i, 1, memory_order_relaxed));
 143   ASSERT_EQ(125, atomic_load(&i));
 144 }
 145
 146 TEST(stdatomic, atomic_fetch_sub) {
 147   atomic_int i = ATOMIC_VAR_INIT(123);
 148   ASSERT_EQ(123, atomic_fetch_sub(&i, 1));
 149   ASSERT_EQ(122, atomic_fetch_sub_explicit(&i, 1, memory_order_relaxed));
 150   ASSERT_EQ(121, atomic_load(&i));
 151 }
 152
 153 TEST(stdatomic, atomic_fetch_or) {
 154   atomic_int i = ATOMIC_VAR_INIT(0x100);
 155   ASSERT_EQ(0x100, atomic_fetch_or(&i, 0x020));
 156   ASSERT_EQ(0x120, atomic_fetch_or_explicit(&i, 0x003, memory_order_relaxed));
 157   ASSERT_EQ(0x123, atomic_load(&i));
 158 }
 159
 160 TEST(stdatomic, atomic_fetch_xor) {
 161   atomic_int i = ATOMIC_VAR_INIT(0x100);
 162   ASSERT_EQ(0x100, atomic_fetch_xor(&i, 0x120));
 163   ASSERT_EQ(0x020, atomic_fetch_xor_explicit(&i, 0x103, memory_order_relaxed));
 164   ASSERT_EQ(0x123, atomic_load(&i));
 165 }
 166
 167 TEST(stdatomic, atomic_fetch_and) {
 168   atomic_int i = ATOMIC_VAR_INIT(0x123);
 169   ASSERT_EQ(0x123, atomic_fetch_and(&i, 0x00f));
 170   ASSERT_EQ(0x003, atomic_fetch_and_explicit(&i, 0x2, memory_order_relaxed));
 171   ASSERT_EQ(0x002, atomic_load(&i));
 172 }
 173
 174 // And a rudimentary test of acquire-release memory ordering:
 175
 176 constexpr static uint_least32_t BIG = 10000000ul; // Assumed even below.
 177
 178 struct three_atomics {
 179   atomic_uint_least32_t x;
 180   char a[123];  // Everything in different cache lines,
 181                 // increase chance of compiler getting alignment wrong.
 182   atomic_uint_least32_t y;
 183   char b[4013];
 184   atomic_uint_least32_t z;
 185 };
 186
 187 // Very simple acquire/release memory ordering sanity check.
 188 static void* writer(void* arg) {
 189   three_atomics* a = reinterpret_cast<three_atomics*>(arg);
 190   for (uint_least32_t i = 0; i <= BIG; i+=2) {
 191     atomic_store_explicit(&a->x, i, memory_order_relaxed);
 192     atomic_store_explicit(&a->z, i, memory_order_relaxed);
 193     atomic_store_explicit(&a->y, i, memory_order_release);
 194     atomic_store_explicit(&a->x, i+1, memory_order_relaxed);
 195     atomic_store_explicit(&a->z, i+1, memory_order_relaxed);
 196     atomic_store_explicit(&a->y, i+1, memory_order_release);
 197   }
 198   return 0;
 199 }
 200
 201 static void* reader(void* arg) {
 202   three_atomics* a = reinterpret_cast<three_atomics*>(arg);
 203   uint_least32_t xval = 0, yval = 0, zval = 0;
 204   size_t repeat = 0;
 205   size_t repeat_limit = 1000;
 206   while (yval != BIG + 1) {
 207     yval = atomic_load_explicit(&a->y, memory_order_acquire);
 208     zval = atomic_load_explicit(&a->z, memory_order_relaxed);
 209     xval = atomic_load_explicit(&a->x, memory_order_relaxed);
 210     // If we see a given value of y, the immediately preceding
 211     // stores to z and x, or later ones, should also be visible.
 212     if (zval < yval) {
 213       // Cant just ASSERT, since we are in a non-void function.
 214       ADD_FAILURE() << "acquire-release ordering violation: "
 215                     << zval << " < " << yval << ", " << xval << "\n";
 216       return 0; // Only report once.
 217     }
 218     if (xval < yval) {
 219       // Cant just ASSERT, since we are in a non-void function.
 220       ADD_FAILURE() << "acquire-release ordering violation: "
 221                     << xval << " < " << yval << ", " << zval <<  "\n";
 222       return 0; // Only report once.
 223     }
 224     if (repeat < repeat_limit) ++repeat;
 225   }
 226   // The following assertion is not technically guaranteed to hold.
 227   // But if it fails to hold, this test was useless, and we have a
 228   // serious scheduling issue that we should probably know about.
 229   EXPECT_EQ(repeat, repeat_limit);
 230   return 0;
 231 }
 232
 233 TEST(stdatomic, ordering) {
 234   // Run a memory ordering sanity test.
 235   void* result;
 236   three_atomics a;
 237   atomic_init(&a.x, 0ul);
 238   atomic_init(&a.y, 0ul);
 239   atomic_init(&a.z, 0ul);
 240   pthread_t t1,t2;
 241   ASSERT_EQ(0, pthread_create(&t1, 0, reader, &a));
 242   ASSERT_EQ(0, pthread_create(&t2, 0, writer, &a));
 243   ASSERT_EQ(0, pthread_join(t1, &result));
 244   EXPECT_EQ(0, result);
 245   ASSERT_EQ(0, pthread_join(t2, &result));
 246   EXPECT_EQ(0, result);
 247   EXPECT_EQ(atomic_load_explicit(&a.x, memory_order_consume), BIG + 1);
 248   EXPECT_EQ(atomic_load_explicit(&a.y, memory_order_seq_cst), BIG + 1);
 249   EXPECT_EQ(atomic_load(&a.z), BIG + 1);
 250 }