Add float128. Remove nonatomic tests, add README.

Author: Logikable

SingleSource/UnitTests/Atomic/README.txt

@@ -0,0 +1,30 @@
+Atomic runtime library tests
+
+========
+
+These tests aim to capture real-world multithreaded use cases of atomic
+builtins. Each test focuses on a single atomic operation. Those using multiple
+operations can be compared with other tests using the same operations to isolate
+bugs to a single atomic operation.
+
+Each test consists of a "looper" body and a test script. The test script
+instantiates 10 threads, each running the looper. The loopers contend the same
+memory address, performing atomic operations on it. Each looper executes
+10^6 times for a total of 10^7 operations. The resultant value in the contended
+pointer is compared against a closed-form solution. It's expected that the two
+values equate.
+
+For example, a looper that increments the shared pointer is expected to end up
+with a value of 10^7. If its final value is not that, the test fails.
+
+Each test is performed on all relevant types.
+
+========
+
+Future test writers should be aware that the set of all tests that appear to
+test atomicity is not the set of all tests that test atomicity. In fact, tests
+that may test atomicity on one processor may not test atomicity on a different
+processor.
+
+As such, test writers are encouraged to write nonatomic variants of their tests,
+and verify that they pass in a variety of scenarios.

SingleSource/UnitTests/Atomic/big_test.cpp

@@ -6,39 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// The following text is present in each test file:
-//
-// These tests aim to capture real-world multithreaded use cases of atomic
-// builtins. Each test focuses on a single atomic operation. Those using
-// multiple operations can be compared with other tests using the same
-// operations to isolate bugs to a single atomic operation.
-//
-// Each test consists of a "looper" body and a test script. The test script
-// instantiates 10 threads, each running the looper. The loopers contend the
-// same memory address, performing atomic operations on it. Each looper executes
-// 10^6 times for a total of 10^7 operations. The resultant value in the
-// contended pointer is compared against a closed-form solution. It's expected
-// that the two values equate.
-//
-// For example, a looper that increments the shared pointer is expected to end
-// up with a value of 10^7. If its final value is not that, the test fails.
-//
-// Each test also tests the corresponding nonatomic operation with a separate
-// shared variable. Ideally, this value differs from the atomic "correct" value,
-// and the test can compare the two. In reality, some simpler operations (e.g.
-// those conducted through the ALU) can still end up with the correct answer,
-// even when performed nonatomically. These tests do not check the nonatomic
-// result, although it is still outputted to aid in debugging.
-//
-// Each test is performed on all relevant types.
-//
-//===----------------------------------------------------------------------===//
-//
 // This file tests atomic operations on big objects with aligned memory
 // addresses.
 //
 // The types tested are: bigs.
-// The ops tested are: xchg, cmpxchg.
+// The ops tested are: cmpxchg.
+// TODO: Test load/store, xchg.
+//
+// Please read the README before contributing.
 //
 //===----------------------------------------------------------------------===//
 
@@ -55,8 +30,7 @@ struct big_t {
 
 // The big struct cmpxchg test is identical to the numeric cmpxchg test, except
 // each element of the underlying array is incremented.
-void looper_big_cmpxchg(big_t *abig, big_t *bbig, int success_model,
-                        int fail_model) {
+void looper_big_cmpxchg(big_t *abig, int success_model, int fail_model) {
   for (int n = 0; n < kIterations; ++n) {
     big_t desired, expected = {};
     do {
@@ -65,8 +39,6 @@ void looper_big_cmpxchg(big_t *abig, big_t *bbig, int success_model,
         desired.v[k]++;
     } while (!__atomic_compare_exchange(abig, &expected, &desired, true,
                                         success_model, fail_model));
-    for (int k = 0; k < kBigSize; ++k)
-      bbig->v[k]++;
   }
 }
 
@@ -75,15 +47,14 @@ void test_big_cmpxchg() {
 
   for (int success_model : atomic_compare_exchange_models) {
     for (int fail_model : atomic_compare_exchange_models) {
-      big_t abig = {}, bbig = {};
+      big_t abig = {};
       for (int n = 0; n < kThreads; ++n)
-        pool.emplace_back(looper_big_cmpxchg, &abig, &bbig,
-                          success_model, fail_model);
+        pool.emplace_back(looper_big_cmpxchg, &abig, success_model, fail_model);
       for (int n = 0; n < kThreads; ++n)
         pool[n].join();
       pool.clear();
       for (int n = 0; n < kBigSize; ++n)
-        if (lt(abig.v[n], bbig.v[n]) || abig.v[n] != kExpected)
+        if (abig.v[n] != kExpected)
           fail();
     }
   }

SingleSource/UnitTests/Atomic/float_test.cpp

@@ -6,40 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// The following text is present in each test file:
-//
-// These tests aim to capture real-world multithreaded use cases of atomic
-// builtins. Each test focuses on a single atomic operation. Those using
-// multiple operations can be compared with other tests using the same
-// operations to isolate bugs to a single atomic operation.
-//
-// Each test consists of a "looper" body and a test script. The test script
-// instantiates 10 threads, each running the looper. The loopers contend the
-// same memory address, performing atomic operations on it. Each looper executes
-// 10^6 times for a total of 10^7 operations. The resultant value in the
-// contended pointer is compared against a closed-form solution. It's expected
-// that the two values equate.
-//
-// For example, a looper that increments the shared pointer is expected to end
-// up with a value of 10^7. If its final value is not that, the test fails.
-//
-// Each test also tests the corresponding nonatomic operation with a separate
-// shared variable. Ideally, this value differs from the atomic "correct" value,
-// and the test can compare the two. In reality, some simpler operations (e.g.
-// those conducted through the ALU) can still end up with the correct answer,
-// even when performed nonatomically. These tests do not check the nonatomic
-// result, although it is still outputted to aid in debugging.
-//
-// Each test is performed on all relevant types.
-//
-//===----------------------------------------------------------------------===//
-//
 // This file tests atomic operations on floating point types with aligned
 // memory addresses.
 //
 // The types tested are: float, double.
 // The ops tested are: xchg, cmpxchg.
 //
+// Please read the README before contributing.
+//
 //===----------------------------------------------------------------------===//
 
 #include <sys/stat.h>
@@ -59,18 +33,13 @@ void test_float_scalar_xchg() {
   std::vector<std::thread> pool;
 
   for (int model : atomic_exchange_models) {
-    T afloat = 0, ffloat = 0;
+    T afloat = 0;
     for (int n = 0; n < kThreads; ++n)
       pool.emplace_back(looper_numeric_xchg_atomic<T>, &afloat, model);
     for (int n = 0; n < kThreads; ++n)
       pool[n].join();
     pool.clear();
-    for (int n = 0; n < kThreads; ++n)
-      pool.emplace_back(looper_numeric_xchg_nonatomic<T>, &ffloat, model);
-    for (int n = 0; n < kThreads; ++n)
-      pool[n].join();
-    pool.clear();
-    if (lt(afloat, ffloat) || afloat < expected * (1 - kEpsilon) ||
+    if (afloat < expected * (1 - kEpsilon) ||
         afloat > expected * (1 + kEpsilon))
       fail();
   }
@@ -85,14 +54,14 @@ void test_float_scalar_cmpxchg() {
 
   for (int success_model : atomic_compare_exchange_models) {
     for (int fail_model : atomic_compare_exchange_models) {
-      T afloat = 0, ffloat = 0;
+      T afloat = 0;
       for (int n = 0; n < kThreads; ++n)
-        pool.emplace_back(looper_numeric_cmpxchg<T>, &afloat, &ffloat,
-                          success_model, fail_model);
+        pool.emplace_back(looper_numeric_cmpxchg<T>, &afloat, success_model,
+                          fail_model);
       for (int n = 0; n < kThreads; ++n)
         pool[n].join();
       pool.clear();
-      if (lt(afloat, ffloat) || afloat < expected * (1 - kEpsilon) ||
+      if (afloat < expected * (1 - kEpsilon) ||
           afloat > expected * (1 + kEpsilon))
         fail();
     }
@@ -107,6 +76,10 @@ void test_floating_point() {
   std::cout << "Testing double\n";
   test_float_scalar_xchg<double>();
   test_float_scalar_cmpxchg<double>();
+
+  std::cout << "Testing float128\n";
+  test_float_scalar_xchg<__float128>();
+  test_float_scalar_cmpxchg<__float128>();
 }
 
 int main() {

SingleSource/UnitTests/Atomic/float_test.reference_output

@@ -1,5 +1,6 @@
 10 threads; 1000000 iterations each; total of 10000000
 Testing float
 Testing double
+Testing float128
 PASSED
 exit 0