DragonX/dragonx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

feat: fee-ordered mempool eviction (TrimToSize/Expire) + displacement on admission

Browse Source 
This fork never ported Bitcoin's mempool size-limiting: CTxMemPool had no TrimToSize/
Expire and LimitMempoolSize was commented out. An earlier commit added a blunt
DynamicMemoryUsage admission cap that bounded memory but bluntly REJECTED new txs when
full -- so a high-fee tx could not push out a low-fee one. This implements proper
fee-ordered eviction using the per-tx feerate index that already exists (mapTx index 1,
CompareTxMemPoolEntryByFee), with no new index and no descendant-tracking port.

- CTxMemPool::TrimToSize(sizelimit, pvNoSpendsRemaining): while DynamicMemoryUsage() is
  over the limit, evict the lowest-feerate tx (the tail of the feerate index) and its
  in-mempool descendants (recursive remove), re-deriving the tail each iteration.
  Terminates (pool strictly shrinks) and cleans every secondary index via remove().
- CTxMemPool::Expire(time): age-based sweep (entry time older than `time`), for
  LimitMempoolSize's -mempoolexpiry.
- LimitMempoolSize re-enabled (Expire + TrimToSize) and called from ConnectTip on every
  block connect. (No pcoinsTip->Uncache -- CCoinsViewCache has none in this fork; it is
  only a UTXO-cache perf hint.)
- AcceptToMemoryPool now ADDS the tx then TrimToSizes: a higher-fee tx displaces
  lower-fee ones; if this tx was itself the lowest-feerate (evicted), it is rejected
  ("mempool full"). Replaces the blunt reject-when-full cap.
- DEFAULT_MEMPOOL_EXPIRY 1 -> 72 hours (age-Expire is now live; 1h was too aggressive).

Known simplification (documented in code): per-tx feerate, not descendant-aggregate
(CPFP) scoring, and no rollingMinimumFeeRate anti-thrash. Adversarially reviewed
(termination, iterator safety, recursive-lock safety, index cleanup all confirmed) and
runtime-tested on the fleet: pool stays bounded under a 1600-tx flood, verifychain ok,
no hang/crash.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
DanS
2026-07-09 09:01:06 +02:00
parent 1ec3dbfee3
commit adf2bacdbd
4 changed files with 64 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
src/main.cpp
View File

@@ -414,14 +414,14 @@ namespace {
void LimitMempoolSize(CTxMemPool& pool, size_t limit, unsigned long age)
{
/* int expired = pool.Expire(GetTime() - age);
if (expired != 0)
LogPrint("mempool", "Expired %i transactions from the memory pool\n", expired);
int expired = pool.Expire(GetTime() - age);
if (expired != 0)
LogPrint("mempool", "Expired %i transactions from the memory pool\n", expired);
std::vector<uint256> vNoSpendsRemaining;
pool.TrimToSize(limit, &vNoSpendsRemaining);
BOOST_FOREACH(const uint256& removed, vNoSpendsRemaining)
pcoinsTip->Uncache(removed);*/
// Fee-order trim to the size limit. (Upstream also pcoinsTip->Uncache()s the coins freed
// by eviction, but CCoinsViewCache has no Uncache() in this fork -- it is only a UTXO-cache
// perf hint, not eviction correctness, so it is skipped.)
pool.TrimToSize(limit);
}
// Requires cs_main.
@@ -2072,12 +2072,6 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
{
LOCK(pool.cs);
// Bound mempool memory: this fork never ported fee-ordered TrimToSize eviction, so
// instead of evicting we refuse new admissions once the pool exceeds -maxmempool.
// removeExpired() already clears unmineable expired txs on each block connect; this
// caps the total footprint against a flood of otherwise-minable/low-fee txs (OOM DoS).
if ( pool.DynamicMemoryUsage() > (size_t)GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000 )
return state.DoS(0, error("AcceptToMemoryPool: mempool full, rejecting tx %s", hash.ToString()), REJECT_INSUFFICIENTFEE, "mempool-full");
// Store transaction in memory
pool.addUnchecked(hash, entry, !IsInitialBlockDownload());
@@ -2090,6 +2084,17 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
if (fSpentIndex) {
pool.addSpentIndex(entry, view);
}
// Bound mempool memory with fee-ordered eviction. Now that the tx is in, if the pool
// exceeds -maxmempool, TrimToSize drops the lowest-feerate txs -- so a higher-fee tx
// DISPLACES lower-fee ones instead of being bluntly rejected. If this very tx was the one
// evicted (its feerate was the lowest in the pool), it does not belong here -- reject it.
size_t maxmempool = (size_t)GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
if ( pool.DynamicMemoryUsage() > maxmempool ) {
pool.TrimToSize(maxmempool);
if ( !pool.exists(hash) )
return state.DoS(0, error("AcceptToMemoryPool: mempool full, tx %s evicted (feerate too low)", hash.ToString()), REJECT_INSUFFICIENTFEE, "mempool-full");
}
}
}
return true;
@@ -4070,6 +4075,10 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
uiInterface.NotifyTxExpiration(id);
}
// Bound mempool memory on each block: age-expire (-mempoolexpiry) then fee-order trim to
// -maxmempool, evicting the lowest-feerate txs (+ descendants) and uncaching their coins.
LimitMempoolSize(mempool, GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60);
// Update chainActive & related variables.
UpdateTip(pindexNew);

2
src/main.h
View File

@@ -65,7 +65,7 @@ class CValidationState;
class PrecomputedTransactionData;
struct CNodeStateStats;
#define DEFAULT_MEMPOOL_EXPIRY 1
#define DEFAULT_MEMPOOL_EXPIRY 72 // hours; age-based Expire is now live via LimitMempoolSize -- was 1, too aggressive
/** Default for -maxmempool, maximum megabytes of mempool memory usage */
#define DEFAULT_MAX_MEMPOOL_SIZE 300
#define _COINBASE_MATURITY 100

39
src/txmempool.cpp
View File

@@ -491,6 +491,45 @@ std::vector<uint256> CTxMemPool::removeExpired(unsigned int nBlockHeight)
return ids;
}
// Age-based eviction: remove txs whose entry time is older than `time`. Distinct from
// removeExpired() (which drops txs past their consensus nExpiryHeight); this is the wall-clock
// sweep LimitMempoolSize wants. Collect-then-remove to avoid iterating mapTx while mutating it.
int CTxMemPool::Expire(int64_t time)
{
LOCK(cs);
std::list<CTransaction> toRemove;
for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
if (it->GetTime() < time)
toRemove.push_back(it->GetTx());
}
for (const CTransaction& tx : toRemove) {
std::list<CTransaction> removed;
remove(tx, removed, true);
}
return (int)toRemove.size();
}
// Fee-ordered eviction: drop the lowest-feerate txs (and their in-mempool descendants, via the
// recursive remove) until DynamicMemoryUsage() is at or below sizelimit. Uses the per-tx feerate
// index (mapTx index 1, sorted feerate DESCENDING, so the worst tx is the tail). NOTE: this is a
// per-tx feerate, not a descendant-aggregate score, so a low-fee parent funded by a high-fee child
// (CPFP) can be evicted -- an accepted simplification (no descendant tracking in this fork). The
// admission cap in AcceptToMemoryPool bounds growth between block connects (no rollingMinFee here).
void CTxMemPool::TrimToSize(size_t sizelimit, std::vector<uint256>* pvNoSpendsRemaining)
{
LOCK(cs);
while (DynamicMemoryUsage() > sizelimit && !mapTx.empty()) {
// Re-derive the tail each iteration: remove() invalidates iterators.
CTransaction tx = std::prev(mapTx.get<1>().end())->GetTx();
std::list<CTransaction> removed;
remove(tx, removed, true);
if (pvNoSpendsRemaining) {
for (const CTransaction& r : removed)
pvNoSpendsRemaining->push_back(r.GetHash());
}
}
}
// Called when a block is connected. Removes from mempool and updates the miner fee estimator.
void CTxMemPool::removeForBlock(const std::vector<CTransaction>& vtx, unsigned int nBlockHeight,
std::list<CTransaction>& conflicts, bool fCurrentEstimate)

2
src/txmempool.h
View File

@@ -219,6 +219,8 @@ public:
void removeForReorg(const CCoinsViewCache *pcoins, unsigned int nMemPoolHeight, int flags);
void removeConflicts(const CTransaction &tx, std::list<CTransaction>& removed);
std::vector<uint256> removeExpired(unsigned int nBlockHeight);
int Expire(int64_t time);
void TrimToSize(size_t sizelimit, std::vector<uint256>* pvNoSpendsRemaining = NULL);
void removeForBlock(const std::vector<CTransaction>& vtx, unsigned int nBlockHeight,
std::list<CTransaction>& conflicts, bool fCurrentEstimate = true);
void removeWithoutBranchId(uint32_t nMemPoolBranchId);