1 mike  1.2 //%2006////////////////////////////////////////////////////////////////////////
  2           //
  3           // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
  4           // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
  5           // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
  6           // IBM Corp.; EMC Corporation, The Open Group.
  7           // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
  8           // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
  9           // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10           // EMC Corporation; VERITAS Software Corporation; The Open Group.
 11           // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 12           // EMC Corporation; Symantec Corporation; The Open Group.
 13           //
 14           // Permission is hereby granted, free of charge, to any person obtaining a copy
 15           // of this software and associated documentation files (the "Software"), to
 16           // deal in the Software without restriction, including without limitation the
 17           // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 18           // sell copies of the Software, and to permit persons to whom the Software is
 19           // furnished to do so, subject to the following conditions:
 20           // 
 21           // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 22 mike  1.2 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 23           // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 24           // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 25           // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 26           // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 27           // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 28           // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 29           //
 30           //==============================================================================
 31           //
 32           //%/////////////////////////////////////////////////////////////////////////////
 33           
 34           #ifndef Pegasus_ReadWriteSem_h
 35           #define Pegasus_ReadWriteSem_h
 36           
 37           #include <Pegasus/Common/Config.h>
 38           #include <Pegasus/Common/Linkage.h>
 39           #include <Pegasus/Common/Semaphore.h>
 40           #include <Pegasus/Common/Mutex.h>
 41           #include <Pegasus/Common/AtomicInt.h>
 42           
 43 mike  1.2 PEGASUS_NAMESPACE_BEGIN
 44           
 45           //==============================================================================
 46           //
 47           // Select the read-write-lock implementation for your platform:
 48           //
 49           //     PEGASUS_USE_POSIX_RWLOCK
 50           //     PEGASUS_USE_SEMAPHORE_RWLOCK
 51           //
 52           //==============================================================================
 53           
 54           #if defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX)
 55           # define PEGASUS_USE_POSIX_RWLOCK

 56 ouyang.jian 1.5 #elif defined(PEGASUS_PLATFORM_PASE_ISERIES_IBMCXX)
 57                 # define PEGASUS_USE_POSIX_RWLOCK

 58 mike        1.2 #elif defined(PEGASUS_PLATFORM_HPUX_ACC)
 59                 # define PEGASUS_USE_POSIX_RWLOCK
 60                 #elif defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)
 61                 # define PEGASUS_USE_POSIX_RWLOCK
 62                 #elif defined(PEGASUS_PLATFORM_TRU64_ALPHA_DECCXX)
 63                 # define PEGASUS_USE_POSIX_RWLOCK
 64                 #elif defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
 65                 # define PEGASUS_USE_POSIX_RWLOCK
 66                 #elif defined(PEGASUS_PLATFORM_VMS_IA64_DECCXX)
 67                 # define PEGASUS_USE_POSIX_RWLOCK
 68                 #elif defined(PEGASUS_PLATFORM_VMS_ALPHA_DECCXX)
 69                 # define PEGASUS_USE_POSIX_RWLOCK
 70                 #elif defined(PEGASUS_PLATFORM_LINUX_X86_64_GNU)
 71                 # define PEGASUS_USE_POSIX_RWLOCK
 72                 #else
 73                 # define PEGASUS_USE_SEMAPHORE_RWLOCK
 74                 #endif
 75                 
 76                 //==============================================================================
 77                 //
 78                 // ReadWriteSemRep
 79 mike        1.2 //
 80                 //==============================================================================
 81                 
 82                 #ifdef PEGASUS_USE_POSIX_RWLOCK
 83                 struct ReadWriteSemRep
 84                 {
 85                     pthread_rwlock_t rwlock;
 86                     ThreadType owner;
 87                 };
 88                 #endif /* PEGASUS_USE_POSIX_RWLOCK */
 89                 
 90                 #ifdef PEGASUS_USE_SEMAPHORE_RWLOCK
 91                 struct ReadWriteSemRep
 92                 {
 93                     Semaphore _rlock;
 94                     Mutex _wlock;
 95                     Mutex _internal_lock;
 96                     ThreadType _owner;

 97 kumpf       1.3     ReadWriteSemRep() :

 98 mike        1.2         _rlock(10), _wlock(), _internal_lock(), _owner(Threads::self())
 99                     {
100                     }
101                 };
102                 #endif /* PEGASUS_USE_POSIX_RWLOCK */
103                 
104                 //==============================================================================
105                 //
106                 // ReadWriteSem
107                 //
108                 //==============================================================================
109                 
110                 class PEGASUS_COMMON_LINKAGE ReadWriteSem
111                 {
112                 public:
113                 
114                     ReadWriteSem();
115                 
116                     ~ReadWriteSem();
117                 
118                     // @exception Permission
119 mike        1.2     // @exception WaitFailed
120                     inline void wait_read(ThreadType caller)
121                     {

122 kumpf       1.7         _wait(false, caller);

123 mike        1.2     }
124                 
125                     // @exception Permission
126                     // @exception WaitFailed
127                     inline void wait_write(ThreadType caller)
128                     {

129 kumpf       1.7         _wait(true, caller);

130 mike        1.2     }
131                 
132                     // @exception Permission
133                     inline void unlock_read(ThreadType caller)
134                     {

135 kumpf       1.7         _unlock(false, caller);

136 mike        1.2     }
137                 
138                     // @exception Permission
139                     inline void unlock_write(ThreadType caller)
140                     {

141 kumpf       1.7         _unlock(true, caller);

142 mike        1.2     }
143                 
144                     int read_count() const;
145                     int write_count() const;
146                 

147 kumpf       1.7 private:

148 mike        1.2     // @exception Permission
149                     // @exception WaitFailed

150 kumpf       1.7     void _wait(Boolean writeLock, ThreadType caller);

151 mike        1.2 
152                     // @exception Permission

153 kumpf       1.7     void _unlock(Boolean writeLock, ThreadType caller);

154 mike        1.2 
155                     AtomicInt _readers;
156                     AtomicInt _writers;
157                     ReadWriteSemRep _rwlock;
158                 };
159                 
160                 //==============================================================================
161                 //
162                 // ReadLock
163                 //
164                 //==============================================================================
165                 
166                 class ReadLock
167                 {
168                 public:
169                 
170                     ReadLock(ReadWriteSem& rwsem) : _rwsem(rwsem)
171                     {
172                         _rwsem.wait_read(Threads::self());
173                     }
174                 
175 mike        1.2     ~ReadLock()
176                     {
177                         _rwsem.unlock_read(Threads::self());
178                     }
179                 
180                 private:
181                     ReadWriteSem & _rwsem;
182                 };
183                 
184                 //==============================================================================
185                 //
186                 // WriteLock
187                 //
188                 //==============================================================================
189                 
190                 class WriteLock
191                 {
192                 public:
193                 
194                     WriteLock(ReadWriteSem& rwsem) : _rwsem(rwsem)
195                     {
196 mike        1.2         _rwsem.wait_write(Threads::self());
197                     }
198                 
199                     ~WriteLock()
200                     {
201                         _rwsem.unlock_write(Threads::self());
202                     }
203                 
204                 private:
205                     ReadWriteSem & _rwsem;
206                 };
207                 
208                 PEGASUS_NAMESPACE_END
209                 
210                 #endif /* Pegasus_ReadWriteSem_h */