Change hashmaps to base2 buckets.

Author: evoskuil

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

@@ -28,7 +28,7 @@ namespace database {
 
 TEMPLATE
 CLASS::arrayhead(storage& head, const Link& buckets) NOEXCEPT
-  : file_(head), initial_buckets_(buckets)
+  : file_(head), initial_buckets_(buckets.value)
 {
 }
 
@@ -49,7 +49,7 @@ inline size_t CLASS::buckets() const NOEXCEPT
 TEMPLATE
 bool CLASS::enabled() const NOEXCEPT
 {
-    return initial_buckets_ > one;
+    return !is_zero(initial_buckets_);
 }
 
 TEMPLATE

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

@@ -30,8 +30,10 @@ namespace libbitcoin {
 namespace database {
 
 TEMPLATE
-CLASS::hashhead(storage& head, const Link& buckets) NOEXCEPT
-  : file_(head), buckets_(buckets)
+CLASS::hashhead(storage& head, size_t bits) NOEXCEPT
+  : file_(head),
+    buckets_(system::power2<Link::integer>(bits)),
+    mask_(system::unmask_right<Link::integer>(bits))
 {
 }
 
@@ -103,13 +105,13 @@ bool CLASS::set_body_count(const Link& count) NOEXCEPT
 TEMPLATE
 inline Link CLASS::index(const Key& key) const NOEXCEPT
 {
+    using namespace system;
+    BC_ASSERT_MSG(mask_ < max_size_t, "insufficient domain");
     BC_ASSERT_MSG(is_nonzero(buckets_), "hash table requires buckets");
 
     // unique_hash assumes sufficient uniqueness in low order key bytes.
-    return system::unique_hash(key) % buckets_;
-
-    // TODO: restrict buckets to power of two and replace modulo above with
-    // return and(sub1(buckets), unique_hash(key)) [and() is much faster].
+    const auto index = possible_narrow_cast<Link::integer>(unique_hash(key));
+    return bit_and<Link::integer>(mask_, index);
 }
 
 TEMPLATE

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

@@ -334,7 +334,7 @@ bool CLASS::commit(const Link& link, const Key& key) NOEXCEPT
     unsafe_array_cast<uint8_t, key_size>(std::next(ptr->begin(),
         Link::size)) = key;
 
-    // Commit element to search index.
+    // Commit element to search index (terminal is a valid bucket index).
     auto& next = unsafe_array_cast<uint8_t, Link::size>(ptr->begin());
     return head_.push(link, next, head_.index(key));
 }
@@ -438,6 +438,7 @@ bool CLASS::write(const memory_ptr& ptr, const Link& link, const Key& key,
     sink.skip_bytes(Link::size);
     sink.write_bytes(key);
 
+    // Commit element to body and search (terminal is a valid bucket index).
     if constexpr (!is_slab) { BC_DEBUG_ONLY(sink.set_limit(Size * element.count());) }
     auto& next = unsafe_array_cast<uint8_t, Link::size>(offset);
     return element.to_data(sink) && head_.push(link, next, head_.index(key));

include/bitcoin/database/impl/store.ipp

@@ -19,8 +19,7 @@
 #ifndef LIBBITCOIN_DATABASE_STORE_IPP
 #define LIBBITCOIN_DATABASE_STORE_IPP
 
-#include <algorithm>
-#include <chrono>
+#include <unordered_map>
 #include <bitcoin/system.hpp>
 #include <bitcoin/database/boost.hpp>
 #include <bitcoin/database/define.hpp>
@@ -33,10 +32,6 @@ namespace database {
 
 BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)
 
-// head doesn't guard (performance) and parameter is cast to Link object,
-// so establish 1 as the minimum value (which also implies disabled).
-constexpr auto nonzero = 1_u32;
-
 // public
 // ----------------------------------------------------------------------------
 
@@ -136,7 +131,7 @@ CLASS::store(const settings& config) NOEXCEPT
 
     header_head_(head(config.path / schema::dir::heads, schema::archive::header)),
     header_body_(body(config.path, schema::archive::header), config.header_size, config.header_rate),
-    header(header_head_, header_body_, std::max(config.header_buckets, nonzero)),
+    header(header_head_, header_body_, config.header_bits),
 
     input_head_(head(config.path / schema::dir::heads, schema::archive::input)),
     input_body_(body(config.path, schema::archive::input), config.input_size, config.input_rate),
@@ -148,7 +143,7 @@ CLASS::store(const settings& config) NOEXCEPT
 
     point_head_(head(config.path / schema::dir::heads, schema::archive::point)),
     point_body_(body(config.path, schema::archive::point), config.point_size, config.point_rate),
-    point(point_head_, point_body_, std::max(config.point_buckets, nonzero)),
+    point(point_head_, point_body_, config.point_bits),
 
     ins_head_(head(config.path / schema::dir::heads, schema::archive::ins)),
     ins_body_(body(config.path, schema::archive::ins), config.ins_size, config.ins_rate),
@@ -160,11 +155,11 @@ CLASS::store(const settings& config) NOEXCEPT
 
     tx_head_(head(config.path / schema::dir::heads, schema::archive::tx)),
     tx_body_(body(config.path, schema::archive::tx), config.tx_size, config.tx_rate),
-    tx(tx_head_, tx_body_, std::max(config.tx_buckets, nonzero)),
+    tx(tx_head_, tx_body_, config.tx_bits),
 
     txs_head_(head(config.path / schema::dir::heads, schema::archive::txs)),
     txs_body_(body(config.path, schema::archive::txs), config.txs_size, config.txs_rate),
-    txs(txs_head_, txs_body_, std::max(config.txs_buckets, nonzero)),
+    txs(txs_head_, txs_body_, config.txs_bits),
 
     // Indexes.
     // ------------------------------------------------------------------------
@@ -179,37 +174,33 @@ CLASS::store(const settings& config) NOEXCEPT
 
     strong_tx_head_(head(config.path / schema::dir::heads, schema::indexes::strong_tx)),
     strong_tx_body_(body(config.path, schema::indexes::strong_tx), config.strong_tx_size, config.strong_tx_rate),
-    strong_tx(strong_tx_head_, strong_tx_body_, std::max(config.strong_tx_buckets, nonzero)),
+    strong_tx(strong_tx_head_, strong_tx_body_, config.strong_tx_bits),
 
     // Caches.
     // ------------------------------------------------------------------------
 
     prevout_head_(head(config.path / schema::dir::heads, schema::caches::prevout)),
     prevout_body_(body(config.path, schema::caches::prevout), config.prevout_size, config.prevout_rate),
-    prevout(prevout_head_, prevout_body_, std::max(config.prevout_buckets, nonzero)),
+    prevout(prevout_head_, prevout_body_, config.prevout_buckets),
 
     validated_bk_head_(head(config.path / schema::dir::heads, schema::caches::validated_bk)),
     validated_bk_body_(body(config.path, schema::caches::validated_bk), config.validated_bk_size, config.validated_bk_rate),
-    validated_bk(validated_bk_head_, validated_bk_body_, std::max(config.validated_bk_buckets, nonzero)),
+    validated_bk(validated_bk_head_, validated_bk_body_, config.validated_bk_bits),
 
     validated_tx_head_(head(config.path / schema::dir::heads, schema::caches::validated_tx)),
     validated_tx_body_(body(config.path, schema::caches::validated_tx), config.validated_tx_size, config.validated_tx_rate),
-    validated_tx(validated_tx_head_, validated_tx_body_, std::max(config.validated_tx_buckets, nonzero)),
+    validated_tx(validated_tx_head_, validated_tx_body_, config.validated_tx_bits),
 
     // Optionals.
     // ------------------------------------------------------------------------
 
     address_head_(head(config.path / schema::dir::heads, schema::optionals::address)),
     address_body_(body(config.path, schema::optionals::address), config.address_size, config.address_rate),
-    address(address_head_, address_body_, std::max(config.address_buckets, nonzero)),
+    address(address_head_, address_body_, config.address_bits),
 
     neutrino_head_(head(config.path / schema::dir::heads, schema::optionals::neutrino)),
     neutrino_body_(body(config.path, schema::optionals::neutrino), config.neutrino_size, config.neutrino_rate),
-    neutrino(neutrino_head_, neutrino_body_, std::max(config.neutrino_buckets, nonzero)),
-
-    ////bootstrap_head_(head(config.path / schema::dir::heads, schema::optionals::bootstrap)),
-    ////bootstrap_body_(body(config.path, schema::optionals::bootstrap), config.bootstrap_size, config.bootstrap_rate),
-    ////bootstrap(bootstrap_head_, bootstrap_body_),
+    neutrino(neutrino_head_, neutrino_body_, config.neutrino_bits),
 
     // Locks.
     // ------------------------------------------------------------------------

include/bitcoin/database/primitives/hashhead.hpp

@@ -35,8 +35,8 @@ class hashhead
 
     using bytes = typename Link::bytes;
 
-    /// A hash head has zero buckets (and cannot call index()).
-    hashhead(storage& head, const Link& buckets) NOEXCEPT;
+    /// An hash head is disabled it if has one or less buckets (0 bits).
+    hashhead(storage& head, size_t bits) NOEXCEPT;
 
     /// Sizing (thread safe).
     inline size_t size() const NOEXCEPT;
@@ -52,7 +52,8 @@ class hashhead
     bool get_body_count(Link& count) const NOEXCEPT;
     bool set_body_count(const Link& count) NOEXCEPT;
 
-    /// Convert natural key to head bucket index.
+    /// Convert natural key to head bucket index (all keys are valid).
+    /// Terminal is a valid bucket index (just not a valid bucket value).
     inline Link index(const Key& key) const NOEXCEPT;
 
     /// Unsafe if verify false.
@@ -80,6 +81,7 @@ class hashhead
 
     storage& file_;
     const Link buckets_;
+    const Link mask_;
     mutable std::shared_mutex mutex_{};
 };
 

include/bitcoin/database/settings.hpp

@@ -42,7 +42,7 @@ struct BCD_API settings
     /// Archives.
     /// -----------------------------------------------------------------------
 
-    uint32_t header_buckets;
+    uint32_t header_bits;
     uint64_t header_size;
     uint16_t header_rate;
 
@@ -52,7 +52,7 @@ struct BCD_API settings
     uint64_t output_size;
     uint16_t output_rate;
 
-    uint32_t point_buckets;
+    uint32_t point_bits;
     uint64_t point_size;
     uint16_t point_rate;
 
@@ -62,11 +62,11 @@ struct BCD_API settings
     uint64_t puts_size;
     uint16_t puts_rate;
 
-    uint32_t tx_buckets;
+    uint32_t tx_bits;
     uint64_t tx_size;
     uint16_t tx_rate;
 
-    uint32_t txs_buckets;
+    uint32_t txs_bits;
     uint64_t txs_size;
     uint16_t txs_rate;
 
@@ -79,7 +79,7 @@ struct BCD_API settings
     uint64_t confirmed_size;
     uint16_t confirmed_rate;
 
-    uint32_t strong_tx_buckets;
+    uint32_t strong_tx_bits;
     uint64_t strong_tx_size;
     uint16_t strong_tx_rate;
 
@@ -90,22 +90,22 @@ struct BCD_API settings
     uint64_t prevout_size;
     uint16_t prevout_rate;
 
-    uint32_t validated_bk_buckets;
+    uint32_t validated_bk_bits;
     uint64_t validated_bk_size;
     uint16_t validated_bk_rate;
 
-    uint32_t validated_tx_buckets;
+    uint32_t validated_tx_bits;
     uint64_t validated_tx_size;
     uint16_t validated_tx_rate;
 
     /// Optionals.
     /// -----------------------------------------------------------------------
 
-    uint32_t address_buckets;
+    uint32_t address_bits;
     uint64_t address_size;
     uint16_t address_rate;
 
-    uint32_t neutrino_buckets;
+    uint32_t neutrino_bits;
     uint64_t neutrino_size;
     uint16_t neutrino_rate;
 

src/settings.cpp

@@ -31,7 +31,7 @@ settings::settings() NOEXCEPT
 
     // Archives.
 
-    header_buckets{ 100 },
+    header_bits{ 7 },
     header_size{ 1 },
     header_rate{ 50 },
 
@@ -41,7 +41,7 @@ settings::settings() NOEXCEPT
     output_size{ 1 },
     output_rate{ 50 },
 
-    point_buckets{ 100 },
+    point_bits{ 7 },
     point_size{ 1 },
     point_rate{ 50 },
 
@@ -51,11 +51,11 @@ settings::settings() NOEXCEPT
     puts_size{ 1 },
     puts_rate{ 50 },
 
-    tx_buckets{ 100 },
+    tx_bits{ 7 },
     tx_size{ 1 },
     tx_rate{ 50 },
 
-    txs_buckets{ 100 },
+    txs_bits{ 7 },
     txs_size{ 1 },
     txs_rate{ 50 },
 
@@ -67,7 +67,7 @@ settings::settings() NOEXCEPT
     confirmed_size{ 1 },
     confirmed_rate{ 50 },
 
-    strong_tx_buckets{ 100 },
+    strong_tx_bits{ 7 },
     strong_tx_size{ 1 },
     strong_tx_rate{ 50 },
 
@@ -77,21 +77,21 @@ settings::settings() NOEXCEPT
     prevout_size{ 1 },
     prevout_rate{ 50 },
 
-    validated_bk_buckets{ 100 },
+    validated_bk_bits{ 7 },
     validated_bk_size{ 1 },
     validated_bk_rate{ 50 },
 
-    validated_tx_buckets{ 100 },
+    validated_tx_bits{ 7 },
     validated_tx_size{ 1 },
     validated_tx_rate{ 50 },
 
     // Optionals.
 
-    address_buckets{ 100 },
+    address_bits{ 7 },
     address_size{ 1 },
     address_rate{ 50 },
 
-    neutrino_buckets{ 100 },
+    neutrino_bits{ 7 },
     neutrino_size{ 1 },
     neutrino_rate{ 50 }
 

test/primitives/arraymap.cpp

@@ -105,12 +105,12 @@ BOOST_AUTO_TEST_CASE(arraymap___enabled__non_empty_slab_zero_buckets__false)
     BOOST_REQUIRE(!instance.get_fault());
 }
 
-BOOST_AUTO_TEST_CASE(arraymap___enabled__empty_slab_one_bucket__false)
+BOOST_AUTO_TEST_CASE(arraymap___enabled__empty_slab_one_bucket__true)
 {
     test::chunk_storage head_store{};
     test::chunk_storage body_store{};
     slab_table instance{ head_store, body_store, 1 };
-    BOOST_REQUIRE(!instance.enabled());
+    BOOST_REQUIRE(instance.enabled());
     BOOST_REQUIRE(!instance.get_fault());
 }