1// shared_ptr atomic access -*- C++ -*-
2
3// Copyright (C) 2014-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file bits/shared_ptr_atomic.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{memory}
28 */
29
30#ifndef _SHARED_PTR_ATOMIC_H
31#define _SHARED_PTR_ATOMIC_H 1
32
33#include <bits/atomic_base.h>
34
35namespace std _GLIBCXX_VISIBILITY(default)
36{
37_GLIBCXX_BEGIN_NAMESPACE_VERSION
38
39 /**
40 * @addtogroup pointer_abstractions
41 * @{
42 */
43
44 struct _Sp_locker
45 {
46 _Sp_locker(const _Sp_locker&) = delete;
47 _Sp_locker& operator=(const _Sp_locker&) = delete;
48
49#ifdef __GTHREADS
50 explicit
51 _Sp_locker(const void*) noexcept;
52 _Sp_locker(const void*, const void*) noexcept;
53 ~_Sp_locker();
54
55 private:
56 unsigned char _M_key1;
57 unsigned char _M_key2;
58#else
59 explicit _Sp_locker(const void*, const void* = nullptr) { }
60#endif
61 };
62
63 /**
64 * @brief Report whether shared_ptr atomic operations are lock-free.
65 * @param __p A non-null pointer to a shared_ptr object.
66 * @return True if atomic access to @c *__p is lock-free, false otherwise.
67 * @{
68 */
69 template<typename _Tp, _Lock_policy _Lp>
70 inline bool
71 atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
72 {
73#ifdef __GTHREADS
74 return __gthread_active_p() == 0;
75#else
76 return true;
77#endif
78 }
79
80 template<typename _Tp>
81 inline bool
82 atomic_is_lock_free(const shared_ptr<_Tp>* __p)
83 { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
84
85 // @}
86
87 /**
88 * @brief Atomic load for shared_ptr objects.
89 * @param __p A non-null pointer to a shared_ptr object.
90 * @return @c *__p
91 *
92 * The memory order shall not be @c memory_order_release or
93 * @c memory_order_acq_rel.
94 * @{
95 */
96 template<typename _Tp>
97 inline shared_ptr<_Tp>
98 atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
99 {
100 _Sp_locker __lock{__p};
101 return *__p;
102 }
103
104 template<typename _Tp>
105 inline shared_ptr<_Tp>
106 atomic_load(const shared_ptr<_Tp>* __p)
107 { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
108
109 template<typename _Tp, _Lock_policy _Lp>
110 inline __shared_ptr<_Tp, _Lp>
111 atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
112 {
113 _Sp_locker __lock{__p};
114 return *__p;
115 }
116
117 template<typename _Tp, _Lock_policy _Lp>
118 inline __shared_ptr<_Tp, _Lp>
119 atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
120 { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
121 // @}
122
123 /**
124 * @brief Atomic store for shared_ptr objects.
125 * @param __p A non-null pointer to a shared_ptr object.
126 * @param __r The value to store.
127 *
128 * The memory order shall not be @c memory_order_acquire or
129 * @c memory_order_acq_rel.
130 * @{
131 */
132 template<typename _Tp>
133 inline void
134 atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
135 memory_order)
136 {
137 _Sp_locker __lock{__p};
138 __p->swap(__r); // use swap so that **__p not destroyed while lock held
139 }
140
141 template<typename _Tp>
142 inline void
143 atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
144 { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
145
146 template<typename _Tp, _Lock_policy _Lp>
147 inline void
148 atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
149 __shared_ptr<_Tp, _Lp> __r,
150 memory_order)
151 {
152 _Sp_locker __lock{__p};
153 __p->swap(__r); // use swap so that **__p not destroyed while lock held
154 }
155
156 template<typename _Tp, _Lock_policy _Lp>
157 inline void
158 atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
159 { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
160 // @}
161
162 /**
163 * @brief Atomic exchange for shared_ptr objects.
164 * @param __p A non-null pointer to a shared_ptr object.
165 * @param __r New value to store in @c *__p.
166 * @return The original value of @c *__p
167 * @{
168 */
169 template<typename _Tp>
170 inline shared_ptr<_Tp>
171 atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
172 memory_order)
173 {
174 _Sp_locker __lock{__p};
175 __p->swap(__r);
176 return __r;
177 }
178
179 template<typename _Tp>
180 inline shared_ptr<_Tp>
181 atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
182 {
183 return std::atomic_exchange_explicit(__p, std::move(__r),
184 memory_order_seq_cst);
185 }
186
187 template<typename _Tp, _Lock_policy _Lp>
188 inline __shared_ptr<_Tp, _Lp>
189 atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
190 __shared_ptr<_Tp, _Lp> __r,
191 memory_order)
192 {
193 _Sp_locker __lock{__p};
194 __p->swap(__r);
195 return __r;
196 }
197
198 template<typename _Tp, _Lock_policy _Lp>
199 inline __shared_ptr<_Tp, _Lp>
200 atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
201 {
202 return std::atomic_exchange_explicit(__p, std::move(__r),
203 memory_order_seq_cst);
204 }
205 // @}
206
207 /**
208 * @brief Atomic compare-and-swap for shared_ptr objects.
209 * @param __p A non-null pointer to a shared_ptr object.
210 * @param __v A non-null pointer to a shared_ptr object.
211 * @param __w A non-null pointer to a shared_ptr object.
212 * @return True if @c *__p was equivalent to @c *__v, false otherwise.
213 *
214 * The memory order for failure shall not be @c memory_order_release or
215 * @c memory_order_acq_rel, or stronger than the memory order for success.
216 * @{
217 */
218 template<typename _Tp>
219 bool
220 atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
221 shared_ptr<_Tp>* __v,
222 shared_ptr<_Tp> __w,
223 memory_order,
224 memory_order)
225 {
226 shared_ptr<_Tp> __x; // goes out of scope after __lock
227 _Sp_locker __lock{__p, __v};
228 owner_less<shared_ptr<_Tp>> __less;
229 if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
230 {
231 __x = std::move(*__p);
232 *__p = std::move(__w);
233 return true;
234 }
235 __x = std::move(*__v);
236 *__v = *__p;
237 return false;
238 }
239
240 template<typename _Tp>
241 inline bool
242 atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
243 shared_ptr<_Tp> __w)
244 {
245 return std::atomic_compare_exchange_strong_explicit(__p, __v,
246 std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
247 }
248
249 template<typename _Tp>
250 inline bool
251 atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
252 shared_ptr<_Tp>* __v,
253 shared_ptr<_Tp> __w,
254 memory_order __success,
255 memory_order __failure)
256 {
257 return std::atomic_compare_exchange_strong_explicit(__p, __v,
258 std::move(__w), __success, __failure);
259 }
260
261 template<typename _Tp>
262 inline bool
263 atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
264 shared_ptr<_Tp> __w)
265 {
266 return std::atomic_compare_exchange_weak_explicit(__p, __v,
267 std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
268 }
269
270 template<typename _Tp, _Lock_policy _Lp>
271 bool
272 atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
273 __shared_ptr<_Tp, _Lp>* __v,
274 __shared_ptr<_Tp, _Lp> __w,
275 memory_order,
276 memory_order)
277 {
278 __shared_ptr<_Tp, _Lp> __x; // goes out of scope after __lock
279 _Sp_locker __lock{__p, __v};
280 owner_less<__shared_ptr<_Tp, _Lp>> __less;
281 if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
282 {
283 __x = std::move(*__p);
284 *__p = std::move(__w);
285 return true;
286 }
287 __x = std::move(*__v);
288 *__v = *__p;
289 return false;
290 }
291
292 template<typename _Tp, _Lock_policy _Lp>
293 inline bool
294 atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
295 __shared_ptr<_Tp, _Lp>* __v,
296 __shared_ptr<_Tp, _Lp> __w)
297 {
298 return std::atomic_compare_exchange_strong_explicit(__p, __v,
299 std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
300 }
301
302 template<typename _Tp, _Lock_policy _Lp>
303 inline bool
304 atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
305 __shared_ptr<_Tp, _Lp>* __v,
306 __shared_ptr<_Tp, _Lp> __w,
307 memory_order __success,
308 memory_order __failure)
309 {
310 return std::atomic_compare_exchange_strong_explicit(__p, __v,
311 std::move(__w), __success, __failure);
312 }
313
314 template<typename _Tp, _Lock_policy _Lp>
315 inline bool
316 atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
317 __shared_ptr<_Tp, _Lp>* __v,
318 __shared_ptr<_Tp, _Lp> __w)
319 {
320 return std::atomic_compare_exchange_weak_explicit(__p, __v,
321 std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
322 }
323 // @}
324
325 // @} group pointer_abstractions
326
327_GLIBCXX_END_NAMESPACE_VERSION
328} // namespace
329
330#endif // _SHARED_PTR_ATOMIC_H
331