Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
spin_rw_mutex.h
Go to the documentation of this file.
1 /*
2  Copyright (c) 2005-2020 Intel Corporation
3 
4  Licensed under the Apache License, Version 2.0 (the "License");
5  you may not use this file except in compliance with the License.
6  You may obtain a copy of the License at
7 
8  http://www.apache.org/licenses/LICENSE-2.0
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 */
16 
17 #ifndef __TBB_spin_rw_mutex_H
18 #define __TBB_spin_rw_mutex_H
19 
20 #include "tbb_stddef.h"
21 #include "tbb_machine.h"
22 #include "tbb_profiling.h"
24 
25 namespace tbb {
26 
27 #if __TBB_TSX_AVAILABLE
28 namespace interface8 { namespace internal {
29  class x86_rtm_rw_mutex;
30 }}
31 #endif
32 
35 
37 
40 
43 
45 
47 
50 
53 
55 
57 
60 
63 
66 
68 public:
71 #if TBB_USE_THREADING_TOOLS
73 #endif
74  }
75 
76 #if TBB_USE_ASSERT
77  ~spin_rw_mutex_v3() {
79  __TBB_ASSERT( !state, "destruction of an acquired mutex");
80  };
81 #endif /* TBB_USE_ASSERT */
82 
84 
87 #if __TBB_TSX_AVAILABLE
88  friend class tbb::interface8::internal::x86_rtm_rw_mutex;
89 #endif
90  public:
92 
93  scoped_lock() : mutex(NULL), is_writer(false) {}
94 
96  scoped_lock( spin_rw_mutex& m, bool write = true ) : mutex(NULL) {
97  acquire(m, write);
98  }
99 
102  if( mutex ) release();
103  }
104 
106  void acquire( spin_rw_mutex& m, bool write = true ) {
107  __TBB_ASSERT( !mutex, "holding mutex already" );
108  is_writer = write;
109  mutex = &m;
110  if( write ) mutex->internal_acquire_writer();
112  }
113 
115 
117  __TBB_ASSERT( mutex, "mutex is not acquired" );
118  if (is_writer) return true; // Already a writer
119  is_writer = true;
120  return mutex->internal_upgrade();
121  }
122 
124  void release() {
125  __TBB_ASSERT( mutex, "mutex is not acquired" );
126  spin_rw_mutex *m = mutex;
127  mutex = NULL;
128 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
130  else m->internal_release_reader();
131 #else
132  if( is_writer ) __TBB_AtomicAND( &m->state, READERS );
133  else __TBB_FetchAndAddWrelease( &m->state, -(intptr_t)ONE_READER);
134 #endif /* TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT */
135  }
136 
139  __TBB_ASSERT( mutex, "mutex is not acquired" );
140  if (!is_writer) return true; // Already a reader
141 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
143 #else
144  __TBB_FetchAndAddW( &mutex->state, ((intptr_t)ONE_READER-WRITER));
145 #endif /* TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT */
146  is_writer = false;
147  return true;
148  }
149 
151  bool try_acquire( spin_rw_mutex& m, bool write = true ) {
152  __TBB_ASSERT( !mutex, "holding mutex already" );
153  bool result;
154  is_writer = write;
155  result = write? m.internal_try_acquire_writer()
157  if( result )
158  mutex = &m;
159  return result;
160  }
161 
162  protected:
163 
166 
168 
169  bool is_writer;
170  };
171 
172  // Mutex traits
173  static const bool is_rw_mutex = true;
174  static const bool is_recursive_mutex = false;
175  static const bool is_fair_mutex = false;
176 
177  // ISO C++0x compatibility methods
178 
181 
183 
185 
187  void unlock() {
188 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
191 #else
193  else __TBB_FetchAndAddWrelease( &state, -(intptr_t)ONE_READER);
194 #endif /* TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT */
195  }
196 
197  // Methods for reader locks that resemble ISO C++0x compatibility methods.
198 
201 
203 
205 
206 protected:
207  typedef intptr_t state_t;
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;
214 
218 
219 private:
221 };
222 
224 
225 } // namespace tbb
226 
227 #if __TBB_TSX_AVAILABLE
229 #endif
230 
231 namespace tbb {
232 namespace interface8 {
234 
242 #if __TBB_TSX_AVAILABLE
244 #else
246 #endif
247 } // namespace interface8
248 
251 } // namespace tbb
252 #endif /* __TBB_spin_rw_mutex_H */
tbb::spin_rw_mutex_v3::internal_acquire_writer
bool __TBB_EXPORTED_METHOD internal_acquire_writer()
Internal acquire write lock.
Definition: spin_rw_mutex.cpp:37
tbb::spin_rw_mutex_v3::internal_release_reader
void __TBB_EXPORTED_METHOD internal_release_reader()
Internal release read lock.
Definition: spin_rw_mutex.cpp:115
internal
Definition: _flow_graph_async_msg_impl.h:24
tbb::internal::mutex_copy_deprecated_and_disabled
Definition: tbb_stddef.h:365
tbb::spin_rw_mutex_v3::state
state_t state
State of lock.
Definition: spin_rw_mutex.h:217
tbb::spin_rw_mutex_v3::internal_try_acquire_writer
bool __TBB_EXPORTED_METHOD internal_try_acquire_writer()
Internal try_acquire write lock.
Definition: spin_rw_mutex.cpp:123
tbb::spin_rw_mutex_v3::try_lock
bool try_lock()
Try acquiring writer lock (non-blocking)
Definition: spin_rw_mutex.h:184
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
_x86_rtm_rw_mutex_impl.h
tbb::spin_rw_mutex_v3::scoped_lock::scoped_lock
scoped_lock(spin_rw_mutex &m, bool write=true)
Acquire lock on given mutex.
Definition: spin_rw_mutex.h:96
tbb::spin_rw_mutex_v3::internal_downgrade
void __TBB_EXPORTED_METHOD internal_downgrade()
Out of line code for downgrading a writer to a reader.
Definition: spin_rw_mutex.cpp:108
tbb::spin_rw_mutex_v3::ONE_READER
static const state_t ONE_READER
Definition: spin_rw_mutex.h:211
tbb::spin_rw_mutex_v3::internal_try_acquire_reader
bool __TBB_EXPORTED_METHOD internal_try_acquire_reader()
Internal try_acquire read lock.
Definition: spin_rw_mutex.cpp:136
tbb
The graph class.
Definition: serial/tbb/parallel_for.h:46
tbb::spin_rw_mutex_v3::scoped_lock::is_writer
bool is_writer
If mutex!=NULL, then is_writer is true if holding a writer lock, false if holding a reader lock.
Definition: spin_rw_mutex.h:169
tbb::spin_rw_mutex_v3::try_lock_read
bool try_lock_read()
Try acquiring reader lock (non-blocking)
Definition: spin_rw_mutex.h:204
tbb::spin_rw_mutex_v3::scoped_lock
The scoped locking pattern.
Definition: spin_rw_mutex.h:86
tbb::spin_rw_mutex
spin_rw_mutex_v3 spin_rw_mutex
Definition: spin_rw_mutex.h:33
tbb::spin_rw_mutex_v3::scoped_lock::mutex
spin_rw_mutex * mutex
The pointer to the current mutex that is held, or NULL if no mutex is held.
Definition: spin_rw_mutex.h:165
tbb::spin_rw_mutex_v3::READERS
static const state_t READERS
Definition: spin_rw_mutex.h:210
tbb::spin_rw_mutex_v3::internal_acquire_reader
void __TBB_EXPORTED_METHOD internal_acquire_reader()
Internal acquire read lock.
Definition: spin_rw_mutex.cpp:62
tbb::spin_rw_mutex_v3::scoped_lock::scoped_lock
scoped_lock()
Construct lock that has not acquired a mutex.
Definition: spin_rw_mutex.h:93
tbb::interface8::speculative_spin_rw_mutex
interface7::internal::padded_mutex< tbb::spin_rw_mutex, true > speculative_spin_rw_mutex
A cross-platform spin reader/writer mutex with speculative lock acquisition.
Definition: spin_rw_mutex.h:245
tbb_profiling.h
tbb::spin_rw_mutex_v3::unlock
void unlock()
Release lock.
Definition: spin_rw_mutex.h:187
tbb::spin_rw_mutex_v3::lock_read
void lock_read()
Acquire reader lock.
Definition: spin_rw_mutex.h:200
tbb::spin_rw_mutex_v3::scoped_lock::downgrade_to_reader
bool downgrade_to_reader()
Downgrade writer to become a reader.
Definition: spin_rw_mutex.h:138
tbb::spin_rw_mutex_v3::scoped_lock::try_acquire
bool try_acquire(spin_rw_mutex &m, bool write=true)
Try acquire lock on given mutex.
Definition: spin_rw_mutex.h:151
tbb::spin_rw_mutex_v3::scoped_lock::release
void release()
Release lock.
Definition: spin_rw_mutex.h:124
tbb::spin_rw_mutex_v3::WRITER_PENDING
static const state_t WRITER_PENDING
Definition: spin_rw_mutex.h:209
tbb::spin_rw_mutex_v3::scoped_lock::~scoped_lock
~scoped_lock()
Release lock (if lock is held).
Definition: spin_rw_mutex.h:101
_mutex_padding.h
tbb::spin_rw_mutex_v3::BUSY
static const state_t BUSY
Definition: spin_rw_mutex.h:212
tbb::interface7::internal::padded_mutex
Definition: _mutex_padding.h:32
tbb::spin_rw_mutex_v3::is_recursive_mutex
static const bool is_recursive_mutex
Definition: spin_rw_mutex.h:174
__TBB_AtomicAND
void __TBB_AtomicAND(volatile void *operand, uintptr_t addend)
Definition: tbb_machine.h:888
tbb::spin_rw_mutex_v3::lock
void lock()
Acquire writer lock.
Definition: spin_rw_mutex.h:180
tbb::spin_rw_mutex_v3::internal_upgrade
bool __TBB_EXPORTED_METHOD internal_upgrade()
Internal upgrade reader to become a writer.
Definition: spin_rw_mutex.cpp:82
tbb::internal::no_copy
Base class for types that should not be copied or assigned.
Definition: tbb_stddef.h:330
tbb_machine.h
tbb::spin_rw_mutex_v3::spin_rw_mutex_v3
spin_rw_mutex_v3()
Construct unacquired mutex.
Definition: spin_rw_mutex.h:70
tbb::spin_rw_mutex_v3
Fast, unfair, spinning reader-writer lock with backoff and writer-preference.
Definition: spin_rw_mutex.h:38
tbb::spin_rw_mutex_v3::scoped_lock::acquire
void acquire(spin_rw_mutex &m, bool write=true)
Acquire lock on given mutex.
Definition: spin_rw_mutex.h:106
tbb::spin_rw_mutex_v3::scoped_lock::upgrade_to_writer
bool upgrade_to_writer()
Upgrade reader to become a writer.
Definition: spin_rw_mutex.h:116
tbb::spin_rw_mutex_v3::WRITER
static const state_t WRITER
Definition: spin_rw_mutex.h:208
tbb_stddef.h
tbb::spin_rw_mutex_v3::is_fair_mutex
static const bool is_fair_mutex
Definition: spin_rw_mutex.h:175
__TBB_DEFINE_PROFILING_SET_NAME
#define __TBB_DEFINE_PROFILING_SET_NAME(sync_object_type)
Definition: tbb_profiling.h:115
tbb::spin_rw_mutex_v3::state_t
intptr_t state_t
Definition: spin_rw_mutex.h:207
__TBB_EXPORTED_METHOD
#define __TBB_EXPORTED_METHOD
Definition: tbb_stddef.h:98
tbb::spin_rw_mutex_v3::is_rw_mutex
static const bool is_rw_mutex
Definition: spin_rw_mutex.h:173
__TBB_FetchAndAddWrelease
#define __TBB_FetchAndAddWrelease(P, V)
Definition: tbb_machine.h:309
tbb::spin_rw_mutex_v3::internal_release_writer
void __TBB_EXPORTED_METHOD internal_release_writer()
Out of line code for releasing a write lock.
Definition: spin_rw_mutex.cpp:55
tbb::spin_rw_mutex_v3::internal_construct
void __TBB_EXPORTED_METHOD internal_construct()
Definition: spin_rw_mutex.cpp:152

Copyright © 2005-2020 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.