perf: use unordered_set / unordered_map where order isn't relevant

PastaPastaPasta · PastaPastaPasta · commit a04d178a3199 · 2024-12-19T16:20:35.000-06:00
Did a few quickbench to ensure there isn't some advantage to using the "worse" data structure at small sizes. set: https://quick-bench.com/q/ApPAGguzG2F9AnqM2GkgDAXCzX4 map: https://quick-bench.com/q/PXDdF0HVGpiSmC9Hh5FUSTp0uJU Using unordered_map did show a tiny insertion regression for ~expected sizes on masternodes, but it appears that only 1 access will compensate for that overhead, and each su, some perf results I have are here, show that this std::set usage is causing an imo unacceptably high cpu usage. ``` - 9.18% 0.00% d-mncon dashd [.] CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager&, CMasternodeMetaMan&, CMasternodeSync&)::{lambda()#▒ - CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager&, CMasternodeMetaMan&, CMasternodeSync&)::{lambda()#1}::operator()() const ▒ + 6.16% CConnman::IsMasternodeOrDisconnectRequested(CService const&) ▒ - 2.66% std::set<CService, std::less<CService>, std::allocator<CService> >::count(CService const&) const ▒ - std::_Rb_tree<CService, CService, std::_Identity<CService>, std::less<CService>, std::allocator<CService> >::find(CService const&) const ▒ - 2.02% std::_Rb_tree<CService, CService, std::_Identity<CService>, std::less<CService>, std::allocator<CService> >::_M_lower_bound(std::_Rb_tree_node<CService> const▒ + 1.99% std::less<CService>::operator()(CService const&, CService const&) const ▒ + 0.62% std::less<CService>::operator()(CService const&, CService const&) const ```
diff --git a/src/llmq/dkgsession.h b/src/llmq/dkgsession.h
@@ -11,10 +11,12 @@
 #include <bls/bls.h>
 #include <bls/bls_ies.h>
 #include <bls/bls_worker.h>
+#include <saltedhasher.h>
 #include <sync.h>
 #include <util/underlying.h>
 
 #include <optional>
+#include <unordered_set>
 
 class CActiveMasternodeManager;
 class CInv;
@@ -293,7 +295,7 @@ class CDKGSession
 private:
     std::vector<std::unique_ptr<CDKGMember>> members;
     std::map<uint256, size_t> membersMap;
-    std::set<uint256> relayMembers;
+    std::unordered_set<uint256, StaticSaltedHasher> relayMembers;
     BLSVerificationVectorPtr vvecContribution;
     std::vector<CBLSSecretKey> m_sk_contributions;
 
@@ -382,7 +384,7 @@ class CDKGSession
 
 public:
     [[nodiscard]] CDKGMember* GetMember(const uint256& proTxHash) const;
-    [[nodiscard]] const std::set<uint256>& RelayMembers() const { return relayMembers; }
+    [[nodiscard]] const std::unordered_set<uint256, StaticSaltedHasher>& RelayMembers() const { return relayMembers; }
     [[nodiscard]] const CBlockIndex* BlockIndex() const { return m_quorum_base_block_index; }
     [[nodiscard]] const uint256& ProTx() const { return myProTxHash; }
     [[nodiscard]] const Consensus::LLMQParams GetParams() const { return params; }
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
@@ -370,7 +370,7 @@ void CQuorumManager::CheckQuorumConnections(CConnman& connman, const Consensus::
                 LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());
             }
         } else if (watchOtherISQuorums && !quorum->IsMember(myProTxHash)) {
-            std::set<uint256> connections;
+            std::unordered_set<uint256, StaticSaltedHasher> connections;
             const auto& cindexes = utils::CalcDeterministicWatchConnections(llmqParams.type, quorum->m_quorum_base_block_index, quorum->members.size(), 1);
             for (auto idx : cindexes) {
                 connections.emplace(quorum->members[idx]->proTxHash);
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
@@ -717,7 +717,7 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s
     bool canTryRecovery = false;
 
     // prepare node set for direct-push in case this is our sig share
-    std::set<NodeId> quorumNodes;
+    std::unordered_set<NodeId> quorumNodes;
     if (!IsAllMembersConnectedEnabled(llmqType, m_sporkman) && sigShare.getQuorumMember() == quorum->GetMemberIndex(m_mn_activeman->GetProTxHash())) {
         quorumNodes = connman.GetMasternodeQuorumNodes(sigShare.getLlmqType(), sigShare.getQuorumHash());
     }
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
@@ -653,12 +653,13 @@ uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256
     return proTxHash2;
 }
 
-std::set<uint256> GetQuorumConnections(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, const CSporkManager& sporkman,
-                                       gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound)
+std::unordered_set<uint256, StaticSaltedHasher> GetQuorumConnections(
+    const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, const CSporkManager& sporkman,
+    gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound)
 {
     if (IsAllMembersConnectedEnabled(llmqParams.type, sporkman)) {
         auto mns = GetAllQuorumMembers(llmqParams.type, dmnman, pQuorumBaseBlockIndex);
-        std::set<uint256> result;
+        std::unordered_set<uint256, StaticSaltedHasher> result;
 
         for (const auto& dmn : mns) {
             if (dmn->proTxHash == forMember) {
@@ -677,23 +678,25 @@ std::set<uint256> GetQuorumConnections(const Consensus::LLMQParams& llmqParams,
     return GetQuorumRelayMembers(llmqParams, dmnman, pQuorumBaseBlockIndex, forMember, onlyOutbound);
 }
 
-std::set<uint256> GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex,
-                                        const uint256& forMember, bool onlyOutbound)
+std::unordered_set<uint256, StaticSaltedHasher> GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams,
+                                                                      CDeterministicMNManager& dmnman,
+                                                                      gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex,
+                                                                      const uint256& forMember, bool onlyOutbound)
 {
     auto mns = GetAllQuorumMembers(llmqParams.type, dmnman, pQuorumBaseBlockIndex);
-    std::set<uint256> result;
+    std::unordered_set<uint256, StaticSaltedHasher> result;
 
     auto calcOutbound = [&](size_t i, const uint256& proTxHash) {
+        // Relay to nodes at indexes (i+2^k)%n, where
+        //   k: 0..max(1, floor(log2(n-1))-1)
+        //   n: size of the quorum/ring
+        std::unordered_set<uint256, StaticSaltedHasher> r{};
         if (mns.size() == 1) {
             // No outbound connections are needed when there is one MN only.
             // Also note that trying to calculate results via the algorithm below
             // would result in an endless loop.
-            return std::set<uint256>();
+            return r;
         }
-        // Relay to nodes at indexes (i+2^k)%n, where
-        //   k: 0..max(1, floor(log2(n-1))-1)
-        //   n: size of the quorum/ring
-        std::set<uint256> r;
         int gap = 1;
         int gap_max = (int)mns.size() - 1;
         int k = 0;
@@ -775,8 +778,8 @@ bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, CConnman&
     LogPrint(BCLog::NET_NETCONN, "%s -- isMember=%d for quorum %s:\n",
             __func__, isMember, pQuorumBaseBlockIndex->GetBlockHash().ToString());
 
-    std::set<uint256> connections;
-    std::set<uint256> relayMembers;
+    std::unordered_set<uint256, StaticSaltedHasher> connections;
+    std::unordered_set<uint256, StaticSaltedHasher> relayMembers;
     if (isMember) {
         connections = GetQuorumConnections(llmqParams, dmnman, sporkman, pQuorumBaseBlockIndex, myProTxHash, true);
         relayMembers = GetQuorumRelayMembers(llmqParams, dmnman, pQuorumBaseBlockIndex, myProTxHash, true);
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
@@ -5,13 +5,15 @@
 #ifndef BITCOIN_LLMQ_UTILS_H
 #define BITCOIN_LLMQ_UTILS_H
 
+#include <gsl/pointers.h>
 #include <llmq/params.h>
+#include <saltedhasher.h>
 #include <sync.h>
-#include <gsl/pointers.h>
 #include <uint256.h>
 
 #include <map>
 #include <set>
+#include <unordered_set>
 #include <vector>
 
 class CConnman;
@@ -34,8 +36,13 @@ namespace utils
 std::vector<CDeterministicMNCPtr> GetAllQuorumMembers(Consensus::LLMQType llmqType, CDeterministicMNManager& dmnman, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, bool reset_cache = false);
 
 uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2);
-std::set<uint256> GetQuorumConnections(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, const CSporkManager& sporkman, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
-std::set<uint256> GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
+std::unordered_set<uint256, StaticSaltedHasher> GetQuorumConnections(
+    const Consensus::LLMQParams& llmqParams, CDeterministicMNManager& dmnman, const CSporkManager& sporkman,
+    gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
+std::unordered_set<uint256, StaticSaltedHasher> GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams,
+                                                                      CDeterministicMNManager& dmnman,
+                                                                      gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex,
+                                                                      const uint256& forMember, bool onlyOutbound);
 std::set<size_t> CalcDeterministicWatchConnections(Consensus::LLMQType llmqType, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, size_t memberCount, size_t connectionCount);
 
 bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, CConnman& connman, CDeterministicMNManager& dmnman, const CSporkManager& sporkman,
diff --git a/src/net.cpp b/src/net.cpp
@@ -3718,12 +3718,11 @@ void CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager& dmnman,
 
         if (!fNetworkActive || !m_masternode_thread_active || !mn_sync.IsBlockchainSynced()) continue;
 
-        std::set<CService> connectedNodes;
-        std::map<uint256 /*proTxHash*/, bool /*fInbound*/> connectedProRegTxHashes;
+        std::unordered_set<CService, CServiceHash> connectedNodes;
+        std::unordered_map<uint256 /*proTxHash*/, bool /*fInbound*/, StaticSaltedHasher> connectedProRegTxHashes;
         ForEachNode([&](const CNode* pnode) {
-            auto verifiedProRegTxHash = pnode->GetVerifiedProRegTxHash();
             connectedNodes.emplace(pnode->addr);
-            if (!verifiedProRegTxHash.IsNull()) {
+            if (auto verifiedProRegTxHash = pnode->GetVerifiedProRegTxHash(); !verifiedProRegTxHash.IsNull()) {
                 connectedProRegTxHashes.emplace(verifiedProRegTxHash, pnode->IsInboundConn());
             }
         });
@@ -4617,7 +4616,7 @@ bool CConnman::AddPendingMasternode(const uint256& proTxHash)
     return true;
 }
 
-void CConnman::SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::set<uint256>& proTxHashes)
+void CConnman::SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::unordered_set<uint256, StaticSaltedHasher>& proTxHashes)
 {
     LOCK(cs_vPendingMasternodes);
     auto it = masternodeQuorumNodes.emplace(std::make_pair(llmqType, quorumHash), proTxHashes);
@@ -4626,7 +4625,7 @@ void CConnman::SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint
     }
 }
 
-void CConnman::SetMasternodeQuorumRelayMembers(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::set<uint256>& proTxHashes)
+void CConnman::SetMasternodeQuorumRelayMembers(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::unordered_set<uint256, StaticSaltedHasher>& proTxHashes)
 {
     {
         LOCK(cs_vPendingMasternodes);
@@ -4657,10 +4656,10 @@ bool CConnman::HasMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint
     return masternodeQuorumNodes.count(std::make_pair(llmqType, quorumHash));
 }
 
-std::set<uint256> CConnman::GetMasternodeQuorums(Consensus::LLMQType llmqType) const
+std::unordered_set<uint256, StaticSaltedHasher> CConnman::GetMasternodeQuorums(Consensus::LLMQType llmqType) const
 {
     LOCK(cs_vPendingMasternodes);
-    std::set<uint256> result;
+    std::unordered_set<uint256, StaticSaltedHasher> result;
     for (const auto& p : masternodeQuorumNodes) {
         if (p.first.first != llmqType) {
             continue;
@@ -4670,7 +4669,7 @@ std::set<uint256> CConnman::GetMasternodeQuorums(Consensus::LLMQType llmqType) c
     return result;
 }
 
-std::set<NodeId> CConnman::GetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash) const
+std::unordered_set<NodeId> CConnman::GetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash) const
 {
     LOCK2(m_nodes_mutex, cs_vPendingMasternodes);
     auto it = masternodeQuorumNodes.find(std::make_pair(llmqType, quorumHash));
@@ -4679,7 +4678,7 @@ std::set<NodeId> CConnman::GetMasternodeQuorumNodes(Consensus::LLMQType llmqType
     }
     const auto& proRegTxHashes = it->second;
 
-    std::set<NodeId> nodes;
+    std::unordered_set<NodeId> nodes;
     for (const auto pnode : m_nodes) {
         if (pnode->fDisconnect) {
             continue;
diff --git a/src/net.h b/src/net.h
@@ -1501,12 +1501,12 @@ friend class CNode;
         EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex, !mutexMsgProc);
 
     bool AddPendingMasternode(const uint256& proTxHash);
-    void SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::set<uint256>& proTxHashes);
-    void SetMasternodeQuorumRelayMembers(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::set<uint256>& proTxHashes);
+    void SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::unordered_set<uint256, StaticSaltedHasher>& proTxHashes);
+    void SetMasternodeQuorumRelayMembers(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::unordered_set<uint256, StaticSaltedHasher>& proTxHashes);
     bool HasMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash) const;
-    std::set<uint256> GetMasternodeQuorums(Consensus::LLMQType llmqType) const;
+    std::unordered_set<uint256, StaticSaltedHasher> GetMasternodeQuorums(Consensus::LLMQType llmqType) const;
     // also returns QWATCH nodes
-    std::set<NodeId> GetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash) const;
+    std::unordered_set<NodeId> GetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash) const;
     void RemoveMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash);
     bool IsMasternodeQuorumNode(const CNode* pnode, const CDeterministicMNList& tip_mn_list) const;
     bool IsMasternodeQuorumRelayMember(const uint256& protxHash);
@@ -1815,8 +1815,8 @@ friend class CNode;
 
     std::vector<uint256> vPendingMasternodes;
     mutable RecursiveMutex cs_vPendingMasternodes;
-    std::map<std::pair<Consensus::LLMQType, uint256>, std::set<uint256>> masternodeQuorumNodes GUARDED_BY(cs_vPendingMasternodes);
-    std::map<std::pair<Consensus::LLMQType, uint256>, std::set<uint256>> masternodeQuorumRelayMembers GUARDED_BY(cs_vPendingMasternodes);
+    std::map<std::pair<Consensus::LLMQType, uint256>, std::unordered_set<uint256, StaticSaltedHasher>> masternodeQuorumNodes GUARDED_BY(cs_vPendingMasternodes);
+    std::map<std::pair<Consensus::LLMQType, uint256>, std::unordered_set<uint256, StaticSaltedHasher>> masternodeQuorumRelayMembers GUARDED_BY(cs_vPendingMasternodes);
     std::set<uint256> masternodePendingProbes GUARDED_BY(cs_vPendingMasternodes);
 
     mutable Mutex cs_mapSocketToNode;

Original file line number	Diff line number	Diff line change
`@@ -370,7 +370,7 @@ void CQuorumManager::CheckQuorumConnections(CConnman& connman, const Consensus::`
`370`	`370`	`LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- llmqType[%d] h[%d] keeping mn quorum connections for quorum: [%d:%s]\n", __func__, ToUnderlying(llmqParams.type), pindexNew->nHeight, quorum->m_quorum_base_block_index->nHeight, quorum->m_quorum_base_block_index->GetBlockHash().ToString());`
`371`	`371`	`}`
`372`	`372`	`} else if (watchOtherISQuorums && !quorum->IsMember(myProTxHash)) {`
`373`		`- std::set<uint256> connections;`
	`373`	`+ std::unordered_set<uint256, StaticSaltedHasher> connections;`
`374`	`374`	`const auto& cindexes = utils::CalcDeterministicWatchConnections(llmqParams.type, quorum->m_quorum_base_block_index, quorum->members.size(), 1);`
`375`	`375`	`for (auto idx : cindexes) {`
`376`	`376`	`connections.emplace(quorum->members[idx]->proTxHash);`
Original file line number	Diff line number	Diff line change
`@@ -717,7 +717,7 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s`
`717`	`717`	`bool canTryRecovery = false;`
`718`	`718`
`719`	`719`	`// prepare node set for direct-push in case this is our sig share`
`720`		`- std::set<NodeId> quorumNodes;`
	`720`	`+ std::unordered_set<NodeId> quorumNodes;`
`721`	`721`	`if (!IsAllMembersConnectedEnabled(llmqType, m_sporkman) && sigShare.getQuorumMember() == quorum->GetMemberIndex(m_mn_activeman->GetProTxHash())) {`
`722`	`722`	`quorumNodes = connman.GetMasternodeQuorumNodes(sigShare.getLlmqType(), sigShare.getQuorumHash());`
`723`	`723`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3718,12 +3718,11 @@ void CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager& dmnman,`
`3718`	`3718`
`3719`	`3719`	`if (!fNetworkActive \|\| !m_masternode_thread_active \|\| !mn_sync.IsBlockchainSynced()) continue;`
`3720`	`3720`
`3721`		`- std::set<CService> connectedNodes;`
`3722`		`- std::map<uint256 /proTxHash/, bool /fInbound/> connectedProRegTxHashes;`
	`3721`	`+ std::unordered_set<CService, CServiceHash> connectedNodes;`
	`3722`	`+ std::unordered_map<uint256 /proTxHash/, bool /fInbound/, StaticSaltedHasher> connectedProRegTxHashes;`
`3723`	`3723`	`ForEachNode([&](const CNode* pnode) {`
`3724`		`- auto verifiedProRegTxHash = pnode->GetVerifiedProRegTxHash();`
`3725`	`3724`	`connectedNodes.emplace(pnode->addr);`
`3726`		`- if (!verifiedProRegTxHash.IsNull()) {`
	`3725`	`+ if (auto verifiedProRegTxHash = pnode->GetVerifiedProRegTxHash(); !verifiedProRegTxHash.IsNull()) {`
`3727`	`3726`	`connectedProRegTxHashes.emplace(verifiedProRegTxHash, pnode->IsInboundConn());`
`3728`	`3727`	`}`
`3729`	`3728`	`});`
`@@ -4617,7 +4616,7 @@ bool CConnman::AddPendingMasternode(const uint256& proTxHash)`
`4617`	`4616`	`return true;`
`4618`	`4617`	`}`
`4619`	`4618`
`4620`		`-void CConnman::SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::set<uint256>& proTxHashes)`
	`4619`	`+void CConnman::SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::unordered_set<uint256, StaticSaltedHasher>& proTxHashes)`
`4621`	`4620`	`{`
`4622`	`4621`	`LOCK(cs_vPendingMasternodes);`
`4623`	`4622`	`auto it = masternodeQuorumNodes.emplace(std::make_pair(llmqType, quorumHash), proTxHashes);`
`@@ -4626,7 +4625,7 @@ void CConnman::SetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint`
`4626`	`4625`	`}`
`4627`	`4626`	`}`
`4628`	`4627`
`4629`		`-void CConnman::SetMasternodeQuorumRelayMembers(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::set<uint256>& proTxHashes)`
	`4628`	`+void CConnman::SetMasternodeQuorumRelayMembers(Consensus::LLMQType llmqType, const uint256& quorumHash, const std::unordered_set<uint256, StaticSaltedHasher>& proTxHashes)`
`4630`	`4629`	`{`
`4631`	`4630`	`{`
`4632`	`4631`	`LOCK(cs_vPendingMasternodes);`
`@@ -4657,10 +4656,10 @@ bool CConnman::HasMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint`
`4657`	`4656`	`return masternodeQuorumNodes.count(std::make_pair(llmqType, quorumHash));`
`4658`	`4657`	`}`
`4659`	`4658`
`4660`		`-std::set<uint256> CConnman::GetMasternodeQuorums(Consensus::LLMQType llmqType) const`
	`4659`	`+std::unordered_set<uint256, StaticSaltedHasher> CConnman::GetMasternodeQuorums(Consensus::LLMQType llmqType) const`
`4661`	`4660`	`{`
`4662`	`4661`	`LOCK(cs_vPendingMasternodes);`
`4663`		`- std::set<uint256> result;`
	`4662`	`+ std::unordered_set<uint256, StaticSaltedHasher> result;`
`4664`	`4663`	`for (const auto& p : masternodeQuorumNodes) {`
`4665`	`4664`	`if (p.first.first != llmqType) {`
`4666`	`4665`	`continue;`
`@@ -4670,7 +4669,7 @@ std::set<uint256> CConnman::GetMasternodeQuorums(Consensus::LLMQType llmqType) c`
`4670`	`4669`	`return result;`
`4671`	`4670`	`}`
`4672`	`4671`
`4673`		`-std::set<NodeId> CConnman::GetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash) const`
	`4672`	`+std::unordered_set<NodeId> CConnman::GetMasternodeQuorumNodes(Consensus::LLMQType llmqType, const uint256& quorumHash) const`
`4674`	`4673`	`{`
`4675`	`4674`	`LOCK2(m_nodes_mutex, cs_vPendingMasternodes);`
`4676`	`4675`	`auto it = masternodeQuorumNodes.find(std::make_pair(llmqType, quorumHash));`
`@@ -4679,7 +4678,7 @@ std::set<NodeId> CConnman::GetMasternodeQuorumNodes(Consensus::LLMQType llmqType`
`4679`	`4678`	`}`
`4680`	`4679`	`const auto& proRegTxHashes = it->second;`
`4681`	`4680`
`4682`		`- std::set<NodeId> nodes;`
	`4681`	`+ std::unordered_set<NodeId> nodes;`
`4683`	`4682`	`for (const auto pnode : m_nodes) {`
`4684`	`4683`	`if (pnode->fDisconnect) {`
`4685`	`4684`	`continue;`