Function ComplexMemPool

src/bench/mempool_stress.cpp:123–165

}

static void ComplexMemPool(benchmark::Bench& bench)
{
    FastRandomContext det_rand{true};
    int childTxs = 50;
    if (bench.complexityN() > 1) {
        childTxs = static_cast<int>(bench.complexityN());
    }
    const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN);
    CTxMemPool& pool = *testing_setup.get()->m_node.mempool;

    std::vector<CTransactionRef> tx_remove_for_block;
    std::vector<Txid> hashes_remove_for_block;

    LOCK2(cs_main, pool.cs);

    for (int i=0; i<1000; i++) {
        std::vector<CTransactionRef> transactions = CreateCoinCluster(det_rand, childTxs, /*min_ancestors=*/1);

        // Add all transactions to the mempool.
        // Also store the first 10 transactions from each cluster as the
        // transactions we'll "mine" in the benchmark.
        int tx_count = 0;
        for (auto& tx : transactions) {
            if (tx_count < 10) {
                tx_remove_for_block.push_back(tx);
                ++tx_count;
                hashes_remove_for_block.emplace_back(tx->GetHash());
            }
            AddTx(tx, pool, det_rand);
        }
    }

    // Since the benchmark will be run repeatedly, we have to leave the mempool
    // in the same state at the end of the function, so we benchmark both
    // mining a block and reorging the block's contents back into the mempool.
    bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
        pool.removeForBlock(tx_remove_for_block, /*nBlockHeight=*/100);
        for (auto& tx: tx_remove_for_block) {
            AddTx(tx, pool, det_rand);
        }
        pool.UpdateTransactionsFromBlock(hashes_remove_for_block);
    });
}

static void MemPoolAncestorsDescendants(benchmark::Bench& bench)
{