/****************************************************************************+
−
**+
−
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).+
−
** All rights reserved.+
−
** Contact: Nokia Corporation (qt-info@nokia.com)+
−
**+
−
** This file is part of the test suite of the Qt Toolkit.+
−
**+
−
** $QT_BEGIN_LICENSE:LGPL$+
−
** No Commercial Usage+
−
** This file contains pre-release code and may not be distributed.+
−
** You may use this file in accordance with the terms and conditions+
−
** contained in the Technology Preview License Agreement accompanying+
−
** this package.+
−
**+
−
** GNU Lesser General Public License Usage+
−
** Alternatively, this file may be used under the terms of the GNU Lesser+
−
** General Public License version 2.1 as published by the Free Software+
−
** Foundation and appearing in the file LICENSE.LGPL included in the+
−
** packaging of this file.  Please review the following information to+
−
** ensure the GNU Lesser General Public License version 2.1 requirements+
−
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+
−
**+
−
** In addition, as a special exception, Nokia gives you certain additional+
−
** rights.  These rights are described in the Nokia Qt LGPL Exception+
−
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+
−
**+
−
** If you have questions regarding the use of this file, please contact+
−
** Nokia at qt-info@nokia.com.+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
** $QT_END_LICENSE$+
−
**+
−
****************************************************************************/+
−
+
−
+
−
#include <QtTest/QtTest>+
−
#include <qcoreapplication.h>+
−
+
−
+
−
#include <qreadwritelock.h>+
−
#include <qmutex.h>+
−
#include <qthread.h>+
−
#include <qwaitcondition.h>+
−
+
−
#ifdef Q_OS_UNIX+
−
#include <unistd.h>+
−
#endif+
−
#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)+
−
#include <windows.h>+
−
#define sleep(X) Sleep(X)+
−
#endif+
−
+
−
//on solaris, threads that loop one the release bool variable+
−
//needs to sleep more than 1 usec.+
−
#ifdef Q_OS_SOLARIS+
−
# define RWTESTSLEEP usleep(10);+
−
#else+
−
# define RWTESTSLEEP usleep(1);+
−
#endif+
−
+
−
#include <stdio.h>+
−
+
−
//TESTED_CLASS=+
−
//TESTED_FILES=+
−
+
−
class tst_QReadWriteLock : public QObject+
−
{+
−
    Q_OBJECT+
−
public:+
−
    tst_QReadWriteLock();+
−
    virtual ~tst_QReadWriteLock();+
−
+
−
+
−
/*+
−
    Singlethreaded tests+
−
*/+
−
private slots:+
−
void constructDestruct();+
−
void readLockUnlock();+
−
void writeLockUnlock();+
−
void readLockUnlockLoop();+
−
void writeLockUnlockLoop();+
−
void readLockLoop();+
−
void writeLockLoop();+
−
void readWriteLockUnlockLoop();+
−
void tryReadLock();+
−
void tryWriteLock();+
−
/*+
−
    Multithreaded tests+
−
*/+
−
private slots:+
−
+
−
void readLockBlockRelease();+
−
void writeLockBlockRelease();+
−
void multipleReadersBlockRelease();+
−
void multipleReadersLoop();+
−
void multipleWritersLoop();+
−
void multipleReadersWritersLoop();+
−
void countingTest();+
−
void limitedReaders();+
−
void deleteOnUnlock();+
−
+
−
/*+
−
    Performance tests+
−
*/+
−
private slots:+
−
void uncontendedLocks();+
−
+
−
    // recursive locking tests+
−
    void recursiveReadLock();+
−
    void recursiveWriteLock();+
−
};+
−
+
−
tst_QReadWriteLock::tst_QReadWriteLock()+
−
{+
−
+
−
}+
−
+
−
tst_QReadWriteLock::~tst_QReadWriteLock()+
−
{+
−
+
−
}+
−
+
−
void tst_QReadWriteLock::constructDestruct()+
−
{+
−
    {+
−
        QReadWriteLock rwlock;+
−
    }+
−
}+
−
+
−
void tst_QReadWriteLock::readLockUnlock()+
−
{+
−
     QReadWriteLock rwlock;+
−
     rwlock.lockForRead();+
−
     rwlock.unlock();+
−
}+
−
+
−
void tst_QReadWriteLock::writeLockUnlock()+
−
{+
−
     QReadWriteLock rwlock;+
−
     rwlock.lockForWrite();+
−
     rwlock.unlock();+
−
}+
−
+
−
void tst_QReadWriteLock::readLockUnlockLoop()+
−
{+
−
    QReadWriteLock rwlock;+
−
    int runs=10000;+
−
    int i;+
−
    for (i=0; i<runs; ++i) {+
−
        rwlock.lockForRead();+
−
        rwlock.unlock();+
−
    }+
−
}+
−
+
−
void tst_QReadWriteLock::writeLockUnlockLoop()+
−
{+
−
    QReadWriteLock rwlock;+
−
    int runs=10000;+
−
    int i;+
−
    for (i=0; i<runs; ++i) {+
−
        rwlock.lockForWrite();+
−
        rwlock.unlock();+
−
    }+
−
}+
−
+
−
+
−
void tst_QReadWriteLock::readLockLoop()+
−
{+
−
    QReadWriteLock rwlock;+
−
    int runs=10000;+
−
    int i;+
−
    for (i=0; i<runs; ++i) {+
−
        rwlock.lockForRead();+
−
    }+
−
    for (i=0; i<runs; ++i) {+
−
        rwlock.unlock();+
−
    }+
−
}+
−
+
−
void tst_QReadWriteLock::writeLockLoop()+
−
{+
−
    /*+
−
        If you include this, the test should print one line+
−
        and then block.+
−
    */+
−
#if 0+
−
    QReadWriteLock rwlock;+
−
    int runs=10000;+
−
    int i;+
−
    for (i=0; i<runs; ++i) {+
−
        rwlock.lockForWrite();+
−
        qDebug("I am going to block now.");+
−
    }+
−
#endif+
−
}+
−
+
−
void tst_QReadWriteLock::readWriteLockUnlockLoop()+
−
{+
−
    QReadWriteLock rwlock;+
−
    int runs=10000;+
−
    int i;+
−
    for (i=0; i<runs; ++i) {+
−
        rwlock.lockForRead();+
−
        rwlock.unlock();+
−
        rwlock.lockForWrite();+
−
        rwlock.unlock();+
−
    }+
−
+
−
}+
−
+
−
QAtomicInt lockCount(0);+
−
QReadWriteLock readWriteLock;+
−
QSemaphore testsTurn;+
−
QSemaphore threadsTurn;+
−
+
−
+
−
void tst_QReadWriteLock::tryReadLock()+
−
{+
−
    QReadWriteLock rwlock;+
−
    QVERIFY(rwlock.tryLockForRead());+
−
    rwlock.unlock();+
−
    QVERIFY(rwlock.tryLockForRead());+
−
    rwlock.unlock();+
−
+
−
    rwlock.lockForRead();+
−
    rwlock.lockForRead();+
−
    QVERIFY(rwlock.tryLockForRead());+
−
    rwlock.unlock();+
−
    rwlock.unlock();+
−
    rwlock.unlock();+
−
+
−
    rwlock.lockForWrite();+
−
    QVERIFY(!rwlock.tryLockForRead());+
−
    rwlock.unlock();+
−
+
−
    // functionality test+
−
    {+
−
        class Thread : public QThread+
−
        {+
−
        public:+
−
            void run()+
−
            {+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                QVERIFY(!readWriteLock.tryLockForRead());+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                QVERIFY(readWriteLock.tryLockForRead());+
−
                lockCount.ref();+
−
                QVERIFY(readWriteLock.tryLockForRead());+
−
                lockCount.ref();+
−
                lockCount.deref();+
−
                readWriteLock.unlock();+
−
                lockCount.deref();+
−
                readWriteLock.unlock();+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                QTime timer;+
−
                timer.start();+
−
                QVERIFY(!readWriteLock.tryLockForRead(1000));+
−
                QVERIFY(timer.elapsed() >= 1000);+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                timer.start();+
−
                QVERIFY(readWriteLock.tryLockForRead(1000));+
−
                QVERIFY(timer.elapsed() <= 1000);+
−
                lockCount.ref();+
−
                QVERIFY(readWriteLock.tryLockForRead(1000));+
−
                lockCount.ref();+
−
                lockCount.deref();+
−
                readWriteLock.unlock();+
−
                lockCount.deref();+
−
                readWriteLock.unlock();+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
            }+
−
        };+
−
+
−
        Thread thread;+
−
        thread.start();+
−
+
−
        testsTurn.acquire();+
−
        readWriteLock.lockForWrite();+
−
        QVERIFY(lockCount.testAndSetRelaxed(0, 1));+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        QVERIFY(lockCount.testAndSetRelaxed(1, 0));+
−
        readWriteLock.unlock();+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        readWriteLock.lockForWrite();+
−
        QVERIFY(lockCount.testAndSetRelaxed(0, 1));+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        QVERIFY(lockCount.testAndSetRelaxed(1, 0));+
−
        readWriteLock.unlock();+
−
        threadsTurn.release();+
−
+
−
        // stop thread+
−
        testsTurn.acquire();+
−
        threadsTurn.release();+
−
        thread.wait();+
−
    }+
−
}+
−
+
−
void tst_QReadWriteLock::tryWriteLock()+
−
{+
−
    {+
−
        QReadWriteLock rwlock;+
−
        QVERIFY(rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
        QVERIFY(rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
+
−
        rwlock.lockForWrite();+
−
        QVERIFY(!rwlock.tryLockForWrite());+
−
        QVERIFY(!rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
+
−
        rwlock.lockForRead();+
−
        QVERIFY(!rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
    }+
−
+
−
    {+
−
        QReadWriteLock rwlock(QReadWriteLock::Recursive);+
−
        QVERIFY(rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
        QVERIFY(rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
+
−
        rwlock.lockForWrite();+
−
        QVERIFY(rwlock.tryLockForWrite());+
−
        QVERIFY(rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
        rwlock.unlock();+
−
        rwlock.unlock();+
−
+
−
        rwlock.lockForRead();+
−
        QVERIFY(!rwlock.tryLockForWrite());+
−
        rwlock.unlock();+
−
    }+
−
+
−
    // functionality test+
−
    {+
−
        class Thread : public QThread+
−
        {+
−
        public:+
−
            void run()+
−
            {+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                Q_ASSERT(!readWriteLock.tryLockForWrite());+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                Q_ASSERT(readWriteLock.tryLockForWrite());+
−
                Q_ASSERT(lockCount.testAndSetRelaxed(0, 1));+
−
                Q_ASSERT(lockCount.testAndSetRelaxed(1, 0));+
−
                readWriteLock.unlock();+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                Q_ASSERT(!readWriteLock.tryLockForWrite(1000));+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
                Q_ASSERT(readWriteLock.tryLockForWrite(1000));+
−
                Q_ASSERT(lockCount.testAndSetRelaxed(0, 1));+
−
                Q_ASSERT(lockCount.testAndSetRelaxed(1, 0));+
−
                readWriteLock.unlock();+
−
                testsTurn.release();+
−
+
−
                threadsTurn.acquire();+
−
            }+
−
        };+
−
+
−
        Thread thread;+
−
        thread.start();+
−
+
−
        testsTurn.acquire();+
−
        readWriteLock.lockForRead();+
−
        lockCount.ref();+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        lockCount.deref();+
−
        readWriteLock.unlock();+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        readWriteLock.lockForRead();+
−
        lockCount.ref();+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        lockCount.deref();+
−
        readWriteLock.unlock();+
−
        threadsTurn.release();+
−
+
−
        // stop thread+
−
        testsTurn.acquire();+
−
        threadsTurn.release();+
−
        thread.wait();+
−
    }+
−
}+
−
+
−
bool threadDone;+
−
volatile bool release;+
−
+
−
/*+
−
    write-lock+
−
    unlock+
−
    set threadone+
−
*/+
−
class WriteLockThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    inline WriteLockThread(QReadWriteLock &l) : testRwlock(l) { }+
−
    void run()+
−
    {+
−
        testRwlock.lockForWrite();+
−
        testRwlock.unlock();+
−
        threadDone=true;+
−
    }+
−
};+
−
+
−
/*+
−
    read-lock+
−
    unlock+
−
    set threadone+
−
*/+
−
class ReadLockThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    inline ReadLockThread(QReadWriteLock &l) : testRwlock(l) { }+
−
    void run()+
−
    {+
−
        testRwlock.lockForRead();+
−
        testRwlock.unlock();+
−
        threadDone=true;+
−
    }+
−
};+
−
/*+
−
    write-lock+
−
    wait for release==true+
−
    unlock+
−
*/+
−
class WriteLockReleasableThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    inline WriteLockReleasableThread(QReadWriteLock &l) : testRwlock(l) { }+
−
    void run()+
−
    {+
−
        testRwlock.lockForWrite();+
−
        while(release==false) {+
−
            RWTESTSLEEP+
−
        }+
−
        testRwlock.unlock();+
−
    }+
−
};+
−
+
−
/*+
−
    read-lock+
−
    wait for release==true+
−
    unlock+
−
*/+
−
class ReadLockReleasableThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    inline ReadLockReleasableThread(QReadWriteLock &l) : testRwlock(l) { }+
−
    void run()+
−
    {+
−
        testRwlock.lockForRead();+
−
        while(release==false) {+
−
            RWTESTSLEEP+
−
        }+
−
        testRwlock.unlock();+
−
    }+
−
};+
−
+
−
+
−
/*+
−
    for(runTime msecs)+
−
        read-lock+
−
        msleep(holdTime msecs)+
−
        release lock+
−
        msleep(waitTime msecs)+
−
*/+
−
class ReadLockLoopThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    int runTime;+
−
    int holdTime;+
−
    int waitTime;+
−
    bool print;+
−
    QTime t;+
−
    inline ReadLockLoopThread(QReadWriteLock &l, int runTime, int holdTime=0, int waitTime=0, bool print=false)+
−
    :testRwlock(l)+
−
    ,runTime(runTime)+
−
    ,holdTime(holdTime)+
−
    ,waitTime(waitTime)+
−
    ,print(print)+
−
    { }+
−
    void run()+
−
    {+
−
        t.start();+
−
        while (t.elapsed()<runTime)  {+
−
            testRwlock.lockForRead();+
−
            if(print) printf("reading\n");+
−
            if (holdTime) msleep(holdTime);+
−
            testRwlock.unlock();+
−
            if (waitTime) msleep(waitTime);+
−
        }+
−
    }+
−
};+
−
+
−
/*+
−
    for(runTime msecs)+
−
        write-lock+
−
        msleep(holdTime msecs)+
−
        release lock+
−
        msleep(waitTime msecs)+
−
*/+
−
class WriteLockLoopThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    int runTime;+
−
    int holdTime;+
−
    int waitTime;+
−
    bool print;+
−
    QTime t;+
−
    inline WriteLockLoopThread(QReadWriteLock &l, int runTime, int holdTime=0, int waitTime=0, bool print=false)+
−
    :testRwlock(l)+
−
    ,runTime(runTime)+
−
    ,holdTime(holdTime)+
−
    ,waitTime(waitTime)+
−
    ,print(print)+
−
    { }+
−
    void run()+
−
    {+
−
        t.start();+
−
        while (t.elapsed() < runTime)  {+
−
            testRwlock.lockForWrite();+
−
            if (print) printf(".");+
−
            if (holdTime) msleep(holdTime);+
−
            testRwlock.unlock();+
−
            if (waitTime) msleep(waitTime);+
−
        }+
−
    }+
−
};+
−
+
−
volatile int count=0;+
−
+
−
/*+
−
    for(runTime msecs)+
−
        write-lock+
−
        count to maxval+
−
        set count to 0+
−
        release lock+
−
        msleep waitTime+
−
*/+
−
class WriteLockCountThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    int runTime;+
−
    int waitTime;+
−
    int maxval;+
−
    QTime t;+
−
    inline WriteLockCountThread(QReadWriteLock &l, int runTime, int waitTime, int maxval)+
−
    :testRwlock(l)+
−
    ,runTime(runTime)+
−
    ,waitTime(waitTime)+
−
    ,maxval(maxval)+
−
    { }+
−
    void run()+
−
    {+
−
        t.start();+
−
        while (t.elapsed() < runTime)  {+
−
            testRwlock.lockForWrite();+
−
            if(count)+
−
                qFatal("Non-zero count at start of write! (%d)",count );+
−
//            printf(".");+
−
            int i;+
−
            for(i=0; i<maxval; ++i) {+
−
                volatile int lc=count;+
−
                ++lc;+
−
                count=lc;+
−
            }+
−
            count=0;+
−
            testRwlock.unlock();+
−
            msleep(waitTime);+
−
        }+
−
    }+
−
};+
−
+
−
/*+
−
    for(runTime msecs)+
−
        read-lock+
−
        verify count==0+
−
        release lock+
−
        msleep waitTime+
−
*/+
−
class ReadLockCountThread : public QThread+
−
{+
−
public:+
−
    QReadWriteLock &testRwlock;+
−
    int runTime;+
−
    int waitTime;+
−
    QTime t;+
−
    inline ReadLockCountThread(QReadWriteLock &l, int runTime, int waitTime)+
−
    :testRwlock(l)+
−
    ,runTime(runTime)+
−
    ,waitTime(waitTime)+
−
    { }+
−
    void run()+
−
    {+
−
        t.start();+
−
        while (t.elapsed() < runTime)  {+
−
            testRwlock.lockForRead();+
−
            if(count)+
−
                qFatal("Non-zero count at Read! (%d)",count );+
−
            testRwlock.unlock();+
−
            msleep(waitTime);+
−
        }+
−
    }+
−
};+
−
+
−
+
−
/*+
−
    A writer aquires a read-lock, a reader locks+
−
    the writer releases the lock, the reader gets the lock+
−
*/+
−
void tst_QReadWriteLock::readLockBlockRelease()+
−
{+
−
    QReadWriteLock testLock;+
−
    testLock.lockForWrite();+
−
    threadDone=false;+
−
    ReadLockThread rlt(testLock);+
−
    rlt.start();+
−
    sleep(1);+
−
    testLock.unlock();+
−
    rlt.wait();+
−
    QVERIFY(threadDone);+
−
}+
−
+
−
/*+
−
    writer1 aquires a read-lock, writer2 blocks,+
−
    writer1 releases the lock, writer2 gets the lock+
−
*/+
−
void tst_QReadWriteLock::writeLockBlockRelease()+
−
{+
−
    QReadWriteLock testLock;+
−
    testLock.lockForWrite();+
−
    threadDone=false;+
−
    WriteLockThread wlt(testLock);+
−
    wlt.start();+
−
    sleep(1);+
−
    testLock.unlock();+
−
    wlt.wait();+
−
    QVERIFY(threadDone);+
−
}+
−
/*+
−
    Two readers aquire a read-lock, one writer attempts a write block,+
−
    the readers release their locks, the writer gets the lock.+
−
*/+
−
void tst_QReadWriteLock::multipleReadersBlockRelease()+
−
{+
−
+
−
    QReadWriteLock testLock;+
−
    release=false;+
−
    threadDone=false;+
−
    ReadLockReleasableThread rlt1(testLock);+
−
    ReadLockReleasableThread rlt2(testLock);+
−
    rlt1.start();+
−
    rlt2.start();+
−
    sleep(1);+
−
    WriteLockThread wlt(testLock);+
−
    wlt.start();+
−
    sleep(1);+
−
    release=true;+
−
    wlt.wait();+
−
    rlt1.wait();+
−
    rlt2.wait();+
−
    QVERIFY(threadDone);+
−
}+
−
+
−
/*+
−
    Multiple readers locks and unlocks a lock.+
−
*/+
−
void tst_QReadWriteLock::multipleReadersLoop()+
−
{+
−
    int time=500;+
−
    int hold=250;+
−
    int wait=0;+
−
#if defined (Q_OS_HPUX)+
−
    const int numthreads=50;+
−
#elif defined(Q_OS_VXWORKS)+
−
    const int numthreads=40;+
−
#else+
−
    const int numthreads=75;+
−
#endif+
−
    QReadWriteLock testLock;+
−
    ReadLockLoopThread *threads[numthreads];+
−
    int i;+
−
    for (i=0; i<numthreads; ++i)+
−
        threads[i] = new ReadLockLoopThread(testLock, time, hold, wait);+
−
    for (i=0; i<numthreads; ++i)+
−
        threads[i]->start();+
−
    for (i=0; i<numthreads; ++i)+
−
        threads[i]->wait();+
−
    for (i=0; i<numthreads; ++i)+
−
        delete threads[i];+
−
}+
−
+
−
/*+
−
    Multiple writers locks and unlocks a lock.+
−
*/+
−
void tst_QReadWriteLock::multipleWritersLoop()+
−
{+
−
        int time=500;+
−
        int wait=0;+
−
        int hold=0;+
−
        const int numthreads=50;+
−
        QReadWriteLock testLock;+
−
        WriteLockLoopThread *threads[numthreads];+
−
        int i;+
−
        for (i=0; i<numthreads; ++i)+
−
            threads[i] = new WriteLockLoopThread(testLock, time, hold, wait);+
−
        for (i=0; i<numthreads; ++i)+
−
            threads[i]->start();+
−
        for (i=0; i<numthreads; ++i)+
−
            threads[i]->wait();+
−
        for (i=0; i<numthreads; ++i)+
−
            delete threads[i];+
−
}+
−
+
−
/*+
−
    Multiple readers and writers locks and unlocks a lock.+
−
*/+
−
void tst_QReadWriteLock::multipleReadersWritersLoop()+
−
{+
−
        //int time=INT_MAX;+
−
        int time=10000;+
−
        int readerThreads=20;+
−
        int readerWait=0;+
−
        int readerHold=1;+
−
+
−
        int writerThreads=2;+
−
        int writerWait=500;+
−
        int writerHold=50;+
−
+
−
        QReadWriteLock testLock;+
−
        ReadLockLoopThread  *readers[1024];+
−
        WriteLockLoopThread *writers[1024];+
−
        int i;+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            readers[i] = new ReadLockLoopThread(testLock, time, readerHold, readerWait, false);+
−
        for (i=0; i<writerThreads; ++i)+
−
            writers[i] = new WriteLockLoopThread(testLock, time, writerHold, writerWait, false);+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            readers[i]->start(QThread::NormalPriority);+
−
        for (i=0; i<writerThreads; ++i)+
−
            writers[i]->start(QThread::IdlePriority);+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            readers[i]->wait();+
−
        for (i=0; i<writerThreads; ++i)+
−
            writers[i]->wait();+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            delete readers[i];+
−
        for (i=0; i<writerThreads; ++i)+
−
            delete writers[i];+
−
}+
−
+
−
/*+
−
    Writers increment a variable from 0 to maxval, then reset it to 0.+
−
    Readers verify that the variable remains at 0.+
−
*/+
−
void tst_QReadWriteLock::countingTest()+
−
{+
−
        //int time=INT_MAX;+
−
        int time=10000;+
−
        int readerThreads=20;+
−
        int readerWait=1;+
−
+
−
        int writerThreads=3;+
−
        int writerWait=150;+
−
        int maxval=10000;+
−
+
−
        QReadWriteLock testLock;+
−
        ReadLockCountThread  *readers[1024];+
−
        WriteLockCountThread *writers[1024];+
−
        int i;+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            readers[i] = new ReadLockCountThread(testLock, time,  readerWait);+
−
        for (i=0; i<writerThreads; ++i)+
−
            writers[i] = new WriteLockCountThread(testLock, time,  writerWait, maxval);+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            readers[i]->start(QThread::NormalPriority);+
−
        for (i=0; i<writerThreads; ++i)+
−
            writers[i]->start(QThread::LowestPriority);+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            readers[i]->wait();+
−
        for (i=0; i<writerThreads; ++i)+
−
            writers[i]->wait();+
−
+
−
        for (i=0; i<readerThreads; ++i)+
−
            delete readers[i];+
−
        for (i=0; i<writerThreads; ++i)+
−
            delete writers[i];+
−
}+
−
+
−
void tst_QReadWriteLock::limitedReaders()+
−
{+
−
+
−
};+
−
+
−
/*+
−
    Test a race-condition that may happen if one thread is in unlock() while+
−
    another thread deletes the rw-lock.+
−
+
−
    MainThread              DeleteOnUnlockThread+
−
+
−
    write-lock+
−
    unlock+
−
      |                     write-lock+
−
      |                     unlock+
−
      |                     delete lock+
−
    deref d inside unlock+
−
*/+
−
class DeleteOnUnlockThread : public QThread+
−
{+
−
public:+
−
    DeleteOnUnlockThread(QReadWriteLock **lock, QWaitCondition *startup, QMutex *waitMutex)+
−
    :m_lock(lock), m_startup(startup), m_waitMutex(waitMutex) {}+
−
    void run()+
−
    {+
−
        m_waitMutex->lock();+
−
        m_startup->wakeAll();+
−
        m_waitMutex->unlock();+
−
+
−
        // DeleteOnUnlockThread and the main thread will race from this point+
−
        (*m_lock)->lockForWrite();+
−
        (*m_lock)->unlock();+
−
        delete *m_lock;+
−
    }+
−
private:+
−
    QReadWriteLock **m_lock;+
−
    QWaitCondition *m_startup;+
−
    QMutex *m_waitMutex;+
−
};+
−
+
−
void tst_QReadWriteLock::deleteOnUnlock()+
−
{+
−
    QReadWriteLock *lock = 0;+
−
    QWaitCondition startup;+
−
    QMutex waitMutex;+
−
+
−
    DeleteOnUnlockThread thread2(&lock, &startup, &waitMutex);+
−
+
−
    QTime t;+
−
    t.start();+
−
    while(t.elapsed() < 4000) {+
−
        lock = new QReadWriteLock();+
−
        waitMutex.lock();+
−
        lock->lockForWrite();+
−
        thread2.start();+
−
        startup.wait(&waitMutex);+
−
        waitMutex.unlock();+
−
+
−
        // DeleteOnUnlockThread and the main thread will race from this point+
−
        lock->unlock();+
−
+
−
        thread2.wait();+
−
    }+
−
}+
−
+
−
+
−
void tst_QReadWriteLock::uncontendedLocks()+
−
{+
−
+
−
    uint read=0;+
−
    uint write=0;+
−
    uint count=0;+
−
    int millisecs=1000;+
−
    {+
−
        QTime t;+
−
        t.start();+
−
        while(t.elapsed() <millisecs)+
−
        {+
−
            ++count;+
−
        }+
−
    }+
−
    {+
−
        QReadWriteLock rwlock;+
−
        QTime t;+
−
        t.start();+
−
        while(t.elapsed() <millisecs)+
−
        {+
−
            rwlock.lockForRead();+
−
            rwlock.unlock();+
−
            ++read;+
−
        }+
−
    }+
−
    {+
−
        QReadWriteLock rwlock;+
−
        QTime t;+
−
        t.start();+
−
        while(t.elapsed() <millisecs)+
−
        {+
−
            rwlock.lockForWrite();+
−
            rwlock.unlock();+
−
            ++write;+
−
        }+
−
    }+
−
+
−
    qDebug("during %d millisecs:", millisecs);+
−
    qDebug("counted to %u", count);+
−
    qDebug("%u uncontended read locks/unlocks", read);+
−
    qDebug("%u uncontended write locks/unlocks", write);+
−
}+
−
+
−
enum { RecursiveLockCount = 10 };+
−
+
−
void tst_QReadWriteLock::recursiveReadLock()+
−
{+
−
    // thread to attempt locking for writing while the test recursively locks for reading+
−
    class RecursiveReadLockThread : public QThread+
−
    {+
−
    public:+
−
        QReadWriteLock *lock;+
−
        bool tryLockForWriteResult;+
−
+
−
        void run()+
−
        {+
−
            testsTurn.release();+
−
+
−
            // test is recursively locking for writing+
−
            for (int i = 0; i < RecursiveLockCount; ++i) {+
−
                threadsTurn.acquire();+
−
                tryLockForWriteResult = lock->tryLockForWrite();+
−
                testsTurn.release();+
−
            }+
−
+
−
            // test is releasing recursive write lock+
−
            for (int i = 0; i < RecursiveLockCount - 1; ++i) {+
−
                threadsTurn.acquire();+
−
                tryLockForWriteResult = lock->tryLockForWrite();+
−
                testsTurn.release();+
−
            }+
−
+
−
            // after final unlock in test, we should get the lock+
−
            threadsTurn.acquire();+
−
            tryLockForWriteResult = lock->tryLockForWrite();+
−
            testsTurn.release();+
−
+
−
            // cleanup+
−
            threadsTurn.acquire();+
−
            lock->unlock();+
−
            testsTurn.release();+
−
+
−
            // test will lockForRead(), then we will lockForWrite()+
−
            // (and block), purpose is to ensure that the test can+
−
            // recursive lockForRead() even with a waiting writer+
−
            threadsTurn.acquire();+
−
            // testsTurn.release(); // ### do not release here, the test uses tryAcquire()+
−
            lock->lockForWrite();+
−
            lock->unlock();+
−
        }+
−
    };+
−
+
−
    // init+
−
    QReadWriteLock lock(QReadWriteLock::Recursive);+
−
    RecursiveReadLockThread thread;+
−
    thread.lock = &lock;+
−
    thread.start();+
−
+
−
    testsTurn.acquire();+
−
+
−
    // verify that we can get multiple read locks in the same thread+
−
    for (int i = 0; i < RecursiveLockCount; ++i) {+
−
        QVERIFY(lock.tryLockForRead());+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        QVERIFY(!thread.tryLockForWriteResult);+
−
    }+
−
+
−
    // have to unlock the same number of times that we locked+
−
    for (int i = 0;i < RecursiveLockCount - 1; ++i) {+
−
        lock.unlock();+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        QVERIFY(!thread.tryLockForWriteResult);+
−
    }+
−
+
−
    // after the final unlock, we should be able to get the write lock+
−
    lock.unlock();+
−
    threadsTurn.release();+
−
+
−
    testsTurn.acquire();+
−
    QVERIFY(thread.tryLockForWriteResult);+
−
    threadsTurn.release();+
−
+
−
    // check that recursive read locking works even when we have a waiting writer+
−
    testsTurn.acquire();+
−
    QVERIFY(lock.tryLockForRead());+
−
    threadsTurn.release();+
−
+
−
    testsTurn.tryAcquire(1, 1000);+
−
    QVERIFY(lock.tryLockForRead());+
−
    lock.unlock();+
−
    lock.unlock();+
−
+
−
    // cleanup+
−
    QVERIFY(thread.wait());+
−
}+
−
+
−
void tst_QReadWriteLock::recursiveWriteLock()+
−
{+
−
    // thread to attempt locking for reading while the test recursively locks for writing+
−
    class RecursiveWriteLockThread : public QThread+
−
    {+
−
    public:+
−
        QReadWriteLock *lock;+
−
        bool tryLockForReadResult;+
−
+
−
        void run()+
−
        {+
−
            testsTurn.release();+
−
+
−
            // test is recursively locking for writing+
−
            for (int i = 0; i < RecursiveLockCount; ++i) {+
−
                threadsTurn.acquire();+
−
                tryLockForReadResult = lock->tryLockForRead();+
−
                testsTurn.release();+
−
            }+
−
+
−
            // test is releasing recursive write lock+
−
            for (int i = 0; i < RecursiveLockCount - 1; ++i) {+
−
                threadsTurn.acquire();+
−
                tryLockForReadResult = lock->tryLockForRead();+
−
                testsTurn.release();+
−
            }+
−
+
−
            // after final unlock in test, we should get the lock+
−
            threadsTurn.acquire();+
−
            tryLockForReadResult = lock->tryLockForRead();+
−
            testsTurn.release();+
−
+
−
            // cleanup+
−
            lock->unlock();+
−
        }+
−
    };+
−
+
−
    // init+
−
    QReadWriteLock lock(QReadWriteLock::Recursive);+
−
    RecursiveWriteLockThread thread;+
−
    thread.lock = &lock;+
−
    thread.start();+
−
+
−
    testsTurn.acquire();+
−
+
−
    // verify that we can get multiple read locks in the same thread+
−
    for (int i = 0; i < RecursiveLockCount; ++i) {+
−
        QVERIFY(lock.tryLockForWrite());+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        QVERIFY(!thread.tryLockForReadResult);+
−
    }+
−
+
−
    // have to unlock the same number of times that we locked+
−
    for (int i = 0;i < RecursiveLockCount - 1; ++i) {+
−
        lock.unlock();+
−
        threadsTurn.release();+
−
+
−
        testsTurn.acquire();+
−
        QVERIFY(!thread.tryLockForReadResult);+
−
    }+
−
+
−
    // after the final unlock, thread should be able to get the read lock+
−
    lock.unlock();+
−
    threadsTurn.release();+
−
+
−
    testsTurn.acquire();+
−
    QVERIFY(thread.tryLockForReadResult);+
−
+
−
    // cleanup+
−
    QVERIFY(thread.wait());+
−
}+
−
+
−
QTEST_MAIN(tst_QReadWriteLock)+
−
+
−
#include "tst_qreadwritelock.moc"+
−