refactor: drop mutex and atomics from CMasternodeMetaInfo

It is already guarded by CMasternodeMetaMan::cs

Author: knst

src/masternode/meta.cpp

@@ -30,29 +30,24 @@ bool CMasternodeMetaMan::LoadCache(bool load_cache)
 
 UniValue CMasternodeMetaInfo::ToJson() const
 {
-    UniValue ret(UniValue::VOBJ);
-
     int64_t now = GetTime<std::chrono::seconds>().count();
 
-    ret.pushKV("lastDSQ", nLastDsq.load());
-    ret.pushKV("mixingTxCount", nMixingTxCount.load());
-    ret.pushKV("outboundAttemptCount", outboundAttemptCount.load());
-    ret.pushKV("lastOutboundAttempt", lastOutboundAttempt.load());
-    ret.pushKV("lastOutboundAttemptElapsed", now - lastOutboundAttempt.load());
-    ret.pushKV("lastOutboundSuccess", lastOutboundSuccess.load());
-    ret.pushKV("lastOutboundSuccessElapsed", now - lastOutboundSuccess.load());
-    {
-        LOCK(cs);
-        ret.pushKV("is_platform_banned", m_platform_ban);
-        ret.pushKV("platform_ban_height_updated", m_platform_ban_updated);
-    }
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("lastDSQ", nLastDsq);
+    ret.pushKV("mixingTxCount", nMixingTxCount);
+    ret.pushKV("outboundAttemptCount", outboundAttemptCount);
+    ret.pushKV("lastOutboundAttempt", lastOutboundAttempt);
+    ret.pushKV("lastOutboundAttemptElapsed", now - lastOutboundAttempt);
+    ret.pushKV("lastOutboundSuccess", lastOutboundSuccess);
+    ret.pushKV("lastOutboundSuccessElapsed", now - lastOutboundSuccess);
+    ret.pushKV("is_platform_banned", m_platform_ban);
+    ret.pushKV("platform_ban_height_updated", m_platform_ban_updated);
 
     return ret;
 }
 
 void CMasternodeMetaInfo::AddGovernanceVote(const uint256& nGovernanceObjectHash)
 {
-    LOCK(cs);
     // Insert a zero value, or not. Then increment the value regardless. This
     // ensures the value is in the map.
     const auto& pair = mapGovernanceObjectsVotedOn.emplace(nGovernanceObjectHash, 0);
@@ -61,14 +56,12 @@ void CMasternodeMetaInfo::AddGovernanceVote(const uint256& nGovernanceObjectHash
 
 void CMasternodeMetaInfo::RemoveGovernanceObject(const uint256& nGovernanceObjectHash)
 {
-    LOCK(cs);
     // Whether or not the govobj hash exists in the map first is irrelevant.
     mapGovernanceObjectsVotedOn.erase(nGovernanceObjectHash);
 }
 
 CMasternodeMetaInfo CMasternodeMetaMan::GetInfo(const uint256& proTxHash)
 {
-    LOCK(cs);
     auto it = metaInfos.find(proTxHash);
     if (it == metaInfos.end()) return CMasternodeMetaInfo{};
 

src/masternode/meta.h

@@ -32,66 +32,42 @@ static constexpr int MASTERNODE_MAX_FAILED_OUTBOUND_ATTEMPTS{5};
 // This is mostly local information, e.g. about mixing and governance
 class CMasternodeMetaInfo
 {
-    friend class CMasternodeMetaMan;
-
-private:
-    mutable Mutex cs;
-
-    uint256 proTxHash GUARDED_BY(cs);
+public:
+    uint256 proTxHash;
 
     //the dsq count from the last dsq broadcast of this node
-    std::atomic<int64_t> nLastDsq{0};
-    std::atomic<int> nMixingTxCount{0};
+    int64_t nLastDsq{0};
+    int nMixingTxCount{0};
 
     // KEEP TRACK OF GOVERNANCE ITEMS EACH MASTERNODE HAS VOTE UPON FOR RECALCULATION
-    std::map<uint256, int> mapGovernanceObjectsVotedOn GUARDED_BY(cs);
+    std::map<uint256, int> mapGovernanceObjectsVotedOn;
 
-    std::atomic<int> outboundAttemptCount{0};
-    std::atomic<int64_t> lastOutboundAttempt{0};
-    std::atomic<int64_t> lastOutboundSuccess{0};
+    int outboundAttemptCount{0};
+    int64_t lastOutboundAttempt{0};
+    int64_t lastOutboundSuccess{0};
 
     //! bool flag is node currently under platform ban by p2p message
-    bool m_platform_ban GUARDED_BY(cs){false};
+    bool m_platform_ban{false};
     //! height at which platform ban has been applied or removed
-    int m_platform_ban_updated GUARDED_BY(cs){0};
+    int m_platform_ban_updated{0};
 
 public:
     CMasternodeMetaInfo() = default;
     explicit CMasternodeMetaInfo(const uint256& _proTxHash) : proTxHash(_proTxHash) {}
-    CMasternodeMetaInfo(const CMasternodeMetaInfo& ref) :
-        proTxHash(ref.proTxHash),
-        nLastDsq(ref.nLastDsq.load()),
-        nMixingTxCount(ref.nMixingTxCount.load()),
-        mapGovernanceObjectsVotedOn(ref.mapGovernanceObjectsVotedOn),
-        lastOutboundAttempt(ref.lastOutboundAttempt.load()),
-        lastOutboundSuccess(ref.lastOutboundSuccess.load()),
-        m_platform_ban(ref.m_platform_ban),
-        m_platform_ban_updated(ref.m_platform_ban_updated)
-    {
-    }
+    CMasternodeMetaInfo(const CMasternodeMetaInfo& ref) = default;
 
-    template <typename Stream>
-    void Serialize(Stream& s) const EXCLUSIVE_LOCKS_REQUIRED(!cs)
+    SERIALIZE_METHODS(CMasternodeMetaInfo, obj)
     {
-        LOCK(cs);
-        s << proTxHash << nLastDsq << nMixingTxCount << mapGovernanceObjectsVotedOn << outboundAttemptCount
-          << lastOutboundAttempt << lastOutboundSuccess << m_platform_ban << m_platform_ban_updated;
-    }
-
-    template <typename Stream>
-    void Unserialize(Stream& s) EXCLUSIVE_LOCKS_REQUIRED(!cs)
-    {
-        LOCK(cs);
-        s >> proTxHash >> nLastDsq >> nMixingTxCount >> mapGovernanceObjectsVotedOn >> outboundAttemptCount >>
-            lastOutboundAttempt >> lastOutboundSuccess >> m_platform_ban >> m_platform_ban_updated;
+        READWRITE(obj.proTxHash, obj.nLastDsq, obj.nMixingTxCount, obj.mapGovernanceObjectsVotedOn,
+                  obj.outboundAttemptCount, obj.lastOutboundAttempt, obj.lastOutboundSuccess, obj.m_platform_ban,
+                  obj.m_platform_ban_updated);
     }
 
     UniValue ToJson() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
 public:
     const uint256 GetProTxHash() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
     {
-        LOCK(cs);
         return proTxHash;
     }
     int64_t GetLastDsq() const { return nLastDsq; }
@@ -111,7 +87,6 @@ class CMasternodeMetaInfo
     int64_t GetLastOutboundSuccess() const { return lastOutboundSuccess; }
     bool SetPlatformBan(bool is_banned, int height) EXCLUSIVE_LOCKS_REQUIRED(!cs)
     {
-        LOCK(cs);
         if (height < m_platform_ban_updated) {
             return false;
         }
@@ -124,7 +99,6 @@ class CMasternodeMetaInfo
     }
     bool IsPlatformBanned() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
     {
-        LOCK(cs);
         return m_platform_ban;
     }
 };