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

Converting Glib's mutex (obsolete) to std::mutex

Browse Source 
(no issue)
This commit is contained in:
Hombre 2019-09-03 22:10:04 +02:00
parent bb97a30058
commit 55cc71608b
4 changed files with 31 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
rtgui/guiutils.cc
View File

@ -83,59 +83,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)
{

25
rtgui/threadutils.cc
View File

@ -17,6 +17,7 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "threadutils.h"
#include <glibmm/threads.h>
#include <csignal>
#include <iostream>
@ -67,7 +68,7 @@ void MyReaderLock::acquire ()
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<std::mutex> lock (mutex.mutex);
if (mutex.writerCount == 0) {
// There's no writer operating, we can increment the writer count which will lock writers.
@ -95,7 +96,7 @@ void MyReaderLock::release ()
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<std::mutex> lock (mutex.mutex);
// decrement the writer number first...
--mutex.readerCount;
@ -105,7 +106,7 @@ void MyReaderLock::release ()
--mutex.writerCount;
// ...and signal the next waiting reader/writer that it's free
mutex.cond.broadcast ();
mutex.cond.notify_one(); // notify_all ?
}
locked = false;
@ -117,7 +118,7 @@ void MyWriterLock::acquire ()
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<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) {
@ -136,12 +137,12 @@ void MyWriterLock::release ()
return;
}
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<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 ();
mutex.cond.notify_one(); // notify_all ?
}
locked = false;
@ -170,7 +171,7 @@ void MyReaderLock::acquire (const char* file, int line)
trace (file, line) << "Acquiring MyReaderLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<std::mutex> lock (mutex.mutex);
if (mutex.writerCount == 0) {
// There's no writer operating, we can increment the writer count which will lock writers.
@ -211,7 +212,7 @@ void MyReaderLock::release (const char* file, int line)
trace (file, line) << "Releasing MyReaderLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<std::mutex> lock (mutex.mutex);
// decrement the writer number first...
--mutex.readerCount;
@ -221,7 +222,7 @@ 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_one(); // notify_all ?
mutex.ownerThread = nullptr;
mutex.lastWriterFile = "";
@ -241,7 +242,7 @@ void MyWriterLock::acquire (const char* file, int line)
trace (file, line) << "Acquiring MyWriterLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<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) {
@ -273,12 +274,12 @@ void MyWriterLock::release (const char* file, int line)
trace (file, line) << "Releasing MyWriterLock..." << std::endl;
Glib::Threads::Mutex::Lock lock (mutex.mutex);
std::lock_guard<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 ();
mutex.cond.notify_one(); // notify_all ?
mutex.ownerThread = nullptr;
mutex.lastWriterFile = "";

28
rtgui/threadutils.h
View File

@ -25,14 +25,14 @@
//#undef STRICT_MUTEX
//#define STRICT_MUTEX 1
#include <glibmm/threads.h>
#include <mutex>
#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
/**
@ -67,8 +67,6 @@ class MyMutex::MyLock :
{
public:
explicit MyLock (MyMutex& mutex);
MyLock (MyMutex& mutex, Glib::Threads::NotLock);
MyLock (MyMutex& mutex, Glib::Threads::TryLock);
~MyLock ();
@ -92,8 +90,8 @@ public:
friend class MyWriterLock;
private:
Glib::Threads::Mutex mutex;
Glib::Threads::Cond cond;
std::mutex mutex;
std::condition_variable_any cond;
std::size_t writerCount = 0;
std::size_t readerCount = 0;
@ -168,7 +166,7 @@ inline void MyMutex::lock ()
inline bool MyMutex::trylock ()
{
if (MyMutexBase::trylock ()) {
if (MyMutexBase::try_lock ()) {
#if STRICT_MUTEX && !NDEBUG
checkLock ();
#endif
@ -195,18 +193,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) {

22
rtgui/thumbimageupdater.cc
View File

@ -83,9 +83,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_any 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_;
@ -93,7 +93,7 @@ public:
bool inactive_waiting_;
Glib::Threads::Cond inactive_;
std::condition_variable_any inactive_;
void
processNextJob()
@ -101,7 +101,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() ) {
@ -164,10 +164,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_one(); // notify_all ?
}
}
}
@ -196,7 +196,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());
@ -228,7 +228,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) {
@ -244,7 +244,7 @@ void ThumbImageUpdater::removeJobs(ThumbImageUpdateListener* listener)
while ( impl_->active_ != 0 ) {
DEBUG("waiting for running jobs1");
{
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::lock_guard<std::mutex> lock(impl_->mutex_);
impl_->inactive_waiting_ = true;
impl_->inactive_.wait(impl_->mutex_);
}
@ -256,7 +256,7 @@ void ThumbImageUpdater::removeAllJobs()
DEBUG("stop");
{
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::lock_guard<std::mutex> lock(impl_->mutex_);
impl_->jobs_.clear();
}
@ -264,7 +264,7 @@ void ThumbImageUpdater::removeAllJobs()
while ( impl_->active_ != 0 ) {
DEBUG("waiting for running jobs2");
{
Glib::Threads::Mutex::Lock lock(impl_->mutex_);
std::lock_guard<std::mutex> lock(impl_->mutex_);
impl_->inactive_waiting_ = true;
impl_->inactive_.wait(impl_->mutex_);
}