coin pointer + pr35295

src/consensus/consensus.h

@@ -20,6 +20,12 @@ static const int COINBASE_MATURITY = 100;
 
 static const int WITNESS_SCALE_FACTOR = 4;
 
+/** The minimum serialized size of a CTxIn even with an empty scriptSig
+ * (32 byte txid + 4 byte vout + 1 byte scriptSig length + 4 byte sequence) */
+static constexpr uint32_t MIN_TXIN_SERIALIZED_SIZE{41};
+/** The maximum number of possible inputs included in a block */
+static constexpr uint32_t MAX_INPUTS_PER_BLOCK{(MAX_BLOCK_WEIGHT / WITNESS_SCALE_FACTOR) / MIN_TXIN_SERIALIZED_SIZE};
+
 static const size_t MIN_TRANSACTION_WEIGHT = WITNESS_SCALE_FACTOR * 60; // 60 is the lower bound for the size of a valid serialized CTransaction
 static const size_t MIN_SERIALIZABLE_TRANSACTION_WEIGHT = WITNESS_SCALE_FACTOR * 10; // 10 is the lower bound for the size of a serialized CTransaction
 

src/init.cpp

@@ -517,6 +517,7 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
     argsman.AddArg("-minimumchainwork=<hex>", strprintf("Minimum work assumed to exist on a valid chain in hex (default: %s, testnet3: %s, testnet4: %s, signet: %s)", defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnetChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnet4ChainParams->GetConsensus().nMinimumChainWork.GetHex(), signetChainParams->GetConsensus().nMinimumChainWork.GetHex()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
     argsman.AddArg("-par=<n>", strprintf("Set the number of script verification threads (0 = auto, up to %d, <0 = leave that many cores free, default: %d)",
         MAX_SCRIPTCHECK_THREADS, DEFAULT_SCRIPTCHECK_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    argsman.AddArg("-inputfetchthreads=<n>", strprintf("Set the number of input fetch threads (0 disables, up to %d, default: %d). Negative values are rejected.", MAX_INPUTFETCH_THREADS, DEFAULT_INPUTFETCH_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-persistmempool", strprintf("Whether to save the mempool on shutdown and load on restart (default: %u)", DEFAULT_PERSIST_MEMPOOL), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-persistmempoolv1",
                    strprintf("Whether a mempool.dat file created by -persistmempool or the savemempool RPC will be written in the legacy format "

src/kernel/CMakeLists.txt

@@ -61,6 +61,7 @@ add_library(bitcoinkernel
   ../uint256.cpp
   ../util/chaintype.cpp
   ../util/check.cpp
+  ../util/exception.cpp
   ../util/expected.cpp
   ../util/feefrac.cpp
   ../util/fs.cpp
@@ -70,6 +71,7 @@ add_library(bitcoinkernel
   ../util/rbf.cpp
   ../util/signalinterrupt.cpp
   ../util/syserror.cpp
+  ../util/thread.cpp
   ../util/threadnames.cpp
   ../util/time.cpp
   ../util/tokenpipe.cpp

src/kernel/chainstatemanager_opts.h

@@ -22,6 +22,7 @@ class CChainParams;
 class ValidationSignals;
 
 static constexpr auto DEFAULT_MAX_TIP_AGE{24h};
+static constexpr int32_t DEFAULT_INPUTFETCH_THREADS{4};
 
 namespace kernel {
 
@@ -46,6 +47,8 @@ struct ChainstateManagerOpts {
     ValidationSignals* signals{nullptr};
     //! Number of script check worker threads. Zero means no parallel verification.
     int worker_threads_num{0};
+    //! Number of input fetch worker threads. Zero means no parallel fetching.
+    int32_t inputfetch_threads_num{DEFAULT_INPUTFETCH_THREADS};
     size_t script_execution_cache_bytes{DEFAULT_SCRIPT_EXECUTION_CACHE_BYTES};
     size_t signature_cache_bytes{DEFAULT_SIGNATURE_CACHE_BYTES};
 };

src/node/chainstatemanager_args.cpp

@@ -60,6 +60,13 @@ util::Result<void> ApplyArgsManOptions(const ArgsManager& args, ChainstateManage
     // Subtract 1 because the main thread counts towards the par threads.
     opts.worker_threads_num = script_threads - 1;
 
+    if (auto value{args.GetIntArg("-inputfetchthreads")}) {
+        if (*value < 0) {
+            return util::Error{Untranslated(strprintf("-inputfetchthreads must be non-negative (got %d). Use 0 to disable input fetching.", *value))};
+        }
+        opts.inputfetch_threads_num = static_cast<int32_t>(std::min<int64_t>(*value, MAX_INPUTFETCH_THREADS));
+    }
+
     if (auto max_size = args.GetIntArg("-maxsigcachesize")) {
         // 1. When supplied with a max_size of 0, both the signature cache and
         //    script execution cache create the minimum possible cache (2

src/test/coins_tests.cpp

@@ -61,8 +61,8 @@ class CCoinsViewTest : public CoinsViewEmpty
         for (auto it{cursor.Begin()}; it != cursor.End(); it = cursor.NextAndMaybeErase(*it)){
             if (it->second.IsDirty()) {
                 // Same optimization used in CCoinsViewDB is to only write dirty entries.
-                map_[it->first] = it->second.coin;
-                if (it->second.coin.IsSpent() && m_rng.randrange(3) == 0) {
+                map_[it->first] = it->second.coin ? *it->second.coin : Coin{};
+                if (it->second.IsSpent() && m_rng.randrange(3) == 0) {
                     // Randomly delete empty entries on write.
                     map_.erase(it->first);
                 }
@@ -84,7 +84,7 @@ class CCoinsViewCacheTest : public CCoinsViewCache
         size_t ret = memusage::DynamicUsage(cacheCoins);
         size_t count = 0;
         for (const auto& entry : cacheCoins) {
-            ret += entry.second.coin.DynamicMemoryUsage();
+            if (entry.second.coin) ret += entry.second.coin->DynamicMemoryUsage();
             ++count;
         }
         BOOST_CHECK_EQUAL(GetCacheSize(), count);
@@ -96,6 +96,7 @@ class CCoinsViewCacheTest : public CCoinsViewCache
 
     CCoinsMap& map() const { return cacheCoins; }
     CoinsCachePair& sentinel() const { return m_sentinel; }
+    CCoinsMapMemoryResource& resource() { return m_cache_coins_memory_resource; }
     size_t& usage() const { return cachedCoinsUsage; }
     size_t& dirty() const { return m_dirty_count; }
 };
@@ -631,22 +632,46 @@ static void SetCoinsValue(const CAmount value, Coin& coin)
     }
 }
 
-static size_t InsertCoinsMapEntry(CCoinsMap& map, CoinsCachePair& sentinel, const CoinEntry& cache_coin)
+static void FreeCoin(CCoinsMapMemoryResource& resource, CCoinsCacheEntry& entry)
+{
+    if (!entry.coin) return;
+    entry.coin->~Coin();
+    resource.Deallocate(entry.coin, sizeof(Coin), alignof(Coin));
+    entry.coin = nullptr;
+}
+
+// Add an (empty) coin to a cache entry. Unlike in the production code, a cache
+// entry can point to a spent (empty) coin.
+static void AddCoin(CCoinsMapMemoryResource& resource, CCoinsCacheEntry& entry)
+{
+    if (entry.coin) FreeCoin(resource, entry);
+    assert(!entry.coin);
+    entry.coin = static_cast<Coin*>(resource.Allocate(sizeof(Coin), alignof(Coin)));
+    new (entry.coin) Coin();
+}
+
+static void FreeAllCoins(CCoinsMap& map, CCoinsMapMemoryResource& resource)
+{
+    for (auto& entry : map) if (entry.second.coin) FreeCoin(resource, entry.second);
+}
+
+static size_t InsertCoinsMapEntry(CCoinsMap& map, CoinsCachePair& sentinel, CCoinsMapMemoryResource& resource, const CoinEntry& cache_coin)
 {
     CCoinsCacheEntry entry;
-    SetCoinsValue(cache_coin.value, entry.coin);
+    AddCoin(resource, entry);
+    SetCoinsValue(cache_coin.value, *entry.coin);
     auto [iter, inserted] = map.emplace(OUTPOINT, std::move(entry));
     assert(inserted);
     if (cache_coin.IsDirty()) CCoinsCacheEntry::SetDirty(*iter, sentinel);
     if (cache_coin.IsFresh()) CCoinsCacheEntry::SetFresh(*iter, sentinel);
-    return iter->second.coin.DynamicMemoryUsage();
+    return iter->second.coin->DynamicMemoryUsage();
 }
 
 static MaybeCoin GetCoinsMapEntry(const CCoinsMap& map, const COutPoint& outp = OUTPOINT)
 {
     if (auto it{map.find(outp)}; it != map.end()) {
         return CoinEntry{
-            it->second.coin.IsSpent() ? SPENT : it->second.coin.out.nValue,
+            (!it->second.coin || it->second.coin->IsSpent()) ? SPENT : it->second.coin->out.nValue,
             CoinEntry::ToState(it->second.IsDirty(), it->second.IsFresh())};
     }
     return MISSING;
@@ -658,11 +683,17 @@ static void WriteCoinsViewEntry(CCoinsView& view, const MaybeCoin& cache_coin)
     sentinel.second.SelfRef(sentinel);
     CCoinsMapMemoryResource resource;
     CCoinsMap map{0, CCoinsMap::hasher{}, CCoinsMap::key_equal{}, &resource};
-    if (cache_coin) InsertCoinsMapEntry(map, sentinel, *cache_coin);
+    if (cache_coin) InsertCoinsMapEntry(map, sentinel, resource, *cache_coin);
     size_t dirty_count{cache_coin && cache_coin->IsDirty()};
-    auto cursor{CoinsViewCacheCursor(dirty_count, sentinel, map, /*will_erase=*/true)};
-    view.BatchWrite(cursor, {});
+    auto cursor{CoinsViewCacheCursor(dirty_count, sentinel, map, resource, /*will_clear=*/true)};
+    try {
+        view.BatchWrite(cursor, {});
+    } catch (...) {
+        FreeAllCoins(map, resource);
+        throw;
+    }
     BOOST_CHECK_EQUAL(dirty_count, 0U);
+    FreeAllCoins(map, resource);
 }
 
 class SingleEntryCacheTest
@@ -673,11 +704,16 @@ class SingleEntryCacheTest
         auto base_cache_coin{base_value == ABSENT ? MISSING : CoinEntry{base_value, CoinEntry::State::DIRTY}};
         WriteCoinsViewEntry(base, base_cache_coin);
         if (cache_coin) {
-            cache.usage() += InsertCoinsMapEntry(cache.map(), cache.sentinel(), *cache_coin);
+            cache.usage() += InsertCoinsMapEntry(cache.map(), cache.sentinel(), cache.resource(), *cache_coin);
             cache.dirty() += cache_coin->IsDirty();
         }
     }
 
+    ~SingleEntryCacheTest() noexcept
+    {
+        FreeAllCoins(cache.map(), cache.resource());
+    }
+
     CCoinsViewCacheTest base{&CoinsViewEmpty::Get()};
     CCoinsViewCacheTest cache{&base};
 };
@@ -1119,6 +1155,27 @@ BOOST_AUTO_TEST_CASE(ccoins_emplace_duplicate_keeps_usage_balanced)
     BOOST_CHECK(cache.AccessCoin(outpoint) == coin1);
 }
 
+BOOST_AUTO_TEST_CASE(ccoins_spend_moveout_keeps_usage_balanced)
+{
+    CCoinsViewCacheTest base{&CoinsViewEmpty::Get()};
+    CCoinsViewCacheTest cache{&base};
+
+    const COutPoint outpoint{Txid::FromUint256(m_rng.rand256()), m_rng.rand32()};
+    const Coin coin{CTxOut{m_rng.randrange(10), CScript{} << m_rng.randbytes(CScriptBase::STATIC_SIZE + 1)}, 1, false};
+
+    base.AddCoin(outpoint, Coin{coin}, /*possible_overwrite=*/false);
+    base.SelfTest();
+
+    BOOST_CHECK(cache.HaveCoin(outpoint));
+    cache.SelfTest();
+
+    Coin moveout;
+    BOOST_CHECK(cache.SpendCoin(outpoint, &moveout));
+    BOOST_CHECK(moveout == coin);
+    BOOST_CHECK_EQUAL(GetCoinsMapEntry(cache.map(), outpoint), SPENT_DIRTY);
+    cache.SelfTest();
+}
+
 BOOST_AUTO_TEST_CASE(ccoins_reset_guard)
 {
     CCoinsViewTest root{m_rng};