mirror of
https://github.com/dashpay/dash.git
synced 2024-12-28 21:42:47 +01:00
0d1c8f914c
29e983386b0aecf99cdb7d0e08ba6b450bed313e Fixes Bug in Transaction generation in ComplexMempool benchmark (Shorya) Pull request description: This fixes issues with `ComplexMempool` benchmark introduced in [#17292](https://github.com/bitcoin/bitcoin/pull/17292) , this stress test benchmarks performance of ancestor and descendant tracking of mempool graph algorithms on a complex Mempool. This Benchmark first creates 100 base transactions and stores them in `available_coins` vector. `available_coins` is used for selecting ancestor transactions while creating 800 new transactions. For this a random transaction is picked from `available_coins` and some of its outputs are mapped to the inputs of the new transaction being created. Now in case we exhaust all the outputs of an entry in `available_coins` then we need to remove it from `available_coins` before the next iteration of choosing a potential ancestor , it is now implemented with this patch. As the index of the entry is randomly chosen from `available_coins` , In order to remove it from the vector , if index of the selected entry is not at the end of `available_coins` vector , it is swapped with the entry at the back of the vector , then the entry at the end of `available_coins` is popped out. Earlier the code responsible for constructing outputs of the newly created transaction was inside the loop used for assigning ancestors to the transaction , which does some unnecessary work as it creates outputs of the transaction again and again , now it is moved out of the loop so outputs of the transaction are created just once before adding it to the final list of the transactions created. This one is a minor change to save some computation. These changes have changed the `ComplexMempool` benchmark results on `bitcoin:master` as follows : **Before** > | ns/op | op/s | err% | total | benchmark |--------------------:|--------------------:|--------:|----------:|:---------- | 232,881,625.00 | 4.29 | 0.7% | 2.55 | `ComplexMemPool` **After** > | ns/op | op/s | err% | total | benchmark |--------------------:|--------------------:|--------:|----------:|:---------- | 497,275,135.00 | 2.01 | 0.5% | 5.49 | `ComplexMemPool` Top commit has no ACKs. Tree-SHA512: d6946d7e65c55f54c84cc49d7abee52e59ffc8b7668b3c80b4ce15a57690ab00a600c6241cc71a2a075def9c30792a311256fed325ef162f37aeacd2cce93624
99 lines
3.7 KiB
C++
99 lines
3.7 KiB
C++
// Copyright (c) 2011-2019 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <bench/bench.h>
|
|
#include <policy/policy.h>
|
|
#include <txmempool.h>
|
|
|
|
#include <vector>
|
|
|
|
static void AddTx(const CTransactionRef& tx, CTxMemPool& pool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
|
|
{
|
|
int64_t nTime = 0;
|
|
unsigned int nHeight = 1;
|
|
bool spendsCoinbase = false;
|
|
unsigned int sigOpCost = 4;
|
|
LockPoints lp;
|
|
pool.addUnchecked(CTxMemPoolEntry(tx, 1000, nTime, nHeight, spendsCoinbase, sigOpCost, lp));
|
|
}
|
|
|
|
struct Available {
|
|
CTransactionRef ref;
|
|
size_t vin_left{0};
|
|
size_t tx_count;
|
|
Available(CTransactionRef& ref, size_t tx_count) : ref(ref), tx_count(tx_count){}
|
|
Available& operator=(Available other) {
|
|
ref = other.ref;
|
|
vin_left = other.vin_left;
|
|
tx_count = other.tx_count;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
static void ComplexMemPool(benchmark::Bench& bench)
|
|
{
|
|
int childTxs = 800;
|
|
if (bench.complexityN() > 1) {
|
|
childTxs = static_cast<int>(bench.complexityN());
|
|
}
|
|
|
|
FastRandomContext det_rand{true};
|
|
std::vector<Available> available_coins;
|
|
std::vector<CTransactionRef> ordered_coins;
|
|
// Create some base transactions
|
|
size_t tx_counter = 1;
|
|
for (auto x = 0; x < 100; ++x) {
|
|
CMutableTransaction tx = CMutableTransaction();
|
|
tx.vin.resize(1);
|
|
tx.vin[0].scriptSig = CScript() << CScriptNum(tx_counter);
|
|
tx.vout.resize(det_rand.randrange(10)+2);
|
|
for (auto& out : tx.vout) {
|
|
out.scriptPubKey = CScript() << CScriptNum(tx_counter) << OP_EQUAL;
|
|
out.nValue = 10 * COIN;
|
|
}
|
|
ordered_coins.emplace_back(MakeTransactionRef(tx));
|
|
available_coins.emplace_back(ordered_coins.back(), tx_counter++);
|
|
}
|
|
for (auto x = 0; x < childTxs && !available_coins.empty(); ++x) {
|
|
CMutableTransaction tx = CMutableTransaction();
|
|
size_t n_ancestors = det_rand.randrange(10)+1;
|
|
for (size_t ancestor = 0; ancestor < n_ancestors && !available_coins.empty(); ++ancestor){
|
|
size_t idx = det_rand.randrange(available_coins.size());
|
|
Available& coin = available_coins[idx];
|
|
uint256 hash = coin.ref->GetHash();
|
|
// biased towards taking just one ancestor, but maybe more
|
|
size_t n_to_take = det_rand.randrange(2) == 0 ? 1 : 1+det_rand.randrange(coin.ref->vout.size() - coin.vin_left);
|
|
for (size_t i = 0; i < n_to_take; ++i) {
|
|
tx.vin.emplace_back();
|
|
tx.vin.back().prevout = COutPoint(hash, coin.vin_left++);
|
|
tx.vin.back().scriptSig = CScript() << coin.tx_count;
|
|
}
|
|
if (coin.vin_left == coin.ref->vout.size()) {
|
|
if(available_coins.size()-1!=idx){ // if idx is not the last index swap it with the end index
|
|
std::swap(available_coins[idx], available_coins.back());
|
|
}
|
|
available_coins.pop_back();
|
|
}
|
|
}
|
|
tx.vout.resize(det_rand.randrange(10)+2);
|
|
for (auto& out : tx.vout) {
|
|
out.scriptPubKey = CScript() << CScriptNum(tx_counter) << OP_EQUAL;
|
|
out.nValue = 10 * COIN;
|
|
}
|
|
ordered_coins.emplace_back(MakeTransactionRef(tx));
|
|
available_coins.emplace_back(ordered_coins.back(), tx_counter++);
|
|
}
|
|
CTxMemPool pool;
|
|
LOCK2(cs_main, pool.cs);
|
|
bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
|
|
for (auto& tx : ordered_coins) {
|
|
AddTx(tx, pool);
|
|
}
|
|
pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
|
|
pool.TrimToSize(GetVirtualTransactionSize(*ordered_coins.front()));
|
|
});
|
|
}
|
|
|
|
BENCHMARK(ComplexMemPool);
|