The test for Bu::ReadWriteMutex is better and there is more documentation now.

2 files changed, 52 insertions, 16 deletions

diff --git a/src/tests/readwritemutex.cpp b/src/tests/readwritemutex.cpp
index 3ed8a49..8cb79e5 100644
--- a/src/tests/readwritemutex.cpp
+++ b/src/tests/readwritemutex.cpp
@@ -11,15 +11,32 @@
 
 using namespace Bu;
 
+#define CNT 15
+
+char disp[CNT*2+1];
+
 ReadWriteMutex mRW;
 bool bRunning;
 
+int rbase;
+
+Mutex mDisp;
+
+void dispUpd( char &ind, char val )
+{
+    mDisp.lock();
+    ind = val;
+    println(disp);
+    mDisp.unlock();
+}
+
 class Writer : public Thread
 {
 public:
-    Writer( int iId ) :
+    Writer( int iId, char &ind ) :
         iId( iId ),
-        rand( iId )
+        rand( rbase+iId ),
+        ind( ind )
     {
     }
 
@@ -30,12 +47,15 @@ public:
 protected:
     virtual void run()
     {
+        usleep( rand.rand(1000000) );
         while( bRunning )
         {
             mRW.lockWrite();
-            println("Writer %1 locking.").arg( iId );
-            usleep( rand.rand(5,10)*100000 );
-            println("Writer %1 unlocking.").arg( iId );
+            dispUpd( ind, 'W' );
+//            println("Writer %1 locking.").arg( iId );
+            usleep( rand.rand(1,10)*10000 );
+//            println("Writer %1 unlocking.").arg( iId );
+            dispUpd( ind, ' ' );
             mRW.unlockWrite();
             usleep( rand.rand(5,10)*10000 );
         }
@@ -44,14 +64,16 @@ protected:
 private:
     int iId;
     RandomCmwc rand;
+    char &ind;
 };
 
 class Reader : public Thread
 {
 public:
-    Reader( int iId ) :
+    Reader( int iId, char &ind ) :
         iId( iId ),
-        rand( -iId )
+        rand( rbase-iId ),
+        ind( ind )
     {
     }
 
@@ -62,12 +84,15 @@ public:
 protected:
     virtual void run()
     {
+        usleep( rand.rand(1000000) );
         while( bRunning )
         {
             mRW.lockRead();
-            println("Reader %1 locking.").arg( iId );
-            usleep( rand.rand(5,10)*100000 );
-            println("Reader %1 unlocking.").arg( iId );
+            dispUpd( ind, 'R' );
+//            println("Reader %1 locking.").arg( iId );
+            usleep( rand.rand(1,10)*10000 );
+//            println("Reader %1 unlocking.").arg( iId );
+            dispUpd( ind, ' ' );
             mRW.unlockRead();
             usleep( rand.rand(5,10)*10000 );
         }
@@ -76,26 +101,28 @@ protected:
 private:
     int iId;
     RandomCmwc rand;
+    char &ind;
 };
 
-#define CNT 5
-
 int main()
 {
     bRunning = true;
+    rbase = time( NULL );
+
+    memset( disp, 0x20, CNT*2+1 );
+    disp[CNT*2] = 0;
 
     Thread **threads = new Thread*[CNT*2];
     for( int j = 0; j < CNT; j++ )
     {
-        threads[j] = new Reader( j+1 );
-        threads[j+CNT] = new Writer( j+1 );
+        threads[j] = new Reader( j+1, disp[j+CNT] );
+        threads[j+CNT] = new Writer( j+1, disp[j] );
     }
 
-    println("Starting.");
     for( int j = 0; j < CNT*2; j++ )
         threads[j]->start();
 
-    sleep( 10 );
+    sleep( 120 );
     bRunning = false;
 
     for( int j = 0; j < CNT*2; j++ )
diff --git a/src/unstable/readwritemutex.cpp b/src/unstable/readwritemutex.cpp
index 3d8ac7a..62e9ee1 100644
--- a/src/unstable/readwritemutex.cpp
+++ b/src/unstable/readwritemutex.cpp
@@ -49,6 +49,15 @@ void Bu::ReadWriteMutex::unlockRead()
     mRead.unlock();
 }
 
+//
+// The bWantWrite could be a counter like the read lock counter, however
+// once a write lock occurs and bWantWrite is set at least one wite
+// will definately occur.  In practice most writes all happen one after
+// the other anyway and this way reads get a chance to mingle in.
+//
+// Really, just getting all currint reads to stop so a write can happen
+// I think is sufficient right now.
+//
 void Bu::ReadWriteMutex::lockWrite()
 {
     // Lock the read counter