Use QBasicMutex instead of QMutex in the signalSlockLock()

Add a simple private QBasicMutexLocker class, and let the
QOrderedMutexLocker operate on a QBasicMutex.

This allows the compiler to inline more things when handling
connections and speeds up activate() a bit more.

                       without change    with change
string based connect:  3621              3368
pointer based connect: 4341              3919
not connected:          433               437
disconnected:           551               538

Change-Id: If979337891178aaeb0b3340b6d4f68b6f86b0260
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>

1 files changed, 56 insertions, 6 deletions

diff --git a/src/corelib/thread/qorderedmutexlocker_p.h b/src/corelib/thread/qorderedmutexlocker_p.h
index ded102d32d..5b2c7ab112 100644
--- a/src/corelib/thread/qorderedmutexlocker_p.h
+++ b/src/corelib/thread/qorderedmutexlocker_p.h
@@ -58,6 +58,8 @@
 
 QT_BEGIN_NAMESPACE
 
+#if QT_CONFIG(thread)
+
 /*
   Locks 2 mutexes in a defined order, avoiding a recursive lock if
   we're trying to lock the same mutex twice.
@@ -65,9 +67,9 @@ QT_BEGIN_NAMESPACE
 class QOrderedMutexLocker
 {
 public:
-    QOrderedMutexLocker(QMutex *m1, QMutex *m2)
-        : mtx1((m1 == m2) ? m1 : (std::less<QMutex *>()(m1, m2) ? m1 : m2)),
-          mtx2((m1 == m2) ?  0 : (std::less<QMutex *>()(m1, m2) ? m2 : m1)),
+    QOrderedMutexLocker(QBasicMutex *m1, QBasicMutex *m2)
+        : mtx1((m1 == m2) ? m1 : (std::less<QBasicMutex *>()(m1, m2) ? m1 : m2)),
+          mtx2((m1 == m2) ?  0 : (std::less<QBasicMutex *>()(m1, m2) ? m2 : m1)),
           locked(false)
     {
         relock();
@@ -95,12 +97,12 @@ public:
         }
     }
 
-    static bool relock(QMutex *mtx1, QMutex *mtx2)
+    static bool relock(QBasicMutex *mtx1, QBasicMutex *mtx2)
     {
         // mtx1 is already locked, mtx2 not... do we need to unlock and relock?
         if (mtx1 == mtx2)
             return false;
-        if (std::less<QMutex *>()(mtx1, mtx2)) {
+        if (std::less<QBasicMutex *>()(mtx1, mtx2)) {
             mtx2->lock();
             return true;
         }
@@ -113,10 +115,58 @@ public:
     }
 
 private:
-    QMutex *mtx1, *mtx2;
+    QBasicMutex *mtx1, *mtx2;
     bool locked;
 };
 
+class QBasicMutexLocker
+{
+public:
+    inline explicit QBasicMutexLocker(QBasicMutex *m) QT_MUTEX_LOCK_NOEXCEPT
+        : m(m), isLocked(true)
+    {
+        m->lock();
+    }
+    inline ~QBasicMutexLocker() { if (isLocked) unlock(); }
+
+    inline void unlock() Q_DECL_NOTHROW
+    {
+        isLocked = false;
+        m->unlock();
+    }
+
+    inline void relock() QT_MUTEX_LOCK_NOEXCEPT
+    {
+        isLocked = true;
+        m->lock();
+    }
+
+private:
+    Q_DISABLE_COPY(QBasicMutexLocker)
+
+    QBasicMutex *m;
+    bool isLocked;
+};
+
+#else
+
+class QOrderedMutexLocker
+{
+public:
+    QOrderedMutexLocker(QBasicMutex *, QBasicMutex *) {}
+    ~QOrderedMutexLocker() {}
+
+    void relock() {}
+    void unlock() {}
+
+    static bool relock(QBasicMutex *, QBasicMutex *) {}
+};
+
+using QBasicMutexLocker = QMutexLocker;
+
+#endif
+
+
 QT_END_NAMESPACE
 
 #endif