gvsafronov/futriix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

only use internal locks when multithreaded (#205)

Browse Source
This commit is contained in:
Malavan Sotheeswaran 2023-09-25 15:53:47 -04:00 committed by GitHub Enterprise
parent 570bcb55c7
commit 596c513d3e
2 changed files with 48 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ae.cpp
View File

@ -861,7 +861,7 @@ void aeReleaseForkLock()
void aeForkLockInChild() void aeForkLockInChild()
{ {
g_forkLock.setNotify(false); g_forkLock.setMulti(false);
} }
int aeThreadOwnsLock() int aeThreadOwnsLock()

36
src/readwritelock.h
View File

@ -8,29 +8,36 @@ class readWriteLock {
int m_readCount = 0; int m_readCount = 0;
int m_writeCount = 0; int m_writeCount = 0;
bool m_writeWaiting = false; bool m_writeWaiting = false;
bool m_notify = true; bool m_multi = true;
public: public:
readWriteLock(const char *name) : m_readLock(name), m_writeLock(name) {} readWriteLock(const char *name) : m_readLock(name), m_writeLock(name) {}
void acquireRead() { void acquireRead() {
std::unique_lock<fastlock> rm(m_readLock); std::unique_lock<fastlock> rm(m_readLock, std::defer_lock);
if (m_multi) {
rm.lock();
while (m_writeCount > 0 || m_writeWaiting) while (m_writeCount > 0 || m_writeWaiting)
m_cv.wait(rm); m_cv.wait(rm);
}
m_readCount++; m_readCount++;
} }
bool tryAcquireRead() { bool tryAcquireRead() {
std::unique_lock<fastlock> rm(m_readLock, std::defer_lock); std::unique_lock<fastlock> rm(m_readLock, std::defer_lock);
if (m_multi) {
if (!rm.try_lock()) if (!rm.try_lock())
return false; return false;
if (m_writeCount > 0 || m_writeWaiting) if (m_writeCount > 0 || m_writeWaiting)
return false; return false;
}
m_readCount++; m_readCount++;
return true; return true;
} }
void acquireWrite(bool exclusive = true) { void acquireWrite(bool exclusive = true) {
std::unique_lock<fastlock> rm(m_readLock); std::unique_lock<fastlock> rm(m_readLock, std::defer_lock);
if (m_multi) {
rm.lock();
m_writeWaiting = true; m_writeWaiting = true;
while (m_readCount > 0) while (m_readCount > 0)
m_cv.wait(rm); m_cv.wait(rm);
@ -41,6 +48,7 @@ public:
while(!m_writeLock.try_lock()) while(!m_writeLock.try_lock())
m_cv.wait(rm); m_cv.wait(rm);
} }
}
m_writeCount++; m_writeCount++;
m_writeWaiting = false; m_writeWaiting = false;
} }
@ -52,6 +60,7 @@ public:
bool tryAcquireWrite(bool exclusive = true) { bool tryAcquireWrite(bool exclusive = true) {
std::unique_lock<fastlock> rm(m_readLock, std::defer_lock); std::unique_lock<fastlock> rm(m_readLock, std::defer_lock);
if (m_multi) {
if (!rm.try_lock()) if (!rm.try_lock())
return false; return false;
if (m_readCount > 0) if (m_readCount > 0)
@ -59,34 +68,39 @@ public:
if (exclusive) if (exclusive)
if (!m_writeLock.try_lock()) if (!m_writeLock.try_lock())
return false; return false;
}
m_writeCount++; m_writeCount++;
return true; return true;
} }
void releaseRead() { void releaseRead() {
std::unique_lock<fastlock> rm(m_readLock); std::unique_lock<fastlock> rm(m_readLock, std::defer_lock);
m_readCount--; if (m_multi) {
if (m_notify) rm.lock();
m_cv.notify_all(); m_cv.notify_all();
} }
m_readCount--;
}
void releaseWrite(bool exclusive = true) { void releaseWrite(bool exclusive = true) {
std::unique_lock<fastlock> rm(m_readLock); std::unique_lock<fastlock> rm(m_readLock, std::defer_lock);
serverAssert(m_writeCount > 0); serverAssert(m_writeCount > 0);
if (m_multi) {
rm.lock();
if (exclusive) if (exclusive)
m_writeLock.unlock(); m_writeLock.unlock();
m_writeCount--;
if (m_notify)
m_cv.notify_all(); m_cv.notify_all();
} }
m_writeCount--;
}
void downgradeWrite(bool exclusive = true) { void downgradeWrite(bool exclusive = true) {
releaseWrite(exclusive); releaseWrite(exclusive);
acquireRead(); acquireRead();
} }
void setNotify(bool notify) { void setMulti(bool multi) {
m_notify = notify; m_multi = multi;
} }
bool hasReader() { bool hasReader() {