Reduce overheads a bit and show Mops / s

Author: polytypic

internals/testing/contention_test.cpp

@@ -3,6 +3,9 @@
 #include "testing_v1/test.hpp"
 
 #include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <memory>
 #include <thread>
 
 using namespace testing_v1;
@@ -16,23 +19,27 @@ auto contention_test = test([]() {
 
   constexpr size_t n_atoms = 7;
 
-  atom<int> atoms[n_atoms];
+  std::unique_ptr<atom<int>[]> atoms(new atom<int>[n_atoms]);
   for (size_t i = 0; i < n_atoms; ++i)
     atomically([&]() { atoms[i] = 0; });
 
+  auto start = std::chrono::high_resolution_clock::now();
+
   for (size_t t = 0; t < n_threads; ++t) {
-    std::thread([&]() {
+    std::thread([&, t]() {
       atomically([&]() { n_threads_started.ref() += 1; });
       atomically([&]() {
         if (n_threads_started != n_threads)
           retry();
       });
 
+      auto s = static_cast<uint32_t>(t);
+
       for (size_t o = 0; o < n_ops; ++o) {
-        auto i = std::rand() % n_atoms;
+        auto i = (s = dumpster::ranqd1(s)) % n_atoms;
         auto j = i;
         while (i == j)
-          j = std::rand() % n_atoms;
+          j = (s = dumpster::ranqd1(s)) % n_atoms;
 
         atomically(stack<128>, [&]() {
           int &x = atoms[i].ref();
@@ -50,6 +57,15 @@ auto contention_test = test([]() {
       retry();
   });
 
+  std::chrono::duration<double> elapsed =
+      std::chrono::high_resolution_clock::now() - start;
+  auto n_total = n_ops * n_threads;
+  fprintf(stderr,
+          "%f Mops in %f s = %f Mops/s\n",
+          n_total / 1000000.0,
+          elapsed.count(),
+          n_total / elapsed.count() / 1000000.0);
+
   auto [sum, non_zeroes] = atomically(assume_readonly, [&]() {
     int sum = 0;
     int non_zeroes = 0;