1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
// Copyright (c) 2023 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 <boost/test/unit_test.hpp>
#include <core_memusage.h>
#include <kernel/disconnected_transactions.h>
#include <test/util/setup_common.h>
BOOST_FIXTURE_TEST_SUITE(disconnected_transactions, TestChain100Setup)
//! Tests that DisconnectedBlockTransactions limits its own memory properly
BOOST_AUTO_TEST_CASE(disconnectpool_memory_limits)
{
// Use the coinbase transactions from TestChain100Setup. It doesn't matter whether these
// transactions would realistically be in a block together, they just need distinct txids and
// uniform size for this test to work.
std::vector<CTransactionRef> block_vtx(m_coinbase_txns);
BOOST_CHECK_EQUAL(block_vtx.size(), 100);
// Roughly estimate sizes to sanity check that DisconnectedBlockTransactions::DynamicMemoryUsage
// is within an expected range.
// Overhead for the hashmap depends on number of buckets
std::unordered_map<uint256, CTransaction*, SaltedTxidHasher> temp_map;
temp_map.reserve(1);
const size_t MAP_1{memusage::DynamicUsage(temp_map)};
temp_map.reserve(100);
const size_t MAP_100{memusage::DynamicUsage(temp_map)};
const size_t TX_USAGE{RecursiveDynamicUsage(block_vtx.front())};
for (const auto& tx : block_vtx)
BOOST_CHECK_EQUAL(RecursiveDynamicUsage(tx), TX_USAGE);
// Our overall formula is unordered map overhead + usage per entry.
// Implementations may vary, but we're trying to guess the usage of data structures.
const size_t ENTRY_USAGE_ESTIMATE{
TX_USAGE
// list entry: 2 pointers (next pointer and prev pointer) + element itself
+ memusage::MallocUsage((2 * sizeof(void*)) + sizeof(decltype(block_vtx)::value_type))
// unordered map: 1 pointer for the hashtable + key and value
+ memusage::MallocUsage(sizeof(void*) + sizeof(decltype(temp_map)::key_type)
+ sizeof(decltype(temp_map)::value_type))};
// DisconnectedBlockTransactions that's just big enough for 1 transaction.
{
DisconnectedBlockTransactions disconnectpool{MAP_1 + ENTRY_USAGE_ESTIMATE};
// Add just 2 (and not all 100) transactions to keep the unordered map's hashtable overhead
// to a minimum and avoid all (instead of all but 1) transactions getting evicted.
std::vector<CTransactionRef> two_txns({block_vtx.at(0), block_vtx.at(1)});
auto evicted_txns{disconnectpool.AddTransactionsFromBlock(two_txns)};
BOOST_CHECK(disconnectpool.DynamicMemoryUsage() <= MAP_1 + ENTRY_USAGE_ESTIMATE);
// Only 1 transaction can be kept
BOOST_CHECK_EQUAL(1, evicted_txns.size());
// Transactions are added from back to front and eviction is FIFO.
BOOST_CHECK_EQUAL(block_vtx.at(1), evicted_txns.front());
disconnectpool.clear();
}
// DisconnectedBlockTransactions with a comfortable maximum memory usage so that nothing is evicted.
// Record usage so we can check size limiting in the next test.
size_t usage_full{0};
{
const size_t USAGE_100_OVERESTIMATE{MAP_100 + ENTRY_USAGE_ESTIMATE * 100};
DisconnectedBlockTransactions disconnectpool{USAGE_100_OVERESTIMATE};
auto evicted_txns{disconnectpool.AddTransactionsFromBlock(block_vtx)};
BOOST_CHECK_EQUAL(evicted_txns.size(), 0);
BOOST_CHECK(disconnectpool.DynamicMemoryUsage() <= USAGE_100_OVERESTIMATE);
usage_full = disconnectpool.DynamicMemoryUsage();
disconnectpool.clear();
}
// DisconnectedBlockTransactions that's just a little too small for all of the transactions.
{
const size_t MAX_MEMUSAGE_99{usage_full - sizeof(void*)};
DisconnectedBlockTransactions disconnectpool{MAX_MEMUSAGE_99};
auto evicted_txns{disconnectpool.AddTransactionsFromBlock(block_vtx)};
BOOST_CHECK(disconnectpool.DynamicMemoryUsage() <= MAX_MEMUSAGE_99);
// Only 1 transaction needed to be evicted
BOOST_CHECK_EQUAL(1, evicted_txns.size());
// Transactions are added from back to front and eviction is FIFO.
// The last transaction of block_vtx should be the first to be evicted.
BOOST_CHECK_EQUAL(block_vtx.back(), evicted_txns.front());
disconnectpool.clear();
}
}
BOOST_AUTO_TEST_SUITE_END()
|
