aboutsummaryrefslogtreecommitdiffstats
path: root/src/lib/arch
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/arch')
-rw-r--r--src/lib/arch/IArchString.cpp26
-rw-r--r--src/lib/arch/unix/ArchMultithreadPosix.cpp118
-rw-r--r--src/lib/arch/unix/ArchMultithreadPosix.h3
3 files changed, 65 insertions, 82 deletions
diff --git a/src/lib/arch/IArchString.cpp b/src/lib/arch/IArchString.cpp
index f618c12..0f7f300 100644
--- a/src/lib/arch/IArchString.cpp
+++ b/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;
}
diff --git a/src/lib/arch/unix/ArchMultithreadPosix.cpp b/src/lib/arch/unix/ArchMultithreadPosix.cpp
index ade6c51..c9ddc6c 100644
--- a/src/lib/arch/unix/ArchMultithreadPosix.cpp
+++ b/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);
- void* data = thread->m_networkData;
- unlockMutex(m_threadMutex);
- return data;
+ std::lock_guard<std::mutex> lock(m_threadMutex);
+ return thread->m_networkData;
}
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);
- assert(findNoRef(thread->m_thread) == thread);
- erase(thread);
- unlockMutex(m_threadMutex);
+ {
+ std::lock_guard<std::mutex> lock(m_threadMutex);
+ assert(findNoRef(thread->m_thread) == thread);
+ erase(thread);
+ }
// 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);
- if (!thread->m_exited && !thread->m_cancelling) {
- thread->m_cancel = true;
- wakeup = true;
+
+ {
+ 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 = findNoRef(pthread_self());
- unlockMutex(m_threadMutex);
+ ArchThreadImpl* thread = nullptr;
+ {
+ 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;
- // find current thread
- ArchThreadImpl* self = findNoRef(pthread_self());
+ {
+ std::lock_guard<std::mutex> lock(m_threadMutex);
- // ignore wait if trying to wait on ourself
- if (target == self) {
- unlockMutex(m_threadMutex);
- return false;
- }
+ // find current thread
+ self = findNoRef(pthread_self());
- // ref the target so it can't go away while we're watching it
- refThread(target);
+ // ignore wait if trying to wait on ourself
+ if (target == self) {
+ return false;
+ }
- unlockMutex(m_threadMutex);
+ // ref the target so it can't go away while we're watching it
+ refThread(target);
+ }
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);
- bool exited = thread->m_exited;
- unlockMutex(m_threadMutex);
- return exited;
+ std::lock_guard<std::mutex> lock(m_threadMutex);
+ return thread->m_exited;
}
void*
ArchMultithreadPosix::getResultOfThread(ArchThread thread)
{
- lockMutex(m_threadMutex);
- void* result = thread->m_result;
- unlockMutex(m_threadMutex);
- return result;
+ std::lock_guard<std::mutex> lock(m_threadMutex);
+ return thread->m_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);
- thread->m_exited = true;
- unlockMutex(m_threadMutex);
+ {
+ std::lock_guard<std::mutex> lock(m_threadMutex);
+ thread->m_exited = true;
+ }
closeThread(thread);
throw;
}
// thread has exited
- lockMutex(m_threadMutex);
- thread->m_result = result;
- thread->m_exited = true;
- unlockMutex(m_threadMutex);
+ {
+ std::lock_guard<std::mutex> lock(m_threadMutex);
+ thread->m_result = result;
+ thread->m_exited = true;
+ }
// done with thread
closeThread(thread);
diff --git a/src/lib/arch/unix/ArchMultithreadPosix.h b/src/lib/arch/unix/ArchMultithreadPosix.h
index 98b5eda..4bd879f 100644
--- a/src/lib/arch/unix/ArchMultithreadPosix.h
+++ b/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;
generated by cgit v1.2.3 (git 2.46.0) at 2026-01-26 22:20:20 +0000