/Users/deen/code/yugabyte-db/src/yb/util/atomic.h
Line | Count | Source (jump to first uncovered line) |
1 | | // Licensed to the Apache Software Foundation (ASF) under one |
2 | | // or more contributor license agreements. See the NOTICE file |
3 | | // distributed with this work for additional information |
4 | | // regarding copyright ownership. The ASF licenses this file |
5 | | // to you under the Apache License, Version 2.0 (the |
6 | | // "License"); you may not use this file except in compliance |
7 | | // with the License. You may obtain a copy of the License at |
8 | | // |
9 | | // http://www.apache.org/licenses/LICENSE-2.0 |
10 | | // |
11 | | // Unless required by applicable law or agreed to in writing, |
12 | | // software distributed under the License is distributed on an |
13 | | // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
14 | | // KIND, either express or implied. See the License for the |
15 | | // specific language governing permissions and limitations |
16 | | // under the License. |
17 | | // |
18 | | // The following only applies to changes made to this file as part of YugaByte development. |
19 | | // |
20 | | // Portions Copyright (c) YugaByte, Inc. |
21 | | // |
22 | | // Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except |
23 | | // in compliance with the License. You may obtain a copy of the License at |
24 | | // |
25 | | // http://www.apache.org/licenses/LICENSE-2.0 |
26 | | // |
27 | | // Unless required by applicable law or agreed to in writing, software distributed under the License |
28 | | // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
29 | | // or implied. See the License for the specific language governing permissions and limitations |
30 | | // under the License. |
31 | | // |
32 | | |
33 | | #ifndef YB_UTIL_ATOMIC_H |
34 | | #define YB_UTIL_ATOMIC_H |
35 | | |
36 | | #include <algorithm> |
37 | | #include <atomic> |
38 | | #include <thread> |
39 | | |
40 | | #include <boost/atomic.hpp> |
41 | | #include <boost/type_traits/make_signed.hpp> |
42 | | #include <glog/logging.h> |
43 | | |
44 | | #include "yb/gutil/atomicops.h" |
45 | | #include "yb/gutil/macros.h" |
46 | | #include "yb/gutil/port.h" |
47 | | |
48 | | #include "yb/util/cast.h" |
49 | | #include "yb/util/random_util.h" |
50 | | |
51 | | namespace yb { |
52 | | |
53 | | // See top-level comments in yb/gutil/atomicops.h for further |
54 | | // explanations of these levels. |
55 | | enum MemoryOrder { |
56 | | // Relaxed memory ordering, doesn't use any barriers. |
57 | | kMemOrderNoBarrier = 0, |
58 | | |
59 | | // Ensures that no later memory access by the same thread can be |
60 | | // reordered ahead of the operation. |
61 | | kMemOrderAcquire = 1, |
62 | | |
63 | | // Ensures that no previous memory access by the same thread can be |
64 | | // reordered after the operation. |
65 | | kMemOrderRelease = 2, |
66 | | |
67 | | // Ensures that neither previous NOR later memory access by the same |
68 | | // thread can be reordered after the operation. |
69 | | kMemOrderBarrier = 3, |
70 | | }; |
71 | | |
72 | | // Atomic integer class inspired by Impala's AtomicInt and |
73 | | // std::atomic<> in C++11. |
74 | | // |
75 | | // NOTE: All of public operations use an implicit memory order of |
76 | | // kMemOrderNoBarrier unless otherwise specified. |
77 | | // |
78 | | // Unlike std::atomic<>, overflowing an unsigned AtomicInt via Increment or |
79 | | // IncrementBy is undefined behavior (it is also undefined for signed types, |
80 | | // as always). |
81 | | // |
82 | | // See also: yb/gutil/atomicops.h |
83 | | template<typename T> |
84 | | class AtomicInt { |
85 | | public: |
86 | | // Initialize the underlying value to 'initial_value'. The |
87 | | // initialization performs a Store with 'kMemOrderNoBarrier'. |
88 | | explicit AtomicInt(T initial_value); |
89 | | |
90 | | // Returns the underlying value. |
91 | | // |
92 | | // Does not support 'kMemOrderBarrier'. |
93 | | T Load(MemoryOrder mem_order = kMemOrderNoBarrier) const; |
94 | | |
95 | | // Sets the underlying value to 'new_value'. |
96 | | // |
97 | | // Does not support 'kMemOrderBarrier'. |
98 | | void Store(T new_value, MemoryOrder mem_order = kMemOrderNoBarrier); |
99 | | |
100 | | // Iff the underlying value is equal to 'expected_val', sets the |
101 | | // underlying value to 'new_value' and returns true; returns false |
102 | | // otherwise. |
103 | | // |
104 | | // Does not support 'kMemOrderBarrier'. |
105 | | bool CompareAndSet(T expected_val, T new_value, MemoryOrder mem_order = kMemOrderNoBarrier); |
106 | | |
107 | | // Iff the underlying value is equal to 'expected_val', sets the |
108 | | // underlying value to 'new_value' and returns |
109 | | // 'expected_val'. Otherwise, returns the current underlying |
110 | | // value. |
111 | | // |
112 | | // Does not support 'kMemOrderBarrier'. |
113 | | T CompareAndSwap(T expected_val, T new_value, MemoryOrder mem_order = kMemOrderNoBarrier); |
114 | | |
115 | | // Sets the underlying value to 'new_value' iff 'new_value' is |
116 | | // greater than the current underlying value. |
117 | | // |
118 | | // Does not support 'kMemOrderBarrier'. |
119 | | void StoreMax(T new_value, MemoryOrder mem_order = kMemOrderNoBarrier); |
120 | | |
121 | | // Sets the underlying value to 'new_value' iff 'new_value' is less |
122 | | // than the current underlying value. |
123 | | // |
124 | | // Does not support 'kMemOrderBarrier'. |
125 | | void StoreMin(T new_value, MemoryOrder mem_order = kMemOrderNoBarrier); |
126 | | |
127 | | // Increments the underlying value by 1 and returns the new |
128 | | // underlying value. |
129 | | // |
130 | | // Does not support 'kMemOrderAcquire' or 'kMemOrderRelease'. |
131 | | T Increment(MemoryOrder mem_order = kMemOrderNoBarrier); |
132 | | |
133 | | // Increments the underlying value by 'delta' and returns the new |
134 | | // underlying value. |
135 | | |
136 | | // Does not support 'kKemOrderAcquire' or 'kMemOrderRelease'. |
137 | | T IncrementBy(T delta, MemoryOrder mem_order = kMemOrderNoBarrier); |
138 | | |
139 | | // Sets the underlying value to 'new_value' and returns the previous |
140 | | // underlying value. |
141 | | // |
142 | | // Does not support 'kMemOrderBarrier'. |
143 | | T Exchange(T new_value, MemoryOrder mem_order = kMemOrderNoBarrier); |
144 | | |
145 | | private: |
146 | | // If a method 'caller' doesn't support memory order described as |
147 | | // 'requested', exit by doing perform LOG(FATAL) logging the method |
148 | | // called, the requested memory order, and the supported memory |
149 | | // orders. |
150 | | static void FatalMemOrderNotSupported(const char* caller, |
151 | | const char* requested = "kMemOrderBarrier", |
152 | | const char* supported = |
153 | | "kMemNorderNoBarrier, kMemOrderAcquire, kMemOrderRelease"); |
154 | | |
155 | | // The gutil/atomicops.h functions only operate on signed types. |
156 | | // So, even if the user specializes on an unsigned type, we use a |
157 | | // signed type internally. |
158 | | typedef typename boost::make_signed<T>::type SignedT; |
159 | | SignedT value_; |
160 | | |
161 | | DISALLOW_COPY_AND_ASSIGN(AtomicInt); |
162 | | }; |
163 | | |
164 | | // Adapts AtomicInt to handle boolean values. |
165 | | // |
166 | | // NOTE: All of public operations use an implicit memory order of |
167 | | // kMemOrderNoBarrier unless otherwise specified. |
168 | | // |
169 | | // See AtomicInt above for documentation on individual methods. |
170 | | class AtomicBool { |
171 | | public: |
172 | | explicit AtomicBool(bool value); |
173 | | |
174 | 33.5M | bool Load(MemoryOrder m = kMemOrderNoBarrier) const { |
175 | 33.5M | return underlying_.Load(m); |
176 | 33.5M | } |
177 | 121k | void Store(bool n, MemoryOrder m = kMemOrderNoBarrier) { |
178 | 121k | underlying_.Store(static_cast<int32_t>(n), m); |
179 | 121k | } |
180 | 75.5k | bool CompareAndSet(bool e, bool n, MemoryOrder m = kMemOrderNoBarrier) { |
181 | 75.5k | return underlying_.CompareAndSet(static_cast<int32_t>(e), static_cast<int32_t>(n), m); |
182 | 75.5k | } |
183 | 3 | bool CompareAndSwap(bool e, bool n, MemoryOrder m = kMemOrderNoBarrier) { |
184 | 3 | return underlying_.CompareAndSwap(static_cast<int32_t>(e), static_cast<int32_t>(n), m); |
185 | 3 | } |
186 | 3 | bool Exchange(bool n, MemoryOrder m = kMemOrderNoBarrier) { |
187 | 3 | return underlying_.Exchange(static_cast<int32_t>(n), m); |
188 | 3 | } |
189 | | private: |
190 | | AtomicInt<int32_t> underlying_; |
191 | | |
192 | | DISALLOW_COPY_AND_ASSIGN(AtomicBool); |
193 | | }; |
194 | | |
195 | | template<typename T> |
196 | 445M | inline T AtomicInt<T>::Load(MemoryOrder mem_order) const { |
197 | 445M | switch (mem_order) { |
198 | 358M | case kMemOrderNoBarrier: { |
199 | 358M | return base::subtle::NoBarrier_Load(&value_); |
200 | 0 | } |
201 | 0 | case kMemOrderBarrier: { |
202 | 0 | FatalMemOrderNotSupported("Load"); |
203 | 0 | break; |
204 | 0 | } |
205 | 95.7k | case kMemOrderAcquire: { |
206 | 95.7k | return base::subtle::Acquire_Load(&value_); |
207 | 0 | } |
208 | 86.5M | case kMemOrderRelease: { |
209 | 86.5M | return base::subtle::Release_Load(&value_); |
210 | 0 | } |
211 | 0 | } |
212 | 0 | abort(); // Unnecessary, but avoids gcc complaining. |
213 | 0 | } _ZNK2yb9AtomicIntIxE4LoadENS_11MemoryOrderE Line | Count | Source | 196 | 410M | inline T AtomicInt<T>::Load(MemoryOrder mem_order) const { | 197 | 410M | switch (mem_order) { | 198 | 323M | case kMemOrderNoBarrier: { | 199 | 323M | return base::subtle::NoBarrier_Load(&value_); | 200 | 0 | } | 201 | 0 | case kMemOrderBarrier: { | 202 | 0 | FatalMemOrderNotSupported("Load"); | 203 | 0 | break; | 204 | 0 | } | 205 | 18 | case kMemOrderAcquire: { | 206 | 18 | return base::subtle::Acquire_Load(&value_); | 207 | 0 | } | 208 | 86.5M | case kMemOrderRelease: { | 209 | 86.5M | return base::subtle::Release_Load(&value_); | 210 | 0 | } | 211 | 0 | } | 212 | 0 | abort(); // Unnecessary, but avoids gcc complaining. | 213 | 0 | } |
_ZNK2yb9AtomicIntIiE4LoadENS_11MemoryOrderE Line | Count | Source | 196 | 33.5M | inline T AtomicInt<T>::Load(MemoryOrder mem_order) const { | 197 | 33.5M | switch (mem_order) { | 198 | 33.4M | case kMemOrderNoBarrier: { | 199 | 33.4M | return base::subtle::NoBarrier_Load(&value_); | 200 | 0 | } | 201 | 0 | case kMemOrderBarrier: { | 202 | 0 | FatalMemOrderNotSupported("Load"); | 203 | 0 | break; | 204 | 0 | } | 205 | 95.6k | case kMemOrderAcquire: { | 206 | 95.6k | return base::subtle::Acquire_Load(&value_); | 207 | 0 | } | 208 | 23 | case kMemOrderRelease: { | 209 | 23 | return base::subtle::Release_Load(&value_); | 210 | 0 | } | 211 | 0 | } | 212 | 0 | abort(); // Unnecessary, but avoids gcc complaining. | 213 | 0 | } |
_ZNK2yb9AtomicIntIjE4LoadENS_11MemoryOrderE Line | Count | Source | 196 | 54 | inline T AtomicInt<T>::Load(MemoryOrder mem_order) const { | 197 | 54 | switch (mem_order) { | 198 | 18 | case kMemOrderNoBarrier: { | 199 | 18 | return base::subtle::NoBarrier_Load(&value_); | 200 | 0 | } | 201 | 0 | case kMemOrderBarrier: { | 202 | 0 | FatalMemOrderNotSupported("Load"); | 203 | 0 | break; | 204 | 0 | } | 205 | 18 | case kMemOrderAcquire: { | 206 | 18 | return base::subtle::Acquire_Load(&value_); | 207 | 0 | } | 208 | 18 | case kMemOrderRelease: { | 209 | 18 | return base::subtle::Release_Load(&value_); | 210 | 0 | } | 211 | 0 | } | 212 | 0 | abort(); // Unnecessary, but avoids gcc complaining. | 213 | 0 | } |
_ZNK2yb9AtomicIntIyE4LoadENS_11MemoryOrderE Line | Count | Source | 196 | 1.24M | inline T AtomicInt<T>::Load(MemoryOrder mem_order) const { | 197 | 1.24M | switch (mem_order) { | 198 | 1.24M | case kMemOrderNoBarrier: { | 199 | 1.24M | return base::subtle::NoBarrier_Load(&value_); | 200 | 0 | } | 201 | 0 | case kMemOrderBarrier: { | 202 | 0 | FatalMemOrderNotSupported("Load"); | 203 | 0 | break; | 204 | 0 | } | 205 | 18 | case kMemOrderAcquire: { | 206 | 18 | return base::subtle::Acquire_Load(&value_); | 207 | 0 | } | 208 | 18 | case kMemOrderRelease: { | 209 | 18 | return base::subtle::Release_Load(&value_); | 210 | 0 | } | 211 | 0 | } | 212 | 0 | abort(); // Unnecessary, but avoids gcc complaining. | 213 | 0 | } |
|
214 | | |
215 | | template<typename T> |
216 | 112M | inline void AtomicInt<T>::Store(T new_value, MemoryOrder mem_order) { |
217 | 112M | switch (mem_order) { |
218 | 112M | case kMemOrderNoBarrier: { |
219 | 112M | base::subtle::NoBarrier_Store(&value_, new_value); |
220 | 112M | break; |
221 | 0 | } |
222 | 0 | case kMemOrderBarrier: { |
223 | 0 | FatalMemOrderNotSupported("Store"); |
224 | 0 | break; |
225 | 0 | } |
226 | 13 | case kMemOrderAcquire: { |
227 | 13 | base::subtle::Acquire_Store(&value_, new_value); |
228 | 13 | break; |
229 | 0 | } |
230 | 47.8k | case kMemOrderRelease: { |
231 | 47.8k | base::subtle::Release_Store(&value_, new_value); |
232 | 47.8k | break; |
233 | 0 | } |
234 | 112M | } |
235 | 112M | } _ZN2yb9AtomicIntIiE5StoreEiNS_11MemoryOrderE Line | Count | Source | 216 | 7.95M | inline void AtomicInt<T>::Store(T new_value, MemoryOrder mem_order) { | 217 | 7.95M | switch (mem_order) { | 218 | 7.90M | case kMemOrderNoBarrier: { | 219 | 7.90M | base::subtle::NoBarrier_Store(&value_, new_value); | 220 | 7.90M | break; | 221 | 0 | } | 222 | 0 | case kMemOrderBarrier: { | 223 | 0 | FatalMemOrderNotSupported("Store"); | 224 | 0 | break; | 225 | 0 | } | 226 | 4 | case kMemOrderAcquire: { | 227 | 4 | base::subtle::Acquire_Store(&value_, new_value); | 228 | 4 | break; | 229 | 0 | } | 230 | 47.8k | case kMemOrderRelease: { | 231 | 47.8k | base::subtle::Release_Store(&value_, new_value); | 232 | 47.8k | break; | 233 | 0 | } | 234 | 7.95M | } | 235 | 7.95M | } |
_ZN2yb9AtomicIntIxE5StoreExNS_11MemoryOrderE Line | Count | Source | 216 | 104M | inline void AtomicInt<T>::Store(T new_value, MemoryOrder mem_order) { | 217 | 104M | switch (mem_order) { | 218 | 104M | case kMemOrderNoBarrier: { | 219 | 104M | base::subtle::NoBarrier_Store(&value_, new_value); | 220 | 104M | break; | 221 | 0 | } | 222 | 0 | case kMemOrderBarrier: { | 223 | 0 | FatalMemOrderNotSupported("Store"); | 224 | 0 | break; | 225 | 0 | } | 226 | 3 | case kMemOrderAcquire: { | 227 | 3 | base::subtle::Acquire_Store(&value_, new_value); | 228 | 3 | break; | 229 | 0 | } | 230 | 3 | case kMemOrderRelease: { | 231 | 3 | base::subtle::Release_Store(&value_, new_value); | 232 | 3 | break; | 233 | 0 | } | 234 | 104M | } | 235 | 104M | } |
_ZN2yb9AtomicIntIjE5StoreEjNS_11MemoryOrderE Line | Count | Source | 216 | 20 | inline void AtomicInt<T>::Store(T new_value, MemoryOrder mem_order) { | 217 | 20 | switch (mem_order) { | 218 | 14 | case kMemOrderNoBarrier: { | 219 | 14 | base::subtle::NoBarrier_Store(&value_, new_value); | 220 | 14 | break; | 221 | 0 | } | 222 | 0 | case kMemOrderBarrier: { | 223 | 0 | FatalMemOrderNotSupported("Store"); | 224 | 0 | break; | 225 | 0 | } | 226 | 3 | case kMemOrderAcquire: { | 227 | 3 | base::subtle::Acquire_Store(&value_, new_value); | 228 | 3 | break; | 229 | 0 | } | 230 | 3 | case kMemOrderRelease: { | 231 | 3 | base::subtle::Release_Store(&value_, new_value); | 232 | 3 | break; | 233 | 0 | } | 234 | 20 | } | 235 | 20 | } |
_ZN2yb9AtomicIntIyE5StoreEyNS_11MemoryOrderE Line | Count | Source | 216 | 32.0k | inline void AtomicInt<T>::Store(T new_value, MemoryOrder mem_order) { | 217 | 32.0k | switch (mem_order) { | 218 | 32.0k | case kMemOrderNoBarrier: { | 219 | 32.0k | base::subtle::NoBarrier_Store(&value_, new_value); | 220 | 32.0k | break; | 221 | 0 | } | 222 | 0 | case kMemOrderBarrier: { | 223 | 0 | FatalMemOrderNotSupported("Store"); | 224 | 0 | break; | 225 | 0 | } | 226 | 3 | case kMemOrderAcquire: { | 227 | 3 | base::subtle::Acquire_Store(&value_, new_value); | 228 | 3 | break; | 229 | 0 | } | 230 | 3 | case kMemOrderRelease: { | 231 | 3 | base::subtle::Release_Store(&value_, new_value); | 232 | 3 | break; | 233 | 0 | } | 234 | 32.0k | } | 235 | 32.0k | } |
|
236 | | |
237 | | template<typename T> |
238 | 289M | inline bool AtomicInt<T>::CompareAndSet(T expected_val, T new_val, MemoryOrder mem_order) { |
239 | 289M | return CompareAndSwap(expected_val, new_val, mem_order) == expected_val; |
240 | 289M | } _ZN2yb9AtomicIntIiE13CompareAndSetEiiNS_11MemoryOrderE Line | Count | Source | 238 | 75.7k | inline bool AtomicInt<T>::CompareAndSet(T expected_val, T new_val, MemoryOrder mem_order) { | 239 | 75.7k | return CompareAndSwap(expected_val, new_val, mem_order) == expected_val; | 240 | 75.7k | } |
_ZN2yb9AtomicIntIxE13CompareAndSetExxNS_11MemoryOrderE Line | Count | Source | 238 | 289M | inline bool AtomicInt<T>::CompareAndSet(T expected_val, T new_val, MemoryOrder mem_order) { | 239 | 289M | return CompareAndSwap(expected_val, new_val, mem_order) == expected_val; | 240 | 289M | } |
_ZN2yb9AtomicIntIjE13CompareAndSetEjjNS_11MemoryOrderE Line | Count | Source | 238 | 6 | inline bool AtomicInt<T>::CompareAndSet(T expected_val, T new_val, MemoryOrder mem_order) { | 239 | 6 | return CompareAndSwap(expected_val, new_val, mem_order) == expected_val; | 240 | 6 | } |
_ZN2yb9AtomicIntIyE13CompareAndSetEyyNS_11MemoryOrderE Line | Count | Source | 238 | 6 | inline bool AtomicInt<T>::CompareAndSet(T expected_val, T new_val, MemoryOrder mem_order) { | 239 | 6 | return CompareAndSwap(expected_val, new_val, mem_order) == expected_val; | 240 | 6 | } |
|
241 | | |
242 | | template<typename T> |
243 | 304M | inline T AtomicInt<T>::CompareAndSwap(T expected_val, T new_val, MemoryOrder mem_order) { |
244 | 304M | switch (mem_order) { |
245 | 304M | case kMemOrderNoBarrier: { |
246 | 304M | return base::subtle::NoBarrier_CompareAndSwap( |
247 | 304M | &value_, expected_val, new_val); |
248 | 0 | } |
249 | 0 | case kMemOrderBarrier: { |
250 | 0 | FatalMemOrderNotSupported("CompareAndSwap/CompareAndSet"); |
251 | 0 | break; |
252 | 0 | } |
253 | 47 | case kMemOrderAcquire: { |
254 | 47 | return base::subtle::Acquire_CompareAndSwap( |
255 | 47 | &value_, expected_val, new_val); |
256 | 0 | } |
257 | 47 | case kMemOrderRelease: { |
258 | 47 | return base::subtle::Release_CompareAndSwap( |
259 | 47 | &value_, expected_val, new_val); |
260 | 0 | } |
261 | 0 | } |
262 | 0 | abort(); |
263 | 0 | } _ZN2yb9AtomicIntIiE14CompareAndSwapEiiNS_11MemoryOrderE Line | Count | Source | 243 | 75.4k | inline T AtomicInt<T>::CompareAndSwap(T expected_val, T new_val, MemoryOrder mem_order) { | 244 | 75.4k | switch (mem_order) { | 245 | 75.2k | case kMemOrderNoBarrier: { | 246 | 75.2k | return base::subtle::NoBarrier_CompareAndSwap( | 247 | 75.2k | &value_, expected_val, new_val); | 248 | 0 | } | 249 | 0 | case kMemOrderBarrier: { | 250 | 0 | FatalMemOrderNotSupported("CompareAndSwap/CompareAndSet"); | 251 | 0 | break; | 252 | 0 | } | 253 | 14 | case kMemOrderAcquire: { | 254 | 14 | return base::subtle::Acquire_CompareAndSwap( | 255 | 14 | &value_, expected_val, new_val); | 256 | 0 | } | 257 | 14 | case kMemOrderRelease: { | 258 | 14 | return base::subtle::Release_CompareAndSwap( | 259 | 14 | &value_, expected_val, new_val); | 260 | 0 | } | 261 | 0 | } | 262 | 0 | abort(); | 263 | 0 | } |
_ZN2yb9AtomicIntIxE14CompareAndSwapExxNS_11MemoryOrderE Line | Count | Source | 243 | 303M | inline T AtomicInt<T>::CompareAndSwap(T expected_val, T new_val, MemoryOrder mem_order) { | 244 | 303M | switch (mem_order) { | 245 | 303M | case kMemOrderNoBarrier: { | 246 | 303M | return base::subtle::NoBarrier_CompareAndSwap( | 247 | 303M | &value_, expected_val, new_val); | 248 | 0 | } | 249 | 0 | case kMemOrderBarrier: { | 250 | 0 | FatalMemOrderNotSupported("CompareAndSwap/CompareAndSet"); | 251 | 0 | break; | 252 | 0 | } | 253 | 11 | case kMemOrderAcquire: { | 254 | 11 | return base::subtle::Acquire_CompareAndSwap( | 255 | 11 | &value_, expected_val, new_val); | 256 | 0 | } | 257 | 11 | case kMemOrderRelease: { | 258 | 11 | return base::subtle::Release_CompareAndSwap( | 259 | 11 | &value_, expected_val, new_val); | 260 | 0 | } | 261 | 0 | } | 262 | 0 | abort(); | 263 | 0 | } |
_ZN2yb9AtomicIntIjE14CompareAndSwapEjjNS_11MemoryOrderE Line | Count | Source | 243 | 33 | inline T AtomicInt<T>::CompareAndSwap(T expected_val, T new_val, MemoryOrder mem_order) { | 244 | 33 | switch (mem_order) { | 245 | 11 | case kMemOrderNoBarrier: { | 246 | 11 | return base::subtle::NoBarrier_CompareAndSwap( | 247 | 11 | &value_, expected_val, new_val); | 248 | 0 | } | 249 | 0 | case kMemOrderBarrier: { | 250 | 0 | FatalMemOrderNotSupported("CompareAndSwap/CompareAndSet"); | 251 | 0 | break; | 252 | 0 | } | 253 | 11 | case kMemOrderAcquire: { | 254 | 11 | return base::subtle::Acquire_CompareAndSwap( | 255 | 11 | &value_, expected_val, new_val); | 256 | 0 | } | 257 | 11 | case kMemOrderRelease: { | 258 | 11 | return base::subtle::Release_CompareAndSwap( | 259 | 11 | &value_, expected_val, new_val); | 260 | 0 | } | 261 | 0 | } | 262 | 0 | abort(); | 263 | 0 | } |
_ZN2yb9AtomicIntIyE14CompareAndSwapEyyNS_11MemoryOrderE Line | Count | Source | 243 | 1.24M | inline T AtomicInt<T>::CompareAndSwap(T expected_val, T new_val, MemoryOrder mem_order) { | 244 | 1.24M | switch (mem_order) { | 245 | 1.24M | case kMemOrderNoBarrier: { | 246 | 1.24M | return base::subtle::NoBarrier_CompareAndSwap( | 247 | 1.24M | &value_, expected_val, new_val); | 248 | 0 | } | 249 | 0 | case kMemOrderBarrier: { | 250 | 0 | FatalMemOrderNotSupported("CompareAndSwap/CompareAndSet"); | 251 | 0 | break; | 252 | 0 | } | 253 | 11 | case kMemOrderAcquire: { | 254 | 11 | return base::subtle::Acquire_CompareAndSwap( | 255 | 11 | &value_, expected_val, new_val); | 256 | 0 | } | 257 | 11 | case kMemOrderRelease: { | 258 | 11 | return base::subtle::Release_CompareAndSwap( | 259 | 11 | &value_, expected_val, new_val); | 260 | 0 | } | 261 | 0 | } | 262 | 0 | abort(); | 263 | 0 | } |
|
264 | | |
265 | | |
266 | | template<typename T> |
267 | 4.29M | inline T AtomicInt<T>::Increment(MemoryOrder mem_order) { |
268 | 4.29M | return IncrementBy(1, mem_order); |
269 | 4.29M | } _ZN2yb9AtomicIntIiE9IncrementENS_11MemoryOrderE Line | Count | Source | 267 | 11.5k | inline T AtomicInt<T>::Increment(MemoryOrder mem_order) { | 268 | 11.5k | return IncrementBy(1, mem_order); | 269 | 11.5k | } |
_ZN2yb9AtomicIntIxE9IncrementENS_11MemoryOrderE Line | Count | Source | 267 | 4.16M | inline T AtomicInt<T>::Increment(MemoryOrder mem_order) { | 268 | 4.16M | return IncrementBy(1, mem_order); | 269 | 4.16M | } |
_ZN2yb9AtomicIntIjE9IncrementENS_11MemoryOrderE Line | Count | Source | 267 | 2 | inline T AtomicInt<T>::Increment(MemoryOrder mem_order) { | 268 | 2 | return IncrementBy(1, mem_order); | 269 | 2 | } |
_ZN2yb9AtomicIntIyE9IncrementENS_11MemoryOrderE Line | Count | Source | 267 | 116k | inline T AtomicInt<T>::Increment(MemoryOrder mem_order) { | 268 | 116k | return IncrementBy(1, mem_order); | 269 | 116k | } |
|
270 | | |
271 | | template<typename T> |
272 | 2.04G | inline T AtomicInt<T>::IncrementBy(T delta, MemoryOrder mem_order) { |
273 | 2.04G | switch (mem_order) { |
274 | 2.04G | case kMemOrderNoBarrier: { |
275 | 2.04G | return base::subtle::NoBarrier_AtomicIncrement(&value_, delta); |
276 | 0 | } |
277 | 12 | case kMemOrderBarrier: { |
278 | 12 | return base::subtle::Barrier_AtomicIncrement(&value_, delta); |
279 | 0 | } |
280 | 0 | case kMemOrderAcquire: { |
281 | 0 | FatalMemOrderNotSupported("Increment/IncrementBy", |
282 | 0 | "kMemOrderAcquire", |
283 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); |
284 | 0 | break; |
285 | 0 | } |
286 | 0 | case kMemOrderRelease: { |
287 | 0 | FatalMemOrderNotSupported("Increment/Incrementby", |
288 | 0 | "kMemOrderAcquire", |
289 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); |
290 | 0 | break; |
291 | 0 | } |
292 | 0 | } |
293 | 0 | abort(); |
294 | 0 | } _ZN2yb9AtomicIntIxE11IncrementByExNS_11MemoryOrderE Line | Count | Source | 272 | 2.04G | inline T AtomicInt<T>::IncrementBy(T delta, MemoryOrder mem_order) { | 273 | 2.04G | switch (mem_order) { | 274 | 2.04G | case kMemOrderNoBarrier: { | 275 | 2.04G | return base::subtle::NoBarrier_AtomicIncrement(&value_, delta); | 276 | 0 | } | 277 | 3 | case kMemOrderBarrier: { | 278 | 3 | return base::subtle::Barrier_AtomicIncrement(&value_, delta); | 279 | 0 | } | 280 | 0 | case kMemOrderAcquire: { | 281 | 0 | FatalMemOrderNotSupported("Increment/IncrementBy", | 282 | 0 | "kMemOrderAcquire", | 283 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 284 | 0 | break; | 285 | 0 | } | 286 | 0 | case kMemOrderRelease: { | 287 | 0 | FatalMemOrderNotSupported("Increment/Incrementby", | 288 | 0 | "kMemOrderAcquire", | 289 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 290 | 0 | break; | 291 | 0 | } | 292 | 0 | } | 293 | 0 | abort(); | 294 | 0 | } |
_ZN2yb9AtomicIntIiE11IncrementByEiNS_11MemoryOrderE Line | Count | Source | 272 | 11.5k | inline T AtomicInt<T>::IncrementBy(T delta, MemoryOrder mem_order) { | 273 | 11.5k | switch (mem_order) { | 274 | 11.5k | case kMemOrderNoBarrier: { | 275 | 11.5k | return base::subtle::NoBarrier_AtomicIncrement(&value_, delta); | 276 | 0 | } | 277 | 3 | case kMemOrderBarrier: { | 278 | 3 | return base::subtle::Barrier_AtomicIncrement(&value_, delta); | 279 | 0 | } | 280 | 0 | case kMemOrderAcquire: { | 281 | 0 | FatalMemOrderNotSupported("Increment/IncrementBy", | 282 | 0 | "kMemOrderAcquire", | 283 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 284 | 0 | break; | 285 | 0 | } | 286 | 0 | case kMemOrderRelease: { | 287 | 0 | FatalMemOrderNotSupported("Increment/Incrementby", | 288 | 0 | "kMemOrderAcquire", | 289 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 290 | 0 | break; | 291 | 0 | } | 292 | 0 | } | 293 | 0 | abort(); | 294 | 0 | } |
_ZN2yb9AtomicIntIjE11IncrementByEjNS_11MemoryOrderE Line | Count | Source | 272 | 6 | inline T AtomicInt<T>::IncrementBy(T delta, MemoryOrder mem_order) { | 273 | 6 | switch (mem_order) { | 274 | 3 | case kMemOrderNoBarrier: { | 275 | 3 | return base::subtle::NoBarrier_AtomicIncrement(&value_, delta); | 276 | 0 | } | 277 | 3 | case kMemOrderBarrier: { | 278 | 3 | return base::subtle::Barrier_AtomicIncrement(&value_, delta); | 279 | 0 | } | 280 | 0 | case kMemOrderAcquire: { | 281 | 0 | FatalMemOrderNotSupported("Increment/IncrementBy", | 282 | 0 | "kMemOrderAcquire", | 283 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 284 | 0 | break; | 285 | 0 | } | 286 | 0 | case kMemOrderRelease: { | 287 | 0 | FatalMemOrderNotSupported("Increment/Incrementby", | 288 | 0 | "kMemOrderAcquire", | 289 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 290 | 0 | break; | 291 | 0 | } | 292 | 0 | } | 293 | 0 | abort(); | 294 | 0 | } |
_ZN2yb9AtomicIntIyE11IncrementByEyNS_11MemoryOrderE Line | Count | Source | 272 | 116k | inline T AtomicInt<T>::IncrementBy(T delta, MemoryOrder mem_order) { | 273 | 116k | switch (mem_order) { | 274 | 116k | case kMemOrderNoBarrier: { | 275 | 116k | return base::subtle::NoBarrier_AtomicIncrement(&value_, delta); | 276 | 0 | } | 277 | 3 | case kMemOrderBarrier: { | 278 | 3 | return base::subtle::Barrier_AtomicIncrement(&value_, delta); | 279 | 0 | } | 280 | 0 | case kMemOrderAcquire: { | 281 | 0 | FatalMemOrderNotSupported("Increment/IncrementBy", | 282 | 0 | "kMemOrderAcquire", | 283 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 284 | 0 | break; | 285 | 0 | } | 286 | 0 | case kMemOrderRelease: { | 287 | 0 | FatalMemOrderNotSupported("Increment/Incrementby", | 288 | 0 | "kMemOrderAcquire", | 289 | 0 | "kMemOrderNoBarrier and kMemOrderBarrier"); | 290 | 0 | break; | 291 | 0 | } | 292 | 0 | } | 293 | 0 | abort(); | 294 | 0 | } |
|
295 | | |
296 | | template<typename T> |
297 | 17 | inline T AtomicInt<T>::Exchange(T new_value, MemoryOrder mem_order) { |
298 | 17 | switch (mem_order) { |
299 | 7 | case kMemOrderNoBarrier: { |
300 | 7 | return base::subtle::NoBarrier_AtomicExchange(&value_, new_value); |
301 | 0 | } |
302 | 0 | case kMemOrderBarrier: { |
303 | 0 | FatalMemOrderNotSupported("Exchange"); |
304 | 0 | break; |
305 | 0 | } |
306 | 5 | case kMemOrderAcquire: { |
307 | 5 | return base::subtle::Acquire_AtomicExchange(&value_, new_value); |
308 | 0 | } |
309 | 5 | case kMemOrderRelease: { |
310 | 5 | return base::subtle::Release_AtomicExchange(&value_, new_value); |
311 | 0 | } |
312 | 0 | } |
313 | 0 | abort(); |
314 | 0 | } _ZN2yb9AtomicIntIiE8ExchangeEiNS_11MemoryOrderE Line | Count | Source | 297 | 6 | inline T AtomicInt<T>::Exchange(T new_value, MemoryOrder mem_order) { | 298 | 6 | switch (mem_order) { | 299 | 2 | case kMemOrderNoBarrier: { | 300 | 2 | return base::subtle::NoBarrier_AtomicExchange(&value_, new_value); | 301 | 0 | } | 302 | 0 | case kMemOrderBarrier: { | 303 | 0 | FatalMemOrderNotSupported("Exchange"); | 304 | 0 | break; | 305 | 0 | } | 306 | 2 | case kMemOrderAcquire: { | 307 | 2 | return base::subtle::Acquire_AtomicExchange(&value_, new_value); | 308 | 0 | } | 309 | 2 | case kMemOrderRelease: { | 310 | 2 | return base::subtle::Release_AtomicExchange(&value_, new_value); | 311 | 0 | } | 312 | 0 | } | 313 | 0 | abort(); | 314 | 0 | } |
_ZN2yb9AtomicIntIxE8ExchangeExNS_11MemoryOrderE Line | Count | Source | 297 | 5 | inline T AtomicInt<T>::Exchange(T new_value, MemoryOrder mem_order) { | 298 | 5 | switch (mem_order) { | 299 | 3 | case kMemOrderNoBarrier: { | 300 | 3 | return base::subtle::NoBarrier_AtomicExchange(&value_, new_value); | 301 | 0 | } | 302 | 0 | case kMemOrderBarrier: { | 303 | 0 | FatalMemOrderNotSupported("Exchange"); | 304 | 0 | break; | 305 | 0 | } | 306 | 1 | case kMemOrderAcquire: { | 307 | 1 | return base::subtle::Acquire_AtomicExchange(&value_, new_value); | 308 | 0 | } | 309 | 1 | case kMemOrderRelease: { | 310 | 1 | return base::subtle::Release_AtomicExchange(&value_, new_value); | 311 | 0 | } | 312 | 0 | } | 313 | 0 | abort(); | 314 | 0 | } |
_ZN2yb9AtomicIntIjE8ExchangeEjNS_11MemoryOrderE Line | Count | Source | 297 | 3 | inline T AtomicInt<T>::Exchange(T new_value, MemoryOrder mem_order) { | 298 | 3 | switch (mem_order) { | 299 | 1 | case kMemOrderNoBarrier: { | 300 | 1 | return base::subtle::NoBarrier_AtomicExchange(&value_, new_value); | 301 | 0 | } | 302 | 0 | case kMemOrderBarrier: { | 303 | 0 | FatalMemOrderNotSupported("Exchange"); | 304 | 0 | break; | 305 | 0 | } | 306 | 1 | case kMemOrderAcquire: { | 307 | 1 | return base::subtle::Acquire_AtomicExchange(&value_, new_value); | 308 | 0 | } | 309 | 1 | case kMemOrderRelease: { | 310 | 1 | return base::subtle::Release_AtomicExchange(&value_, new_value); | 311 | 0 | } | 312 | 0 | } | 313 | 0 | abort(); | 314 | 0 | } |
_ZN2yb9AtomicIntIyE8ExchangeEyNS_11MemoryOrderE Line | Count | Source | 297 | 3 | inline T AtomicInt<T>::Exchange(T new_value, MemoryOrder mem_order) { | 298 | 3 | switch (mem_order) { | 299 | 1 | case kMemOrderNoBarrier: { | 300 | 1 | return base::subtle::NoBarrier_AtomicExchange(&value_, new_value); | 301 | 0 | } | 302 | 0 | case kMemOrderBarrier: { | 303 | 0 | FatalMemOrderNotSupported("Exchange"); | 304 | 0 | break; | 305 | 0 | } | 306 | 1 | case kMemOrderAcquire: { | 307 | 1 | return base::subtle::Acquire_AtomicExchange(&value_, new_value); | 308 | 0 | } | 309 | 1 | case kMemOrderRelease: { | 310 | 1 | return base::subtle::Release_AtomicExchange(&value_, new_value); | 311 | 0 | } | 312 | 0 | } | 313 | 0 | abort(); | 314 | 0 | } |
|
315 | | |
316 | | template<typename T> |
317 | 15.2M | inline void AtomicInt<T>::StoreMax(T new_value, MemoryOrder mem_order) { |
318 | 15.2M | T old_value = Load(mem_order); |
319 | 15.2M | while (true) { |
320 | 15.2M | T max_value = std::max(old_value, new_value); |
321 | 15.2M | T prev_value = CompareAndSwap(old_value, max_value, mem_order); |
322 | 15.2M | if (PREDICT_TRUE(old_value == prev_value)) { |
323 | 15.2M | break; |
324 | 15.2M | } |
325 | 8.27k | old_value = prev_value; |
326 | 8.27k | } |
327 | 15.2M | } _ZN2yb9AtomicIntIiE8StoreMaxEiNS_11MemoryOrderE Line | Count | Source | 317 | 9 | inline void AtomicInt<T>::StoreMax(T new_value, MemoryOrder mem_order) { | 318 | 9 | T old_value = Load(mem_order); | 319 | 9 | while (true) { | 320 | 9 | T max_value = std::max(old_value, new_value); | 321 | 9 | T prev_value = CompareAndSwap(old_value, max_value, mem_order); | 322 | 9 | if (PREDICT_TRUE(old_value == prev_value)) { | 323 | 9 | break; | 324 | 9 | } | 325 | 0 | old_value = prev_value; | 326 | 0 | } | 327 | 9 | } |
_ZN2yb9AtomicIntIxE8StoreMaxExNS_11MemoryOrderE Line | Count | Source | 317 | 13.9M | inline void AtomicInt<T>::StoreMax(T new_value, MemoryOrder mem_order) { | 318 | 13.9M | T old_value = Load(mem_order); | 319 | 13.9M | while (true) { | 320 | 13.9M | T max_value = std::max(old_value, new_value); | 321 | 13.9M | T prev_value = CompareAndSwap(old_value, max_value, mem_order); | 322 | 13.9M | if (PREDICT_TRUE(old_value == prev_value)) { | 323 | 13.9M | break; | 324 | 13.9M | } | 325 | 6.97k | old_value = prev_value; | 326 | 6.97k | } | 327 | 13.9M | } |
_ZN2yb9AtomicIntIjE8StoreMaxEjNS_11MemoryOrderE Line | Count | Source | 317 | 9 | inline void AtomicInt<T>::StoreMax(T new_value, MemoryOrder mem_order) { | 318 | 9 | T old_value = Load(mem_order); | 319 | 9 | while (true) { | 320 | 9 | T max_value = std::max(old_value, new_value); | 321 | 9 | T prev_value = CompareAndSwap(old_value, max_value, mem_order); | 322 | 9 | if (PREDICT_TRUE(old_value == prev_value)) { | 323 | 9 | break; | 324 | 9 | } | 325 | 0 | old_value = prev_value; | 326 | 0 | } | 327 | 9 | } |
_ZN2yb9AtomicIntIyE8StoreMaxEyNS_11MemoryOrderE Line | Count | Source | 317 | 1.24M | inline void AtomicInt<T>::StoreMax(T new_value, MemoryOrder mem_order) { | 318 | 1.24M | T old_value = Load(mem_order); | 319 | 1.24M | while (true) { | 320 | 1.24M | T max_value = std::max(old_value, new_value); | 321 | 1.24M | T prev_value = CompareAndSwap(old_value, max_value, mem_order); | 322 | 1.24M | if (PREDICT_TRUE(old_value == prev_value)) { | 323 | 1.24M | break; | 324 | 1.24M | } | 325 | 1.29k | old_value = prev_value; | 326 | 1.29k | } | 327 | 1.24M | } |
|
328 | | |
329 | | template<typename T> |
330 | 36 | inline void AtomicInt<T>::StoreMin(T new_value, MemoryOrder mem_order) { |
331 | 36 | T old_value = Load(mem_order); |
332 | 36 | while (true) { |
333 | 36 | T min_value = std::min(old_value, new_value); |
334 | 36 | T prev_value = CompareAndSwap(old_value, min_value, mem_order); |
335 | 36 | if (PREDICT_TRUE(old_value == prev_value)) { |
336 | 36 | break; |
337 | 36 | } |
338 | 0 | old_value = prev_value; |
339 | 0 | } |
340 | 36 | } _ZN2yb9AtomicIntIiE8StoreMinEiNS_11MemoryOrderE Line | Count | Source | 330 | 9 | inline void AtomicInt<T>::StoreMin(T new_value, MemoryOrder mem_order) { | 331 | 9 | T old_value = Load(mem_order); | 332 | 9 | while (true) { | 333 | 9 | T min_value = std::min(old_value, new_value); | 334 | 9 | T prev_value = CompareAndSwap(old_value, min_value, mem_order); | 335 | 9 | if (PREDICT_TRUE(old_value == prev_value)) { | 336 | 9 | break; | 337 | 9 | } | 338 | 0 | old_value = prev_value; | 339 | 0 | } | 340 | 9 | } |
_ZN2yb9AtomicIntIxE8StoreMinExNS_11MemoryOrderE Line | Count | Source | 330 | 9 | inline void AtomicInt<T>::StoreMin(T new_value, MemoryOrder mem_order) { | 331 | 9 | T old_value = Load(mem_order); | 332 | 9 | while (true) { | 333 | 9 | T min_value = std::min(old_value, new_value); | 334 | 9 | T prev_value = CompareAndSwap(old_value, min_value, mem_order); | 335 | 9 | if (PREDICT_TRUE(old_value == prev_value)) { | 336 | 9 | break; | 337 | 9 | } | 338 | 0 | old_value = prev_value; | 339 | 0 | } | 340 | 9 | } |
_ZN2yb9AtomicIntIjE8StoreMinEjNS_11MemoryOrderE Line | Count | Source | 330 | 9 | inline void AtomicInt<T>::StoreMin(T new_value, MemoryOrder mem_order) { | 331 | 9 | T old_value = Load(mem_order); | 332 | 9 | while (true) { | 333 | 9 | T min_value = std::min(old_value, new_value); | 334 | 9 | T prev_value = CompareAndSwap(old_value, min_value, mem_order); | 335 | 9 | if (PREDICT_TRUE(old_value == prev_value)) { | 336 | 9 | break; | 337 | 9 | } | 338 | 0 | old_value = prev_value; | 339 | 0 | } | 340 | 9 | } |
_ZN2yb9AtomicIntIyE8StoreMinEyNS_11MemoryOrderE Line | Count | Source | 330 | 9 | inline void AtomicInt<T>::StoreMin(T new_value, MemoryOrder mem_order) { | 331 | 9 | T old_value = Load(mem_order); | 332 | 9 | while (true) { | 333 | 9 | T min_value = std::min(old_value, new_value); | 334 | 9 | T prev_value = CompareAndSwap(old_value, min_value, mem_order); | 335 | 9 | if (PREDICT_TRUE(old_value == prev_value)) { | 336 | 9 | break; | 337 | 9 | } | 338 | 0 | old_value = prev_value; | 339 | 0 | } | 340 | 9 | } |
|
341 | | |
342 | | template<typename T> |
343 | | class AtomicUniquePtr { |
344 | | public: |
345 | 2.18M | AtomicUniquePtr() {} _ZN2yb15AtomicUniquePtrINS_20ServerRegistrationPBEEC2Ev Line | Count | Source | 345 | 5.45k | AtomicUniquePtr() {} |
_ZN2yb15AtomicUniquePtrIN7rocksdb11IndexReaderEEC2Ev Line | Count | Source | 345 | 72.6k | AtomicUniquePtr() {} |
_ZN2yb15AtomicUniquePtrINS_6StatusEEC2Ev Line | Count | Source | 345 | 88.7k | AtomicUniquePtr() {} |
_ZN2yb15AtomicUniquePtrINS_3rpc6StrandEEC2Ev Line | Count | Source | 345 | 88.5k | AtomicUniquePtr() {} |
_ZN2yb15AtomicUniquePtrINSt3__18functionIFiRKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEESA_EEEEC2Ev Line | Count | Source | 345 | 6.10k | AtomicUniquePtr() {} |
_ZN2yb15AtomicUniquePtrINS_6client8YBClientEEC2Ev Line | Count | Source | 345 | 24.1k | AtomicUniquePtr() {} |
_ZN2yb15AtomicUniquePtrIN2ev5timerEEC2Ev Line | Count | Source | 345 | 1.88M | AtomicUniquePtr() {} |
_ZN2yb15AtomicUniquePtrINS_3rpc10ThreadPoolEEC2Ev Line | Count | Source | 345 | 21.3k | AtomicUniquePtr() {} |
|
346 | | AtomicUniquePtr(const AtomicUniquePtr<T>&) = delete; |
347 | | void operator=(const AtomicUniquePtr&) = delete; |
348 | | |
349 | 1.00k | explicit AtomicUniquePtr(T* ptr) : ptr_(ptr) {} _ZN2yb15AtomicUniquePtrINS_7TestObjEEC2EPS1_ Line | Count | Source | 349 | 1.00k | explicit AtomicUniquePtr(T* ptr) : ptr_(ptr) {} |
_ZN2yb15AtomicUniquePtrINS_6StatusEEC2EPS1_ Line | Count | Source | 349 | 7 | explicit AtomicUniquePtr(T* ptr) : ptr_(ptr) {} |
|
350 | | |
351 | 273k | AtomicUniquePtr(AtomicUniquePtr<T>&& other) : ptr_(other.release()) {} |
352 | | |
353 | 264k | void operator=(AtomicUniquePtr<T>&& other) { |
354 | 264k | reset(other.release()); |
355 | 264k | } _ZN2yb15AtomicUniquePtrINS_7TestObjEEaSEOS2_ Line | Count | Source | 353 | 264k | void operator=(AtomicUniquePtr<T>&& other) { | 354 | 264k | reset(other.release()); | 355 | 264k | } |
_ZN2yb15AtomicUniquePtrINS_6StatusEEaSEOS2_ Line | Count | Source | 353 | 7 | void operator=(AtomicUniquePtr<T>&& other) { | 354 | 7 | reset(other.release()); | 355 | 7 | } |
|
356 | | |
357 | 1.72M | ~AtomicUniquePtr() { |
358 | 1.72M | delete get(); |
359 | 1.72M | } _ZN2yb15AtomicUniquePtrINS_7TestObjEED2Ev Line | Count | Source | 357 | 313k | ~AtomicUniquePtr() { | 358 | 313k | delete get(); | 359 | 313k | } |
_ZN2yb15AtomicUniquePtrINS_20ServerRegistrationPBEED2Ev Line | Count | Source | 357 | 92 | ~AtomicUniquePtr() { | 358 | 92 | delete get(); | 359 | 92 | } |
_ZN2yb15AtomicUniquePtrIN7rocksdb11IndexReaderEED2Ev Line | Count | Source | 357 | 71.4k | ~AtomicUniquePtr() { | 358 | 71.4k | delete get(); | 359 | 71.4k | } |
_ZN2yb15AtomicUniquePtrINS_6StatusEED2Ev Line | Count | Source | 357 | 47.0k | ~AtomicUniquePtr() { | 358 | 47.0k | delete get(); | 359 | 47.0k | } |
_ZN2yb15AtomicUniquePtrINS_3rpc6StrandEED2Ev Line | Count | Source | 357 | 47.0k | ~AtomicUniquePtr() { | 358 | 47.0k | delete get(); | 359 | 47.0k | } |
_ZN2yb15AtomicUniquePtrINSt3__18functionIFiRKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEESA_EEEED2Ev Line | Count | Source | 357 | 111 | ~AtomicUniquePtr() { | 358 | 111 | delete get(); | 359 | 111 | } |
_ZN2yb15AtomicUniquePtrINS_6client8YBClientEED2Ev Line | Count | Source | 357 | 1.96k | ~AtomicUniquePtr() { | 358 | 1.96k | delete get(); | 359 | 1.96k | } |
_ZN2yb15AtomicUniquePtrIN2ev5timerEED2Ev Line | Count | Source | 357 | 1.23M | ~AtomicUniquePtr() { | 358 | 1.23M | delete get(); | 359 | 1.23M | } |
_ZN2yb15AtomicUniquePtrINS_3rpc10ThreadPoolEED2Ev Line | Count | Source | 357 | 4.04k | ~AtomicUniquePtr() { | 358 | 4.04k | delete get(); | 359 | 4.04k | } |
|
360 | | |
361 | 261M | T* get(std::memory_order memory_order = std::memory_order_acquire) const { |
362 | 261M | return ptr_.load(memory_order); |
363 | 261M | } _ZNK2yb15AtomicUniquePtrINS_7TestObjEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 508k | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 508k | return ptr_.load(memory_order); | 363 | 508k | } |
_ZNK2yb15AtomicUniquePtrINS_20ServerRegistrationPBEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 3.90M | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 3.90M | return ptr_.load(memory_order); | 363 | 3.90M | } |
_ZNK2yb15AtomicUniquePtrIN7rocksdb11IndexReaderEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 11.8M | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 11.8M | return ptr_.load(memory_order); | 363 | 11.8M | } |
_ZNK2yb15AtomicUniquePtrINS_6StatusEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 48.0k | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 48.0k | return ptr_.load(memory_order); | 363 | 48.0k | } |
_ZNK2yb15AtomicUniquePtrINS_3rpc6StrandEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 1.06M | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 1.06M | return ptr_.load(memory_order); | 363 | 1.06M | } |
_ZNK2yb15AtomicUniquePtrINSt3__18functionIFiRKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEESA_EEEE3getENS1_12memory_orderE Line | Count | Source | 361 | 111 | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 111 | return ptr_.load(memory_order); | 363 | 111 | } |
_ZNK2yb15AtomicUniquePtrINS_6client8YBClientEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 30.0k | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 30.0k | return ptr_.load(memory_order); | 363 | 30.0k | } |
_ZNK2yb15AtomicUniquePtrIN2ev5timerEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 233M | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 233M | return ptr_.load(memory_order); | 363 | 233M | } |
_ZNK2yb15AtomicUniquePtrINS_3rpc10ThreadPoolEE3getENSt3__112memory_orderE Line | Count | Source | 361 | 10.5M | T* get(std::memory_order memory_order = std::memory_order_acquire) const { | 362 | 10.5M | return ptr_.load(memory_order); | 363 | 10.5M | } |
|
364 | | |
365 | 2.40M | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { |
366 | 2.40M | delete ptr_.exchange(ptr, memory_order); |
367 | 2.40M | } _ZN2yb15AtomicUniquePtrINS_7TestObjEE5resetEPS1_NSt3__112memory_orderE Line | Count | Source | 365 | 614k | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 614k | delete ptr_.exchange(ptr, memory_order); | 367 | 614k | } |
_ZN2yb15AtomicUniquePtrINS_20ServerRegistrationPBEE5resetEPS1_NSt3__112memory_orderE Line | Count | Source | 365 | 5.42k | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 5.42k | delete ptr_.exchange(ptr, memory_order); | 367 | 5.42k | } |
_ZN2yb15AtomicUniquePtrIN7rocksdb11IndexReaderEE5resetEPS2_NSt3__112memory_orderE Line | Count | Source | 365 | 68.2k | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 68.2k | delete ptr_.exchange(ptr, memory_order); | 367 | 68.2k | } |
_ZN2yb15AtomicUniquePtrINS_3rpc6StrandEE5resetEPS2_NSt3__112memory_orderE Line | Count | Source | 365 | 136k | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 136k | delete ptr_.exchange(ptr, memory_order); | 367 | 136k | } |
_ZN2yb15AtomicUniquePtrINS_6StatusEE5resetEPS1_NSt3__112memory_orderE Line | Count | Source | 365 | 7 | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 7 | delete ptr_.exchange(ptr, memory_order); | 367 | 7 | } |
_ZN2yb15AtomicUniquePtrINSt3__18functionIFiRKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEESA_EEEE5resetEPSC_NS1_12memory_orderE Line | Count | Source | 365 | 181 | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 181 | delete ptr_.exchange(ptr, memory_order); | 367 | 181 | } |
_ZN2yb15AtomicUniquePtrINS_6client8YBClientEE5resetEPS2_NSt3__112memory_orderE Line | Count | Source | 365 | 22.6k | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 22.6k | delete ptr_.exchange(ptr, memory_order); | 367 | 22.6k | } |
_ZN2yb15AtomicUniquePtrIN2ev5timerEE5resetEPS2_NSt3__112memory_orderE Line | Count | Source | 365 | 1.54M | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 1.54M | delete ptr_.exchange(ptr, memory_order); | 367 | 1.54M | } |
_ZN2yb15AtomicUniquePtrINS_3rpc10ThreadPoolEE5resetEPS2_NSt3__112memory_orderE Line | Count | Source | 365 | 11.2k | void reset(T* ptr = nullptr, std::memory_order memory_order = std::memory_order_acq_rel) { | 366 | 11.2k | delete ptr_.exchange(ptr, memory_order); | 367 | 11.2k | } |
|
368 | | |
369 | 2.95M | T* release(std::memory_order memory_order = std::memory_order_acq_rel) { |
370 | 2.95M | return ptr_.exchange(nullptr, memory_order); |
371 | 2.95M | } _ZN2yb15AtomicUniquePtrINS_7TestObjEE7releaseENSt3__112memory_orderE Line | Count | Source | 369 | 540k | T* release(std::memory_order memory_order = std::memory_order_acq_rel) { | 370 | 540k | return ptr_.exchange(nullptr, memory_order); | 371 | 540k | } |
_ZN2yb15AtomicUniquePtrINS_6StatusEE7releaseENSt3__112memory_orderE Line | Count | Source | 369 | 7 | T* release(std::memory_order memory_order = std::memory_order_acq_rel) { | 370 | 7 | return ptr_.exchange(nullptr, memory_order); | 371 | 7 | } |
_ZN2yb15AtomicUniquePtrIN2ev5timerEE7releaseENSt3__112memory_orderE Line | Count | Source | 369 | 2.41M | T* release(std::memory_order memory_order = std::memory_order_acq_rel) { | 370 | 2.41M | return ptr_.exchange(nullptr, memory_order); | 371 | 2.41M | } |
|
372 | | |
373 | | private: |
374 | | std::atomic<T*> ptr_ = { nullptr }; |
375 | | }; |
376 | | |
377 | | template<class T, class... Args> |
378 | 1.00k | AtomicUniquePtr<T> MakeAtomicUniquePtr(Args&&... args) { |
379 | 1.00k | return AtomicUniquePtr<T>(new T(std::forward<Args>(args)...)); |
380 | 1.00k | } _ZN2yb19MakeAtomicUniquePtrINS_7TestObjEJRmPNSt3__16atomicImEEEEENS_15AtomicUniquePtrIT_EEDpOT0_ Line | Count | Source | 378 | 1.00k | AtomicUniquePtr<T> MakeAtomicUniquePtr(Args&&... args) { | 379 | 1.00k | return AtomicUniquePtr<T>(new T(std::forward<Args>(args)...)); | 380 | 1.00k | } |
_ZN2yb19MakeAtomicUniquePtrINS_6StatusEJRKS1_EEENS_15AtomicUniquePtrIT_EEDpOT0_ Line | Count | Source | 378 | 7 | AtomicUniquePtr<T> MakeAtomicUniquePtr(Args&&... args) { | 379 | 7 | return AtomicUniquePtr<T>(new T(std::forward<Args>(args)...)); | 380 | 7 | } |
|
381 | | |
382 | | template <class T> |
383 | 1.78G | T GetAtomicFlag(T* flag) { |
384 | 1.78G | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); |
385 | 1.78G | return atomic_flag.load(std::memory_order::memory_order_relaxed); |
386 | 1.78G | } _ZN2yb13GetAtomicFlagIiEET_PS1_ Line | Count | Source | 383 | 129M | T GetAtomicFlag(T* flag) { | 384 | 129M | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); | 385 | 129M | return atomic_flag.load(std::memory_order::memory_order_relaxed); | 386 | 129M | } |
_ZN2yb13GetAtomicFlagIyEET_PS1_ Line | Count | Source | 383 | 203M | T GetAtomicFlag(T* flag) { | 384 | 203M | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); | 385 | 203M | return atomic_flag.load(std::memory_order::memory_order_relaxed); | 386 | 203M | } |
_ZN2yb13GetAtomicFlagIbEET_PS1_ Line | Count | Source | 383 | 1.35G | T GetAtomicFlag(T* flag) { | 384 | 1.35G | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); | 385 | 1.35G | return atomic_flag.load(std::memory_order::memory_order_relaxed); | 386 | 1.35G | } |
_ZN2yb13GetAtomicFlagIxEET_PS1_ Line | Count | Source | 383 | 102M | T GetAtomicFlag(T* flag) { | 384 | 102M | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); | 385 | 102M | return atomic_flag.load(std::memory_order::memory_order_relaxed); | 386 | 102M | } |
_ZN2yb13GetAtomicFlagIdEET_PS1_ Line | Count | Source | 383 | 2.05M | T GetAtomicFlag(T* flag) { | 384 | 2.05M | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); | 385 | 2.05M | return atomic_flag.load(std::memory_order::memory_order_relaxed); | 386 | 2.05M | } |
|
387 | | |
388 | | template <class U, class T> |
389 | 11.2k | void SetAtomicFlag(U value, T* flag) { |
390 | 11.2k | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); |
391 | 11.2k | atomic_flag.store(value); |
392 | 11.2k | } Unexecuted instantiation: _ZN2yb13SetAtomicFlagIxyEEvT_PT0_ Unexecuted instantiation: _ZN2yb13SetAtomicFlagIiyEEvT_PT0_ Unexecuted instantiation: _ZN2yb13SetAtomicFlagIddEEvT_PT0_ _ZN2yb13SetAtomicFlagIbbEEvT_PT0_ Line | Count | Source | 389 | 261 | void SetAtomicFlag(U value, T* flag) { | 390 | 261 | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); | 391 | 261 | atomic_flag.store(value); | 392 | 261 | } |
_ZN2yb13SetAtomicFlagIiiEEvT_PT0_ Line | Count | Source | 389 | 10.9k | void SetAtomicFlag(U value, T* flag) { | 390 | 10.9k | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); | 391 | 10.9k | atomic_flag.store(value); | 392 | 10.9k | } |
Unexecuted instantiation: _ZN2yb13SetAtomicFlagIyyEEvT_PT0_ Unexecuted instantiation: _ZN2yb13SetAtomicFlagIidEEvT_PT0_ |
393 | | |
394 | | template <class T> |
395 | 6.20M | void AtomicFlagSleepMs(T* flag) { |
396 | 6.20M | auto value = GetAtomicFlag(flag); |
397 | 6.20M | if (value != 0) { |
398 | 751 | std::this_thread::sleep_for(std::chrono::milliseconds(value)); |
399 | 751 | } |
400 | 6.20M | } _ZN2yb17AtomicFlagSleepMsIxEEvPT_ Line | Count | Source | 395 | 1.05k | void AtomicFlagSleepMs(T* flag) { | 396 | 1.05k | auto value = GetAtomicFlag(flag); | 397 | 1.05k | if (value != 0) { | 398 | 0 | std::this_thread::sleep_for(std::chrono::milliseconds(value)); | 399 | 0 | } | 400 | 1.05k | } |
_ZN2yb17AtomicFlagSleepMsIyEEvPT_ Line | Count | Source | 395 | 1.06M | void AtomicFlagSleepMs(T* flag) { | 396 | 1.06M | auto value = GetAtomicFlag(flag); | 397 | 1.06M | if (value != 0) { | 398 | 751 | std::this_thread::sleep_for(std::chrono::milliseconds(value)); | 399 | 751 | } | 400 | 1.06M | } |
_ZN2yb17AtomicFlagSleepMsIiEEvPT_ Line | Count | Source | 395 | 5.14M | void AtomicFlagSleepMs(T* flag) { | 396 | 5.14M | auto value = GetAtomicFlag(flag); | 397 | 5.14M | if (value != 0) { | 398 | 0 | std::this_thread::sleep_for(std::chrono::milliseconds(value)); | 399 | 0 | } | 400 | 5.14M | } |
|
401 | | |
402 | | template <class T> |
403 | 1 | void AtomicFlagRandomSleepMs(T* flag) { |
404 | 1 | auto value = GetAtomicFlag(flag); |
405 | 1 | if (value != 0) { |
406 | 0 | std::this_thread::sleep_for(std::chrono::milliseconds(RandomUniformInt<T>(0, value))); |
407 | 0 | } |
408 | 1 | } Unexecuted instantiation: _ZN2yb23AtomicFlagRandomSleepMsIxEEvPT_ _ZN2yb23AtomicFlagRandomSleepMsIiEEvPT_ Line | Count | Source | 403 | 1 | void AtomicFlagRandomSleepMs(T* flag) { | 404 | 1 | auto value = GetAtomicFlag(flag); | 405 | 1 | if (value != 0) { | 406 | 0 | std::this_thread::sleep_for(std::chrono::milliseconds(RandomUniformInt<T>(0, value))); | 407 | 0 | } | 408 | 1 | } |
|
409 | | |
410 | | template <class U, class T> |
411 | 3 | bool CompareAndSetFlag(T* flag, U exp, U desired) { |
412 | 3 | std::atomic<T>& atomic_flag = *pointer_cast<std::atomic<T>*>(flag); |
413 | 3 | return atomic_flag.compare_exchange_strong(exp, desired); |
414 | 3 | } |
415 | | |
416 | | template<typename T> |
417 | 396k | void UpdateAtomicMax(std::atomic<T>* max_holder, T new_value) { |
418 | 396k | auto current_max = max_holder->load(std::memory_order_acquire); |
419 | 396k | while (new_value > current_max && !max_holder->compare_exchange_weak(current_max, new_value)) {} |
420 | 396k | } _ZN2yb15UpdateAtomicMaxIyEEvPNSt3__16atomicIT_EES3_ Line | Count | Source | 417 | 396k | void UpdateAtomicMax(std::atomic<T>* max_holder, T new_value) { | 418 | 396k | auto current_max = max_holder->load(std::memory_order_acquire); | 419 | 396k | while (new_value > current_max && !max_holder->compare_exchange_weak(current_max, new_value)) {} | 420 | 396k | } |
_ZN2yb15UpdateAtomicMaxINS_8MonoTimeEEEvPNSt3__16atomicIT_EES4_ Line | Count | Source | 417 | 5 | void UpdateAtomicMax(std::atomic<T>* max_holder, T new_value) { | 418 | 5 | auto current_max = max_holder->load(std::memory_order_acquire); | 419 | 5 | while (new_value > current_max && !max_holder->compare_exchange_weak(current_max, new_value)) {} | 420 | 5 | } |
|
421 | | |
422 | | class AtomicTryMutex { |
423 | | public: |
424 | 11.6M | void unlock() { |
425 | 11.6M | auto value = locked_.exchange(false, std::memory_order_acq_rel); |
426 | 11.6M | DCHECK(value); |
427 | 11.6M | } |
428 | | |
429 | 14.7M | bool try_lock() { |
430 | 14.7M | bool expected = false; |
431 | 14.7M | return locked_.compare_exchange_strong(expected, true, std::memory_order_acq_rel); |
432 | 14.7M | } |
433 | | |
434 | 23.7M | bool is_locked() const { |
435 | 23.7M | return locked_.load(std::memory_order_acquire); |
436 | 23.7M | } |
437 | | |
438 | | private: |
439 | | std::atomic<bool> locked_{false}; |
440 | | }; |
441 | | |
442 | | template <class T, class D> |
443 | 4.90M | T AddFetch(std::atomic<T>* atomic, const D& delta, std::memory_order memory_order) { |
444 | 4.90M | return atomic->fetch_add(delta, memory_order) + delta; |
445 | 4.90M | } |
446 | | |
447 | | // ------------------------------------------------------------------------------------------------ |
448 | | // A utility for testing if an atomic is lock-free. |
449 | | |
450 | | namespace atomic_internal { |
451 | | |
452 | | template <class T> |
453 | 13.6M | bool IsAcceptableAtomicImpl(const T& atomic_variable) { |
454 | 13.6M | #ifdef __aarch64__ |
455 | | // TODO: ensure we are using proper 16-byte atomics on aarch64. |
456 | | // https://github.com/yugabyte/yugabyte-db/issues/9196 |
457 | 13.6M | return true; |
458 | | #else |
459 | | return atomic_variable.is_lock_free(); |
460 | | #endif |
461 | 13.6M | } lockfree-test.cc:_ZN2yb15atomic_internal22IsAcceptableAtomicImplIN5boost7atomics6atomicINS_13LockFreeStackIZNS_23LockfreeTest_Stack_Test8TestBodyEvE5EntryE4HeadEEEEEbRKT_ Line | Count | Source | 453 | 1 | bool IsAcceptableAtomicImpl(const T& atomic_variable) { | 454 | 1 | #ifdef __aarch64__ | 455 | | // TODO: ensure we are using proper 16-byte atomics on aarch64. | 456 | | // https://github.com/yugabyte/yugabyte-db/issues/9196 | 457 | 1 | return true; | 458 | | #else | 459 | | return atomic_variable.is_lock_free(); | 460 | | #endif | 461 | 1 | } |
_ZN2yb15atomic_internal22IsAcceptableAtomicImplIN5boost7atomics6atomicINS_9consensus12ReplicaState16LeaderStateCacheEEEEEbRKT_ Line | Count | Source | 453 | 88.7k | bool IsAcceptableAtomicImpl(const T& atomic_variable) { | 454 | 88.7k | #ifdef __aarch64__ | 455 | | // TODO: ensure we are using proper 16-byte atomics on aarch64. | 456 | | // https://github.com/yugabyte/yugabyte-db/issues/9196 | 457 | 88.7k | return true; | 458 | | #else | 459 | | return atomic_variable.is_lock_free(); | 460 | | #endif | 461 | 88.7k | } |
_ZN2yb15atomic_internal22IsAcceptableAtomicImplINSt3__16atomicIyEEEEbRKT_ Line | Count | Source | 453 | 11.5k | bool IsAcceptableAtomicImpl(const T& atomic_variable) { | 454 | 11.5k | #ifdef __aarch64__ | 455 | | // TODO: ensure we are using proper 16-byte atomics on aarch64. | 456 | | // https://github.com/yugabyte/yugabyte-db/issues/9196 | 457 | 11.5k | return true; | 458 | | #else | 459 | | return atomic_variable.is_lock_free(); | 460 | | #endif | 461 | 11.5k | } |
_ZN2yb15atomic_internal22IsAcceptableAtomicImplIN5boost7atomics6atomicINS_4OpIdEEEEEbRKT_ Line | Count | Source | 453 | 13.5M | bool IsAcceptableAtomicImpl(const T& atomic_variable) { | 454 | 13.5M | #ifdef __aarch64__ | 455 | | // TODO: ensure we are using proper 16-byte atomics on aarch64. | 456 | | // https://github.com/yugabyte/yugabyte-db/issues/9196 | 457 | 13.5M | return true; | 458 | | #else | 459 | | return atomic_variable.is_lock_free(); | 460 | | #endif | 461 | 13.5M | } |
stack_trace.cc:_ZN2yb15atomic_internal22IsAcceptableAtomicImplIN5boost7atomics6atomicINS_13LockFreeStackINS_12_GLOBAL__N_116ThreadStackEntryEE4HeadEEEEEbRKT_ Line | Count | Source | 453 | 41.3k | bool IsAcceptableAtomicImpl(const T& atomic_variable) { | 454 | 41.3k | #ifdef __aarch64__ | 455 | | // TODO: ensure we are using proper 16-byte atomics on aarch64. | 456 | | // https://github.com/yugabyte/yugabyte-db/issues/9196 | 457 | 41.3k | return true; | 458 | | #else | 459 | | return atomic_variable.is_lock_free(); | 460 | | #endif | 461 | 41.3k | } |
|
462 | | |
463 | | } // namespace atomic_internal |
464 | | |
465 | | template <class T> |
466 | 13.6M | bool IsAcceptableAtomicImpl(const boost::atomics::atomic<T>& atomic_variable) { |
467 | 13.6M | return atomic_internal::IsAcceptableAtomicImpl(atomic_variable); |
468 | 13.6M | } lockfree-test.cc:_ZN2yb22IsAcceptableAtomicImplINS_13LockFreeStackIZNS_23LockfreeTest_Stack_Test8TestBodyEvE5EntryE4HeadEEEbRKN5boost7atomics6atomicIT_EE Line | Count | Source | 466 | 1 | bool IsAcceptableAtomicImpl(const boost::atomics::atomic<T>& atomic_variable) { | 467 | 1 | return atomic_internal::IsAcceptableAtomicImpl(atomic_variable); | 468 | 1 | } |
_ZN2yb22IsAcceptableAtomicImplINS_9consensus12ReplicaState16LeaderStateCacheEEEbRKN5boost7atomics6atomicIT_EE Line | Count | Source | 466 | 88.7k | bool IsAcceptableAtomicImpl(const boost::atomics::atomic<T>& atomic_variable) { | 467 | 88.7k | return atomic_internal::IsAcceptableAtomicImpl(atomic_variable); | 468 | 88.7k | } |
_ZN2yb22IsAcceptableAtomicImplINS_4OpIdEEEbRKN5boost7atomics6atomicIT_EE Line | Count | Source | 466 | 13.4M | bool IsAcceptableAtomicImpl(const boost::atomics::atomic<T>& atomic_variable) { | 467 | 13.4M | return atomic_internal::IsAcceptableAtomicImpl(atomic_variable); | 468 | 13.4M | } |
stack_trace.cc:_ZN2yb22IsAcceptableAtomicImplINS_13LockFreeStackINS_12_GLOBAL__N_116ThreadStackEntryEE4HeadEEEbRKN5boost7atomics6atomicIT_EE Line | Count | Source | 466 | 41.3k | bool IsAcceptableAtomicImpl(const boost::atomics::atomic<T>& atomic_variable) { | 467 | 41.3k | return atomic_internal::IsAcceptableAtomicImpl(atomic_variable); | 468 | 41.3k | } |
|
469 | | |
470 | | template <class T> |
471 | 11.5k | bool IsAcceptableAtomicImpl(const std::atomic<T>& atomic_variable) { |
472 | 11.5k | return atomic_internal::IsAcceptableAtomicImpl(atomic_variable); |
473 | 11.5k | } |
474 | | |
475 | | } // namespace yb |
476 | | #endif /* YB_UTIL_ATOMIC_H */ |