/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2012 Intel Corporation
** Contact: http://www.qt-project.org/
**
** This file is part of the QtCore module of the Qt Toolkit.
QT_BEGIN_NAMESPACE
+static inline bool isRecursive(QMutexData *d)
+{
+ register quintptr u = quintptr(d);
+ if (Q_LIKELY(u <= 0x3))
+ return false;
+#ifdef QT_LINUX_FUTEX
+ Q_ASSERT(d->recursive);
+ return true;
+#else
+ return d->recursive;
+#endif
+}
+
/*
\class QBasicMutex
\inmodule QtCore
*/
void QMutex::lock() QT_MUTEX_LOCK_NOEXCEPT
{
- QBasicMutex::lock();
+ if (fastTryLock())
+ return;
+ QMutexData *current = d_ptr.loadAcquire();
+ if (QT_PREPEND_NAMESPACE(isRecursive)(current))
+ static_cast<QRecursiveMutexPrivate *>(current)->lock(-1);
+ else
+ lockInternal();
}
/*! \fn bool QMutex::tryLock(int timeout)
*/
bool QMutex::tryLock(int timeout) QT_MUTEX_LOCK_NOEXCEPT
{
- return QBasicMutex::tryLock(timeout);
+ if (fastTryLock())
+ return true;
+ QMutexData *current = d_ptr.loadAcquire();
+ if (QT_PREPEND_NAMESPACE(isRecursive)(current))
+ return static_cast<QRecursiveMutexPrivate *>(current)->lock(timeout);
+ else
+ return lockInternal(timeout);
}
/*! \fn void QMutex::unlock()
*/
void QMutex::unlock() Q_DECL_NOTHROW
{
- QBasicMutex::unlock();
+ if (fastTryUnlock())
+ return;
+ QMutexData *current = d_ptr.loadAcquire();
+ if (QT_PREPEND_NAMESPACE(isRecursive)(current))
+ static_cast<QRecursiveMutexPrivate *>(current)->unlock();
+ else
+ unlockInternal();
}
/*!
Returns true if the mutex is recursive
*/
-bool QBasicMutex::isRecursive() {
- QMutexData *d = d_ptr.load();
- if (quintptr(d) <= 0x3)
- return false;
-#ifdef QT_LINUX_FUTEX
- Q_ASSERT(d->recursive);
- return true;
-#else
- return d->recursive;
-#endif
+bool QBasicMutex::isRecursive()
+{
+ return QT_PREPEND_NAMESPACE(isRecursive)(d_ptr.loadAcquire());
}
*/
bool QBasicMutex::lockInternal(int timeout) QT_MUTEX_LOCK_NOEXCEPT
{
- if (isRecursive())
- return static_cast<QRecursiveMutexPrivate *>(d_ptr.load())->lock(timeout);
+ Q_ASSERT(!isRecursive());
while (!fastTryLock()) {
QMutexData *copy = d_ptr.loadAcquire();
QMutexData *copy = d_ptr.loadAcquire();
Q_ASSERT(copy); //we must be locked
Q_ASSERT(copy != dummyLocked()); // testAndSetRelease(dummyLocked(), 0) failed
-
- if (copy->recursive) {
- static_cast<QRecursiveMutexPrivate *>(copy)->unlock();
- return;
- }
+ Q_ASSERT(!isRecursive());
QMutexPrivate *d = reinterpret_cast<QMutexPrivate *>(copy);
inline void unlock() Q_DECL_NOTHROW {
Q_ASSERT(d_ptr.load()); //mutex must be locked
- if (!d_ptr.testAndSetRelease(dummyLocked(), 0))
+ if (!fastTryUnlock())
unlockInternal();
}
inline bool fastTryLock() Q_DECL_NOTHROW {
return d_ptr.testAndSetAcquire(0, dummyLocked());
}
+ inline bool fastTryUnlock() Q_DECL_NOTHROW {
+ return d_ptr.testAndSetRelease(dummyLocked(), 0);
+ }
+
bool lockInternal(int timeout = -1) QT_MUTEX_LOCK_NOEXCEPT;
void unlockInternal() Q_DECL_NOTHROW;
bool QBasicMutex::lockInternal(int timeout) Q_DECL_NOTHROW
{
- // we're here because fastTryLock() has just failed
- QMutexData *d = d_ptr.load();
- if (quintptr(d) > 0x3) { //d == dummyLocked() || d == dummyFutexValue()
- Q_ASSERT(d->recursive);
- return static_cast<QRecursiveMutexPrivate *>(d)->lock(timeout);
- }
+ Q_ASSERT(!isRecursive());
+ // we're here because fastTryLock() has just failed
if (timeout == 0)
return false;
QMutexData *d = d_ptr.load();
Q_ASSERT(d); //we must be locked
Q_ASSERT(d != dummyLocked()); // testAndSetRelease(dummyLocked(), 0) failed
+ Q_UNUSED(d);
+ Q_ASSERT(!isRecursive());
- if (d == dummyFutexValue()) {
- d_ptr.fetchAndStoreRelease(0);
- _q_futex(&d_ptr, FUTEX_WAKE, 1, 0);
- return;
- }
-
- Q_ASSERT(d->recursive);
- static_cast<QRecursiveMutexPrivate *>(d)->unlock();
+ d_ptr.fetchAndStoreRelease(0);
+ _q_futex(&d_ptr, FUTEX_WAKE, 1, 0);
}