mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-14 12:43:40 +02:00
e758b26b85
Carrying non-kernel related fields in the cache sizes for the indexes is confusing for kernel library users. The cache sizes also are set currently with magic numbers in bitcoin-chainstate. The comments for the cache size calculations are also not completely clear. Solve these things by moving the kernel-specific cache size fields to their own struct. This slightly changes the way the cache is allocated if the txindex and/or blockfilterindex is used. Since they are now given precedence over the block tree db cache, this results in a bit less cache being allocated to the block tree db, coinsdb and coins caches. The effect is negligible though, i.e. cache sizes with default dbcache reported through the logs are: master: Cache configuration: * Using 2.0 MiB for block index database * Using 56.0 MiB for transaction index database * Using 49.0 MiB for basic block filter index database * Using 8.0 MiB for chain state database * Using 335.0 MiB for in-memory UTXO set (plus up to 286.1 MiB of unused mempool space) this branch: Cache configuration: * Using 2.0 MiB for block index database * Using 56.2 MiB for transaction index database * Using 49.2 MiB for basic block filter index database * Using 8.0 MiB for chain state database * Using 334.5 MiB for in-memory UTXO set (plus up to 286.1 MiB of unused mempool space)
79 lines
2.9 KiB
C++
79 lines
2.9 KiB
C++
// Copyright (c) 2021-2022 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_NODE_CHAINSTATE_H
|
|
#define BITCOIN_NODE_CHAINSTATE_H
|
|
|
|
#include <util/translation.h>
|
|
#include <validation.h>
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <tuple>
|
|
|
|
class CTxMemPool;
|
|
|
|
namespace kernel {
|
|
struct CacheSizes;
|
|
} // namespace kernel
|
|
|
|
namespace node {
|
|
|
|
struct ChainstateLoadOptions {
|
|
CTxMemPool* mempool{nullptr};
|
|
bool block_tree_db_in_memory{false};
|
|
bool coins_db_in_memory{false};
|
|
// Whether to wipe the block tree database when loading it. If set, this
|
|
// will also set a reindexing flag so any existing block data files will be
|
|
// scanned and added to the database.
|
|
bool wipe_block_tree_db{false};
|
|
// Whether to wipe the chainstate database when loading it. If set, this
|
|
// will cause the chainstate database to be rebuilt starting from genesis.
|
|
bool wipe_chainstate_db{false};
|
|
bool prune{false};
|
|
//! Setting require_full_verification to true will require all checks at
|
|
//! check_level (below) to succeed for loading to succeed. Setting it to
|
|
//! false will skip checks if cache is not big enough to run them, so may be
|
|
//! helpful for running with a small cache.
|
|
bool require_full_verification{true};
|
|
int64_t check_blocks{DEFAULT_CHECKBLOCKS};
|
|
int64_t check_level{DEFAULT_CHECKLEVEL};
|
|
std::function<void()> coins_error_cb;
|
|
};
|
|
|
|
//! Chainstate load status. Simple applications can just check for the success
|
|
//! case, and treat other cases as errors. More complex applications may want to
|
|
//! try reindexing in the generic failure case, and pass an interrupt callback
|
|
//! and exit cleanly in the interrupted case.
|
|
enum class ChainstateLoadStatus {
|
|
SUCCESS,
|
|
FAILURE, //!< Generic failure which reindexing may fix
|
|
FAILURE_FATAL, //!< Fatal error which should not prompt to reindex
|
|
FAILURE_INCOMPATIBLE_DB,
|
|
FAILURE_INSUFFICIENT_DBCACHE,
|
|
INTERRUPTED,
|
|
};
|
|
|
|
//! Chainstate load status code and optional error string.
|
|
using ChainstateLoadResult = std::tuple<ChainstateLoadStatus, bilingual_str>;
|
|
|
|
/** This sequence can have 4 types of outcomes:
|
|
*
|
|
* 1. Success
|
|
* 2. Shutdown requested
|
|
* - nothing failed but a shutdown was triggered in the middle of the
|
|
* sequence
|
|
* 3. Soft failure
|
|
* - a failure that might be recovered from with a reindex
|
|
* 4. Hard failure
|
|
* - a failure that definitively cannot be recovered from with a reindex
|
|
*
|
|
* LoadChainstate returns a (status code, error string) tuple.
|
|
*/
|
|
ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const kernel::CacheSizes& cache_sizes,
|
|
const ChainstateLoadOptions& options);
|
|
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options);
|
|
} // namespace node
|
|
|
|
#endif // BITCOIN_NODE_CHAINSTATE_H
|