Merge pull request #581 from evoskuil/master

Add overrides to hashmap, write key in unlinked tx.set, contiguous txs.

Author: evoskuil

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

@@ -143,16 +143,28 @@ inline Link CLASS::top(const Link& link) const NOEXCEPT
     return head_.top(link);
 }
 
+TEMPLATE
+inline bool CLASS::exists(const memory_ptr& ptr, const Key& key) const NOEXCEPT
+{
+    return !first(ptr, key).is_terminal();
+}
+
 TEMPLATE
 inline bool CLASS::exists(const Key& key) const NOEXCEPT
 {
     return !first(key).is_terminal();
 }
 
+TEMPLATE
+inline Link CLASS::first(const memory_ptr& ptr, const Key& key) const NOEXCEPT
+{
+    return first(ptr, head_.top(key), key);
+}
+
 TEMPLATE
 inline Link CLASS::first(const Key& key) const NOEXCEPT
 {
-    return first(get_memory(), head_.top(key), key);
+    return first(get_memory(), key);
 }
 
 TEMPLATE
@@ -250,14 +262,32 @@ inline bool CLASS::get(const iterator& it, const Link& link,
 
 TEMPLATE
 template <typename Element, if_equal<Element::size, Size>>
-bool CLASS::set(const Link& link, const Element& element) NOEXCEPT
+bool CLASS::set(const memory_ptr& ptr, const Link& link, const Key& key,
+    const Element& element) NOEXCEPT
 {
     using namespace system;
-    const auto ptr = body_.get(link);
     if (!ptr)
         return false;
 
-    iostream stream{ *ptr };
+    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;
+
+    // Stream starts at record and the index is skipped for reader convenience.
+    const auto offset = ptr->offset(start);
+    if (is_null(offset))
+        return false;
+
+    // Set element search key.
+    unsafe_array_cast<uint8_t, key_size>(std::next(offset,
+        Link::size)) = key;
+
+    iostream stream{ offset, size - position };
     finalizer sink{ stream };
     sink.skip_bytes(index_size);
 
@@ -267,21 +297,30 @@ bool CLASS::set(const Link& link, const Element& element) NOEXCEPT
 
 TEMPLATE
 template <typename Element, if_equal<Element::size, Size>>
-inline Link CLASS::set_link(const Element& element) NOEXCEPT
+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>>
+inline Link CLASS::set_link(const Key& key, const Element& element) NOEXCEPT
 {
     Link link{};
-    if (!set_link(link, element))
+    if (!set_link(link, key, element))
         return {};
 
     return link;
 }
 
 TEMPLATE
 template <typename Element, if_equal<Element::size, Size>>
-inline bool CLASS::set_link(Link& link, const Element& element) NOEXCEPT
+inline bool CLASS::set_link(Link& link, const Key& key,
+    const Element& element) NOEXCEPT
 {
     link = allocate(element.count());
-    return set(link, element);
+    return set(link, key, element);
 }
 
 TEMPLATE
@@ -329,22 +368,33 @@ inline bool CLASS::put(const memory_ptr& ptr, const Link& link, const Key& key,
 }
 
 TEMPLATE
-bool CLASS::commit(const Link& link, const Key& key) NOEXCEPT
+bool CLASS::commit(const memory_ptr& ptr, const Link& link,
+    const Key& key) NOEXCEPT
 {
     using namespace system;
-    const auto ptr = body_.get(link);
     if (!ptr)
         return false;
 
-    // Set element search key.
-    unsafe_array_cast<uint8_t, key_size>(std::next(ptr->begin(),
-        Link::size)) = key;
+    // get element offset (fault)
+    const auto offset = ptr->offset(body::link_to_position(link));
+    if (is_null(offset))
+        return false;
+
+    //// Set element search key.
+    //unsafe_array_cast<uint8_t, key_size>(std::next(offset,
+    //    Link::size)) = key;
 
     // Commit element to search index (terminal is a valid bucket index).
-    auto& next = unsafe_array_cast<uint8_t, Link::size>(ptr->begin());
+    auto& next = unsafe_array_cast<uint8_t, Link::size>(offset);
     return head_.push(link, next, head_.index(key));
 }
 
+TEMPLATE
+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
 {

include/bitcoin/database/impl/query/archive_read.ipp

@@ -96,7 +96,7 @@ size_t CLASS::get_tx_count(const header_link& link) const NOEXCEPT
     if (!store_.txs.find(link, txs))
         return {};
 
-    return txs.quantity;
+    return txs.number;
 }
 
 TEMPLATE

include/bitcoin/database/impl/query/archive_write.ipp

@@ -77,12 +77,18 @@ bool CLASS::set(const block& block, bool strong) NOEXCEPT
 TEMPLATE
 code CLASS::set_code(const transaction& tx) NOEXCEPT
 {
-    tx_link unused{};
-    return set_code(unused, tx);
+    constexpr auto txs = system::possible_narrow_cast<tx_link::integer>(one);
+
+    // Allocate tx record.
+    const auto tx_fk = store_.tx.allocate(txs);
+    if (tx_fk.is_terminal())
+        return error::tx_tx_allocate;
+
+    return set_code(tx_fk, tx);
 }
 
 TEMPLATE
-code CLASS::set_code(tx_link& tx_fk, const transaction& tx) NOEXCEPT
+code CLASS::set_code(const tx_link& tx_fk, const transaction& tx) NOEXCEPT
 {
     // This is the only multitable write query (except initialize/genesis).
     using namespace system;
@@ -92,19 +98,13 @@ code CLASS::set_code(tx_link& tx_fk, const transaction& tx) NOEXCEPT
     using ix = linkage<schema::index>;
     const auto& ins = tx.inputs_ptr();
     const auto& ous = tx.outputs_ptr();
-    const auto txs = possible_narrow_cast<tx_link::integer>(one);
     const auto inputs = possible_narrow_cast<ix::integer>(ins->size());
     const auto outputs = possible_narrow_cast<ix::integer>(ous->size());
 
 
     // ========================================================================
     const auto scope = store_.get_transactor();
 
-    // Allocate tx record.
-    tx_fk = store_.tx.allocate(txs);
-    if (tx_fk.is_terminal())
-        return error::tx_tx_allocate;
-
     // Allocate contiguously and store inputs.
     input_link in_fk{};
     if (!store_.input.put_link(in_fk, table::input::put_ref{ {}, tx }))
@@ -127,7 +127,7 @@ code CLASS::set_code(tx_link& tx_fk, const transaction& tx) NOEXCEPT
 
     // Create tx record.
     // Commit is deferred for point/address index consistency.
-    if (!store_.tx.set(tx_fk, table::transaction::record_put_ref
+    if (!store_.tx.set(tx_fk, tx.get_hash(false), table::transaction::put_ref
     {
         {},
         tx,
@@ -232,7 +232,7 @@ code CLASS::set_code(header_link& out_fk, const header& header,
     const auto scope = store_.get_transactor();
 
     // Clean single allocation failure (e.g. disk full).
-    out_fk = store_.header.put_link(key, table::header::record_put_ref
+    out_fk = store_.header.put_link(key, table::header::put_ref
     {
         {},
         ctx,
@@ -321,46 +321,48 @@ TEMPLATE
 code CLASS::set_code(txs_link& out_fk, const block& block,
     const header_link& key, bool strong) NOEXCEPT
 {
+    using namespace system;
     if (key.is_terminal())
         return error::txs_header;
 
-    const auto count = block.transactions();
-    if (is_zero(count))
+    const auto txs = block.transactions();
+    if (is_zero(txs))
         return error::txs_empty;
 
+    const auto count = possible_narrow_cast<tx_link::integer>(txs);
+    const auto tx_fks = store_.tx.allocate(count);
+    if (tx_fks.is_terminal())
+        return error::tx_tx_allocate;
+
     code ec{};
-    tx_link tx_fk{};
-    tx_links links{};
-    links.reserve(count);
+    auto fk = tx_fks;
+
+    // Each tx is set under a distinct transactor.
     for (const auto& tx: *block.transactions_ptr())
-    {
-        // Each tx is set under a distinct transactor.
-        if ((ec = set_code(tx_fk, *tx)))
+        if ((ec = set_code(fk++, *tx)))
             return ec;
 
-        links.push_back(tx_fk.value);
-    }
-
     using bytes = linkage<schema::size>::integer;
     const auto size = block.serialized_size(true);
-    const auto wire = system::possible_narrow_cast<bytes>(size);
+    const auto wire = possible_narrow_cast<bytes>(size);
 
     // ========================================================================
     const auto scope = store_.get_transactor();
     constexpr auto positive = true;
 
     // Clean allocation failure (e.g. disk full), see set_strong() comments.
     // Transactor assures cannot be restored without txs, as required to unset.
-    if (strong && !set_strong(key, links, positive))
+    if (strong && !set_strong(key, txs, tx_fks, positive))
         return error::txs_confirm;
 
     // Header link is the key for the txs table.
     // Clean single allocation failure (e.g. disk full).
-    out_fk = store_.txs.put_link(key, table::txs::slab
+    out_fk = store_.txs.put_link(key, table::txs::put_group
     {
         {},
         wire,
-        links
+        count,
+        tx_fks
     });
 
     return out_fk.is_terminal() ? error::txs_txs_put : error::success;

include/bitcoin/database/impl/query/consensus.ipp

@@ -411,7 +411,6 @@ code CLASS::block_confirmable(const header_link& link) const NOEXCEPT
 // ----------------------------------------------------------------------------
 
 // protected
-// This is also invoked from block.txs archival (when checkpoint/milestone).
 TEMPLATE
 bool CLASS::set_strong(const header_link& link, const tx_links& txs,
     bool positive) NOEXCEPT
@@ -436,6 +435,34 @@ bool CLASS::set_strong(const header_link& link, const tx_links& txs,
     return true;
 }
 
+// protected
+// This is invoked from block.txs archival (when checkpoint/milestone).
+TEMPLATE
+bool CLASS::set_strong(const header_link& link, size_t count,
+    const tx_link& first_fk, bool positive) NOEXCEPT
+{
+    using namespace system;
+    using link_t = table::strong_tx::link;
+    using element_t = table::strong_tx::record;
+
+    // Preallocate all strong_tx records for the block and reuse memory ptr.
+    const auto records = possible_narrow_cast<link_t::integer>(count);
+    auto record = store_.strong_tx.allocate(records);
+    const auto ptr = store_.strong_tx.get_memory();
+    const auto end = first_fk + count;
+
+    // Contiguous tx links.
+    for (auto fk = first_fk; fk < end; ++fk)
+        if (!store_.strong_tx.put(ptr, record++, fk, element_t
+            {
+                {},
+                link,
+                positive
+            })) return false;
+
+    return true;
+}
+
 TEMPLATE
 bool CLASS::set_strong(const header_link& link) NOEXCEPT
 {

include/bitcoin/database/primitives/hashmap.hpp

@@ -96,9 +96,11 @@ class hashmap
     inline Link top(const Link& list) const NOEXCEPT;
 
     /// True if an instance of object with key exists.
+    inline bool exists(const memory_ptr& ptr, const Key& key) const NOEXCEPT;
     inline bool exists(const Key& key) const NOEXCEPT;
 
     /// Return first element link or terminal if not found/error.
+    inline Link first(const memory_ptr& ptr, const Key& key) const NOEXCEPT;
     inline Link first(const Key& key) const NOEXCEPT;
 
     /// Iterator holds shared lock on storage remap.
@@ -143,13 +145,19 @@ class hashmap
 
     /// Set element into previously allocated link (follow with commit).
     template <typename Element, if_equal<Element::size, Size> = true>
-    bool set(const Link& link, const Element& element) NOEXCEPT;
+    bool set(const memory_ptr& ptr, const Link& link, const Key& key,
+        const Element& element) NOEXCEPT;
+
+    /// Set element into previously allocated link (follow with commit).
+    template <typename Element, if_equal<Element::size, Size> = true>
+    bool set(const Link& link, const Key& key, const Element& element) NOEXCEPT;
 
     /// Allocate and set element, and return link (follow with commit).
     template <typename Element, if_equal<Element::size, Size> = true>
-    inline Link set_link(const Element& element) NOEXCEPT;
+    inline Link set_link(const Key& key, const Element& element) NOEXCEPT;
     template <typename Element, if_equal<Element::size, Size> = true>
-    inline bool set_link(Link& link, const Element& element) NOEXCEPT;
+    inline bool set_link(Link& link, const Key& key,
+        const Element& element) NOEXCEPT;
 
     /// Allocate, set, commit element to key, and return link.
     template <typename Element, if_equal<Element::size, Size> = true>
@@ -173,6 +181,7 @@ class hashmap
         const Element& element) NOEXCEPT;
 
     /// Commit previously set element at link to key.
+    bool commit(const memory_ptr& ptr, const Link& link, const Key& key) NOEXCEPT;
     bool commit(const Link& link, const Key& key) NOEXCEPT;
     inline Link commit_link(const Link& link, const Key& key) NOEXCEPT;
 

include/bitcoin/database/query.hpp

@@ -374,7 +374,6 @@ class query
 
     /// Set transaction.
     code set_code(const transaction& tx) NOEXCEPT;
-    code set_code(tx_link& tx_fk, const transaction& tx) NOEXCEPT;
 
     /// Set header (headers-first).
     code set_code(const header& header, const context& ctx,
@@ -563,6 +562,8 @@ class query
         const tx_link& prevout_tx, uint32_t version,
         const context& ctx) const NOEXCEPT;
 
+    bool set_strong(const header_link& link, size_t count,
+        const tx_link& first_fk, bool positive) NOEXCEPT;
     bool set_strong(const header_link& link, const tx_links& txs,
         bool positive) NOEXCEPT;
 
@@ -601,6 +602,10 @@ class query
         const system::settings& settings, const header& header,
         const header_link& link, size_t height) const NOEXCEPT;
 
+    /// tx_fk must be allocated.
+    /// -----------------------------------------------------------------------
+    code set_code(const tx_link& tx_fk, const transaction& tx) NOEXCEPT;
+
 private:
     struct maybe_strong
     {

include/bitcoin/database/tables/archives/header.hpp

@@ -116,7 +116,7 @@ struct header
     ////};
 
     // This is redundant with record_put_ptr except this does not capture.
-    struct record_put_ref
+    struct put_ref
       : public schema::header
     {
         // header.previous_block_hash() ignored.