perf: cache shared_ptr to SML instead of SML list

Shared_ptr to SML is preserved between multiple CDeterministicMNList and
it helps to avoid building SML from a scratch; also it helps to avoid comparision
of SML item-by-item.

Author: knst

src/evo/cbtx.cpp

@@ -4,6 +4,7 @@
 
 #include <consensus/validation.h>
 #include <evo/cbtx.h>
+#include <evo/deterministicmns.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
 #include <llmq/blockprocessor.h>
@@ -47,16 +48,16 @@ bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationSta
 
 // This can only be done after the block has been fully processed, as otherwise we won't have the finished MN list
 bool CheckCbTxMerkleRoots(const CBlock& block, const CCbTx& cbTx, const CBlockIndex* pindex,
-                          const llmq::CQuorumBlockProcessor& quorum_block_processor, CSimplifiedMNList&& sml,
-                          BlockValidationState& state)
+                          const llmq::CQuorumBlockProcessor& quorum_block_processor,
+                          const CDeterministicMNList& mn_list, BlockValidationState& state)
 {
     if (pindex) {
         static int64_t nTimeMerkleMNL = 0;
         static int64_t nTimeMerkleQuorum = 0;
 
         int64_t nTime1 = GetTimeMicros();
         uint256 calculatedMerkleRoot;
-        if (!CalcCbTxMerkleRootMNList(calculatedMerkleRoot, std::move(sml), state)) {
+        if (!CalcCbTxMerkleRootMNList(calculatedMerkleRoot, mn_list, state)) {
             // pass the state returned by the function above
             return false;
         }
@@ -88,20 +89,22 @@ bool CheckCbTxMerkleRoots(const CBlock& block, const CCbTx& cbTx, const CBlockIn
     return true;
 }
 
-bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, CSimplifiedMNList&& sml, BlockValidationState& state)
+bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, const CDeterministicMNList& mn_list, BlockValidationState& state)
 {
     try {
         static std::atomic<int64_t> nTimeMerkle = 0;
 
         int64_t nTime1 = GetTimeMicros();
 
         static Mutex cached_mutex;
-        static CSimplifiedMNList smlCached GUARDED_BY(cached_mutex);
+        static std::shared_ptr<const CSimplifiedMNList> cached_sml GUARDED_BY(cached_mutex){
+            std::make_shared<const CSimplifiedMNList>()};
         static uint256 merkleRootCached GUARDED_BY(cached_mutex);
         static bool mutatedCached GUARDED_BY(cached_mutex) {false};
 
+        std::shared_ptr<const CSimplifiedMNList> sml{mn_list.GetSML()};
         LOCK(cached_mutex);
-        if (sml == smlCached) {
+        if (sml == cached_sml || *sml == *cached_sml) {
             merkleRootRet = merkleRootCached;
             if (mutatedCached) {
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "mutated-cached-calc-cb-mnmerkleroot");
@@ -110,14 +113,14 @@ bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, CSimplifiedMNList&& sml, B
         }
 
         bool mutated = false;
-        merkleRootRet = sml.CalcMerkleRoot(&mutated);
+        merkleRootRet = sml->CalcMerkleRoot(&mutated);
 
         int64_t nTime2 = GetTimeMicros();
         nTimeMerkle += nTime2 - nTime1;
         LogPrint(BCLog::BENCHMARK, "            - CalcMerkleRoot: %.2fms [%.2fs]\n", 0.001 * (nTime2 - nTime1),
                  nTimeMerkle * 0.000001);
 
-        smlCached = std::move(sml);
+        cached_sml = sml;
         merkleRootCached = merkleRootRet;
         mutatedCached = mutated;
 

src/evo/cbtx.h

@@ -14,8 +14,8 @@
 class BlockValidationState;
 class CBlock;
 class CBlockIndex;
+class CDeterministicMNList;
 class TxValidationState;
-class CSimplifiedMNList;
 
 namespace llmq {
 class CChainLocksHandler;
@@ -67,9 +67,9 @@ template<> struct is_serializable_enum<CCbTx::Version> : std::true_type {};
 bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationState& state);
 
 bool CheckCbTxMerkleRoots(const CBlock& block, const CCbTx& cbTx, const CBlockIndex* pindex,
-                          const llmq::CQuorumBlockProcessor& quorum_block_processor, CSimplifiedMNList&& sml,
-                          BlockValidationState& state);
-bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, CSimplifiedMNList&& sml, BlockValidationState& state);
+                          const llmq::CQuorumBlockProcessor& quorum_block_processor,
+                          const CDeterministicMNList& mn_list, BlockValidationState& state);
+bool CalcCbTxMerkleRootMNList(uint256& merkleRootRet, const CDeterministicMNList& mn_list, BlockValidationState& state);
 bool CalcCbTxMerkleRootQuorums(const CBlock& block, const CBlockIndex* pindexPrev,
                                const llmq::CQuorumBlockProcessor& quorum_block_processor, uint256& merkleRootRet,
                                BlockValidationState& state);

src/evo/deterministicmns.cpp

@@ -615,6 +615,8 @@ bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<co
     int nHeight = pindex->nHeight;
 
     try {
+        newList.GetSML(); // to fullfill cache of SML
+
         LOCK(cs);
 
         oldList = GetListForBlockInternal(pindex->pprev);
@@ -630,6 +632,7 @@ bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<co
 
         diff.nHeight = pindex->nHeight;
         mnListDiffsCache.emplace(pindex->GetBlockHash(), diff);
+        mnListsCache.emplace(newList.GetBlockHash(), newList);
     } catch (const std::exception& e) {
         LogPrintf("CDeterministicMNManager::%s -- internal error: %s\n", __func__, e.what());
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "failed-dmn-block");
@@ -1088,7 +1091,10 @@ CDeterministicMNList CDeterministicMNManager::GetListForBlockInternal(gsl::not_n
     if (tipIndex) {
         // always keep a snapshot for the tip
         if (snapshot.GetBlockHash() == tipIndex->GetBlockHash()) {
-            mnListsCache.emplace(snapshot.GetBlockHash(), snapshot);
+            auto hash = snapshot.GetBlockHash();
+            if (mnListsCache.find(hash) == mnListsCache.end()) {
+                mnListsCache.emplace(snapshot.GetBlockHash(), snapshot);
+            }
         } else {
             // keep snapshots for yet alive quorums
             if (ranges::any_of(Params().GetConsensus().llmqs,

src/evo/specialtxman.cpp

@@ -193,7 +193,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
         LogPrint(BCLog::BENCHMARK, "      - m_dmnman: %.2fms [%.2fs]\n", 0.001 * (nTime6 - nTime5), nTimeDMN * 0.000001);
 
         if (opt_cbTx.has_value()) {
-            if (!CheckCbTxMerkleRoots(block, *opt_cbTx, pindex, m_qblockman, CSimplifiedMNList(mn_list), state)) {
+            if (!CheckCbTxMerkleRoots(block, *opt_cbTx, pindex, m_qblockman, mn_list, state)) {
                 // pass the state returned by the function above
                 return false;
             }

src/node/miner.cpp

@@ -232,7 +232,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         if (!m_dmnman.BuildNewListFromBlock(*pblock, pindexPrev, state, m_chainstate.CoinsTip(), mn_list, m_qsnapman, true)) {
             throw std::runtime_error(strprintf("%s: BuildNewListFromBlock failed: %s", __func__, state.ToString()));
         }
-        if (!CalcCbTxMerkleRootMNList(cbTx.merkleRootMNList, CSimplifiedMNList(mn_list), state)) {
+        if (!CalcCbTxMerkleRootMNList(cbTx.merkleRootMNList, std::move(mn_list), state)) {
             throw std::runtime_error(strprintf("%s: CalcCbTxMerkleRootMNList failed: %s", __func__, state.ToString()));
         }
         if (fDIP0008Active_context) {

src/test/util/setup_common.cpp

@@ -506,7 +506,7 @@ CBlock TestChainSetup::CreateBlock(
         if (!m_node.dmnman->BuildNewListFromBlock(block, chainstate.m_chain.Tip(), state, chainstate.CoinsTip(), mn_list, *m_node.llmq_ctx->qsnapman, true)) {
             Assert(false);
         }
-        if (!CalcCbTxMerkleRootMNList(cbTx->merkleRootMNList, CSimplifiedMNList(mn_list), state)) {
+        if (!CalcCbTxMerkleRootMNList(cbTx->merkleRootMNList, std::move(mn_list), state)) {
             Assert(false);
         }
         if (!CalcCbTxMerkleRootQuorums(block, chainstate.m_chain.Tip(), *m_node.llmq_ctx->quorum_block_processor, cbTx->merkleRootQuorums, state)) {