Refactor hashmap to allow for filter sizing.

Author: evoskuil

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

@@ -32,8 +32,8 @@ namespace database {
 TEMPLATE
 CLASS::hashhead(storage& head, size_t bits) NOEXCEPT
   : file_(head),
-    buckets_(system::power2<integer>(bits)),
-    mask_(system::unmask_right<integer>(bits))
+    buckets_(system::power2<bucket_integer>(bits)),
+    mask_(system::unmask_right<bucket_integer>(bits))
 {
 }
 
@@ -110,8 +110,8 @@ inline Link CLASS::index(const Key& key) const NOEXCEPT
     BC_ASSERT_MSG(mask_ < max_size_t, "insufficient domain");
     BC_ASSERT_MSG(is_nonzero(buckets_), "hash table requires buckets");
 
-    const auto index = possible_narrow_cast<integer>(keys::hash<Key>(key));
-    return bit_and<integer>(mask_, index);
+    const auto index = possible_narrow_cast<bucket_integer>(keys::hash<Key>(key));
+    return bit_and<bucket_integer>(mask_, index);
 }
 
 TEMPLATE
@@ -128,25 +128,27 @@ inline Link CLASS::top(const Link& index) const NOEXCEPT
     if (is_null(raw))
         return {};
 
-    if constexpr (Align)
+    if constexpr (aligned)
     {
         // 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);
+        ////const std::atomic_ref<bucket_integer> head(unsafe_byte_cast<bucket_integer>(raw));
+        const auto& head = *pointer_cast<std::atomic<bucket_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);
+        const auto& head = to_array<bucket_size>(raw);
         mutex_.lock_shared();
         const auto top = head;
         mutex_.unlock_shared();
         return top;
     }
+
+    // TODO: return terminal if filtered.
 }
 
 TEMPLATE
@@ -159,25 +161,33 @@ inline bool CLASS::push(const Link& current, bytes& next,
 TEMPLATE
 inline bool CLASS::push(const Link& current, bytes& next,
     const Link& index) NOEXCEPT
+{
+    bool collision{};
+    return push(collision, current, next, index);
+}
+
+TEMPLATE
+inline bool CLASS::push(bool& collision, const Link& current, bytes& next,
+    const Link& index) NOEXCEPT
 {
     using namespace system;
     const auto raw = file_.get_raw(link_to_position(index));
     if (is_null(raw))
         return false;
 
-    if constexpr (Align)
+    if constexpr (aligned)
     {
         // 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);
+        ////const std::atomic_ref<bucket_integer> head(unsafe_byte_cast<bucket_integer>(raw));
+        auto& head = *pointer_cast<std::atomic<bucket_integer>>(raw);
         auto 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. 
+            // completed before any subsequent atomic store.
             next = Link{ top };
             std::atomic_thread_fence(std::memory_order_release);
         }
@@ -186,13 +196,18 @@ inline bool CLASS::push(const Link& current, bytes& next,
     }
     else
     {
-        auto& head = to_array<size_>(raw);
+        auto& head = to_array<bucket_size>(raw);
         mutex_.lock();
         next = head;
         head = current;
         mutex_.unlock();
     }
 
+    // TODO: set collision when unfiltered or fingerprint matches filter.
+    collision = false;
+
+    // The returned next is set to prevous head, which is where collisions may
+    // be resolved to duplicate or not, when 'collision' is set to true.
     return true;
 }
 

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

@@ -205,14 +205,14 @@ Key CLASS::get_key(const Link& link) NOEXCEPT
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::find(const Key& key, Element& element) const NOEXCEPT
 {
     return !find_link(key, element).is_terminal();
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline Link CLASS::find_link(const Key& key, Element& element) const NOEXCEPT
 {
     // This override avoids duplicated memory_ptr construct in get(first()).
@@ -225,7 +225,7 @@ inline Link CLASS::find_link(const Key& key, Element& element) const NOEXCEPT
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::get(const Link& link, Element& element) const NOEXCEPT
 {
     // This override is the normal form.
@@ -234,7 +234,7 @@ inline bool CLASS::get(const Link& link, Element& element) const NOEXCEPT
 
 // static
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::get(const memory_ptr& ptr, const Link& link,
     Element& element) NOEXCEPT
 {
@@ -243,7 +243,7 @@ inline bool CLASS::get(const memory_ptr& ptr, const Link& link,
 
 // static
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::get(const iterator& it, Element& element) NOEXCEPT
 {
     // This override avoids deadlock when holding iterator to the same table.
@@ -252,16 +252,17 @@ inline bool CLASS::get(const iterator& it, Element& element) NOEXCEPT
 
 // static
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::get(const iterator& it, const Link& link,
     Element& element) NOEXCEPT
 {
     // This override avoids deadlock when holding iterator to the same table.
     return read(it.get(), link, element);
 }
 
+// static
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 bool CLASS::set(const memory_ptr& ptr, const Link& link, const Key& key,
     const Element& element) NOEXCEPT
 {
@@ -296,15 +297,15 @@ bool CLASS::set(const memory_ptr& ptr, const Link& link, const Key& key,
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 bool CLASS::set(const Link& link, const Key& key,
     const Element& element) NOEXCEPT
 {
     return set(get_memory(), link, key, element);
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline Link CLASS::set_link(const Key& key, const Element& element) NOEXCEPT
 {
     Link link{};
@@ -315,7 +316,7 @@ inline Link CLASS::set_link(const Key& key, const Element& element) NOEXCEPT
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::set_link(Link& link, const Key& key,
     const Element& element) NOEXCEPT
 {
@@ -324,7 +325,7 @@ inline bool CLASS::set_link(Link& link, const Key& key,
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline Link CLASS::put_link(const Key& key, const Element& element) NOEXCEPT
 {
     Link link{};
@@ -335,7 +336,7 @@ inline Link CLASS::put_link(const Key& key, const Element& element) NOEXCEPT
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::put_link(Link& link, const Key& key,
     const Element& element) NOEXCEPT
 {
@@ -344,14 +345,14 @@ inline bool CLASS::put_link(Link& link, const Key& key,
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::put(const Key& key, const Element& element) NOEXCEPT
 {
     return !put_link(key, element).is_terminal();
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::put(const Link& link, const Key& key,
     const Element& element) NOEXCEPT
 {
@@ -360,53 +361,63 @@ inline bool CLASS::put(const Link& link, const Key& key,
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 inline bool CLASS::put(const memory_ptr& ptr, const Link& link, const Key& key,
     const Element& element) NOEXCEPT
 {
     return write(ptr, link, key, element);
 }
 
 TEMPLATE
-bool CLASS::commit(const memory_ptr& ptr, const Link& link,
-    const Key& key) NOEXCEPT
+ELEMENT_CONSTRAINT
+inline bool CLASS::put(bool& duplicate, const memory_ptr& ptr,
+    const Link& link, const Key& key, const Element& element) NOEXCEPT
 {
-    using namespace system;
-    if (!ptr)
+    Link previous_head{};
+    if (!write(previous_head, ptr, link, key, element))
         return false;
 
-    // get element offset (fault)
-    const auto offset = ptr->offset(body::link_to_position(link));
-    if (is_null(offset))
-        return false;
+    duplicate = !first(ptr, previous_head, key).is_terminal();
+    return true;
+}
 
-    //// Set element search key.
-    //unsafe_array_cast<uint8_t, key_size>(std::next(offset,
-    //    Link::size)) = key;
+TEMPLATE
+inline Link CLASS::commit_link(const Link& link, const Key& key) NOEXCEPT
+{
+    if (!commit(link, key))
+        return {};
 
-    // Commit element to search index (terminal is a valid bucket index).
-    auto& next = unsafe_array_cast<uint8_t, Link::size>(offset);
-    return head_.push(link, next, head_.index(key));
+    return link;
 }
 
 TEMPLATE
-bool CLASS::commit(const Link& link, const Key& key) NOEXCEPT
+inline bool CLASS::commit(const Link& link, const Key& key) NOEXCEPT
 {
     return commit(get_memory(), link, key);
 }
 
 TEMPLATE
-inline Link CLASS::commit_link(const Link& link, const Key& key) NOEXCEPT
+bool CLASS::commit(const memory_ptr& ptr, const Link& link,
+    const Key& key) NOEXCEPT
 {
-    if (!commit(link, key))
-        return {};
+    using namespace system;
+    if (!ptr)
+        return false;
 
-    return link;
+    // get element offset (fault)
+    const auto offset = ptr->offset(body::link_to_position(link));
+    if (is_null(offset))
+        return false;
+
+    // Commit element to search index (terminal is a valid bucket index).
+    auto& next = unsafe_array_cast<uint8_t, Link::size>(offset);
+    return head_.push(link, next, head_.index(key));
 }
 
-// protected/static
+// protected
 // ----------------------------------------------------------------------------
 
+// static
 TEMPLATE
 Link CLASS::first(const memory_ptr& ptr, const Link& link,
     const Key& key) NOEXCEPT
@@ -435,8 +446,9 @@ Link CLASS::first(const memory_ptr& ptr, const Link& link,
     return next;
 }
 
+// static
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 bool CLASS::read(const memory_ptr& ptr, const Link& link,
     Element& element) NOEXCEPT
 {
@@ -462,12 +474,12 @@ bool CLASS::read(const memory_ptr& ptr, const Link& link,
     reader source{ stream };
     source.skip_bytes(index_size);
 
-    if constexpr (!is_slab) { BC_DEBUG_ONLY(source.set_limit(Size * element.count());) }
+    if constexpr (!is_slab) { BC_DEBUG_ONLY(source.set_limit(RowSize * element.count());) }
     return element.from_data(source);
 }
 
 TEMPLATE
-template <typename Element, if_equal<Element::size, Size>>
+ELEMENT_CONSTRAINT
 bool CLASS::write(const memory_ptr& ptr, const Link& link, const Key& key,
     const Element& element) NOEXCEPT
 {
@@ -500,6 +512,50 @@ bool CLASS::write(const memory_ptr& ptr, const Link& link, const Key& key,
     return element.to_data(sink) && head_.push(link, next, head_.index(key));
 }
 
+TEMPLATE
+ELEMENT_CONSTRAINT
+bool CLASS::write(Link& previous, const memory_ptr& ptr, const Link& link,
+    const Key& key, const Element& element) NOEXCEPT
+{
+    using namespace system;
+    if (!ptr || link.is_terminal())
+        return false;
+
+    const auto start = body::link_to_position(link);
+    if (is_limited<ptrdiff_t>(start))
+        return false;
+
+    const auto size = ptr->size();
+    const auto position = possible_narrow_and_sign_cast<ptrdiff_t>(start);
+    if (position > size)
+        return false;
+
+    const auto offset = ptr->offset(start);
+    if (is_null(offset))
+        return false;
+
+    // iostream.flush is a nop (direct copy).
+    iostream stream{ offset, size - position };
+    finalizer sink{ stream };
+    sink.skip_bytes(Link::size);
+    keys::write(sink, key);
+
+    // Commit element to body.
+    if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(RowSize * element.count());) }
+    auto& next = unsafe_array_cast<uint8_t, Link::size>(offset);
+    if (!element.to_data(sink))
+        return false;
+
+    // Commit element to search (terminal is a valid bucket index).
+    bool collision{};
+    if (!head_.push(collision, link, next, head_.index(key)))
+        return false;
+
+    // If filter collision set previous stack head for conflict resolution.
+    previous = collision ? next : Link::terminal;
+    return true;
+}
+
 } // namespace database
 } // namespace libbitcoin