(file) Return to ReadWriteSem.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/ReadWriteSem.cpp between version 1.1.2.7 and 1.3

version 1.1.2.7, 2006/07/28 21:22:01 version 1.3, 2006/08/21 08:48:20
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Day (mdday@us.ibm.com)  
 //  
 // Reworked By: Mike Brasher (m.brasher@inovadevelopment.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "ReadWriteSem.h" #include "ReadWriteSem.h"
Line 58 
Line 54 
  
 ReadWriteSem::~ReadWriteSem() ReadWriteSem::~ReadWriteSem()
 { {
       int r=0;
     while (EBUSY == pthread_rwlock_destroy(&_rwlock.rwlock))      while (r=pthread_rwlock_destroy(&_rwlock.rwlock) == EBUSY || (r == -1 && errno == EBUSY))
     {     {
         Threads::yield();         Threads::yield();
     }     }
Line 116 
Line 112 
     }     }
     else     else
         throw(Permission(Threads::self()));         throw(Permission(Threads::self()));
       if (errorcode == -1)
           errorcode = errno;
     if (errorcode == EBUSY)     if (errorcode == EBUSY)
         throw(AlreadyLocked(_rwlock.owner));         throw(AlreadyLocked(_rwlock.owner));
     else if (errorcode == EDEADLK)     else if (errorcode == EDEADLK)
Line 131 
Line 128 
 void ReadWriteSem::timed_wait(Uint32 mode, void ReadWriteSem::timed_wait(Uint32 mode,
                               ThreadType caller, int milliseconds)                               ThreadType caller, int milliseconds)
 { {
     int errorcode = 0, timeout;      int errorcode = 0, timeout = 0;
     struct timeval now, finish, remaining;     struct timeval now, finish, remaining;
     Uint32 usec;     Uint32 usec;
  
Line 147 
Line 144 
         do         do
         {         {
             errorcode = pthread_rwlock_tryrdlock(&_rwlock.rwlock);             errorcode = pthread_rwlock_tryrdlock(&_rwlock.rwlock);
               if (errorcode == -1)
                   errorcode = errno;
             gettimeofday(&now, NULL);             gettimeofday(&now, NULL);
         }         }
         while (errorcode == EBUSY &&         while (errorcode == EBUSY &&
Line 162 
Line 161 
         do         do
         {         {
             errorcode = pthread_rwlock_trywrlock(&_rwlock.rwlock);             errorcode = pthread_rwlock_trywrlock(&_rwlock.rwlock);
               if (errorcode == -1)
                   errorcode = errno;
             gettimeofday(&now, NULL);             gettimeofday(&now, NULL);
         }         }
         while (errorcode == EBUSY &&         while (errorcode == EBUSY &&
Line 206 
Line 207 
  
 int ReadWriteSem::read_count() const int ReadWriteSem::read_count() const
 { {
 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)  
     PEGASUS_ASSERT(_readers.get() == _rwlock.rwlock.__rw_readers);  
 #endif  
     return (_readers.get());     return (_readers.get());
 } }
  
 int ReadWriteSem::write_count() const int ReadWriteSem::write_count() const
 { {
 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)  
     if (_rwlock.rwlock.__rw_writer != NULL)  
     {  
         PEGASUS_ASSERT(_writers.get() == 1);  
     }  
 #endif  
     return (_writers.get());     return (_writers.get());
 } }
  
Line 238 
Line 230 
 // 2) I do not hold the write lock // 2) I do not hold the write lock
 // 3) I am not using a reader slot // 3) I am not using a reader slot
  
   #if 0
 void extricate_read_write(void *parm) void extricate_read_write(void *parm)
 { {
     ReadWriteSem *rws = (ReadWriteSem *) parm;     ReadWriteSem *rws = (ReadWriteSem *) parm;
Line 251 
Line 244 
     if (Threads::equal(rws->_rwlock._internal_lock.get_owner(), myself))     if (Threads::equal(rws->_rwlock._internal_lock.get_owner(), myself))
         rws->_rwlock._internal_lock.unlock();         rws->_rwlock._internal_lock.unlock();
 } }
   #endif
  
  
 ReadWriteSem::ReadWriteSem():_readers(0), _writers(0), _rwlock() ReadWriteSem::ReadWriteSem():_readers(0), _writers(0), _rwlock()
Line 262 
Line 256 
     // lock everyone out of this object     // lock everyone out of this object
     try     try
     {     {
         _rwlock._internal_lock.lock(Threads::self());          _rwlock._internal_lock.lock();
     }     }
     catch(Deadlock & d)      catch(Deadlock &)
     {     {
         d = d;                  // no problem - we own the lock, which is          // no problem - we own the lock, which is what we want
                                 // what we want  
     }     }
     catch(IPCException &)     catch(IPCException &)
     {     {
Line 310 
Line 303 
  
     // cleanup stack frame     // cleanup stack frame
     {     {
           // Threads::cleanup_push(extricate_read_write, this);
         Threads::cleanup_push(extricate_read_write, this);  
  
         try         try
         {         {
             if (milliseconds == 0)             if (milliseconds == 0)
                 _rwlock._internal_lock.try_lock(Threads::self());                  _rwlock._internal_lock.try_lock();
             else if (milliseconds == -1)             else if (milliseconds == -1)
                 _rwlock._internal_lock.lock(Threads::self());                  _rwlock._internal_lock.lock();
             else             else
                 _rwlock._internal_lock.timed_lock(milliseconds,                  _rwlock._internal_lock.timed_lock(milliseconds);
                                                   Threads::self());  
         }         }
         catch(const IPCException & e)         catch(const IPCException & e)
         {         {
Line 378 
Line 369 
             {             {
                 try                 try
                 {                 {
                     _rwlock._wlock.try_lock(Threads::self());                      _rwlock._wlock.try_lock();
                 }                 }
                 catch(IPCException & e)                 catch(IPCException & e)
                 {                 {
Line 391 
Line 382 
             {             {
                 try                 try
                 {                 {
                     _rwlock._wlock.lock(Threads::self());                      _rwlock._wlock.lock();
                 }                 }
                 catch(const IPCException & e)                 catch(const IPCException & e)
                 {                 {
Line 404 
Line 395 
             {             {
                 try                 try
                 {                 {
                     _rwlock._wlock.timed_lock(milliseconds, Threads::self());                      _rwlock._wlock.timed_lock(milliseconds);
                 }                 }
                 catch(const IPCException & e)                 catch(const IPCException & e)
                 {                 {

Legend:
Removed from v.1.1.2.7  
changed lines
  Added in v.1.3
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2