Change prevout table to slab.

Author: evoskuil

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

@@ -301,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::integrity7;
 
-        if (bip68 &&
+        if (relative &&
             input::is_locked(sequence, ctx.height, ctx.mtp, out.height, out.mtp))
             return error::relative_time_locked;
 
@@ -333,7 +333,7 @@ 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::integrity8;
@@ -347,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;
         }
 
@@ -489,7 +489,7 @@ code CLASS::set_prevouts(const header_link& link, const block& block) NOEXCEPT
     const auto scope = store_.get_transactor();
 
     // Clean single allocation failure (e.g. disk full).
-    const table::prevout::record_put_ref prevouts{ {}, spenders, block };
+    const table::prevout::slab_put_ref prevouts{ {}, spenders, block };
     return store_.prevout.put(link, prevouts) ? error::success :
         error::integrity11;
     // ========================================================================

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>();

include/bitcoin/database/tables/schema.hpp

@@ -115,6 +115,7 @@ namespace schema
     constexpr size_t puts_ = 4;     // ->puts record.
     constexpr size_t spend_ = 4;    // ->spend record.
     constexpr size_t point_ = 4;    // ->point record.
+    constexpr size_t prevout_ = 5;  // ->prevout slab.
     constexpr size_t txs_ = 5;      // ->txs slab.
     constexpr size_t tx = 4;        // ->tx record.
     constexpr size_t block = 3;     // ->header record.
@@ -318,21 +319,19 @@ namespace schema
     /// Cache tables.
     /// -----------------------------------------------------------------------
 
-    // record arraymap
+    // slab arraymap, one slab per block
     struct prevout
     {
-        // Buckets are limited to header links, but links are based on the
-        // number of spends plus conflicts. Conflicts are assumed to be zero
-        // per block and conflict count is one (tx::pk) per non-empty block.
-        static constexpr size_t pk = schema::point_;
+        static constexpr size_t pk = schema::prevout_;
         static constexpr size_t minsize =
             ////schema::bit + // merged bit into tx.
-            schema::transaction::pk;
+            one +                       // varint(conflict-count)
+            schema::transaction::pk +   // prevout_tx
+            one;                        // varint(sequence)
         static constexpr size_t minrow = minsize;
-        static constexpr size_t size = minsize;
-        ////static constexpr linkage<pk> count() NOEXCEPT { return 1; }
-        static_assert(minsize == 4u);
-        static_assert(minrow == 4u);
+        static constexpr size_t size = max_size_t;
+        static_assert(minsize == 6u);
+        static_assert(minrow == 6u);
     };
 
     // slab hashmap