Refs #15288 Add mutex to DiskBuffer

Framework/Kernel/src/DiskBuffer.cpp

@@ -52,19 +52,18 @@ void DiskBuffer::toWrite(ISaveable *item) {
                              // its size in memory
   {
     // forget old memory size
-    m_mutex.lock();
+    Kernel::UniqueLockMutex uniqueLock(m_mutex);
     m_writeBufferUsed -= item->getBufferSize();
     // add new size
     size_t newMemorySize = item->getDataMemorySize();
     m_writeBufferUsed += newMemorySize;
-    m_mutex.unlock();
+    uniqueLock.unlock();
     item->setBufferSize(newMemorySize);
   } else {
-    m_mutex.lock();
+    Kernel::LockGuardMutex lock(m_mutex);
     m_toWriteBuffer.push_front(item);
     m_writeBufferUsed += item->setBufferPosition(m_toWriteBuffer.begin());
     m_nObjectsToWrite++;
-    m_mutex.unlock();
   }
 
   // Should we now write out the old data?
@@ -84,19 +83,18 @@ void DiskBuffer::objectDeleted(ISaveable *item) {
   if (item == nullptr)
     return;
   // have it ever been in the buffer?
-  m_mutex.lock();
+  Kernel::UniqueLockMutex uniqueLock(m_mutex);
   auto opt2it = item->getBufPostion();
   if (opt2it) {
     m_writeBufferUsed -= item->getBufferSize();
     m_toWriteBuffer.erase(*opt2it);
   } else {
-    m_mutex.unlock();
     return;
   }
 
   // indicate to the object that it is not stored in memory any more
   item->clearBufferState();
-  m_mutex.unlock();
+  uniqueLock.unlock();
 
   // Mark the amount of space used on disk as free
   if (item->wasSaved())
@@ -109,7 +107,7 @@ void DiskBuffer::objectDeleted(ISaveable *item) {
  */
 void DiskBuffer::writeOldObjects() {
 
-  Poco::ScopedLock<Kernel::Mutex> _lock(m_mutex);
+  Kernel::LockGuardMutex _lock(m_mutex);
   // Holder for any objects that you were NOT able to write.
   std::list<ISaveable *> couldNotWrite;
   size_t objectsNotWritten(0);
@@ -208,7 +206,7 @@ void DiskBuffer::flushCache() {
 void DiskBuffer::freeBlock(uint64_t const pos, uint64_t const size) {
   if (size == 0 || size == std::numeric_limits<uint64_t>::max())
     return;
-  m_freeMutex.lock();
+  Kernel::LockGuardMutex lock(m_freeMutex);
 
   // Make the block
   FreeBlock newBlock(pos, size);
@@ -219,7 +217,6 @@ void DiskBuffer::freeBlock(uint64_t const pos, uint64_t const size) {
   // Or, if the map has only 1 item then it cannot do any merging. This solves a
   // hanging bug in MacOS. Refs #3652
   if (!p.second || m_free.size() <= 1) {
-    m_freeMutex.unlock();
     return;
   }
 
@@ -254,8 +251,6 @@ void DiskBuffer::freeBlock(uint64_t const pos, uint64_t const size) {
       m_free.erase(it_after);
     }
   }
-
-  m_freeMutex.unlock();
 }
 
 //---------------------------------------------------------------------------------------------
@@ -264,7 +259,7 @@ void DiskBuffer::freeBlock(uint64_t const pos, uint64_t const size) {
  * automatically defrags neighboring blocks.
  */
 void DiskBuffer::defragFreeBlocks() {
-  m_freeMutex.lock();
+  Kernel::LockGuardMutex lock(m_freeMutex);
 
   freeSpace_t::iterator it = m_free.begin();
   FreeBlock thisBlock;
@@ -289,7 +284,6 @@ void DiskBuffer::defragFreeBlocks() {
       thisBlock = *it;
     }
   }
-  m_freeMutex.unlock();
 }
 
 //---------------------------------------------------------------------------------------------
@@ -300,7 +294,7 @@ void DiskBuffer::defragFreeBlocks() {
  * @return a new position at which the data can be saved.
  */
 uint64_t DiskBuffer::allocate(uint64_t const newSize) {
-  m_freeMutex.lock();
+  Kernel::UniqueLockMutex uniqueLock(m_freeMutex);
 
   // Now, find the first available block of sufficient size.
   freeSpace_bySize_t::iterator it;
@@ -318,7 +312,6 @@ uint64_t DiskBuffer::allocate(uint64_t const newSize) {
     // And we assume the file will grow by this much.
     m_fileLength += newSize;
     // Will place the new block at the end of the file
-    m_freeMutex.unlock();
     return retVal;
   } else {
     //      std::cout << "Block found for allocate " << newSize << std::endl;
@@ -326,7 +319,7 @@ uint64_t DiskBuffer::allocate(uint64_t const newSize) {
     uint64_t foundSize = it->getSize();
     // Remove the free block you found - it is no longer free
     m_free_bySize.erase(it);
-    m_freeMutex.unlock();
+    uniqueLock.unlock();
     // Block was too large - free the bit of space after it.
     if (foundSize > newSize) {
       this->freeBlock(foundPos + newSize, foundSize - newSize);

Framework/Kernel/test/DiskBufferTest.h

@@ -736,7 +736,7 @@ public:
 
   /// Fake a seek followed by a write
   static void fakeSeekAndWrite(uint64_t newPos) {
-    streamMutex.lock();
+    Kernel::LockGuardMutex lock(streamMutex);
     int64_t seek = int64_t(filePos) - int64_t(newPos);
     if (seek < 0)
       seek = -seek;
@@ -748,7 +748,6 @@ public:
     while (tim.elapsed_no_reset() < seekTime) { /*Wait*/
     }
     filePos = newPos;
-    streamMutex.unlock();
   }
   virtual void load() {
     if (this->wasSaved() && !this->isLoaded()) {