Merge pull request #5435 from Beep6581/std-mutex

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

rtgui/guiutils.cc

@@ -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)
 {
 

rtgui/histogrampanel.cc

@@ -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());

rtgui/threadutils.cc

@@ -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.
+        // ...and if the writer count is zero again, we wake up all of the waiting writer or reader.
-        mutex.cond.broadcast ();
+        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.
+        // ...and if the writer count is zero again, we wake up all of the waiting writer or reader.
-        mutex.cond.broadcast ();
+        mutex.cond.notify_all ();
 
-        mutex.ownerThread = nullptr;
+        mutex.ownerThread = std::thread::id();
         mutex.lastWriterFile = "";
         mutex.lastWriterLine = 0;
     }

rtgui/threadutils.h

@@ -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;
+    std::thread::id ownerThread;
-    const char* lastWriterFile = "";
+    const char* lastWriterFile;
-    int lastWriterLine = 0;
+    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) {

rtgui/thumbimageupdater.cc

@@ -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);
         }
     }
 }