highperfocused/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-08-26 15:21:10 +02:00
Code Issues Packages Projects Releases Wiki Activity

test: revive getcoinscachesizestate

Browse Source 
After the changes in https://github.com/bitcoin/bitcoin/pull/25325 `getcoinscachesizestate` always end the test early, see:
https://maflcko.github.io/b-c-cov/test_bitcoin.coverage/src/test/validation_flush_tests.cpp.gcov.html

The test revival was extracted from a related PR where it was discovered, see: https://github.com/bitcoin/bitcoin/pull/28531#discussion_r2109417797

Co-authored-by: Larry Ruane <larryruane@gmail.com>
This commit is contained in:
Lőrinc
2025-07-19 17:16:52 -07:00
parent 64ed0fa6b7
commit 554befd873
1 changed files with 34 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

157
src/test/validation_flush_tests.cpp
View File

@@ -1,7 +1,7 @@
// Copyright (c) 2019-2022 The Bitcoin Core developers // Copyright (c) 2019-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying // Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
//
#include <sync.h> #include <sync.h>
#include <test/util/coins.h> #include <test/util/coins.h>
#include <test/util/random.h> #include <test/util/random.h>
@@ -12,145 +12,56 @@
BOOST_FIXTURE_TEST_SUITE(validation_flush_tests, TestingSetup) BOOST_FIXTURE_TEST_SUITE(validation_flush_tests, TestingSetup)
//! Test utilities for detecting when we need to flush the coins cache based //! Verify that Chainstate::GetCoinsCacheSizeState() switches from OK→LARGE→CRITICAL
//! on estimated memory usage. //! at the expected utilization thresholds, first with *no* mempool head-room,
//! //! then with additional mempool head-room.
//! @sa Chainstate::GetCoinsCacheSizeState()
//!
BOOST_AUTO_TEST_CASE(getcoinscachesizestate) BOOST_AUTO_TEST_CASE(getcoinscachesizestate)
{ {
Chainstate& chainstate{m_node.chainman->ActiveChainstate()}; Chainstate& chainstate{m_node.chainman->ActiveChainstate()};
constexpr bool is_64_bit = sizeof(void*) == 8;
LOCK(::cs_main); LOCK(::cs_main);
auto& view = chainstate.CoinsTip(); CCoinsViewCache& view{chainstate.CoinsTip()};
// The number of bytes consumed by coin's heap data, i.e. // Sanity: an empty cache should be ≲ 1 chunk (~ 256 KiB).
// CScript (prevector<36, unsigned char>) when assigned 56 bytes of data per above. BOOST_CHECK_LT(view.DynamicMemoryUsage() / (256 * 1024.0), 1.1);
// See also: Coin::DynamicMemoryUsage().
constexpr unsigned int COIN_SIZE = is_64_bit ? 80 : 64;
auto print_view_mem_usage = [](CCoinsViewCache& view) { constexpr size_t MAX_COINS_BYTES{8_MiB};
BOOST_TEST_MESSAGE("CCoinsViewCache memory usage: " << view.DynamicMemoryUsage()); constexpr size_t MAX_MEMPOOL_BYTES{4_MiB};
}; constexpr size_t MAX_ATTEMPTS{50'000};
// PoolResource defaults to 256 KiB that will be allocated, so we'll take that and make it a bit larger. // Run the same growth-path twice: first with 0 head-room, then with extra head-room
constexpr size_t MAX_COINS_CACHE_BYTES = 262144 + 512; for (size_t max_mempool_size_bytes : {size_t{0}, MAX_MEMPOOL_BYTES}) {
const int64_t full_cap{int64_t(MAX_COINS_BYTES + max_mempool_size_bytes)};
const int64_t large_cap{LargeCoinsCacheThreshold(full_cap)};
// Without any coins in the cache, we shouldn't need to flush. // OK → LARGE
BOOST_TEST( auto state{chainstate.GetCoinsCacheSizeState(MAX_COINS_BYTES, max_mempool_size_bytes)};
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes=*/ 0) != CoinsCacheSizeState::CRITICAL); for (size_t i{0}; i < MAX_ATTEMPTS && int64_t(view.DynamicMemoryUsage()) <= large_cap; ++i) {
BOOST_CHECK_EQUAL(state, CoinsCacheSizeState::OK);
// If the initial memory allocations of cacheCoins don't match these common AddTestCoin(m_rng, view);
// cases, we can't really continue to make assertions about memory usage. state = chainstate.GetCoinsCacheSizeState(MAX_COINS_BYTES, max_mempool_size_bytes);
// End the test early.
if (view.DynamicMemoryUsage() != 32 && view.DynamicMemoryUsage() != 16) {
// Add a bunch of coins to see that we at least flip over to CRITICAL.
for (int i{0}; i < 1000; ++i) {
const COutPoint res = AddTestCoin(m_rng, view);
BOOST_CHECK_EQUAL(view.AccessCoin(res).DynamicMemoryUsage(), COIN_SIZE);
} }
BOOST_CHECK_EQUAL( // LARGE → CRITICAL
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes=*/0), for (size_t i{0}; i < MAX_ATTEMPTS && int64_t(view.DynamicMemoryUsage()) <= full_cap; ++i) {
CoinsCacheSizeState::CRITICAL); BOOST_CHECK_EQUAL(state, CoinsCacheSizeState::LARGE);
AddTestCoin(m_rng, view);
BOOST_TEST_MESSAGE("Exiting cache flush tests early due to unsupported arch"); state = chainstate.GetCoinsCacheSizeState(MAX_COINS_BYTES, max_mempool_size_bytes);
return;
}
print_view_mem_usage(view);
BOOST_CHECK_EQUAL(view.DynamicMemoryUsage(), is_64_bit ? 32U : 16U);
// We should be able to add COINS_UNTIL_CRITICAL coins to the cache before going CRITICAL.
// This is contingent not only on the dynamic memory usage of the Coins
// that we're adding (COIN_SIZE bytes per), but also on how much memory the
// cacheCoins (unordered_map) preallocates.
constexpr int COINS_UNTIL_CRITICAL{3};
// no coin added, so we have plenty of space left.
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes*/ 0),
CoinsCacheSizeState::OK);
for (int i{0}; i < COINS_UNTIL_CRITICAL; ++i) {
const COutPoint res = AddTestCoin(m_rng, view);
print_view_mem_usage(view);
BOOST_CHECK_EQUAL(view.AccessCoin(res).DynamicMemoryUsage(), COIN_SIZE);
// adding first coin causes the MemoryResource to allocate one 256 KiB chunk of memory,
// pushing us immediately over to LARGE
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes=*/ 0),
CoinsCacheSizeState::LARGE);
}
// Adding some additional coins will push us over the edge to CRITICAL.
for (int i{0}; i < 4; ++i) {
AddTestCoin(m_rng, view);
print_view_mem_usage(view);
if (chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes=*/0) ==
CoinsCacheSizeState::CRITICAL) {
break;
} }
BOOST_CHECK_EQUAL(state, CoinsCacheSizeState::CRITICAL);
} }
BOOST_CHECK_EQUAL( // Default thresholds (no explicit limits) permit many more coins.
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes=*/0), for (int i{0}; i < 1'000; ++i) {
CoinsCacheSizeState::CRITICAL);
// Passing non-zero max mempool usage (512 KiB) should allow us more headroom.
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes=*/ 1 << 19),
CoinsCacheSizeState::OK);
for (int i{0}; i < 3; ++i) {
AddTestCoin(m_rng, view); AddTestCoin(m_rng, view);
print_view_mem_usage(view); BOOST_CHECK_EQUAL(chainstate.GetCoinsCacheSizeState(), CoinsCacheSizeState::OK);
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes=*/ 1 << 19),
CoinsCacheSizeState::OK);
} }
// Adding another coin with the additional mempool room will put us >90% // CRITICAL → OK via Flush
// but not yet critical. BOOST_CHECK_EQUAL(chainstate.GetCoinsCacheSizeState(MAX_COINS_BYTES, /*max_mempool_size_bytes=*/0), CoinsCacheSizeState::CRITICAL);
AddTestCoin(m_rng, view);
print_view_mem_usage(view);
// Only perform these checks on 64 bit hosts; I haven't done the math for 32.
if (is_64_bit) {
float usage_percentage = (float)view.DynamicMemoryUsage() / (MAX_COINS_CACHE_BYTES + (1 << 10));
BOOST_TEST_MESSAGE("CoinsTip usage percentage: " << usage_percentage);
BOOST_CHECK(usage_percentage >= 0.9);
BOOST_CHECK(usage_percentage < 1);
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, /*max_mempool_size_bytes*/ 1 << 10), // 1024
CoinsCacheSizeState::LARGE);
}
// Using the default max_* values permits way more coins to be added.
for (int i{0}; i < 1000; ++i) {
AddTestCoin(m_rng, view);
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(),
CoinsCacheSizeState::OK);
}
// Flushing the view does take us back to OK because ReallocateCache() is called
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, 0),
CoinsCacheSizeState::CRITICAL);
view.SetBestBlock(m_rng.rand256()); view.SetBestBlock(m_rng.rand256());
BOOST_CHECK(view.Flush()); BOOST_REQUIRE(view.Flush());
print_view_mem_usage(view); BOOST_CHECK_EQUAL(chainstate.GetCoinsCacheSizeState(MAX_COINS_BYTES, /*max_mempool_size_bytes=*/0), CoinsCacheSizeState::OK);
BOOST_CHECK_EQUAL(
chainstate.GetCoinsCacheSizeState(MAX_COINS_CACHE_BYTES, 0),
CoinsCacheSizeState::OK);
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()