phRWLockTest.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission : 
        Realtime Vision Processing System
    
    Copyright (C) 2003-2006 Philip D.S. Thoren (pthoren@cs.uml.edu)
    University of Massachusetts at Lowell,
    Laboratory for Artificial Intelligence and Robotics
    
    This file is part of Phission.

 ---------------------------------------------------------------------------*/
#include <phRWLockTest.h>
#include <phission.h>
#include <time.h>

/* ------------------------------------------------------------------------ */
int glbl_disable_displays = 0;

/* ------------------------------------------------------------------------ */
/* phRWLockThread : Test the normal successful operation of a phThread    */
/* ------------------------------------------------------------------------ */
class phRWLockThread : public phThread
{
private:
    phRWLock    *m_external_rwlock;
    
    int run();
    int setup();
    int wakeup();
    int cleanup();
    int error();
    
public:
    phRWLockThread();
    ~phRWLockThread();

    phSemaphore *m_sem;
    void set( phRWLock *rwlock );
};

/* ------------------------------------------------------------------------ */
phRWLockThread::phRWLockThread()
{
    phFUNCTION("phRWLockThread::phRWLockThread")
    this->setName("phRWLockThread");
    this->m_sem = new phSemaphore(0,1);
    phPROGRESS("\n");
}

/* ------------------------------------------------------------------------ */
phRWLockThread::~phRWLockThread()
{
    phFUNCTION("phRWLockThread::~phRWLockThread")
    phPROGRESS("\n");
}

/* ------------------------------------------------------------------------ */
int phRWLockThread::run()
{
    phFUNCTION("phRWLockThread::run")
    int nlocks = 0;

    phPROGRESS("calling signal_running() %p\n",this);
    
    /* Signal the spawning thread that we've woken up */
    rc = this->signal_running();
    phPRINT_RC(rc,NULL,"this->signal_error");
   
    while (this->isRunning())
    {
        /* Wait till we're allowed to try for the rwlock */
        phPROGRESS("this->m_sem->take()\n");
        rc = this->m_sem->take();
        phPRINT_RC(rc,NULL,"this->m_sem->take() failed.");
  
        /* check to make sure we're still running. If we woke up and isRunning()
         * is false then 'wakeup' was called and we should return */
        if (!this->isRunning()) continue;
        
        /* Try for the read lock */
        phPROGRESS("rc = this->m_external_rwlock->readLock()\n");
        rc = this->m_external_rwlock->readLock();
        phPRINT_RC(rc,NULL,"this->m_extenral_rwlock->readLock()");

        /* Print some information */
        phPRINT("(%d) Have read lock #%d\n",
                phGetCurrentThreadId(),
                nlocks );

        /* Count the number of loops we get the lock */
        nlocks++;

        /* Sleep for a while */
        phUSleep(100);

        /* Release the lock */
        phPROGRESS("rc = this->m_external_rwlock->rwUnlock()\n");
        rc = this->m_external_rwlock->rwUnlock();
        phPRINT_RC(rc,NULL,"this->m_external_rwlock->rwUnlock()");
    }
    
    phPROGRESS("returning\n");
    return phSUCCESS;
#if 0
error:
    phPROGRESS("\n");

    rc = this->signal_error();
    phPRINT_RC(rc,NULL,"this->signal_error");
    
    return phFAIL;
#endif
}

/* ------------------------------------------------------------------------ */
int phRWLockThread::setup()
{
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phRWLockThread::wakeup()
{
    /* The thread is likely waiting on the semaphore, so post to it. It's the
     * thread's responsibility to check to make sure it's still running when it
     * wakes up */
    this->m_sem->post();
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phRWLockThread::cleanup()
{
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phRWLockThread::error()
{
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
void phRWLockThread::set( phRWLock *rwlock )
{
    this->m_external_rwlock = rwlock;
    
    return;
}

/* ------------------------------------------------------------------------ */
int phRWLock_test()
{
    phFUNCTION("phRWLock_test")
    
    phRWLock *lock = new phRWLock();

    /* -------------------------------------------------------------------- */
    /* Step 5: Test read/write lock between actual threads */
    /* -------------------------------------------------------------------- */
#define SLEEP_TIME 1000 /* us */
    /* We're going to allocate 'num_threads' threads to test the
     * read-write locks and contention between threads */
    const int       num_threads         = 7;
    const int       write_lock_count    = 10;
    phSystem       *system              = NULL;
    phRWLockThread *threads             = NULL;
    int             testid              = 0;
    int             i                   = 0;
    int             j                   = 0;
    int             nlocks              = 0;
    /* -------------------------------------------------------------------- */

    phPROGRESS("\n");
#if 0
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("1.) 2 x Write Locks: recursive\n");
    
    phPROGRESS("rc = lock->writeLock()\n");
    rc = lock->writeLock();
    phPRINT_RC(rc,NULL,"lock->writeLock()");

    phPROGRESS("rc = lock->writeLock()\n");
    rc = lock->writeLock();
    phPRINT_RC(rc,NULL,"lock->writeLock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
   
    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("2.) Write Lock | Read Lock\n");
    
    phPROGRESS("rc = lock->writeLock()\n");
    rc = lock->writeLock();
    phPRINT_RC(rc,NULL,"lock->writeLock()");

    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
    
    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("3.) 2 x Read Locks \n");
    
    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
    
    
    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("4.) Read Lock | Try Write Lock\n");

    /* timeouts were removed because they aren't supported by pthreads */
#if 0
    lock->setTimeoutNS(100000000);
    lock->enableTimeout();
#endif
    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("rc = lock->tryWriteLock()\n");
    rc = lock->tryWriteLock();
    phPRINT_RC(rc,NULL,"lock->tryWriteLock()");

    /* Check to see if tryWriteLock succeeded */
    if (rc == 0)
    {
        phPROGRESS("rc = lock->rwUnlock()\n");
        rc = lock->rwUnlock();
        phPRINT_RC(rc,NULL,"lock->rwUnlock()");
    }
    else
    {
        phPROGRESS("SUCCESS: Failure to get lock with tryWriteLock\n");
    }

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
    
    /* timeouts were removed because they aren't supported by pthreads */
#if 0
    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("5a.) Read Lock | Timed Write Lock (1*10^9ns)\n");
   
    lock->setTimeoutNS(100000000);
    lock->enableTimeout();
    
    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("*** NOTE: This will deadlock! ***\n");
    
    phPROGRESS("rc = lock->writeLock()\n");
    rc = lock->writeLock();
    phPRINT_RC(rc,NULL,"lock->writeLock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
    
    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("5b.) Read Lock | Timed Write Lock (2*10^9ns)\n");
    struct timespec t;
    t.tv_sec = 10;
    t.tv_nsec = 2000000000;
    lock->setTimeoutTimeSpec(t);
    lock->enableTimeout();
    
    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("rc = lock->writeLock()\n");
    rc = lock->writeLock();
    phPRINT_RC(rc,NULL,"lock->writeLock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
    
    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("5c.) Read Lock | Timed Write Lock (5s)\n");
    t.tv_sec = 5;
    t.tv_nsec = 0;
    lock->setTimeoutTimeSpec(t);
    lock->enableTimeout();
    
    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("rc = lock->writeLock()\n");
    rc = lock->writeLock();
    phPRINT_RC(rc,NULL,"lock->writeLock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
#endif
#endif /* skipping tests, remove this */

    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("5.) Read/Write locking between threads\n");

    threads = new phRWLockThread[num_threads];
    phPRINT_PTR(threads,"new",
                "new failed to allocate %d phThreads",num_threads);

    system = new phSystem();
    phPRINT_PTR(system,"new","new failed to allocate phSystem");
    
    for (i = 0; i < num_threads; i++ )
    {
        rc = system->add(&(threads[i]));
        phPRINT_RC(rc,NULL,"system->add(threads[%d]) failed",i);

        threads[i].set(lock);
    }
    
    /* Start the system of read locking threads */
    phPROGRESS("rc = system.startup()\n");
    rc = system->startup();
    phPRINT_RC(rc,NULL,"rc = system.startup()");
    
    for (i = 0; i < write_lock_count; i++ )
    {
        /* wait for the readers to get started with the read lock */
        /* A problem exists between rwUnlock and writelock that can cause
         * starvation of the readers in our implementation. If the rwUnlock
         * and writelock happen in the same timeslice, waiting readers will
         * not get through. Simple yielding may not work. If the write
         * thread has higher priorty, then it could signal the readers but
         * get the lock again before any reader can get through. 
         *  The assumption is that the write thread will take some amount of
         * time between it's rwUnlock and it's writeLock to acquire new data.
         * This is simulated with a lengthy sleep */
        if (i > 0) 
        {
            phPROGRESS("phUSleep(2000);\n");
            phUSleep(2000);
        }

        /* Try to get the write lock */
        phPROGRESS("rc = lock->writeLock()\n");
        rc = lock->writeLock();
        phPRINT_RC(rc,NULL,"rc = lock->writeLock()");

        phPRINT("(%d) Have write lock #%d\n",
                phGetCurrentThreadId(),  nlocks );

        nlocks++;

        /* Let the reader threads go */
        for (j = 0; j < num_threads; j++ )
        {
            phPROGRESS("rc = threads[j].sem->post()\n");
            rc = threads[j].m_sem->post();
            phPRINT_RC(rc,NULL,"rc = threads[j].sem->post()");
        }

        /* wait a little bit - give the other processes time to wake up and wait
         * on the reader lock */
        /* This could simulate the writing of a large amount of data that causes
         * the writing thread to take up more than one timeslice. It allows
         * other threads to get through and try the read lock */
        phPROGRESS("phUSleep(2000);\n");
        phUSleep(2000);

        /* release the lock */
        phPROGRESS("rc = lock->rwUnlock()\n");
        rc = lock->rwUnlock();
        phPRINT_RC(rc,NULL,"rc = lock->rwUnlock()");
    }

    /* stop the threads */
    for (i = 0; i < num_threads; i++ )
    {
        phPROGRESS("rc = system->shutdown()\n");
        rc = system->shutdown();
        phPRINT_RC(rc,NULL,"rc = system->shutdown()");
    }

    /* Delete the array of threads and the system */
    phDeleteArray(threads);
    phDelete(system);
    
    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("6.) Read Lock | Write Lock\n");
   
    /* timeouts were removed because they aren't supported by pthreads */
#if 0
    lock->disableTimeout();
#endif
    
    phPROGRESS("rc = lock->readLock()\n");
    rc = lock->readLock();
    phPRINT_RC(rc,NULL,"lock->readLock()");

    phPROGRESS("rc = lock->writeLock() - we should never get through\n");
    rc = lock->writeLock();
    phPRINT_RC(rc,NULL,"lock->writeLock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");

    phPROGRESS("rc = lock->rwUnlock()\n");
    rc = lock->rwUnlock();
    phPRINT_RC(rc,NULL,"lock->rwUnlock()");
    

    /* ----------------------------------------------------------------------*/
    phPROGRESS("--------------------------------------------------\n");
    phPROGRESS("phDelete(lock)\n");
    phDelete(lock);
    
    return phSUCCESS;
}
    
/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */
int main(int argc, char *argv[] )
{
    phFUNCTION("main")

    rc = phRWLock_test();
error:

    return phSUCCESS;
}

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---