Support find without automatic insert-if-not-present

Author: hsutter

experimental/extrinsic_storage.h

@@ -121,20 +121,31 @@ class extrinsic_storage {
     }
 
     //--------------------------------------------------------------------------
-    //  operator[]( pobj ) - returns the data entry for pobj
+    //  find_or_insert( pobj ) - returns the data entry for pobj
     //
     //  If pobj does not yet have an entry, creates it
     //
-    auto operator[](void* pobj) -> Value& {
+    auto find_or_insert(void* pobj) -> 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);
         }
-        auto v = lookup(pobj);
+        auto v = lookup(pobj, lookup_mode::find_or_insert);
         assert (v);
         return *v;
     }
 
+    //--------------------------------------------------------------------------
+    //  find( pobj ) - returns the data entry for pobj or null if not present
+    //
+    auto find(void* pobj) -> 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);
+        }
+        return lookup(pobj, lookup_mode::find_or_insert);
+    }
+
     //--------------------------------------------------------------------------
     //  erase( pobj ) - removes the entry for pobj
     //
@@ -143,7 +154,7 @@ class extrinsic_storage {
             //  m_o_relaxed is enough, inc order doesn't matter for totals
             instrument_erase_count.fetch_add(1, std::memory_order_relaxed);
         }
-        lookup(pobj, true);
+        lookup(pobj, lookup_mode::erase);
     }
 
 private:
@@ -178,9 +189,10 @@ class extrinsic_storage {
     //      as I think they can be correct here and they are in the hot path
     //      of the data structure traversal.
     //
+    enum class lookup_mode { find, find_or_insert, erase };
     auto lookup(
-        void* pobj,
-        bool  erase = false
+        void*       pobj,
+        lookup_mode mode
     )
         -> Value*
     {
@@ -202,7 +214,7 @@ class extrinsic_storage {
                 //  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 (erase) { 
+                    if (mode == lookup_mode::erase) { 
                         pchunk->keys[i].store(nullptr, std::memory_order_relaxed); 
                         return nullptr;
                     }
@@ -217,11 +229,14 @@ class extrinsic_storage {
             pchunk = pchunk->next.load(std::memory_order_relaxed);
         }
 
-        //  2. Otherwise, if we're erasing we're done but we didn't actually find something to erase
-        if (erase) { 
+        //  2. Otherwise, if we're not allowed to insert we're done 
+        //     but we didn't actually find something so return null
+        if (mode != lookup_mode::find_or_insert) { 
             if constexpr (debug_instrumentation) {
-                //  m_o_relaxed is enough, inc order doesn't matter for totals
-                instrument_erase_fail_count.fetch_add(1, std::memory_order_relaxed);
+                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);
+                }
             }
             return nullptr;
         }

experimental/union_test.cpp

@@ -55,25 +55,25 @@
 //
 template<typename Tag = uint8_t>
 class union_registry {
-    inline static auto tags    = extrinsic_storage<Tag>{};
-    inline static auto log     = std::ofstream{ "union-violations.log" };
+    static inline auto tags    = extrinsic_storage<Tag>{};
+    static inline auto log     = std::ofstream{ "union-violations.log" };
 public:
-    inline static auto invalid = std::numeric_limits<Tag>::max();
-    inline static auto unknown = std::numeric_limits<Tag>::max()-1;
+    static inline auto invalid = std::numeric_limits<Tag>::max();
+    static inline auto unknown = std::numeric_limits<Tag>::max()-1;
 
-    static auto on_destroy        (void* pobj)               -> void { tags.erase(pobj); }
-    static auto on_set_alternative(void* pobj, uint32_t alt) -> void { tags[pobj] = alt; }
-    static auto on_get_alternative(void* pobj, uint32_t alt, std::source_location where = std::source_location::current()) -> void
+    static inline auto on_destroy        (void* pobj)               -> void { tags.erase(pobj); }
+    static inline auto on_set_alternative(void* pobj, uint32_t alt) -> void { tags.find_or_insert(pobj) = alt; }
+    static inline auto on_get_alternative(void* pobj, uint32_t alt, std::source_location where = std::source_location::current()) -> void
     {
-        if (auto active = tags[pobj];
-            active != alt
-            && active != unknown
+        if (auto active = tags.find(pobj);
+            active                  // if we have discriminator info for this union
+            && *active != alt       // and the discriminator not what is expected
+            && *active != unknown   // and is not unknown
             )
         { 
-            log << where.file_name() << '(' << where.line() << ") " << where.function_name()
-                << ": union " << pobj 
-                << ", active " << (active == invalid ? "invalid" : std::to_string(active))
-                << ", accessed " << alt << "\n";
+            log << where.file_name() << '(' << where.line()
+                << "): union type safety violation - active member " << (*active == invalid ? "invalid" : std::to_string(*active))
+                << ", attempted to access " << alt << "\n";
         }
     }
 };