17 #ifndef __TBB_spin_rw_mutex_H 18 #define __TBB_spin_rw_mutex_H 27 #if __TBB_TSX_AVAILABLE 28 namespace interface8 {
namespace internal {
29 class x86_rtm_rw_mutex;
71 #if TBB_USE_THREADING_TOOLS 79 __TBB_ASSERT( !state,
"destruction of an acquired mutex");
87 #if __TBB_TSX_AVAILABLE 88 friend class tbb::interface8::internal::x86_rtm_rw_mutex;
106 void acquire( spin_rw_mutex& m,
bool write =
true ) {
110 if( write )
mutex->internal_acquire_writer();
111 else mutex->internal_acquire_reader();
118 if (is_writer)
return true;
120 return mutex->internal_upgrade();
126 spin_rw_mutex *m =
mutex;
128 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT 140 if (!is_writer)
return true;
141 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT 142 mutex->internal_downgrade();
144 __TBB_FetchAndAddW( &
mutex->state, ((intptr_t)ONE_READER-WRITER));
173 static const bool is_rw_mutex =
true;
174 static const bool is_recursive_mutex =
false;
175 static const bool is_fair_mutex =
false;
180 void lock() {internal_acquire_writer();}
184 bool try_lock() {
return internal_try_acquire_writer();}
188 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT 189 if( state&WRITER ) internal_release_writer();
190 else internal_release_reader();
208 static const state_t WRITER = 1;
209 static const state_t WRITER_PENDING = 2;
210 static const state_t READERS = ~(WRITER | WRITER_PENDING);
211 static const state_t ONE_READER = 4;
212 static const state_t BUSY = WRITER | READERS;
227 #if __TBB_TSX_AVAILABLE 232 namespace interface8 {
242 #if __TBB_TSX_AVAILABLE bool downgrade_to_reader()
Downgrade writer to become a reader.
#define __TBB_DEFINE_PROFILING_SET_NAME(sync_object_type)
bool __TBB_EXPORTED_METHOD internal_try_acquire_writer()
Internal try_acquire write lock.
spin_rw_mutex_v3()
Construct unacquired mutex.
void __TBB_EXPORTED_METHOD internal_release_writer()
Out of line code for releasing a write lock.
bool try_acquire(spin_rw_mutex &m, bool write=true)
Try acquire lock on given mutex.
bool is_writer
If mutex!=NULL, then is_writer is true if holding a writer lock, false if holding a reader lock...
void __TBB_EXPORTED_METHOD internal_release_reader()
Internal release read lock.
#define __TBB_EXPORTED_METHOD
void lock_read()
Acquire reader lock.
bool try_lock()
Try acquiring writer lock (non-blocking)
Wrapper around the platform's native lock.
#define __TBB_FetchAndAddWrelease(P, V)
bool __TBB_EXPORTED_METHOD internal_try_acquire_reader()
Internal try_acquire read lock.
state_t state
State of lock.
void acquire(spin_rw_mutex &m, bool write=true)
Acquire lock on given mutex.
void lock()
Acquire writer lock.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
scoped_lock()
Construct lock that has not acquired a mutex.
void unlock()
Release lock.
~scoped_lock()
Release lock (if lock is held).
bool upgrade_to_writer()
Upgrade reader to become a writer.
bool try_lock_read()
Try acquiring reader lock (non-blocking)
spin_rw_mutex * mutex
The pointer to the current mutex that is held, or NULL if no mutex is held.
void __TBB_AtomicAND(volatile void *operand, uintptr_t addend)
The scoped locking pattern.
interface7::internal::padded_mutex< tbb::spin_rw_mutex, true > speculative_spin_rw_mutex
A cross-platform spin reader/writer mutex with speculative lock acquisition.
spin_rw_mutex_v3 spin_rw_mutex
void release()
Release lock.
scoped_lock(spin_rw_mutex &m, bool write=true)
Acquire lock on given mutex.
Fast, unfair, spinning reader-writer lock with backoff and writer-preference.