Merge pull request #569 from evoskuil/master

Change prevout table to slab.

Author: evoskuil

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

@@ -199,7 +199,7 @@ code CLASS::unspent_duplicates(const header_link& link,
 
 // protected
 TEMPLATE
-bool CLASS::get_conflicts(point_links& points, const point& point,
+code CLASS::get_conflicts(point_links& points, const point& point,
     const point_link& self) const NOEXCEPT
 {
     // Iterate to all matching spend table keys. Since these are stubs of the
@@ -213,28 +213,28 @@ bool CLASS::get_conflicts(point_links& points, const point& point,
     // the existence of multiple spends of outputs in the same transaction.
     auto it = store_.spend.it(table::spend::compose(point));
     if (!it)
-        return false;
+        return error::integrity4;
 
     do
     {
         table::spend::record get{};
         if (!store_.spend.get(it, get))
-            return false;
+            return error::integrity5;
 
         if (get.point_fk != self)
             points.push_back(get.point_fk);
     }
     while (it.advance());
-    return true;
+    return error::success;
 }
 
 // protected
 TEMPLATE
-bool CLASS::push_doubles(tx_links& out, const point& point,
+code CLASS::push_doubles(tx_links& out, const point& point,
     const point_links& points) const NOEXCEPT
 {
     if (points.empty())
-        return true;
+        return error::success;
 
     // The expected self spend and primary conflicts are removed. This serves
     // to remove secondary conflicts, leaving only actual additional spends.
@@ -243,39 +243,44 @@ bool CLASS::push_doubles(tx_links& out, const point& point,
     {
         table::point::get_parent_key parent_tx{};
         if (!store_.point.get(ptr, link, parent_tx))
-            return false;
+            return error::integrity6;
 
         if (parent_tx.hash == point.hash())
             out.push_back(parent_tx.fk);
     }
 
-    return true;
+    return error::success;
 }
 
 // protected
 TEMPLATE
-bool CLASS::push_spenders(tx_links& out, const point& point,
+code CLASS::push_spenders(tx_links& out, const point& point,
     const point_link& self) const NOEXCEPT
 {
+    code ec{};
     point_links points{};
-    return get_conflicts(points, point, self) && 
-        push_doubles(out, point, points);
+    if ((ec = get_conflicts(points, point, self)))
+        return ec;
+
+    return push_doubles(out, point, points);
 }
 
 TEMPLATE
-bool CLASS::get_double_spenders(tx_links& out, const block& block) const NOEXCEPT
+code CLASS::get_double_spenders(tx_links& out,
+    const block& block) const NOEXCEPT
 {
     // Empty or coinbase only implies no spends.
     const auto& txs = *block.transactions_ptr();
     if (txs.size() <= one)
-        return true;
+        return error::success;
 
+    code ec{};
     for (auto tx = std::next(txs.begin()); tx != txs.end(); ++tx)
         for (const auto& in: *(*tx)->inputs_ptr())
-            if (!push_spenders(out, in->point(), in->metadata.link))
-                return false;
+            if ((ec = push_spenders(out, in->point(), in->metadata.link)))
+                return ec;
 
-    return true;
+    return error::success;
 }
 
 // unspendable
@@ -296,16 +301,16 @@ error::error_t CLASS::unspendable(uint32_t sequence, bool coinbase,
             return error::unconfirmed_spend;
     }
 
-    const auto bip68 = ctx.is_enabled(system::chain::flags::bip68_rule) &&
-        (version >= system::chain::relative_locktime_min_version);
+    const auto relative = ctx.is_enabled(system::chain::flags::bip68_rule) &&
+        transaction::is_relative_locktime_applied(coinbase, version, sequence);
 
-    if (bip68 || coinbase)
+    if (relative || coinbase)
     {
         context out{};
         if (!get_context(out, strong))
-            return error::integrity4;
+            return error::integrity7;
 
-        if (bip68 &&
+        if (relative &&
             input::is_locked(sequence, ctx.height, ctx.mtp, out.height, out.mtp))
             return error::relative_time_locked;
 
@@ -328,10 +333,10 @@ code CLASS::populate_prevouts(point_sets& sets, size_t points,
     if (sets.empty())
         return error::success;
 
-    table::prevout::record_get cache{};
+    table::prevout::slab_get cache{};
     cache.spends.resize(points);
     if (!store_.prevout.at(link, cache))
-        return error::integrity5;
+        return error::integrity8;
 
     for (const auto& spender: cache.conflicts)
         if (is_strong_tx(spender))
@@ -342,8 +347,8 @@ code CLASS::populate_prevouts(point_sets& sets, size_t points,
         for (auto& point: set.points)
         {
             const auto& pair = *it++;
-            point.tx = table::prevout::record_get::output_tx_fk(pair.first);
-            point.coinbase = table::prevout::record_get::coinbase(pair.first);
+            point.tx = table::prevout::slab_get::output_tx_fk(pair.first);
+            point.coinbase = table::prevout::slab_get::coinbase(pair.first);
             point.sequence = pair.second;
         }
 
@@ -360,7 +365,7 @@ code CLASS::block_confirmable(const header_link& link) const NOEXCEPT
 
     context ctx{};
     if (!get_context(ctx, link))
-        return error::integrity6;
+        return error::integrity9;
 
     // bip30 coinbase check.
     code ec{};
@@ -382,7 +387,7 @@ code CLASS::block_confirmable(const header_link& link) const NOEXCEPT
         point_set set{};
         table::transaction::get_set_ref get{ {}, set };
         if (!store_.tx.get(tx, get))
-            failure.store(error::integrity7);
+            failure.store(error::integrity10);
 
         points.fetch_add(set.points.size(), std::memory_order_relaxed);
         return set;
@@ -473,18 +478,20 @@ bool CLASS::set_unstrong(const header_link& link) NOEXCEPT
 }
 
 TEMPLATE
-bool CLASS::set_prevouts(const header_link& link, const block& block) NOEXCEPT
+code CLASS::set_prevouts(const header_link& link, const block& block) NOEXCEPT
 {
+    code ec{};
     tx_links spenders{};
-    if (!get_double_spenders(spenders, block))
-        return false;
+    if ((ec = get_double_spenders(spenders, block)))
+        return ec;
 
     // ========================================================================
     const auto scope = store_.get_transactor();
 
     // Clean single allocation failure (e.g. disk full).
-    const table::prevout::record_put_ref prevouts{ {}, spenders, block };
-    return store_.prevout.put(link, prevouts);
+    const table::prevout::slab_put_ref prevouts{ {}, spenders, block };
+    return store_.prevout.put(link, prevouts) ? error::success :
+        error::integrity11;
     // ========================================================================
 }
 

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

@@ -46,6 +46,8 @@ inline code CLASS::to_block_code(
         case schema::block_state::unconfirmable:
             return error::block_unconfirmable;
         // Fault: Has no state, should not happen when read from store.
+        // block_unknown also used to reset a state (debugging).
+        case schema::block_state::block_unknown:
         default:
             return error::unknown_state;
     }
@@ -68,6 +70,8 @@ inline code CLASS::to_tx_code(
         case schema::tx_state::disconnected:
             return error::tx_disconnected;
         // Fault: Has no state, should not happen when read from store.
+        // tx_unknown also used to reset a state (debugging).
+        case schema::tx_state::tx_unknown:
         default:
             return error::unknown_state;
     }
@@ -296,6 +300,40 @@ bool CLASS::set_block_unconfirmable(const header_link& link) NOEXCEPT
     // ========================================================================
 }
 
+TEMPLATE
+bool CLASS::set_block_unknown(const header_link& link) NOEXCEPT
+{
+    // ========================================================================
+    const auto scope = store_.get_transactor();
+
+    // Clean single allocation failure (e.g. disk full).
+    return store_.validated_bk.put(link, table::validated_bk::slab
+    {
+        {},
+        schema::block_state::block_unknown,
+        0 // fees
+    });
+    // ========================================================================
+}
+
+TEMPLATE
+bool CLASS::set_tx_unknown(const tx_link& link) NOEXCEPT
+{
+    // ========================================================================
+    const auto scope = store_.get_transactor();
+
+    // Clean single allocation failure (e.g. disk full).
+    return store_.validated_tx.put(link, table::validated_tx::slab
+    {
+        {},
+        {},
+        schema::tx_state::tx_unknown,
+        0, // fee
+        0  // sigops
+    });
+    // ========================================================================
+}
+
 TEMPLATE
 bool CLASS::set_tx_disconnected(const tx_link& link,
     const context& ctx) NOEXCEPT

include/bitcoin/database/query.hpp

@@ -450,6 +450,8 @@ class query
     bool set_block_valid(const header_link& link, uint64_t fees) NOEXCEPT;
     bool set_block_unconfirmable(const header_link& link) NOEXCEPT;
     bool set_block_confirmable(const header_link& link) NOEXCEPT;
+    bool set_block_unknown(const header_link& link) NOEXCEPT;
+    bool set_tx_unknown(const tx_link& link) NOEXCEPT;
     bool set_tx_disconnected(const tx_link& link, const context& ctx) NOEXCEPT;
     bool set_tx_connected(const tx_link& link, const context& ctx,
         uint64_t fee, size_t sigops) NOEXCEPT;
@@ -486,7 +488,7 @@ class query
 
     bool set_strong(const header_link& link) NOEXCEPT;
     bool set_unstrong(const header_link& link) NOEXCEPT;
-    bool set_prevouts(const header_link& link, const block& block) NOEXCEPT;
+    code set_prevouts(const header_link& link, const block& block) NOEXCEPT;
 
     /// Height indexation.
     /// -----------------------------------------------------------------------
@@ -560,13 +562,13 @@ class query
     code populate_prevouts(point_sets& sets, size_t points,
         const header_link& link) const NOEXCEPT;
 
-    bool get_conflicts(point_links& points, const point& point,
+    code get_conflicts(point_links& points, const point& point,
         const point_link& self) const NOEXCEPT;
-    bool push_doubles(tx_links& out, const point& point,
+    code push_doubles(tx_links& out, const point& point,
         const point_links& points) const NOEXCEPT;
-    bool push_spenders(tx_links& out, const point& point,
+    code push_spenders(tx_links& out, const point& point,
         const point_link& self) const NOEXCEPT;
-    bool get_double_spenders(tx_links& out, const block& block) const NOEXCEPT;
+    code get_double_spenders(tx_links& out, const block& block) const NOEXCEPT;
 
     error::error_t unspendable(uint32_t sequence, bool coinbase,
         const tx_link& prevout_tx, uint32_t version,

include/bitcoin/database/tables/caches/prevout.hpp

@@ -31,7 +31,7 @@ namespace table {
 
 /// prevout is an array map index of previous outputs by block link.
 /// The coinbase flag is merged into the tx field, reducing it's domain.
-/// Masking is from the right in order to accomodate non-integral domain.
+/// Masking is from the right in order to accomodate integral tx domain.
 struct prevout
   : public array_map<schema::prevout>
 {
@@ -44,12 +44,12 @@ struct prevout
     static_assert(tx::size == sizeof(uint32_t), "sequence-tx overload error");
 
     // This supports only a single record (not too useful).
-    struct record
+    struct slab
       : public schema::prevout
     {
         inline link count() const NOEXCEPT
         {
-            return one;
+            return tx::size;
         }
 
         inline bool coinbase() const NOEXCEPT
@@ -83,7 +83,7 @@ struct prevout
             return sink;
         }
 
-        inline bool operator==(const record& other) const NOEXCEPT
+        inline bool operator==(const slab& other) const NOEXCEPT
         {
             return coinbase() == other.coinbase()
                 && output_tx_fk() == other.output_tx_fk();
@@ -92,15 +92,16 @@ struct prevout
         tx::integer prevout_tx{};
     };
 
-    struct record_put_ref
+    struct slab_put_ref
       : public schema::prevout
     {
         inline link count() const NOEXCEPT
         {
             // TODO: assert overflow.
             using namespace system;
-            return add1(possible_narrow_cast<tx::integer>(conflicts.size())) +
-                two * possible_narrow_cast<tx::integer>(block.spends());
+            const auto conflicts_ = conflicts.size();
+            return variable_size(conflicts_) + (conflicts_ * tx::size) +
+                (block.spends() * (tx::size + sizeof(uint32_t)));
         }
 
         static constexpr tx::integer merge(bool coinbase,
@@ -140,7 +141,7 @@ struct prevout
             BC_ASSERT_MSG(txs.size() > one, "empty block");
 
             // Count is written as a tx link so the table can remain an array.
-            sink.write_little_endian<tx::integer, tx::size>(number);
+            sink.write_variable(number);
             std::for_each(cons.begin(), cons.end(), write_con);
             std::for_each(std::next(txs.begin()), txs.end(), write_tx);
 
@@ -152,21 +153,22 @@ struct prevout
         const system::chain::block& block{};
     };
 
-    struct record_get
+    struct slab_get
       : public schema::prevout
     {
         inline link count() const NOEXCEPT
         {
             // TODO: assert overflow.
             using namespace system;
-            return possible_narrow_cast<tx::integer>(add1(conflicts.size())) +
-                two * possible_narrow_cast<tx::integer>(spends.size());
+            const auto conflicts_ = conflicts.size();
+            return variable_size(conflicts_) + (conflicts_ * tx::size) +
+                (spends.size() * (tx::size + sizeof(uint32_t)));
         }
 
         inline bool from_data(reader& source) NOEXCEPT
         {
             auto& cons = conflicts;
-            cons.resize(source.read_little_endian<tx::integer, tx::size>());
+            cons.resize(source.read_variable());
             std::for_each(cons.begin(), cons.end(), [&](auto& value) NOEXCEPT
             {
                 value = source.read_little_endian<tx::integer, tx::size>();