Add macro for m_o_relaxed checking in extrinsic_storage

Author: hsutter

experimental/extrinsic_storage.h

@@ -10,7 +10,13 @@
 
 //  *****************************************************************
 //  Enable/disable debug instrumentation and statistics printing here
-constexpr inline auto debug_instrumentation = false;
+constexpr inline auto debug_instrumentation = true;
+
+//  Try with/without m_o_relaxed
+#define M_O_RELAXED         , std::memory_order_relaxed
+#define M_O_RELAXED_NOCOMMA std::memory_order_relaxed
+//#define M_O_RELAXED
+//#define M_O_RELAXED_NOCOMMA
 //  *****************************************************************
 
 #include <algorithm>
@@ -125,7 +131,7 @@ class extrinsic_storage {
     auto find_or_insert(void* pobj) noexcept -> Value* {
         if constexpr (debug_instrumentation) {
             //  m_o_relaxed is enough, inc order doesn't matter for totals
-            instrument_access_count.fetch_add(1, std::memory_order_relaxed);
+            instrument_access_count.fetch_add(1 M_O_RELAXED);
         }
         return lookup(pobj, lookup_mode::find_or_insert);
     }
@@ -136,7 +142,7 @@ class extrinsic_storage {
     auto find(void* pobj) noexcept -> Value* {
         if constexpr (debug_instrumentation) {
             //  m_o_relaxed is enough, inc order doesn't matter for totals
-            instrument_access_count.fetch_add(1, std::memory_order_relaxed);
+            instrument_access_count.fetch_add(1 M_O_RELAXED);
         }
         return lookup(pobj, lookup_mode::find);
     }
@@ -147,7 +153,7 @@ class extrinsic_storage {
     auto erase(void* pobj) noexcept -> void {
         if constexpr (debug_instrumentation) {
             //  m_o_relaxed is enough, inc order doesn't matter for totals
-            instrument_erase_count.fetch_add(1, std::memory_order_relaxed);
+            instrument_erase_count.fetch_add(1 M_O_RELAXED);
         }
         lookup(pobj, lookup_mode::erase);
     }
@@ -202,7 +208,7 @@ class extrinsic_storage {
         assert( 0 <= hash && hash < Buckets );
         if constexpr (debug_instrumentation) {
             //  m_o_relaxed is enough, inc order doesn't matter for totals
-            instrument_bucket_access[hash].fetch_add(1, std::memory_order_relaxed);
+            instrument_bucket_access[hash].fetch_add(1 M_O_RELAXED);
         }
 
         //  1. If we find key==pobj, we're done
@@ -212,9 +218,9 @@ class extrinsic_storage {
                 //  (*) m_o_relaxed is enough, equality means we own the slot
                 //  and so this thread already has exclusive access to *pobj
                 //  and its .values data
-                if (pchunk->keys[i].load(std::memory_order_relaxed) == pobj) {
+                if (pchunk->keys[i].load(M_O_RELAXED_NOCOMMA) == pobj) {
                     if (mode == lookup_mode::erase) { 
-                        pchunk->keys[i].store(nullptr, std::memory_order_relaxed); 
+                        pchunk->keys[i].store(nullptr M_O_RELAXED); 
                         return nullptr;
                     }
                     //  Else
@@ -225,7 +231,7 @@ class extrinsic_storage {
             //  it is first set to non-null, and if a new chunk(s) was just
             //  concurrently added by a different thread then that new
             //  chunk(s) cannot contain an entry for pobj
-            pchunk = pchunk->next.load(std::memory_order_relaxed);
+            pchunk = pchunk->next.load(M_O_RELAXED_NOCOMMA);
         }
 
         //  2. Otherwise, if we're not allowed to insert we're done 
@@ -234,7 +240,7 @@ class extrinsic_storage {
             if constexpr (debug_instrumentation) {
                 if (mode == lookup_mode::erase) {
                     //  m_o_relaxed is enough, inc order doesn't matter for totals
-                    instrument_erase_fail_count.fetch_add(1, std::memory_order_relaxed);
+                    instrument_erase_fail_count.fetch_add(1 M_O_RELAXED);
                 }
             }
             return nullptr;
@@ -249,22 +255,22 @@ class extrinsic_storage {
                 void* null = nullptr;
                 if (
                     //  m_o_relaxed is enough for this first load...
-                    pchunk->keys[i].load(std::memory_order_relaxed) == nullptr
+                    pchunk->keys[i].load(M_O_RELAXED_NOCOMMA) == nullptr
                     //  ... because it's just a best-effort optimization to
                     //  avoid this maybe-unneeded c_e_weak (which is safely SC)
                     && pchunk->keys[i].compare_exchange_weak( null, pobj )
                     ) {
                     if constexpr (debug_instrumentation) {
                         //  m_o_relaxed is enough, inc order doesn't matter for totals
-                        instrument_insert_count.fetch_add(1, std::memory_order_relaxed);
+                        instrument_insert_count.fetch_add(1 M_O_RELAXED);
                     }
                     return &pchunk->values[i];
                 }
             }
             //  (*) m_o_relaxed is enough here, because if a new chunk(s)
             //  was just concurrently added by a different thread then we'll
             //  just add an extra chunk which is fine
-            if ( pchunk->next.load(std::memory_order_relaxed) == nullptr ) {
+            if ( pchunk->next.load(M_O_RELAXED_NOCOMMA) == nullptr ) {
                 break;
             }
             pchunk = pchunk->next.load();
@@ -290,7 +296,7 @@ class extrinsic_storage {
 
         if constexpr (debug_instrumentation) {
             //  m_o_relaxed is enough, inc order doesn't matter for totals
-            instrument_alloc_count.fetch_add(1, std::memory_order_relaxed);
+            instrument_alloc_count.fetch_add(1 M_O_RELAXED);
         }
         return ret;
     }

experimental/union_test.cpp

@@ -12,6 +12,7 @@
 #include <cstdint>
 #include <fstream>
 #include <iostream>
+#include <map>
 #include <source_location>
 #include <thread>
 #include <vector>
@@ -151,14 +152,9 @@ auto test(int threads = 1) -> void
         }
     };
 
-    if (threads == 1) {
-        run();
-    }
-    else {
-        std::vector<std::jthread> thds;
-        for (auto i = 0; i < threads; ++i) {
-            thds.emplace_back( run );
-        }
+    std::vector<std::jthread> thds;
+    for (auto i = 0; i < threads; ++i) {
+        thds.emplace_back( run );
     }
 }
 
@@ -176,29 +172,39 @@ int main()
     auto tot_raw = int64_t{0};
     auto tot_chk = int64_t{0};
 
-    //  Repeat test sequence a couple of times
-    for (auto reps = 0; reps < 2; ++reps)
+    auto stats = std::map<int,uint64_t>{};
+
+    //  Repeat test sequence a few times
+    for (auto reps = 0; reps < 5; ++reps)
     {
-       //  Run "raw" vs "checked" test for 1, 2, 4, 8, 16, 32, and 64 threads
-       for (auto i = 1; i <= 64; i *= 2)
-       {
-           std::cout << "# threads: " << i << "\n";
-
-           //  First without checks
-           auto t = timer{};
-           test(i);
-           auto raw_time = t.microseconds();
-           std::cout << "  raw:     " << print(raw_time) << "\n";
-           tot_raw += raw_time;
-
-           //  Then with checks, via specifying <true>
-           t = timer{};
-           test<true>(i);
-           auto chk_time = t.microseconds();
-           std::cout << "  checked: " << print(chk_time) << "\n";
-           tot_chk += chk_time;
-       }
+        //  Run "raw" vs "checked" test for 1, 2, 4, 8, 16, 32, 64, and 128 threads
+        for (auto i = 1; i <= 128; i *= 2)
+        {
+            ////std::cout << "# threads: " << i << "\n";
+
+            //  First without checks
+            auto t = timer{};
+            test(i);
+            auto raw_time = t.microseconds();
+            ////std::cout << "  raw:     " << print(raw_time) << "\n";
+            tot_raw += raw_time;
+
+            //  Then with checks, via specifying <true>
+            t = timer{};
+            test<true>(i);
+            auto chk_time = t.microseconds();
+            ////std::cout << "  checked: " << print(chk_time) << "\n";
+            stats[i] += chk_time-raw_time;
+            tot_chk += chk_time;
+        }
+    }
+
+    //  Print each #threads timings in an Excel-friendly format
+    for (auto [threads, timings] : stats) {
+        if (threads != 1) { std::cout << " "; }
+        std::cout << timings;
     }
+    std::cout << "\n";
 
     std::cout << "totals\n"
               << "  raw:     " << print(tot_raw) << "\n"