Use standard mutex APIs instead of the home-grown wrapper (#410)

Use standard mutex APIs instead of the home-grown wrapper

src/lib/arch/IArchString.cpp

@@ -24,7 +24,9 @@
 #include <cstring>
 #include <cstdlib>
 
-static ArchMutex              s_mutex = NULL;
+#include <mutex>
+
+std::mutex s_mutex;
 
 //
 // use C library non-reentrant multibyte conversion with mutex
@@ -32,16 +34,14 @@ static ArchMutex              s_mutex = NULL;
 
 IArchString::~IArchString()
 {
-    if (s_mutex != NULL) {
-        ARCH->closeMutex(s_mutex);
-        s_mutex = NULL;
-    }
 }
 
 int
 IArchString::convStringWCToMB(char* dst,
                 const wchar_t* src, UInt32 n, bool* errors)
 {
+    std::lock_guard<std::mutex> lock(s_mutex);
+
     ptrdiff_t len = 0;
 
     bool dummyErrors;
@@ -49,12 +49,6 @@ IArchString::convStringWCToMB(char* dst,
         errors = &dummyErrors;
     }
 
-    if (s_mutex == NULL) {
-        s_mutex = ARCH->newMutex();
-    }
-
-    ARCH->lockMutex(s_mutex);
-
     if (dst == NULL) {
         char dummy[MB_LEN_MAX];
         for (const wchar_t* scan = src; n > 0; ++scan, --n) {
@@ -89,7 +83,6 @@ IArchString::convStringWCToMB(char* dst,
         }
         len = dst - dst0;
     }
-    ARCH->unlockMutex(s_mutex);
 
     return (int)len;
 }
@@ -98,6 +91,8 @@ int
 IArchString::convStringMBToWC(wchar_t* dst,
                 const char* src, UInt32 n_param, bool* errors)
 {
+    std::lock_guard<std::mutex> lock(s_mutex);
+
     ptrdiff_t n = (ptrdiff_t)n_param; // fix compiler warning
     ptrdiff_t len = 0;
     wchar_t dummy;
@@ -107,12 +102,6 @@ IArchString::convStringMBToWC(wchar_t* dst,
         errors = &dummyErrors;
     }
 
-    if (s_mutex == NULL) {
-        s_mutex = ARCH->newMutex();
-    }
-
-    ARCH->lockMutex(s_mutex);
-
     if (dst == NULL) {
         for (const char* scan = src; n > 0; ) {
             ptrdiff_t mblen = mbtowc(&dummy, scan, n);
@@ -184,7 +173,6 @@ IArchString::convStringMBToWC(wchar_t* dst,
         }
         len = dst - dst0;
     }
-    ARCH->unlockMutex(s_mutex);
 
     return (int)len;
 }

src/lib/arch/unix/ArchMultithreadPosix.cpp

@@ -114,9 +114,6 @@ ArchMultithreadPosix::ArchMultithreadPosix() :
         m_signalUserData[i] = NULL;
     }
 
-    // create mutex for thread list
-    m_threadMutex = newMutex();
-
     // create thread for calling (main) thread and add it to our
     // list.  no need to lock the mutex since we're the only thread.
     m_mainThread           = new ArchThreadImpl;
@@ -153,26 +150,22 @@ ArchMultithreadPosix::~ArchMultithreadPosix()
 {
     assert(s_instance != NULL);
 
-    closeMutex(m_threadMutex);
     s_instance = NULL;
 }
 
 void
 ArchMultithreadPosix::setNetworkDataForCurrentThread(void* data)
 {
-    lockMutex(m_threadMutex);
+    std::lock_guard<std::mutex> lock(m_threadMutex);
     ArchThreadImpl* thread = find(pthread_self());
     thread->m_networkData = data;
-    unlockMutex(m_threadMutex);
 }
 
 void*
 ArchMultithreadPosix::getNetworkDataForThread(ArchThread thread)
 {
-    lockMutex(m_threadMutex);
+    std::lock_guard<std::mutex> lock(m_threadMutex);
-    void* data = thread->m_networkData;
+    return thread->m_networkData;
-    unlockMutex(m_threadMutex);
-    return data;
 }
 
 ArchMultithreadPosix*
@@ -356,7 +349,8 @@ ArchMultithreadPosix::newThread(ThreadFunc func, void* data)
 #endif
     }
 
-    lockMutex(m_threadMutex);
+    // note that the child thread will wait until we release this mutex
+    std::lock_guard<std::mutex> lock(m_threadMutex);
 
     // create thread impl for new thread
     ArchThreadImpl* thread = new ArchThreadImpl;
@@ -387,18 +381,15 @@ ArchMultithreadPosix::newThread(ThreadFunc func, void* data)
         refThread(thread);
     }
 
-    // note that the child thread will wait until we release this mutex
-    unlockMutex(m_threadMutex);
-
     return thread;
 }
 
 ArchThread
 ArchMultithreadPosix::newCurrentThread()
 {
-    lockMutex(m_threadMutex);
+    std::lock_guard<std::mutex> lock(m_threadMutex);
+
     ArchThreadImpl* thread = find(pthread_self());
-    unlockMutex(m_threadMutex);
     assert(thread != NULL);
     return thread;
 }
@@ -416,10 +407,11 @@ ArchMultithreadPosix::closeThread(ArchThread thread)
         }
 
         // remove thread from list
-        lockMutex(m_threadMutex);
+        {
+            std::lock_guard<std::mutex> lock(m_threadMutex);
             assert(findNoRef(thread->m_thread) == thread);
             erase(thread);
-        unlockMutex(m_threadMutex);
+        }
 
         // done with thread
         delete thread;
@@ -440,12 +432,14 @@ ArchMultithreadPosix::cancelThread(ArchThread thread)
 
     // set cancel and wakeup flags if thread can be cancelled
     bool wakeup = false;
-    lockMutex(m_threadMutex);
+
+    {
+        std::lock_guard<std::mutex> lock(m_threadMutex);
         if (!thread->m_exited && !thread->m_cancelling) {
             thread->m_cancel = true;
             wakeup = true;
         }
-    unlockMutex(m_threadMutex);
+    }
 
     // force thread to exit system calls if wakeup is true
     if (wakeup) {
@@ -465,9 +459,11 @@ void
 ArchMultithreadPosix::testCancelThread()
 {
     // find current thread
-    lockMutex(m_threadMutex);
+    ArchThreadImpl* thread = nullptr;
-    ArchThreadImpl* thread = findNoRef(pthread_self());
+    {
-    unlockMutex(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
+        thread = findNoRef(pthread_self());
+    }
 
     // test cancel on thread
     testCancelThreadImpl(thread);
@@ -478,21 +474,22 @@ ArchMultithreadPosix::wait(ArchThread target, double timeout)
 {
     assert(target != NULL);
 
-    lockMutex(m_threadMutex);
+    ArchThreadImpl* self = nullptr;
+
+    {
+        std::lock_guard<std::mutex> lock(m_threadMutex);
 
         // find current thread
-    ArchThreadImpl* self = findNoRef(pthread_self());
+        self = findNoRef(pthread_self());
 
         // ignore wait if trying to wait on ourself
         if (target == self) {
-        unlockMutex(m_threadMutex);
             return false;
         }
 
         // ref the target so it can't go away while we're watching it
         refThread(target);
-
+    }
-    unlockMutex(m_threadMutex);
 
     try {
         // do first test regardless of timeout
@@ -538,19 +535,15 @@ ArchMultithreadPosix::isSameThread(ArchThread thread1, ArchThread thread2)
 bool
 ArchMultithreadPosix::isExitedThread(ArchThread thread)
 {
-    lockMutex(m_threadMutex);
+    std::lock_guard<std::mutex> lock(m_threadMutex);
-    bool exited = thread->m_exited;
+    return thread->m_exited;
-    unlockMutex(m_threadMutex);
-    return exited;
 }
 
 void*
 ArchMultithreadPosix::getResultOfThread(ArchThread thread)
 {
-    lockMutex(m_threadMutex);
+    std::lock_guard<std::mutex> lock(m_threadMutex);
-    void* result = thread->m_result;
+    return thread->m_result;
-    unlockMutex(m_threadMutex);
-    return result;
 }
 
 IArchMultithread::ThreadID
@@ -563,16 +556,15 @@ void
 ArchMultithreadPosix::setSignalHandler(
                 ESignal signal, SignalFunc func, void* userData)
 {
-    lockMutex(m_threadMutex);
+    std::lock_guard<std::mutex> lock(m_threadMutex);
     m_signalFunc[signal]     = func;
     m_signalUserData[signal] = userData;
-    unlockMutex(m_threadMutex);
 }
 
 void
 ArchMultithreadPosix::raiseSignal(ESignal signal) 
 {
-    lockMutex(m_threadMutex);
+    std::lock_guard<std::mutex> lock(m_threadMutex);
     if (m_signalFunc[signal] != NULL) {
         m_signalFunc[signal](signal, m_signalUserData[signal]);
         pthread_kill(m_mainThread->m_thread, SIGWAKEUP);
@@ -580,7 +572,6 @@ ArchMultithreadPosix::raiseSignal(ESignal signal)
     else if (signal == kINTERRUPT || signal == kTERMINATE) {
         ARCH->cancelThread(m_mainThread);
     }
-    unlockMutex(m_threadMutex);
 }
 
 void
@@ -677,15 +668,15 @@ ArchMultithreadPosix::testCancelThreadImpl(ArchThreadImpl* thread)
 {
     assert(thread != NULL);
 
+    std::lock_guard<std::mutex> lock(m_threadMutex);
+
     // update cancel state
-    lockMutex(m_threadMutex);
     bool cancel = false;
     if (thread->m_cancel && !thread->m_cancelling) {
         thread->m_cancelling = true;
         thread->m_cancel     = false;
         cancel               = true;
     }
-    unlockMutex(m_threadMutex);
 
     // unwind thread's stack if cancelling
     if (cancel) {
@@ -717,8 +708,9 @@ ArchMultithreadPosix::doThreadFunc(ArchThread thread)
     setPriorityOfThread(thread, 1);
 
     // wait for parent to initialize this object
-    lockMutex(m_threadMutex);
+    {
-    unlockMutex(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
+    }
 
     void* result = NULL;
     try {
@@ -731,18 +723,20 @@ ArchMultithreadPosix::doThreadFunc(ArchThread thread)
     }
     catch (...) {
         // note -- don't catch (...) to avoid masking bugs
-        lockMutex(m_threadMutex);
+        {
+            std::lock_guard<std::mutex> lock(m_threadMutex);
             thread->m_exited = true;
-        unlockMutex(m_threadMutex);
+        }
         closeThread(thread);
         throw;
     }
 
     // thread has exited
-    lockMutex(m_threadMutex);
+    {
+        std::lock_guard<std::mutex> lock(m_threadMutex);
         thread->m_result = result;
         thread->m_exited = true;
-    unlockMutex(m_threadMutex);
+    }
 
     // done with thread
     closeThread(thread);

src/lib/arch/unix/ArchMultithreadPosix.h

@@ -22,6 +22,7 @@
 #include "common/stdlist.h"
 
 #include <pthread.h>
+#include <mutex>
 
 #define ARCH_MULTITHREAD ArchMultithreadPosix
 
@@ -104,7 +105,7 @@ private:
 
     bool                m_newThreadCalled;
 
-    ArchMutex            m_threadMutex;
+    std::mutex m_threadMutex;
     ArchThread            m_mainThread;
     ThreadList            m_threadList;
     ThreadID            m_nextID;

src/lib/base/EventQueue.cpp

@@ -90,7 +90,6 @@ EventQueue::EventQueue() :
     m_readyMutex(new Mutex),
     m_readyCondVar(new CondVar<bool>(m_readyMutex, false))
 {
-    m_mutex = ARCH->newMutex();
     ARCH->setSignalHandler(Arch::kINTERRUPT, &interrupt, this);
     ARCH->setSignalHandler(Arch::kTERMINATE, &interrupt, this);
     m_buffer = new SimpleEventQueueBuffer;
@@ -104,7 +103,6 @@ EventQueue::~EventQueue()
     
     ARCH->setSignalHandler(Arch::kINTERRUPT, NULL, NULL);
     ARCH->setSignalHandler(Arch::kTERMINATE, NULL, NULL);
-    ARCH->closeMutex(m_mutex);
 }
 
 void
@@ -136,7 +134,7 @@ EventQueue::loop()
 Event::Type
 EventQueue::registerTypeOnce(Event::Type& type, const char* name)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     if (type == Event::kUnknown) {
         m_typeMap.insert(std::make_pair(m_nextType, name));
         m_nameMap.insert(std::make_pair(name, m_nextType));
@@ -176,7 +174,7 @@ EventQueue::getTypeName(Event::Type type)
 void
 EventQueue::adoptBuffer(IEventQueueBuffer* buffer)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
 
     LOG((CLOG_DEBUG "adopting new buffer"));
 
@@ -261,7 +259,7 @@ retry:
 
     case IEventQueueBuffer::kUser:
         {
-            ArchMutexLock lock(m_mutex);
+            std::lock_guard<std::mutex> lock(m_mutex);
             event = removeEvent(dataID);
             return true;
         }
@@ -316,7 +314,7 @@ EventQueue::addEvent(const Event& event)
 void
 EventQueue::addEventToBuffer(const Event& event)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     
     // store the event's data locally
     UInt32 eventID = saveEvent(event);
@@ -338,7 +336,7 @@ EventQueue::newTimer(double duration, void* target)
     if (target == NULL) {
         target = timer;
     }
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     m_timers.insert(timer);
     // initial duration is requested duration plus whatever's on
     // the clock currently because the latter will be subtracted
@@ -357,7 +355,7 @@ EventQueue::newOneShotTimer(double duration, void* target)
     if (target == NULL) {
         target = timer;
     }
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     m_timers.insert(timer);
     // initial duration is requested duration plus whatever's on
     // the clock currently because the latter will be subtracted
@@ -370,7 +368,7 @@ EventQueue::newOneShotTimer(double duration, void* target)
 void
 EventQueue::deleteTimer(EventQueueTimer* timer)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     for (TimerQueue::iterator index = m_timerQueue.begin();
                             index != m_timerQueue.end(); ++index) {
         if (index->getTimer() == timer) {
@@ -388,7 +386,7 @@ EventQueue::deleteTimer(EventQueueTimer* timer)
 void
 EventQueue::adoptHandler(Event::Type type, void* target, IEventJob* handler)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     IEventJob*& job = m_handlers[target][type];
     delete job;
     job = handler;
@@ -399,7 +397,7 @@ EventQueue::removeHandler(Event::Type type, void* target)
 {
     IEventJob* handler = NULL;
     {
-        ArchMutexLock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         HandlerTable::iterator index = m_handlers.find(target);
         if (index != m_handlers.end()) {
             TypeHandlerTable& typeHandlers = index->second;
@@ -418,7 +416,7 @@ EventQueue::removeHandlers(void* target)
 {
     std::vector<IEventJob*> handlers;
     {
-        ArchMutexLock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         HandlerTable::iterator index = m_handlers.find(target);
         if (index != m_handlers.end()) {
             // copy to handlers array and clear table for target
@@ -447,7 +445,7 @@ EventQueue::isEmpty() const
 IEventJob*
 EventQueue::getHandler(Event::Type type, void* target) const
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     HandlerTable::const_iterator index = m_handlers.find(target);
     if (index != m_handlers.end()) {
         const TypeHandlerTable& typeHandlers = index->second;

src/lib/base/EventQueue.h

@@ -28,10 +28,9 @@
 #include "common/stdset.h"
 #include "base/NonBlockingStream.h"
 
+#include <mutex>
 #include <queue>
 
-class Mutex;
-
 //! Event queue
 /*!
 An event queue that implements the platform independent parts and
@@ -114,7 +113,7 @@ private:
     typedef std::map<void*, TypeHandlerTable> HandlerTable;
 
     int                    m_systemTarget;
-    ArchMutex            m_mutex;
+    mutable std::mutex m_mutex;
 
     // registered events
     Event::Type        m_nextType;

src/lib/base/Log.cpp

@@ -63,9 +63,6 @@ Log::Log()
 {
     assert(s_log == NULL);
 
-    // create mutex for multithread safe operation
-    m_mutex = ARCH->newMutex();
-
     // other initalization
     m_maxPriority = g_defaultMaxPriority;
     m_maxNewlineLength = 0;
@@ -90,7 +87,6 @@ Log::~Log()
                                     index != m_alwaysOutputters.end(); ++index) {
         delete *index;
     }
-    ARCH->closeMutex(m_mutex);
 }
 
 Log*
@@ -214,7 +210,7 @@ Log::insert(ILogOutputter* outputter, bool alwaysAtHead)
 {
     assert(outputter != NULL);
 
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     if (alwaysAtHead) {
         m_alwaysOutputters.push_front(outputter);
     }
@@ -237,7 +233,7 @@ Log::insert(ILogOutputter* outputter, bool alwaysAtHead)
 void
 Log::remove(ILogOutputter* outputter)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     m_outputters.remove(outputter);
     m_alwaysOutputters.remove(outputter);
 }
@@ -245,7 +241,7 @@ Log::remove(ILogOutputter* outputter)
 void
 Log::pop_front(bool alwaysAtHead)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     OutputterList* list = alwaysAtHead ? &m_alwaysOutputters : &m_outputters;
     if (!list->empty()) {
         delete list->front();
@@ -271,14 +267,14 @@ Log::setFilter(const char* maxPriority)
 void
 Log::setFilter(int maxPriority)
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     m_maxPriority = maxPriority;
 }
 
 int
 Log::getFilter() const
 {
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
     return m_maxPriority;
 }
 
@@ -289,7 +285,7 @@ Log::output(ELevel priority, char* msg)
     assert(msg != NULL);
     if (!msg) return;
 
-    ArchMutexLock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
 
     OutputterList::const_iterator i;
 

src/lib/base/Log.h

@@ -24,6 +24,7 @@
 #include "common/stdlist.h"
 
 #include <stdarg.h>
+#include <mutex>
 
 #define CLOG (Log::getInstance())
 #define BYE "\nTry `%s --help' for more information."
@@ -132,7 +133,7 @@ private:
 
     static Log*        s_log;
 
-    ArchMutex            m_mutex;
+    mutable std::mutex m_mutex;
     OutputterList        m_outputters;
     OutputterList        m_alwaysOutputters;
     int                    m_maxNewlineLength;

src/lib/ipc/IpcClientProxy.cpp

@@ -34,8 +34,6 @@ IpcClientProxy::IpcClientProxy(barrier::IStream& stream, IEventQueue* events) :
     m_stream(stream),
     m_clientType(kIpcClientUnknown),
     m_disconnecting(false),
-    m_readMutex(ARCH->newMutex()),
-    m_writeMutex(ARCH->newMutex()),
     m_events(events)
 {
     m_events->adoptHandler(
@@ -71,14 +69,11 @@ IpcClientProxy::~IpcClientProxy()
         m_events->forIStream().outputShutdown(), m_stream.getEventTarget());
     
     // don't delete the stream while it's being used.
-    ARCH->lockMutex(m_readMutex);
+    {
-    ARCH->lockMutex(m_writeMutex);
+        std::lock_guard<std::mutex> lock_read(m_readMutex);
+        std::lock_guard<std::mutex> lock_write(m_writeMutex);
         delete &m_stream;
-    ARCH->unlockMutex(m_readMutex);
+    }
-    ARCH->unlockMutex(m_writeMutex);
-
-    ARCH->closeMutex(m_readMutex);
-    ARCH->closeMutex(m_writeMutex);
 }
 
 void
@@ -99,7 +94,7 @@ void
 IpcClientProxy::handleData(const Event&, void*)
 {
     // don't allow the dtor to destroy the stream while we're using it.
-    ArchMutexLock lock(m_readMutex);
+    std::lock_guard<std::mutex> lock(m_readMutex);
 
     LOG((CLOG_DEBUG "start ipc handle data"));
 
@@ -139,7 +134,7 @@ IpcClientProxy::send(const IpcMessage& message)
     // don't allow other threads to write until we've finished the entire
     // message. stream write is locked, but only for that single write.
     // also, don't allow the dtor to destroy the stream while we're using it.
-    ArchMutexLock lock(m_writeMutex);
+    std::lock_guard<std::mutex> lock(m_writeMutex);
 
     LOG((CLOG_DEBUG4 "ipc write: %d", message.type()));
 

src/lib/ipc/IpcClientProxy.h

@@ -23,6 +23,8 @@
 #include "base/EventTypes.h"
 #include "base/Event.h"
 
+#include <mutex>
+
 namespace barrier { class IStream; }
 class IpcMessage;
 class IpcCommandMessage;
@@ -49,7 +51,7 @@ private:
     barrier::IStream&    m_stream;
     EIpcClientType        m_clientType;
     bool                m_disconnecting;
-    ArchMutex            m_readMutex;
+    std::mutex m_readMutex;
-    ArchMutex            m_writeMutex;
+    std::mutex m_writeMutex;
     IEventQueue*        m_events;
 };

src/lib/ipc/IpcLogOutputter.cpp

@@ -39,7 +39,6 @@ enum EIpcLogOutputter {
 
 IpcLogOutputter::IpcLogOutputter(IpcServer& ipcServer, EIpcClientType clientType, bool useThread) :
     m_ipcServer(ipcServer),
-    m_bufferMutex(ARCH->newMutex()),
     m_sending(false),
     m_bufferThread(nullptr),
     m_running(false),
@@ -52,8 +51,7 @@ IpcLogOutputter::IpcLogOutputter(IpcServer& ipcServer, EIpcClientType clientType
     m_bufferRateTimeLimit(kBufferRateTimeLimit),
     m_bufferWriteCount(0),
     m_bufferRateStart(ARCH->time()),
-    m_clientType(clientType),
+    m_clientType(clientType)
-    m_runningMutex(ARCH->newMutex())
 {
     if (useThread) {
         m_bufferThread = new Thread(new TMethodJob<IpcLogOutputter>(
@@ -65,8 +63,6 @@ IpcLogOutputter::~IpcLogOutputter()
 {
     close();
 
-    ARCH->closeMutex(m_bufferMutex);
-
     if (m_bufferThread != nullptr) {
         m_bufferThread->cancel();
         m_bufferThread->wait();
@@ -86,7 +82,7 @@ void
 IpcLogOutputter::close()
 {
     if (m_bufferThread != nullptr) {
-        ArchMutexLock lock(m_runningMutex);
+        std::lock_guard<std::mutex> lock(m_runningMutex);
         m_running = false;
         notifyBuffer();
         m_bufferThread->wait(5);
@@ -116,7 +112,7 @@ IpcLogOutputter::write(ELevel, const char* text)
 void
 IpcLogOutputter::appendBuffer(const String& text)
 {
-    ArchMutexLock lock(m_bufferMutex);
+    std::lock_guard<std::mutex> lock(m_bufferMutex);
 
     double elapsed = ARCH->time() - m_bufferRateStart;
     if (elapsed < m_bufferRateTimeLimit) {
@@ -143,7 +139,7 @@ IpcLogOutputter::appendBuffer(const String& text)
 bool
 IpcLogOutputter::isRunning()
 {
-    ArchMutexLock lock(m_runningMutex);
+    std::lock_guard<std::mutex> lock(m_runningMutex);
     return m_running;
 }
 
@@ -180,7 +176,7 @@ IpcLogOutputter::notifyBuffer()
 String
 IpcLogOutputter::getChunk(size_t count)
 {
-    ArchMutexLock lock(m_bufferMutex);
+    std::lock_guard<std::mutex> lock(m_bufferMutex);
 
     if (m_buffer.size() < count) {
         count = m_buffer.size();

src/lib/ipc/IpcLogOutputter.h

@@ -24,6 +24,7 @@
 #include "ipc/Ipc.h"
 
 #include <deque>
+#include <mutex>
 
 class IpcServer;
 class Event;
@@ -100,7 +101,7 @@ private:
 
     IpcServer&            m_ipcServer;
     Buffer                m_buffer;
-    ArchMutex            m_bufferMutex;
+    std::mutex m_bufferMutex;
     bool                m_sending;
     Thread*                m_bufferThread;
     bool                m_running;
@@ -115,5 +116,5 @@ private:
     UInt16                m_bufferWriteCount;
     double                m_bufferRateStart;
     EIpcClientType        m_clientType;
-    ArchMutex            m_runningMutex;
+    std::mutex m_runningMutex;
 };

src/lib/ipc/IpcServer.cpp

@@ -56,7 +56,6 @@ IpcServer::init()
 {
     m_socket = new TCPListenSocket(m_events, m_socketMultiplexer, IArchNetwork::kINET);
 
-    m_clientsMutex = ARCH->newMutex();
     m_address.resolve();
 
     m_events->adoptHandler(
@@ -75,14 +74,14 @@ IpcServer::~IpcServer()
         delete m_socket;
     }
 
-    ARCH->lockMutex(m_clientsMutex);
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
         ClientList::iterator it;
         for (it = m_clients.begin(); it != m_clients.end(); it++) {
             deleteClient(*it);
         }
         m_clients.clear();
-    ARCH->unlockMutex(m_clientsMutex);
+    }
-    ARCH->closeMutex(m_clientsMutex);
 
     m_events->removeHandler(m_events->forIListenSocket().connecting(), m_socket);
 }
@@ -103,10 +102,12 @@ IpcServer::handleClientConnecting(const Event&, void*)
 
     LOG((CLOG_DEBUG "accepted ipc client connection"));
 
-    ARCH->lockMutex(m_clientsMutex);
+    IpcClientProxy* proxy = nullptr;
-    IpcClientProxy* proxy = new IpcClientProxy(*stream, m_events);
+    {
+        std::lock_guard<std::mutex> lock(m_clientsMutex);
+        proxy = new IpcClientProxy(*stream, m_events);
         m_clients.push_back(proxy);
-    ARCH->unlockMutex(m_clientsMutex);
+    }
 
     m_events->adoptHandler(
         m_events->forIpcClientProxy().disconnected(), proxy,
@@ -127,7 +128,7 @@ IpcServer::handleClientDisconnected(const Event& e, void*)
 {
     IpcClientProxy* proxy = static_cast<IpcClientProxy*>(e.getTarget());
 
-    ArchMutexLock lock(m_clientsMutex);
+    std::lock_guard<std::mutex> lock(m_clientsMutex);
     m_clients.remove(proxy);
     deleteClient(proxy);
 
@@ -153,7 +154,7 @@ IpcServer::deleteClient(IpcClientProxy* proxy)
 bool
 IpcServer::hasClients(EIpcClientType clientType) const
 {
-    ArchMutexLock lock(m_clientsMutex);
+    std::lock_guard<std::mutex> lock(m_clientsMutex);
 
     if (m_clients.empty()) {
         return false;
@@ -175,7 +176,7 @@ IpcServer::hasClients(EIpcClientType clientType) const
 void
 IpcServer::send(const IpcMessage& message, EIpcClientType filterType)
 {
-    ArchMutexLock lock(m_clientsMutex);
+    std::lock_guard<std::mutex> lock(m_clientsMutex);
 
     ClientList::iterator it;
     for (it = m_clients.begin(); it != m_clients.end(); it++) {

src/lib/ipc/IpcServer.h

@@ -25,6 +25,7 @@
 #include "base/EventTypes.h"
 
 #include <list>
+#include <mutex>
 
 class Event;
 class IpcClientProxy;
@@ -79,7 +80,7 @@ private:
     TCPListenSocket*    m_socket;
     NetworkAddress        m_address;
     ClientList            m_clients;
-    ArchMutex            m_clientsMutex;
+    mutable std::mutex m_clientsMutex;
 
 #ifdef TEST_ENV
 public: