refactor: enhance thread safety for SML caching with mutex protection

Author: PastaPastaPasta

src/evo/deterministicmns.cpp

@@ -266,6 +266,7 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl
 
 gsl::not_null<std::shared_ptr<const CSimplifiedMNList>> CDeterministicMNList::to_sml() const
 {
+    LOCK(m_cached_sml_mutex);
     if (!m_cached_sml) {
         std::vector<std::unique_ptr<CSimplifiedMNListEntry>> sml_entries;
         sml_entries.reserve(mnMap.size());
@@ -464,7 +465,10 @@ void CDeterministicMNList::AddMN(const CDeterministicMNCPtr& dmn, bool fBumpTota
 
     mnMap = mnMap.set(dmn->proTxHash, dmn);
     mnInternalIdMap = mnInternalIdMap.set(dmn->GetInternalId(), dmn->proTxHash);
-    m_cached_sml = nullptr;
+    {
+        LOCK(m_cached_sml_mutex);
+        m_cached_sml = nullptr;
+    }
     if (fBumpTotalCount) {
         // nTotalRegisteredCount acts more like a checkpoint, not as a limit,
         nTotalRegisteredCount = std::max(dmn->GetInternalId() + 1, (uint64_t)nTotalRegisteredCount);
@@ -535,8 +539,11 @@ void CDeterministicMNList::UpdateMN(const CDeterministicMN& oldDmn, const std::s
 
     dmn->pdmnState = pdmnState;
     mnMap = mnMap.set(oldDmn.proTxHash, dmn);
-    if (m_cached_sml && oldDmn.to_sml_entry() != dmn->to_sml_entry()) {
-        m_cached_sml = nullptr;
+    {
+        LOCK(m_cached_sml_mutex);
+        if (m_cached_sml && oldDmn.to_sml_entry() != dmn->to_sml_entry()) {
+            m_cached_sml = nullptr;
+        }
     }
 }
 
@@ -609,7 +616,10 @@ void CDeterministicMNList::RemoveMN(const uint256& proTxHash)
 
     mnMap = mnMap.erase(proTxHash);
     mnInternalIdMap = mnInternalIdMap.erase(dmn->GetInternalId());
-    m_cached_sml = nullptr;
+    {
+        LOCK(m_cached_sml_mutex);
+        m_cached_sml = nullptr;
+    }
 }
 
 bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<const CBlockIndex*> pindex,

src/evo/deterministicmns.h

@@ -179,7 +179,9 @@ class CDeterministicMNList
     // for multiple CDeterministicMNList until mnMap is actually changed.
     // Calls of AddMN, RemoveMN and (in some cases) UpdateMN reset this cache;
     // it happens also for indirect calls such as ApplyDiff
-    mutable std::shared_ptr<const CSimplifiedMNList> m_cached_sml;
+    // Thread safety: Protected by its own mutex for thread-safe access
+    mutable Mutex m_cached_sml_mutex;
+    mutable std::shared_ptr<const CSimplifiedMNList> m_cached_sml GUARDED_BY(m_cached_sml_mutex);
 
 public:
     CDeterministicMNList() = default;
@@ -191,6 +193,36 @@ class CDeterministicMNList
         assert(nHeight >= 0);
     }
 
+    // Copy constructor
+    CDeterministicMNList(const CDeterministicMNList& other) :
+        blockHash(other.blockHash),
+        nHeight(other.nHeight),
+        nTotalRegisteredCount(other.nTotalRegisteredCount),
+        mnMap(other.mnMap),
+        mnInternalIdMap(other.mnInternalIdMap),
+        mnUniquePropertyMap(other.mnUniquePropertyMap)
+    {
+        LOCK(other.m_cached_sml_mutex);
+        m_cached_sml = other.m_cached_sml;
+    }
+
+    // Assignment operator
+    CDeterministicMNList& operator=(const CDeterministicMNList& other)
+    {
+        if (this != &other) {
+            blockHash = other.blockHash;
+            nHeight = other.nHeight;
+            nTotalRegisteredCount = other.nTotalRegisteredCount;
+            mnMap = other.mnMap;
+            mnInternalIdMap = other.mnInternalIdMap;
+            mnUniquePropertyMap = other.mnUniquePropertyMap;
+            
+            LOCK2(m_cached_sml_mutex, other.m_cached_sml_mutex);
+            m_cached_sml = other.m_cached_sml;
+        }
+        return *this;
+    }
+
     template <typename Stream, typename Operation>
     inline void SerializationOpBase(Stream& s, Operation ser_action)
     {
@@ -215,7 +247,10 @@ class CDeterministicMNList
         mnMap = MnMap();
         mnUniquePropertyMap = MnUniquePropertyMap();
         mnInternalIdMap = MnInternalIdMap();
-        m_cached_sml = nullptr;
+        {
+            LOCK(m_cached_sml_mutex);
+            m_cached_sml = nullptr;
+        }
 
         SerializationOpBase(s, CSerActionUnserialize());
 
@@ -344,6 +379,7 @@ class CDeterministicMNList
 
     /**
      * Calculates CSimplifiedMNList for current list and cache it
+     * Thread safety: Uses internal mutex for thread-safe cache access
      */
     gsl::not_null<std::shared_ptr<const CSimplifiedMNList>> to_sml() const;