OLD | NEW |
1 #ifndef SkAtomics_std_DEFINED | 1 #ifndef SkAtomics_std_DEFINED |
2 #define SkAtomics_std_DEFINED | 2 #define SkAtomics_std_DEFINED |
3 | 3 |
4 // We try not to depend on the C++ standard library, | 4 // We try not to depend on the C++ standard library, |
5 // but these uses of <atomic> should all inline, so we don't feel to bad here. | 5 // but these uses of <atomic> should all inline, so we don't feel to bad here. |
6 #include <atomic> | 6 #include <atomic> |
7 | 7 |
8 template <typename T> | 8 template <typename T> |
9 T sk_atomic_load(const T* ptr, sk_memory_order mo) { | 9 T sk_atomic_load(const T* ptr, sk_memory_order mo) { |
| 10 SkASSERT(mo == sk_memory_order_relaxed || |
| 11 mo == sk_memory_order_seq_cst || |
| 12 mo == sk_memory_order_acquire || |
| 13 mo == sk_memory_order_consume); |
10 const std::atomic<T>* ap = reinterpret_cast<const std::atomic<T>*>(ptr); | 14 const std::atomic<T>* ap = reinterpret_cast<const std::atomic<T>*>(ptr); |
11 return std::atomic_load_explicit(ap, (std::memory_order)mo); | 15 return std::atomic_load_explicit(ap, (std::memory_order)mo); |
12 } | 16 } |
13 | 17 |
14 template <typename T> | 18 template <typename T> |
15 void sk_atomic_store(T* ptr, T val, sk_memory_order mo) { | 19 void sk_atomic_store(T* ptr, T val, sk_memory_order mo) { |
| 20 SkASSERT(mo == sk_memory_order_relaxed || |
| 21 mo == sk_memory_order_seq_cst || |
| 22 mo == sk_memory_order_release); |
16 std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr); | 23 std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr); |
17 return std::atomic_store_explicit(ap, val, (std::memory_order)mo); | 24 return std::atomic_store_explicit(ap, val, (std::memory_order)mo); |
18 } | 25 } |
19 | 26 |
20 template <typename T> | 27 template <typename T> |
21 T sk_atomic_fetch_add(T* ptr, T val, sk_memory_order mo) { | 28 T sk_atomic_fetch_add(T* ptr, T val, sk_memory_order mo) { |
| 29 // All values of mo are valid. |
22 std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr); | 30 std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr); |
23 return std::atomic_fetch_add_explicit(ap, val, (std::memory_order)mo); | 31 return std::atomic_fetch_add_explicit(ap, val, (std::memory_order)mo); |
24 } | 32 } |
25 | 33 |
26 template <typename T> | 34 template <typename T> |
27 bool sk_atomic_compare_exchange(T* ptr, T* expected, T desired, | 35 bool sk_atomic_compare_exchange(T* ptr, T* expected, T desired, |
28 sk_memory_order success, | 36 sk_memory_order success, |
29 sk_memory_order failure) { | 37 sk_memory_order failure) { |
| 38 // All values of success are valid. |
| 39 SkASSERT(failure == sk_memory_order_relaxed || |
| 40 failure == sk_memory_order_seq_cst || |
| 41 failure == sk_memory_order_acquire || |
| 42 failure == sk_memory_order_consume); |
| 43 SkASSERT(failure <= success); |
30 std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr); | 44 std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr); |
31 return std::atomic_compare_exchange_strong_explicit(ap, expected, desired, | 45 return std::atomic_compare_exchange_strong_explicit(ap, expected, desired, |
32 (std::memory_order)succe
ss, | 46 (std::memory_order)succe
ss, |
33 (std::memory_order)failu
re); | 47 (std::memory_order)failu
re); |
34 } | 48 } |
35 | 49 |
36 #endif//SkAtomics_std_DEFINED | 50 #endif//SkAtomics_std_DEFINED |
OLD | NEW |