refactor: drop remaining gArgs usage in LLMQ code

kwvg · kwvg · commit 263dd67ca73c · 2025-12-23T19:42:09.000+05:30
Same rationale as previous commit.
diff --git a/src/init.cpp b/src/init.cpp
@@ -2035,6 +2035,17 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                               /*dash_dbs_in_memory=*/false,
                                               quorums_recovery,
                                               quorums_watch,
+                                              /*bls_threads=*/[&args]() -> int8_t {
+                                                  int8_t threads = args.GetIntArg("-parbls", llmq::DEFAULT_BLSCHECK_THREADS);
+                                                  if (threads <= 0) {
+                                                      // -parbls=0 means autodetect (number of cores - 1 validator threads)
+                                                      // -parbls=-n means "leave n cores free" (number of cores - n - 1 validator threads)
+                                                      threads += GetNumCores();
+                                                  }
+                                                  // Subtract 1 because the main thread counts towards the par threads
+                                                  return std::clamp<int8_t>(threads - 1, 0, llmq::MAX_BLSCHECK_THREADS);
+                                              }(),
+                                              args.GetIntArg("-maxrecsigsage", llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE),
                                               /*shutdown_requested=*/ShutdownRequested,
                                               /*coins_error_cb=*/[]() {
                                                   uiInterface.ThreadSafeMessageBox(
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
@@ -46,26 +46,13 @@ static const std::string DB_MINED_COMMITMENT_BY_INVERSED_HEIGHT_Q_INDEXED = "q_m
 static const std::string DB_BEST_BLOCK_UPGRADE = "q_bbu2";
 
 CQuorumBlockProcessor::CQuorumBlockProcessor(CChainState& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
-                                             CQuorumSnapshotManager& qsnapman) :
+                                             CQuorumSnapshotManager& qsnapman, int8_t bls_threads) :
     m_chainstate{chainstate},
     m_dmnman{dmnman},
     m_evoDb{evoDb},
     m_qsnapman{qsnapman}
 {
     utils::InitQuorumsCache(mapHasMinedCommitmentCache);
-
-    int bls_threads = gArgs.GetIntArg("-parbls", DEFAULT_BLSCHECK_THREADS);
-    if (bls_threads <= 0) {
-        // -parbls=0 means autodetect (number of cores - 1 validator threads)
-        // -parbls=-n means "leave n cores free" (number of cores - n - 1 validator threads)
-        bls_threads += GetNumCores();
-    }
-    // Subtract 1 because the main thread counts towards the par threads
-    bls_threads = std::max(bls_threads - 1, 0);
-
-    // Number of script-checking threads <= MAX_BLSCHECK_THREADS
-    bls_threads = std::min(bls_threads, MAX_BLSCHECK_THREADS);
-
     LogPrintf("BLS verification uses %d additional threads\n", bls_threads);
     m_bls_queue.StartWorkerThreads(bls_threads);
 }
diff --git a/src/llmq/blockprocessor.h b/src/llmq/blockprocessor.h
@@ -59,7 +59,7 @@ class CQuorumBlockProcessor
     CQuorumBlockProcessor(const CQuorumBlockProcessor&) = delete;
     CQuorumBlockProcessor& operator=(const CQuorumBlockProcessor&) = delete;
     explicit CQuorumBlockProcessor(CChainState& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
-                                   CQuorumSnapshotManager& qsnapman);
+                                   CQuorumSnapshotManager& qsnapman, int8_t bls_threads);
     ~CQuorumBlockProcessor();
 
     [[nodiscard]] MessageProcessingResult ProcessMessage(const CNode& peer, std::string_view msg_type, CDataStream& vRecv)
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
@@ -19,19 +19,20 @@ LLMQContext::LLMQContext(ChainstateManager& chainman, CDeterministicMNManager& d
                          CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman, CSporkManager& sporkman,
                          CTxMemPool& mempool, const CActiveMasternodeManager* const mn_activeman,
                          const CMasternodeSync& mn_sync, const llmq::QvvecSyncModeMap& sync_map,
-                         const util::DbWrapperParams& db_params, bool quorums_recovery, bool quorums_watch) :
+                         const util::DbWrapperParams& db_params, bool quorums_recovery, bool quorums_watch,
+                         int8_t bls_threads, int64_t max_recsigs_age) :
     bls_worker{std::make_shared<CBLSWorker>()},
     dkg_debugman{std::make_unique<llmq::CDKGDebugManager>()},
     qsnapman{std::make_unique<llmq::CQuorumSnapshotManager>(evo_db)},
-    quorum_block_processor{
-        std::make_unique<llmq::CQuorumBlockProcessor>(chainman.ActiveChainstate(), dmnman, evo_db, *qsnapman)},
+    quorum_block_processor{std::make_unique<llmq::CQuorumBlockProcessor>(chainman.ActiveChainstate(), dmnman, evo_db,
+                                                                         *qsnapman, bls_threads)},
     qdkgsman{std::make_unique<llmq::CDKGSessionManager>(*bls_worker, dmnman, *dkg_debugman, mn_metaman,
                                                         *quorum_block_processor, *qsnapman, mn_activeman, chainman,
                                                         sporkman, db_params, quorums_watch)},
     qman{std::make_unique<llmq::CQuorumManager>(*bls_worker, dmnman, *qdkgsman, evo_db, *quorum_block_processor,
                                                 *qsnapman, mn_activeman, chainman, mn_sync, sporkman, sync_map,
                                                 db_params, quorums_recovery, quorums_watch)},
-    sigman{std::make_unique<llmq::CSigningManager>(*qman, db_params)},
+    sigman{std::make_unique<llmq::CSigningManager>(*qman, db_params, max_recsigs_age)},
     clhandler{std::make_unique<llmq::CChainLocksHandler>(chainman.ActiveChainstate(), *qman, sporkman, mempool, mn_sync)},
     isman{std::make_unique<llmq::CInstantSendManager>(*clhandler, chainman.ActiveChainstate(), *sigman, sporkman,
                                                       mempool, mn_sync, db_params)}
diff --git a/src/llmq/context.h b/src/llmq/context.h
@@ -44,7 +44,8 @@ struct LLMQContext {
                          CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman, CSporkManager& sporkman,
                          CTxMemPool& mempool, const CActiveMasternodeManager* const mn_activeman,
                          const CMasternodeSync& mn_sync, const llmq::QvvecSyncModeMap& sync_map,
-                         const util::DbWrapperParams& db_params, bool quorums_recovery, bool quorums_watch);
+                         const util::DbWrapperParams& db_params, bool quorums_recovery, bool quorums_watch,
+                         int8_t bls_threads, int64_t max_recsigs_age);
     ~LLMQContext();
 
     void Interrupt();
diff --git a/src/llmq/options.h b/src/llmq/options.h
@@ -28,9 +28,9 @@ enum class QvvecSyncMode {
 };
 
 /** Maximum number of dedicated script-checking threads allowed */
-static const int MAX_BLSCHECK_THREADS{33};
+static const int8_t MAX_BLSCHECK_THREADS{33};
 /** -parbls default (number of bls-checking threads, 0 = auto) */
-static const int DEFAULT_BLSCHECK_THREADS{0};
+static const int8_t DEFAULT_BLSCHECK_THREADS{0};
 /** -llmq-data-recovery default */
 static constexpr bool DEFAULT_ENABLE_QUORUM_DATA_RECOVERY{true};
 /** -watchquorums default, if true, we will connect to all new quorums and watch their communication */
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
@@ -326,9 +326,11 @@ void CRecoveredSigsDb::CleanupOldVotes(int64_t maxAge)
 
 //////////////////
 
-CSigningManager::CSigningManager(const CQuorumManager& _qman, const util::DbWrapperParams& db_params) :
+CSigningManager::CSigningManager(const CQuorumManager& _qman, const util::DbWrapperParams& db_params,
+                                 int64_t max_recsigs_age) :
     db{db_params},
-    qman{_qman}
+    qman{_qman},
+    m_max_recsigs_age{max_recsigs_age}
 {
 }
 
@@ -534,10 +536,8 @@ void CSigningManager::TruncateRecoveredSig(Consensus::LLMQType llmqType, const u
 
 void CSigningManager::Cleanup()
 {
-    int64_t maxAge = gArgs.GetIntArg("-maxrecsigsage", DEFAULT_MAX_RECOVERED_SIGS_AGE);
-
-    db.CleanupOldRecoveredSigs(maxAge);
-    db.CleanupOldVotes(maxAge);
+    db.CleanupOldRecoveredSigs(m_max_recsigs_age);
+    db.CleanupOldVotes(m_max_recsigs_age);
 }
 
 void CSigningManager::RegisterRecoveredSigsListener(CRecoveredSigsListener* l)
diff --git a/src/llmq/signing.h b/src/llmq/signing.h
@@ -158,9 +158,9 @@ class CRecoveredSigsListener
 class CSigningManager
 {
 private:
-
     CRecoveredSigsDb db;
     const CQuorumManager& qman;
+    const int64_t m_max_recsigs_age;
 
     mutable Mutex cs_pending;
     // Incoming and not verified yet
@@ -176,7 +176,7 @@ class CSigningManager
     CSigningManager() = delete;
     CSigningManager(const CSigningManager&) = delete;
     CSigningManager& operator=(const CSigningManager&) = delete;
-    explicit CSigningManager(const CQuorumManager& _qman, const util::DbWrapperParams& db_params);
+    explicit CSigningManager(const CQuorumManager& _qman, const util::DbWrapperParams& db_params, int64_t max_recsigs_age);
     ~CSigningManager();
 
     bool AlreadyHave(const CInv& inv) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pending);
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
@@ -64,6 +64,8 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      bool dash_dbs_in_memory,
                                                      bool quorums_recovery,
                                                      bool quorums_watch,
+                                                     int8_t bls_threads,
+                                                     int64_t max_recsigs_age,
                                                      std::function<bool()> shutdown_requested,
                                                      std::function<void()> coins_error_cb)
 {
@@ -91,7 +93,8 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
 
     DashChainstateSetup(chainman, govman, mn_metaman, mn_sync, sporkman, mn_activeman, chain_helper, cpoolman,
                         dmnman, evodb, mnhf_manager, llmq_ctx, mempool, data_dir, sync_map, dash_dbs_in_memory,
-                        /*llmq_dbs_wipe=*/fReset || fReindexChainState, quorums_recovery, quorums_watch, consensus_params);
+                        /*llmq_dbs_wipe=*/fReset || fReindexChainState, quorums_recovery, quorums_watch,
+                        bls_threads, max_recsigs_age, consensus_params);
 
     if (fReset) {
         pblocktree->WriteReindexing(true);
@@ -230,6 +233,8 @@ void DashChainstateSetup(ChainstateManager& chainman,
                          bool llmq_dbs_wipe,
                          bool quorums_recovery,
                          bool quorums_watch,
+                         int8_t bls_threads,
+                         int64_t max_recsigs_age,
                          const Consensus::Params& consensus_params)
 {
     // Same logic as pblocktree
@@ -247,7 +252,7 @@ void DashChainstateSetup(ChainstateManager& chainman,
     llmq_ctx = std::make_unique<LLMQContext>(chainman, *dmnman, *evodb, mn_metaman, *mnhf_manager, sporkman,
                                              *mempool, mn_activeman.get(), mn_sync, sync_map,
                                              util::DbWrapperParams{.path = data_dir, .memory = llmq_dbs_in_memory, .wipe = llmq_dbs_wipe},
-                                             quorums_recovery, quorums_watch);
+                                             quorums_recovery, quorums_watch, bls_threads, max_recsigs_age);
     mempool->ConnectManagers(dmnman.get(), llmq_ctx->isman.get());
     // Enable CMNHFManager::{Process, Undo}Block
     mnhf_manager->ConnectManagers(llmq_ctx->qman.get());
diff --git a/src/node/chainstate.h b/src/node/chainstate.h
@@ -110,6 +110,8 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      bool dash_dbs_in_memory,
                                                      bool quorums_recovery,
                                                      bool quorums_watch,
+                                                     int8_t bls_threads,
+                                                     int64_t max_recsigs_age,
                                                      std::function<bool()> shutdown_requested = nullptr,
                                                      std::function<void()> coins_error_cb = nullptr);
 
@@ -133,6 +135,8 @@ void DashChainstateSetup(ChainstateManager& chainman,
                          bool llmq_dbs_wipe,
                          bool quorums_recovery,
                          bool quorums_watch,
+                         int8_t bls_threads,
+                         int64_t max_recsigs_age,
                          const Consensus::Params& consensus_params);
 
 void DashChainstateSetupClose(std::unique_ptr<CChainstateHelper>& chain_helper,
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
@@ -65,6 +65,7 @@
 #include <governance/governance.h>
 #include <llmq/context.h>
 #include <llmq/options.h>
+#include <llmq/signing.h>
 #include <masternode/active/context.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
@@ -135,8 +136,8 @@ void DashChainstateSetup(ChainstateManager& chainman,
     DashChainstateSetup(chainman, *Assert(node.govman.get()), *Assert(node.mn_metaman.get()), *Assert(node.mn_sync.get()),
                         *Assert(node.sporkman.get()), node.mn_activeman, node.chain_helper, node.cpoolman, node.dmnman,
                         node.evodb, node.mnhf_manager, node.llmq_ctx, Assert(node.mempool.get()), node.args->GetDataDirNet(),
-                        llmq::QvvecSyncModeMap{}, llmq_dbs_in_memory, llmq_dbs_wipe, /*quorums_recovery=*/false,
-                        /*quorums_watch=*/false, consensus_params);
+                        llmq::QvvecSyncModeMap{}, llmq_dbs_in_memory, llmq_dbs_wipe, /*quorums_recovery=*/false, /*quorums_watch=*/false,
+                        llmq::DEFAULT_BLSCHECK_THREADS, llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE, consensus_params);
 }
 
 void DashChainstateSetupClose(NodeContext& node)
@@ -336,7 +337,9 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
                                            /*coins_db_in_memory=*/true,
                                            /*dash_dbs_in_memory=*/true,
                                            m_args.GetBoolArg("-llmq-data-recovery", llmq::DEFAULT_ENABLE_QUORUM_DATA_RECOVERY),
-                                           m_args.GetBoolArg("-watchquorums", llmq::DEFAULT_WATCH_QUORUMS));
+                                           m_args.GetBoolArg("-watchquorums", llmq::DEFAULT_WATCH_QUORUMS),
+                                           llmq::DEFAULT_BLSCHECK_THREADS,
+                                           llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE);
     assert(!maybe_load_error.has_value());
 
     auto maybe_verify_error = VerifyLoadedChainstate(
diff --git a/src/test/validation_chainstatemanager_tests.cpp b/src/test/validation_chainstatemanager_tests.cpp
@@ -4,22 +4,24 @@
 //
 #include <chainparams.h>
 #include <consensus/validation.h>
-#include <evo/evodb.h>
 #include <index/txindex.h>
-#include <llmq/blockprocessor.h>
-#include <llmq/context.h>
 #include <node/chainstate.h>
 #include <node/utxo_snapshot.h>
 #include <random.h>
 #include <rpc/blockchain.h>
-#include <spork.h>
 #include <sync.h>
 #include <test/util/chainstate.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
 #include <validation.h>
 #include <validationinterface.h>
 
+#include <evo/evodb.h>
+#include <llmq/blockprocessor.h>
+#include <llmq/context.h>
+#include <llmq/signing.h>
+#include <spork.h>
+
 #include <tinyformat.h>
 
 #include <vector>

Original file line number	Diff line number	Diff line change
`@@ -326,9 +326,11 @@ void CRecoveredSigsDb::CleanupOldVotes(int64_t maxAge)`
`326`	`326`
`327`	`327`	`//////////////////`
`328`	`328`
`329`		`-CSigningManager::CSigningManager(const CQuorumManager& _qman, const util::DbWrapperParams& db_params) :`
	`329`	`+CSigningManager::CSigningManager(const CQuorumManager& _qman, const util::DbWrapperParams& db_params,`
	`330`	`+ int64_t max_recsigs_age) :`
`330`	`331`	`db{db_params},`
`331`		`- qman{_qman}`
	`332`	`+ qman{_qman},`
	`333`	`+ m_max_recsigs_age{max_recsigs_age}`
`332`	`334`	`{`
`333`	`335`	`}`
`334`	`336`
`@@ -534,10 +536,8 @@ void CSigningManager::TruncateRecoveredSig(Consensus::LLMQType llmqType, const u`
`534`	`536`
`535`	`537`	`void CSigningManager::Cleanup()`
`536`	`538`	`{`
`537`		`- int64_t maxAge = gArgs.GetIntArg("-maxrecsigsage", DEFAULT_MAX_RECOVERED_SIGS_AGE);`
`538`		`-`
`539`		`- db.CleanupOldRecoveredSigs(maxAge);`
`540`		`- db.CleanupOldVotes(maxAge);`
	`539`	`+ db.CleanupOldRecoveredSigs(m_max_recsigs_age);`
	`540`	`+ db.CleanupOldVotes(m_max_recsigs_age);`
`541`	`541`	`}`
`542`	`542`
`543`	`543`	`void CSigningManager::RegisterRecoveredSigsListener(CRecoveredSigsListener* l)`