limit the scope of m_stateMutex

include/sync-logic.h

@@ -165,6 +165,10 @@ private:
   sendSyncData (const std::string &name,
                 DigestConstPtr digest, StateConstPtr state);
 
+  void
+  sendSyncData (const std::string &name,
+                DigestConstPtr digest, SyncStateMsg &msg);
+
   size_t
   getNumberOfBranches () const;
   

model/sync-logic.cc

@@ -216,16 +216,26 @@ SyncLogic::respondSyncData (const std::string &name, const char *wireData, size_
 void
 SyncLogic::processSyncInterest (const std::string &name, DigestConstPtr digest, bool timedProcessing/*=false*/)
 {
-  recursive_mutex::scoped_lock lock (m_stateMutex);
+  DigestConstPtr rootDigest;
+  {
+    recursive_mutex::scoped_lock lock (m_stateMutex);
+    rootDigest = m_state->getDigest();
+  }
 
   // Special case when state is not empty and we have received request with zero-root digest
-  if (digest->isZero () && !m_state->getDigest()->isZero ())
+  if (digest->isZero () && !rootDigest->isZero ())
     {
-      sendSyncData (name, digest, m_state);
+      
+      SyncStateMsg ssm;
+      {
+        recursive_mutex::scoped_lock lock (m_stateMutex);
+        ssm << (*m_state);
+      }
+      sendSyncData (name, digest, ssm);
       return;
     }
 
-  if (*m_state->getDigest() == *digest)
+  if (*rootDigest == *digest)
     {
       _LOG_TRACE ("processSyncInterest (): Same state. Adding to PIT");
       m_syncInterestTable.insert (digest, name, false);
@@ -275,7 +285,6 @@ SyncLogic::processSyncData (const std::string &name, DigestConstPtr digest, cons
   
   try
     {
-      recursive_mutex::scoped_lock lock (m_stateMutex);
 
       m_syncInterestTable.remove (name); // Remove satisfied interest from PIT
 
@@ -304,7 +313,10 @@ SyncLogic::processSyncData (const std::string &name, DigestConstPtr digest, cons
               bool inserted = false;
               bool updated = false;
               SeqNo oldSeq;
-              tie (inserted, updated, oldSeq) = m_state->update (info, seq);
+              {
+                recursive_mutex::scoped_lock lock (m_stateMutex);
+                tie (inserted, updated, oldSeq) = m_state->update (info, seq);
+              }
 
               if (inserted || updated)
                 {
@@ -328,6 +340,7 @@ SyncLogic::processSyncData (const std::string &name, DigestConstPtr digest, cons
             }
           else if (diffLeaf->getOperation() == REMOVE)
             {
+              recursive_mutex::scoped_lock lock (m_stateMutex);
               if (m_state->remove (info))
                 {
                   diffLog->remove (info);
@@ -373,7 +386,6 @@ SyncLogic::processSyncData (const std::string &name, DigestConstPtr digest, cons
 void
 SyncLogic::processSyncRecoveryInterest (const std::string &name, DigestConstPtr digest)
 {
-  recursive_mutex::scoped_lock lock (m_stateMutex);
   
   DiffStateContainer::iterator stateInDiffLog = m_log.find (digest);
 
@@ -383,7 +395,12 @@ SyncLogic::processSyncRecoveryInterest (const std::string &name, DigestConstPtr
       return;
     }
 
-  sendSyncData (name, digest, m_state);
+  SyncStateMsg ssm;
+  {
+    recursive_mutex::scoped_lock lock (m_stateMutex);
+    ssm << (*m_state);
+  }
+  sendSyncData (name, digest, ssm);
 }
 
 void
@@ -542,11 +559,18 @@ SyncLogic::sendSyncRecoveryInterests (DigestConstPtr digest)
 
 void
 SyncLogic::sendSyncData (const std::string &name, DigestConstPtr digest, StateConstPtr state)
+{
+  SyncStateMsg msg;
+  msg << (*state);
+  sendSyncData(name, digest, msg);
+}
+
+// pass in state msg instead of state, so that there is no need to lock the state until
+// this function returns
+void
+SyncLogic::sendSyncData (const std::string &name, DigestConstPtr digest, SyncStateMsg &ssm)
 {
   _LOG_TRACE (">> D " << name);
-  // sending
-  SyncStateMsg ssm;
-  ssm << (*state);
   int size = ssm.ByteSize();
   char *wireData = new char[size];
   ssm.SerializeToArray(wireData, size);