Stub in hashhead cascade filter.

Author: evoskuil

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

@@ -29,11 +29,14 @@
 namespace libbitcoin {
 namespace database {
 
+// configuration
+// ----------------------------------------------------------------------------
+
 TEMPLATE
 CLASS::hashhead(storage& head, size_t bits) NOEXCEPT
   : file_(head),
-    buckets_(system::power2<bucket_integer>(bits)),
-    mask_(system::unmask_right<bucket_integer>(bits))
+    buckets_(system::power2<link>(bits)),
+    mask_(system::unmask_right<link>(bits))
 {
     BC_ASSERT_MSG(mask_ < max_size_t, "insufficient domain");
 }
@@ -88,7 +91,7 @@ bool CLASS::get_body_count(Link& count) const NOEXCEPT
     if (!ptr)
         return false;
 
-    count = to_array<Link::size>(ptr->data());
+    link_array(count.value) = link_array(ptr->data());
     return true;
 }
 
@@ -100,112 +103,181 @@ bool CLASS::set_body_count(const Link& count) NOEXCEPT
         return false;
 
     // If head is padded then last bytes are fill (0xff).
-    to_array<Link::size>(ptr->data()) = count;
+    auto value = count.value;
+    link_array(ptr->data()) = link_array(value);
     return true;
 }
 
+// operation
+// ----------------------------------------------------------------------------
+
 TEMPLATE
 inline Link CLASS::index(const Key& key) const NOEXCEPT
 {
     using namespace system;
-    const auto index = possible_narrow_cast<bucket_integer>(keys::hash<Key>(key));
-    return bit_and<bucket_integer>(mask_, index);
+    const auto index = possible_narrow_cast<link>(keys::hash<Key>(key));
+    return bit_and<link>(mask_, index);
+}
+
+TEMPLATE
+inline Link CLASS::top(const Link& index) const NOEXCEPT
+{
+    return to_link(get_cell(index));
 }
 
 TEMPLATE
 inline Link CLASS::top(const Key& key) const NOEXCEPT
 {
-    return top(index(key));
+    const auto value = get_cell(index(key));
+    if (is_collision(value, key))
+        return to_link(value);
+    
+    return {};
 }
 
 TEMPLATE
-inline Link CLASS::top(const Link& index) const NOEXCEPT
+inline bool CLASS::push(const Link& current, bytes& next,
+    const Key& key) NOEXCEPT
+{
+    return push(current, next, index(key));
+}
+
+TEMPLATE
+inline bool CLASS::push(const Link& current, bytes& next,
+    const Link& index) NOEXCEPT
+{
+    return set_cell(next, current, index) != fault_cell;
+}
+
+TEMPLATE
+inline bool CLASS::push(bool& collision, const Link& current, bytes& next,
+    const Key& key) NOEXCEPT
+{
+    const auto previous = set_cell(next, current, index(key));
+    if (previous == fault_cell)
+        return false;
+
+    // Caller searches Link{ next } for duplicate in case of filter collision.
+    collision = is_collision(previous, key);
+    return true;
+}
+
+// protected
+// ----------------------------------------------------------------------------
+// read/write
+
+TEMPLATE
+inline CLASS::cell CLASS::get_cell(const Link& index) const NOEXCEPT
 {
     using namespace system;
     const auto raw = file_.get_raw(link_to_position(index));
     if (is_null(raw))
-        return {};
+        return fault_cell;
 
     if constexpr (aligned)
     {
         // Reads full padded word.
         // xcode clang++16 does not support C++20 std::atomic_ref.
-        ////const std::atomic_ref<bucket_integer> head(unsafe_byte_cast<bucket_integer>(raw));
-        const auto& head = *pointer_cast<std::atomic<bucket_integer>>(raw);
+        ////const std::atomic_ref<cell> top(unsafe_byte_cast<cell>(raw));
+        const auto& top = *pointer_cast<std::atomic<cell>>(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);
+        return top.load(std::memory_order_acquire);
     }
     else
     {
-        const auto& head = to_array<bucket_size>(raw);
+        cell top{};
+        const auto& head = cell_array(raw);
+
         mutex_.lock_shared();
-        const auto top = head;
+        cell_array(top) = head;
         mutex_.unlock_shared();
+
         return top;
     }
-
-    // TODO: return terminal if filtered.
 }
 
 TEMPLATE
-inline bool CLASS::push(const Link& current, bytes& next,
-    const Key& key) NOEXCEPT
-{
-    return push(current, next, index(key));
-}
-
-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,
+inline CLASS::cell CLASS::set_cell(bytes& next, const Link& current,
     const Link& index) NOEXCEPT
 {
     using namespace system;
     const auto raw = file_.get_raw(link_to_position(index));
     if (is_null(raw))
-        return false;
+        return fault_cell;
 
     if constexpr (aligned)
     {
         // Writes full padded word (0x00 fill).
         // xcode clang++16 does not support C++20 std::atomic_ref.
-        ////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);
+        ////const std::atomic_ref<cell> head(unsafe_byte_cast<cell>(raw));
+        auto& top = *pointer_cast<std::atomic<cell>>(raw);
+        auto head = top.load(std::memory_order_acquire);
         do
         {
-            // Compiler could order this after head.store, which would expose key
+            // Compiler could order this after top.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 };
+            next = link_array(head);
             std::atomic_thread_fence(std::memory_order_release);
         }
-        while (!head.compare_exchange_weak(top, current,
+        while (!top.compare_exchange_weak(head, to_cell(head, current),
             std::memory_order_release, std::memory_order_acquire));
     }
     else
     {
-        auto& head = to_array<bucket_size>(raw);
+        cell top{};
+        auto& head = cell_array(raw);
+
         mutex_.lock();
-        next = head;
-        head = current;
+        cell_array(top) = head;
+        next = link_array(top);
+        auto bytes = to_cell(top, current);
+        head = cell_array(bytes);
         mutex_.unlock();
     }
 
-    // TODO: set collision when unfiltered or fingerprint matches filter.
-    collision = false;
+    return true;
+}
+
+// protected
+// ----------------------------------------------------------------------------
+// filters
+
+TEMPLATE
+constexpr CLASS::link CLASS::to_link(cell value) NOEXCEPT
+{
+    if (value == fault_cell)
+        return {};
+
+    using namespace system;
+    constexpr auto mask = unmask_right<cell>(link_bits);
+    return possible_narrow_cast<link>(bit_and(value, mask));
+}
+
+TEMPLATE
+constexpr CLASS::cell CLASS::to_filter(cell value) NOEXCEPT
+{
+    // TODO: mask link bits and return cell (private use).
+    return value;
+}
+
+TEMPLATE
+constexpr CLASS::cell CLASS::to_cell(cell /*previous*/, link current) NOEXCEPT
+{
+    // TODO: merge link into previous cell and update fingers.
+    return current;
+}
+
+TEMPLATE
+constexpr bool CLASS::is_collision(cell value, const Key& /*key*/) NOEXCEPT
+{
+    if (value == fault_cell)
+        return 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.
+    // TODO: true if overflow sentinel or any matching finger.
     return true;
 }
 

include/bitcoin/database/primitives/hashhead.hpp

@@ -66,34 +66,73 @@ class hashhead
     /// Unsafe if verify false.
     inline Link top(const Key& key) const NOEXCEPT;
     inline Link top(const Link& index) const NOEXCEPT;
-    inline bool push(const Link& current, bytes& next, const Key& key) NOEXCEPT;
     inline bool push(const Link& current, bytes& next, const Link& index) NOEXCEPT;
+    inline bool push(const Link& current, bytes& next, const Key& key) NOEXCEPT;
     inline bool push(bool& collision, const Link& current, bytes& next,
+        const Key& key) NOEXCEPT;
+
+protected:
+    /// One sentinel bit per sentinel byte but no less than three.
+    /// This is optimal based on a load factor of 1.5, approximate otherwise.
+    static constexpr size_t min_sentinal = 3;
+    static constexpr size_t cell_size = CellSize;
+    static constexpr size_t link_size = Link::size;
+    static constexpr size_t link_bits = to_bits(link_size);
+    static constexpr size_t filter_size = cell_size - link_size;
+    static constexpr size_t filter_bits = to_bits(filter_size);
+    static constexpr size_t sentinel_bits = std::max(filter_size, min_sentinal);
+    static constexpr size_t finger_bits = filter_bits - sentinel_bits;
+    static constexpr size_t fingers = sub1(system::power2(sentinel_bits));
+    static constexpr size_t overflow = zero;
+
+    using link = Link::integer;
+    using cell = unsigned_type<cell_size>;
+    using filter = unsigned_type<filter_size>;
+    static constexpr cell fault_cell = system::bit_all<cell>;
+    static constexpr bool aligned = (cell_size == sizeof(cell));
+    static_assert(link_bits + filter_bits == to_bits(cell_size));
+    static_assert(std::atomic<cell>::is_always_lock_free);
+    static_assert(is_nonzero(Link::size));
+
+    static constexpr link to_link(cell value) NOEXCEPT;
+    static constexpr cell to_filter(cell value) NOEXCEPT;
+    static constexpr cell to_cell(cell previous, link current) NOEXCEPT;
+    static constexpr bool is_collision(cell value, const Key& key) NOEXCEPT;
+    inline cell get_cell(const Link& index) const NOEXCEPT;
+    inline cell set_cell(bytes& next, const Link& current,
         const Link& index) NOEXCEPT;
 
 private:
-    using bucket_integer = Link::integer;
-    using cell_integer = unsigned_type<CellSize>;
-    static_assert(std::atomic<cell_integer>::is_always_lock_free);
-    static_assert(is_nonzero(Link::size));
-    static constexpr auto bucket_size = Link::size;
-    static constexpr auto filter_size = CellSize - bucket_size;
-    static constexpr auto aligned = (CellSize == sizeof(cell_integer));
+    static INLINE auto& cell_array(memory::iterator it) NOEXCEPT
+    {
+        return system::unsafe_array_cast<uint8_t, cell_size>(it);
+    }
+
+    template <typename Integral, if_integral<Integral> = true>
+    static INLINE auto& cell_array(Integral& value) NOEXCEPT
+    {
+        return cell_array(system::pointer_cast<uint8_t>(&value));
+    }
+
+    static INLINE auto& link_array(memory::iterator it) NOEXCEPT
+    {
+        return system::unsafe_array_cast<uint8_t, link_size>(it);
+    }
 
-    template <size_t Bytes>
-    static inline auto& to_array(memory::iterator it) NOEXCEPT
+    template <typename Integral, if_integral<Integral> = true>
+    static INLINE auto& link_array(Integral& value) NOEXCEPT
     {
-        return system::unsafe_array_cast<uint8_t, Bytes>(it);
+        return link_array(system::pointer_cast<uint8_t>(&value));
     }
 
     // Byte offset of bucket index within head file.
     // [body_size][[bucket[0]...bucket[buckets-1]]]
     static constexpr size_t link_to_position(const Link& index) NOEXCEPT
     {
         using namespace system;
-        BC_ASSERT(!is_multiply_overflow<size_t>(index, CellSize));
-        BC_ASSERT(!is_add_overflow(CellSize, index * CellSize));
-        return possible_narrow_cast<size_t>(add1(index) * CellSize);
+        BC_ASSERT(!is_multiply_overflow<size_t>(index, cell_size));
+        BC_ASSERT(!is_add_overflow(cell_size, index * cell_size));
+        return possible_narrow_cast<size_t>(add1(index) * cell_size);
     }
 
     // These are thread safe.