Make atomic test use Atomic<T>

Make the atomic functional test use `Atomic<T>` rather than the
standalone functions - this then tests both layers simultaneously.

Author: kjbracey

TESTS/mbed_platform/atomic/main.cpp

@@ -26,67 +26,69 @@
 
 using utest::v1::Case;
 
-
 namespace {
 
 /* Lock-free operations will be much faster - keep runtime down */
-#if MBED_ATOMIC_INT_LOCK_FREE
-#define ADD_ITERATIONS (SystemCoreClock / 1000)
-#else
-#define ADD_ITERATIONS (SystemCoreClock / 8000)
-#endif
+#define ADD_UNLOCKED_ITERATIONS (SystemCoreClock / 1000)
+#define ADD_LOCKED_ITERATIONS   (SystemCoreClock / 8000)
 
 template <typename T>
-void add_incrementer(T *ptr)
+static inline long add_iterations(const Atomic<T> &a)
 {
-    for (long i = ADD_ITERATIONS; i > 0; i--) {
-        core_util_atomic_fetch_add(ptr, T(1));
+    return a.is_lock_free() ? ADD_UNLOCKED_ITERATIONS : ADD_LOCKED_ITERATIONS;
+}
+
+template <typename T>
+void add_incrementer(Atomic<T> *ptr)
+{
+    for (long i = add_iterations(*ptr); i > 0; i--) {
+        ++(*ptr);
     }
 }
 
 template <typename T>
-void add_release_incrementer(T *ptr)
+void add_release_incrementer(Atomic<T> *ptr)
 {
-    for (long i = ADD_ITERATIONS; i > 0; i--) {
-        core_util_atomic_fetch_add_explicit(ptr, T(1), mbed_memory_order_release);
+    for (long i = add_iterations(*ptr); i > 0; i--) {
+        ptr->fetch_add(1, mbed::memory_order_release);
     }
 }
 
 template <typename T>
-void sub_incrementer(T *ptr)
+void sub_incrementer(Atomic<T> *ptr)
 {
-    for (long i = ADD_ITERATIONS; i > 0; i--) {
-        core_util_atomic_fetch_sub(ptr, T(-1));
+    for (long i = add_iterations(*ptr); i > 0; i--) {
+        ptr->fetch_sub(-1);
     }
 }
 
 template <typename T>
-void bitops_incrementer(T *ptr)
+void bitops_incrementer(Atomic<T> *ptr)
 {
-    for (long i = ADD_ITERATIONS; i > 0; i--) {
-        core_util_atomic_fetch_add(ptr, T(1));
-        core_util_atomic_fetch_and(ptr, T(-1));
-        core_util_atomic_fetch_or(ptr, T(0));
+    for (long i = add_iterations(*ptr); i > 0; i--) {
+        (*ptr) += 1;
+        (*ptr) &= -1;
+        (*ptr) |= 0;
     }
 }
 
 template <typename T>
-void weak_incrementer(T *ptr)
+void weak_incrementer(Atomic<T> *ptr)
 {
-    for (long i = ADD_ITERATIONS; i > 0; i--) {
-        T val = core_util_atomic_load(ptr);
+    for (long i = add_iterations(*ptr); i > 0; i--) {
+        T val = ptr->load();
         do {
-        } while (!core_util_atomic_compare_exchange_weak(ptr, &val, T(val + 1)));
+        } while (!ptr->compare_exchange_weak(val, val + 1));
     }
 }
 
 template <typename T>
-void strong_incrementer(T *ptr)
+void strong_incrementer(Atomic<T> *ptr)
 {
-    for (long i = ADD_ITERATIONS; i > 0; i--) {
-        T val = core_util_atomic_load(ptr);
+    for (long i = add_iterations(*ptr); i > 0; i--) {
+        T val = *ptr;
         do {
-        } while (!core_util_atomic_compare_exchange_strong(ptr, &val, T(val + 1)));
+        } while (!ptr->compare_exchange_strong(val, val + 1));
     }
 }
 
@@ -100,19 +102,23 @@ void strong_incrementer(T *ptr)
  * Using core_util_atomic_ templates, and exercising
  * load and store briefly.
  */
-template<typename T, void (*Fn)(T *)>
+template<typename T, void (*Fn)(Atomic<T> *)>
 void test_atomic_add()
 {
     struct  {
         volatile T nonatomic1;
-        T atomic1;
-        T atomic2;
+        Atomic<T> atomic1;
+        Atomic<T> atomic2;
         volatile T nonatomic2;
     } data;
 
+    TEST_ASSERT_EQUAL(sizeof(T), sizeof data.nonatomic1);
+    TEST_ASSERT_EQUAL(sizeof(T), sizeof data.atomic1);
+    TEST_ASSERT_EQUAL(4 * sizeof(T), sizeof data);
+
     data.nonatomic1 = 0;
-    core_util_atomic_store(&data.atomic1, T(0));
-    core_util_atomic_store(&data.atomic2, T(0));
+    data.atomic1 = 0;
+    data.atomic2 = 0;
     data.nonatomic2 = 0;
 
     Thread t1(osPriorityNormal, THREAD_STACK);
@@ -125,7 +131,7 @@ void test_atomic_add()
     TEST_ASSERT_EQUAL(osOK, t3.start(callback(Fn, &data.atomic2)));
     TEST_ASSERT_EQUAL(osOK, t4.start(callback(Fn, &data.atomic2)));
 
-    for (long i = ADD_ITERATIONS; i > 0; i--) {
+    for (long i = ADD_UNLOCKED_ITERATIONS; i > 0; i--) {
         data.nonatomic1++;
         data.nonatomic2++;
     }
@@ -135,10 +141,10 @@ void test_atomic_add()
     t3.join();
     t4.join();
 
-    TEST_ASSERT_EQUAL(T(ADD_ITERATIONS), data.nonatomic1);
-    TEST_ASSERT_EQUAL(T(2 * ADD_ITERATIONS), core_util_atomic_load(&data.atomic1));
-    TEST_ASSERT_EQUAL(T(2 * ADD_ITERATIONS), core_util_atomic_load(&data.atomic2));
-    TEST_ASSERT_EQUAL(T(ADD_ITERATIONS), data.nonatomic2);
+    TEST_ASSERT_EQUAL(T(ADD_UNLOCKED_ITERATIONS), data.nonatomic1);
+    TEST_ASSERT_EQUAL(T(2 * add_iterations(data.atomic1)), data.atomic1);
+    TEST_ASSERT_EQUAL(T(2 * add_iterations(data.atomic2)), data.atomic2);
+    TEST_ASSERT_EQUAL(T(ADD_UNLOCKED_ITERATIONS), data.nonatomic2);
 }
 
 } // namespace