liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #5435 from Beep6581/std-mutex

Browse Source 
Converting Glib's mutex (obsolete) to std::mutex
This commit is contained in:
Jean-Christophe 2023-08-02 21:10:28 +02:00 committed by GitHub
commit e3e73e6a83
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 73 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
rtgui/guiutils.cc
View File

@ -82,59 +82,6 @@ void IdleRegister::destroy()
mutex.unlock();
}
/*
gboolean giveMeAGo(void* data) {
GThreadLock *threadMutex = static_cast<GThreadLock*>(data);
printf("A\n");
Glib::Threads::Mutex::Lock GUILock(threadMutex->GUI);
printf("B\n");
{
Glib::Threads::Mutex::Lock operationLock(threadMutex->operation);
printf("C\n");
threadMutex->operationCond.signal();
printf("D\n");
operationLock.release(); // because we're not sure that "lock" destructor happens here...
}
threadMutex->GUICond.wait(threadMutex->GUI);
printf("E\n");
GUILock.release();
return false;
}
GThreadLock::GThreadLock() : sameThread(false) {
if (Glib::Threads::Thread::self() == mainThread) {
sameThread = true;
return;
}
printf("10\n");
{
Glib::Threads::Mutex::Lock operationLock(operation);
printf("20\n");
gdk_threads_add_idle(giveMeAGo, this);
printf("30\n");
operationCond.wait(operation);
printf("40\n");
operationLock.release();
}
}
GThreadLock::~GThreadLock() {
if (!sameThread) {
printf("50\n");
Glib::Threads::Mutex::Lock lock(GUI);
printf("60\n");
GUICond.signal();
printf("Fin\n");
}
}
*/
Glib::ustring escapeHtmlChars(const Glib::ustring &src)
{

6
rtgui/histogrampanel.cc
View File

@ -1197,7 +1197,7 @@ void HistogramArea::update(
break;
case ScopeType::PARADE:
case ScopeType::WAVEFORM: {
MyWriterLock wave_lock(wave_mutex);
MYWRITERLOCK(wave_lock, wave_mutex)
waveform_scale = waveformScale;
rwave = waveformRed;
gwave = waveformGreen;
@ -1330,7 +1330,7 @@ void HistogramArea::updateBackBuffer ()
cr->unset_dash();
MyReaderLock wave_lock(wave_mutex);
MYREADERLOCK(wave_lock, wave_mutex)
if (valid && (scopeType == ScopeType::HISTOGRAM || scopeType == ScopeType::HISTOGRAM_RAW)) {
bool rawMode = scopeType == ScopeType::HISTOGRAM_RAW;
@ -1447,7 +1447,7 @@ void HistogramArea::updateBackBuffer ()
} else if (scopeType == ScopeType::VECTORSCOPE_HC || scopeType == ScopeType::VECTORSCOPE_HS) {
drawVectorscope(cr, w, h);
}
wave_lock.release();
MYREADERLOCK_RELEASE(wave_lock);
// Draw the frame's border
style->render_frame(cr, 0, 0, surface->get_width(), surface->get_height());

60
rtgui/threadutils.cc
View File

@ -27,6 +27,8 @@
#if STRICT_MUTEX && !NDEBUG
MyMutex::MyMutex() : locked(false) {}
void MyMutex::checkLock ()
{
if (locked) {
@ -61,13 +63,18 @@ void MyMutex::checkUnlock ()
#if !TRACE_MYRWMUTEX
MyRWMutex::MyRWMutex() :
writerCount(0),
readerCount(0)
{}
void MyReaderLock::acquire ()
{
if (locked) {
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
if (mutex.writerCount == 0) {
// There's no writer operating, we can increment the writer count which will lock writers.
@ -76,7 +83,7 @@ void MyReaderLock::acquire ()
// The writer count is non null, but a reader can be the owner of the writer lock,
// which will be the case if the reader count is not zero too.
while (mutex.writerCount != 0) {
mutex.cond.wait(mutex.mutex);
mutex.cond.wait (lock);
}
// Then, we can increment the writer count.
@ -95,7 +102,7 @@ void MyReaderLock::release ()
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
// decrement the writer number first...
--mutex.readerCount;
@ -105,7 +112,7 @@ void MyReaderLock::release ()
--mutex.writerCount;
// ...and signal the next waiting reader/writer that it's free
mutex.cond.broadcast ();
mutex.cond.notify_all ();
}
locked = false;
@ -117,11 +124,11 @@ void MyWriterLock::acquire ()
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
// The writer count is not zero, so we have to wait for it to be zero again...
while (mutex.writerCount != 0) {
mutex.cond.wait (mutex.mutex);
mutex.cond.wait (lock);
}
// ...then we can increment the writer count.
@ -136,12 +143,12 @@ void MyWriterLock::release ()
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
// Decrement the writer number first...
if (--mutex.writerCount == 0) {
// ...and if the writer count is zero again, we can wake up the next writer or reader.
mutex.cond.broadcast ();
// ...and if the writer count is zero again, we wake up all of the waiting writer or reader.
mutex.cond.notify_all ();
}
locked = false;
@ -154,13 +161,20 @@ namespace
std::ostream& trace (const char* file, int line)
{
const auto currentThread = Glib::Threads::Thread::self ();
const auto currentThread = std::this_thread::get_id();
return std::cout << currentThread << ":" << file << ":" << line << ": ";
}
}
MyRWMutex::MyRWMutex() :
lastWriterFile(nullptr),
lastWriterLine(0),
writerCount(0),
readerCount(0)
{}
void MyReaderLock::acquire (const char* file, int line)
{
if (locked) {
@ -170,7 +184,7 @@ void MyReaderLock::acquire (const char* file, int line)
trace (file, line) << "Acquiring MyReaderLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
if (mutex.writerCount == 0) {
// There's no writer operating, we can increment the writer count which will lock writers.
@ -184,13 +198,13 @@ void MyReaderLock::acquire (const char* file, int line)
<< "\tLast writer file: " << mutex.lastWriterFile << std::endl
<< "\tLast writer line: " << mutex.lastWriterLine << std::endl;
mutex.cond.wait(mutex.mutex);
mutex.cond.wait (lock);
}
// Then, we can increment the writer count.
++mutex.writerCount;
mutex.ownerThread = Glib::Threads::Thread::self ();
mutex.ownerThread = std::this_thread::get_id ();
mutex.lastWriterFile = file;
mutex.lastWriterLine = line;
}
@ -211,7 +225,7 @@ void MyReaderLock::release (const char* file, int line)
trace (file, line) << "Releasing MyReaderLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
// decrement the writer number first...
--mutex.readerCount;
@ -221,9 +235,9 @@ void MyReaderLock::release (const char* file, int line)
--mutex.writerCount;
// ...and signal the next waiting reader/writer that it's free
mutex.cond.broadcast ();
mutex.cond.notify_all ();
mutex.ownerThread = nullptr;
mutex.ownerThread = std::thread::id();
mutex.lastWriterFile = "";
mutex.lastWriterLine = 0;
}
@ -241,7 +255,7 @@ void MyWriterLock::acquire (const char* file, int line)
trace (file, line) << "Acquiring MyWriterLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
// The writer count is not zero, so we have to wait for it to be zero again...
while (mutex.writerCount != 0) {
@ -250,13 +264,13 @@ void MyWriterLock::acquire (const char* file, int line)
<< "\tLast writer file: " << mutex.lastWriterFile << std::endl
<< "\tLast writer line: " << mutex.lastWriterLine << std::endl;
mutex.cond.wait (mutex.mutex);
mutex.cond.wait (lock);
}
// ...then we can increment the writer count.
++mutex.writerCount;
mutex.ownerThread = Glib::Threads::Thread::self ();
mutex.ownerThread = std::this_thread::get_id ();
mutex.lastWriterFile = file;
mutex.lastWriterLine = line;
@ -273,14 +287,14 @@ void MyWriterLock::release (const char* file, int line)
trace (file, line) << "Releasing MyWriterLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::unique_lock<std::mutex> lock (mutex.mutex);
// Decrement the writer number first...
if (--mutex.writerCount == 0) {
// ...and if the writer count is zero again, we can wake up the next writer or reader.
mutex.cond.broadcast ();
// ...and if the writer count is zero again, we wake up all of the waiting writer or reader.
mutex.cond.notify_all ();
mutex.ownerThread = nullptr;
mutex.ownerThread = std::thread::id();
mutex.lastWriterFile = "";
mutex.lastWriterLine = 0;
}

49
rtgui/threadutils.h
View File

@ -24,14 +24,15 @@
//#undef STRICT_MUTEX
//#define STRICT_MUTEX 1
#include <glibmm/threads.h>
#include <mutex>
#include <thread>
#include <condition_variable>
#include "../rtengine/noncopyable.h"
#if STRICT_MUTEX && NDEBUG
using MyMutexBase = Glib::Threads::Mutex;
using MyMutexBase = std::mutex;
#else
using MyMutexBase = Glib::Threads::RecMutex;
using MyMutexBase = std::recursive_mutex;
#endif
/**
@ -54,8 +55,10 @@ public:
void unlock ();
#if STRICT_MUTEX && !NDEBUG
MyMutex();
private:
bool locked = false;
bool locked;
void checkLock ();
void checkUnlock ();
#endif
@ -66,8 +69,6 @@ class MyMutex::MyLock :
{
public:
explicit MyLock (MyMutex& mutex);
MyLock (MyMutex& mutex, Glib::Threads::NotLock);
MyLock (MyMutex& mutex, Glib::Threads::TryLock);
~MyLock ();
@ -90,18 +91,20 @@ public:
friend class MyReaderLock;
friend class MyWriterLock;
MyRWMutex();
private:
Glib::Threads::Mutex mutex;
Glib::Threads::Cond cond;
std::size_t writerCount = 0;
std::size_t readerCount = 0;
#if TRACE_MYRWMUTEX
Glib::Threads::Thread* ownerThread = nullptr;
const char* lastWriterFile = "";
int lastWriterLine = 0;
std::thread::id ownerThread;
const char* lastWriterFile;
int lastWriterLine;
#endif
std::mutex mutex;
std::condition_variable cond;
std::size_t writerCount;
std::size_t readerCount;
};
/**
@ -167,7 +170,7 @@ inline void MyMutex::lock ()
inline bool MyMutex::trylock ()
{
if (MyMutexBase::trylock ()) {
if (MyMutexBase::try_lock ()) {
#if STRICT_MUTEX && !NDEBUG
checkLock ();
#endif
@ -194,18 +197,6 @@ inline MyMutex::MyLock::MyLock (MyMutex& mutex)
mutex.lock();
}
inline MyMutex::MyLock::MyLock (MyMutex& mutex, Glib::Threads::NotLock)
: mutex (mutex)
, locked (false)
{
}
inline MyMutex::MyLock::MyLock (MyMutex& mutex, Glib::Threads::TryLock)
: mutex (mutex)
, locked (mutex.trylock ())
{
}
inline MyMutex::MyLock::~MyLock ()
{
if (locked) {

26
rtgui/thumbimageupdater.cc
View File

@ -85,9 +85,9 @@ public:
Glib::ThreadPool* threadPool_;
// Need to be a Glib::Threads::Mutex because used in a Glib::Threads::Cond object...
// Need to be a std::mutex because used in a std::condition_variable object...
// This is the only exceptions along with GThreadMutex (guiutils.cc), MyMutex is used everywhere else
Glib::Threads::Mutex mutex_;
std::mutex mutex_;
JobList jobs_;
@ -95,7 +95,7 @@ public:
bool inactive_waiting_;
Glib::Threads::Cond inactive_;
std::condition_variable inactive_;
void
processNextJob()
@ -103,7 +103,7 @@ public:
Job j;
{
Glib::Threads::Mutex::Lock lock(mutex_);
std::lock_guard<std::mutex> lock(mutex_);
// nothing to do; could be jobs have been removed
if ( jobs_.empty() ) {
@ -166,10 +166,10 @@ public:
}
if ( --active_ == 0 ) {
Glib::Threads::Mutex::Lock lock(mutex_);
std::lock_guard<std::mutex> lock(mutex_);
if (inactive_waiting_) {
inactive_waiting_ = false;
inactive_.broadcast();
inactive_.notify_all();
}
}
}
@ -198,7 +198,7 @@ void ThumbImageUpdater::add(ThumbBrowserEntryBase* tbe, bool* priority, bool upg
return;
}
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::lock_guard<std::mutex> lock(impl_->mutex_);
// look up if an older version is in the queue
Impl::JobList::iterator i(impl_->jobs_.begin());
@ -230,7 +230,7 @@ void ThumbImageUpdater::removeJobs(ThumbImageUpdateListener* listener)
DEBUG("removeJobs(%p)", listener);
{
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::lock_guard<std::mutex> lock(impl_->mutex_);
for( Impl::JobList::iterator i(impl_->jobs_.begin()); i != impl_->jobs_.end(); ) {
if (i->listener_ == listener) {
@ -246,9 +246,9 @@ void ThumbImageUpdater::removeJobs(ThumbImageUpdateListener* listener)
while ( impl_->active_ != 0 ) {
DEBUG("waiting for running jobs1");
{
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::unique_lock<std::mutex> lock(impl_->mutex_);
impl_->inactive_waiting_ = true;
impl_->inactive_.wait(impl_->mutex_);
impl_->inactive_.wait(lock);
}
}
}
@ -258,7 +258,7 @@ void ThumbImageUpdater::removeAllJobs()
DEBUG("stop");
{
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::lock_guard<std::mutex> lock(impl_->mutex_);
impl_->jobs_.clear();
}
@ -266,9 +266,9 @@ void ThumbImageUpdater::removeAllJobs()
while ( impl_->active_ != 0 ) {
DEBUG("waiting for running jobs2");
{
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::unique_lock<std::mutex> lock(impl_->mutex_);
impl_->inactive_waiting_ = true;
impl_->inactive_.wait(impl_->mutex_);
impl_->inactive_.wait(lock);
}
}
}