Remove logging, & -> *

Author: Logikable

SingleSource/UnitTests/Atomic/CMakeLists.txt

@@ -1,13 +1,3 @@
-# These tests output numerical values to improve debuggability.
-# Setting FP_TOLERANCE causes the test checker to use fpcmp to compare
-#   test and expected output.
-# Because the nonatomic output may vary wildly even in a passing run,
-#   we set FP_TOLERANCE high so the test will never fail due to
-#   differing numerical results.
-# The tests each have their own correctness checking and will fail
-#   properly if something is actually wrong.
-set(FP_TOLERANCE 1000000)
-
 # Link the Clang built libatomic. 
 execute_process(COMMAND ${CMAKE_C_COMPILER} --print-file-name=libclang_rt.atomic.so
                 OUTPUT_VARIABLE _path_to_libatomic

SingleSource/UnitTests/Atomic/big_test.cpp

@@ -42,7 +42,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <cstdio>
 #include <iostream>
 #include <thread>
 #include <vector>
@@ -56,7 +55,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,
+void looper_big_cmpxchg(big_t *abig, big_t *bbig, int success_model,
                         int fail_model) {
   for (int n = 0; n < kIterations; ++n) {
     big_t desired, expected = {};
@@ -67,7 +66,7 @@ void looper_big_cmpxchg(big_t *abig, big_t &bbig, int success_model,
     } while (!__atomic_compare_exchange(abig, &expected, &desired, true,
                                         success_model, fail_model));
     for (int k = 0; k < kBigSize; ++k)
-      bbig.v[k]++;
+      bbig->v[k]++;
   }
 }
 
@@ -76,23 +75,13 @@ void test_big_cmpxchg() {
 
   for (int success_model : atomic_compare_exchange_models) {
     for (int fail_model : atomic_compare_exchange_models) {
-      big_t abig = {};
-      big_t bbig = {};
+      big_t abig = {}, bbig = {};
       for (int n = 0; n < kThreads; ++n)
-        pool.emplace_back(looper_big_cmpxchg, &abig, std::ref(bbig),
+        pool.emplace_back(looper_big_cmpxchg, &abig, &bbig,
                           success_model, fail_model);
       for (int n = 0; n < kThreads; ++n)
         pool[n].join();
       pool.clear();
-      std::cout << "CMPXCHG: ";
-      std::cout << "atomic: ";
-      for (int n = 0; n < kBigSize; ++n)
-        std::cout << abig.v[n] << " ";
-      std::cout << "\n      ";
-      std::cout << "nonatomic: ";
-      for (int n = 0; n < kBigSize; ++n)
-        std::cout << bbig.v[n] << " ";
-      std::cout << "\n";
       for (int n = 0; n < kBigSize; ++n)
         if (lt(abig.v[n], bbig.v[n]) || abig.v[n] != kExpected)
           fail();
@@ -101,14 +90,14 @@ void test_big_cmpxchg() {
 }
 
 void test_big() {
-  printf("Testing big\n");
+  std::cout << "Testing big\n";
   test_big_cmpxchg();
 }
 
 int main() {
-  printf("%d threads; %d iterations each; total of %d\n", kThreads, kIterations,
-         kExpected);
-
+  std::cout << kThreads << " threads; "
+            << kIterations << " iterations each; total of "
+            << kExpected << "\n";
   test_big();
-  printf("PASSED\n");
+  std::cout << "PASSED\n";
 }

SingleSource/UnitTests/Atomic/big_test.reference_output

@@ -1,6 +1,4 @@
 10 threads; 1000000 iterations each; total of 10000000
 Testing big
-CMPXCHG: atomic: 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 
-      nonatomic: 9970397 9970397 9970397 9970397 9972269 9972269 9972269 9972269 9941180 9941180 
 PASSED
 exit 0

SingleSource/UnitTests/Atomic/float_test.cpp

@@ -44,7 +44,7 @@
 
 #include <sys/stat.h>
 
-#include <cstdio>
+#include <iostream>
 #include <thread>
 #include <vector>
 
@@ -59,22 +59,17 @@ void test_float_scalar_xchg() {
   std::vector<std::thread> pool;
 
   for (int model : atomic_exchange_models) {
-    T afloat = 0;
-    T ffloat = 0;
+    T afloat = 0, ffloat = 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>, std::ref(ffloat),
-                        model);
+      pool.emplace_back(looper_numeric_xchg_nonatomic<T>, &ffloat, model);
     for (int n = 0; n < kThreads; ++n)
       pool[n].join();
     pool.clear();
-    std::cout << "SCALAR (FETCH ADD): "
-              << "atomic: " << afloat << " "
-              << "nonatomic: " << ffloat << "\n";
     if (lt(afloat, ffloat) || afloat < expected * (1 - kEpsilon) ||
         afloat > expected * (1 + kEpsilon))
       fail();
@@ -90,17 +85,13 @@ void test_float_scalar_cmpxchg() {
 
   for (int success_model : atomic_compare_exchange_models) {
     for (int fail_model : atomic_compare_exchange_models) {
-      T afloat = 0;
-      T ffloat = 0;
+      T afloat = 0, ffloat = 0;
       for (int n = 0; n < kThreads; ++n)
-        pool.emplace_back(looper_numeric_cmpxchg<T>, &afloat, std::ref(ffloat),
+        pool.emplace_back(looper_numeric_cmpxchg<T>, &afloat, &ffloat,
                           success_model, fail_model);
       for (int n = 0; n < kThreads; ++n)
         pool[n].join();
       pool.clear();
-      std::cout << "SCALAR (FETCH ADD): "
-                << "atomic: " << afloat << " "
-                << "nonatomic: " << ffloat << "\n";
       if (lt(afloat, ffloat) || afloat < expected * (1 - kEpsilon) ||
           afloat > expected * (1 + kEpsilon))
         fail();
@@ -109,19 +100,19 @@ void test_float_scalar_cmpxchg() {
 }
 
 void test_floating_point() {
-  printf("Testing float\n");
+  std::cout << "Testing float\n";
   test_float_scalar_xchg<float>();
   test_float_scalar_cmpxchg<float>();
 
-  printf("Testing double\n");
+  std::cout << "Testing double\n";
   test_float_scalar_xchg<double>();
   test_float_scalar_cmpxchg<double>();
 }
 
 int main() {
-  printf("%d threads; %d iterations each; total of %d\n", kThreads, kIterations,
-         kExpected);
-
+  std::cout << kThreads << " threads; "
+            << kIterations << " iterations each; total of "
+            << kExpected << "\n";
   test_floating_point();
-  printf("PASSED\n");
+  std::cout << "PASSED\n";
 }

SingleSource/UnitTests/Atomic/float_test.reference_output

@@ -1,9 +1,5 @@
 10 threads; 1000000 iterations each; total of 10000000
 Testing float
-SCALAR (FETCH ADD): atomic: 6.50116e+08 nonatomic: 6.6e+07
-SCALAR (FETCH ADD): atomic: 6.41017e+08 nonatomic: 5.8511e+08
 Testing double
-SCALAR (FETCH ADD): atomic: 2.84596e+18 nonatomic: 2.84596e+17
-SCALAR (FETCH ADD): atomic: 2.84596e+18 nonatomic: 2.5513e+18
 PASSED
 exit 0