Restore hash_head memory fence with corrected CAS writer.

Author: evoskuil

include/bitcoin/database/impl/primitives/hashhead.ipp

@@ -129,15 +129,18 @@ inline Link CLASS::top(const Link& index) const NOEXCEPT
     if (is_null(raw))
         return {};
 
-    ////if constexpr (Align)
-    ////{
-    ////    // Reads full padded word.
-    ////    // xcode clang++16 does not support C++20 std::atomic_ref.
-    ////    ////const std::atomic_ref<integer> head(unsafe_byte_cast<integer>(raw));
-    ////    const auto& head = *pointer_cast<std::atomic<integer>>(raw);
-    ////    return head.load(std::memory_order_acquire);
-    ////}
-    ////else
+    if constexpr (Align)
+    {
+        // Reads full padded word.
+        // xcode clang++16 does not support C++20 std::atomic_ref.
+        ////const std::atomic_ref<integer> head(unsafe_byte_cast<integer>(raw));
+        const auto& head = *pointer_cast<std::atomic<integer>>(raw);
+
+        // Acquire is necessary to synchronize with push release.
+        // Relaxed would miss next updates, so acquire is optimal.
+        return head.load(std::memory_order_acquire);
+    }
+    else
     {
         const auto& head = to_array<size_>(raw);
         mutex_.lock_shared();
@@ -163,15 +166,27 @@ inline bool CLASS::push(const Link& current, bytes& next,
     if (is_null(raw))
         return false;
 
-    ////if constexpr (Align)
-    ////{
-    ////    // Writes full padded word (0x00 fill).
-    ////    // xcode clang++16 does not support C++20 std::atomic_ref.
-    ////    ////const std::atomic_ref<integer> head(unsafe_byte_cast<integer>(raw));
-    ////    auto& head = *pointer_cast<std::atomic<integer>>(raw);
-    ////    next = Link(head.exchange(current, std::memory_order_acq_rel));
-    ////}
-    ////else
+    if constexpr (Align)
+    {
+        // Writes full padded word (0x00 fill).
+        // xcode clang++16 does not support C++20 std::atomic_ref.
+        ////const std::atomic_ref<integer> head(unsafe_byte_cast<integer>(raw));
+        auto& head = *pointer_cast<std::atomic<integer>>(raw);
+
+        integer top = head.load(std::memory_order_acquire);
+        do
+        {
+            // Compiler could order this after head.store, which would expose key
+            // to search before next entry is linked. Thread fence imposes order.
+            // A release fence ensures that all prior writes (like next) are
+            // completed before any subsequent atomic store. 
+            next = Link{ top };
+            std::atomic_thread_fence(std::memory_order_release);
+        }
+        while (!head.compare_exchange_weak(top, current,
+            std::memory_order_release, std::memory_order_acquire));
+    }
+    else
     {
         auto& head = to_array<size_>(raw);
         mutex_.lock();

include/bitcoin/database/primitives/hashhead.hpp

@@ -67,7 +67,7 @@ class hashhead
 private:
     using integer = Link::integer;
     static_assert(std::atomic<integer>::is_always_lock_free);
-    static constexpr auto size_ = /*Align ? sizeof(integer) :*/ Link::size;
+    static constexpr auto size_ = Align ? sizeof(integer) : Link::size;
 
     template <size_t Bytes>
     static inline auto& to_array(memory::iterator it) NOEXCEPT