Clean up the ParkingLot uparking API a bit
[WebKit-https.git] / Source / WTF / wtf / Atomics.h
1 /*
2  * Copyright (C) 2007-2008, 2010, 2012-2015 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
21  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
23  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef Atomics_h
27 #define Atomics_h
28
29 #include <atomic>
30 #include <wtf/StdLibExtras.h>
31
32 #if OS(WINDOWS)
33 #if !COMPILER(GCC_OR_CLANG)
34 extern "C" void _ReadWriteBarrier(void);
35 #pragma intrinsic(_ReadWriteBarrier)
36 #endif
37 #include <windows.h>
38 #endif
39
40 namespace WTF {
41
42 // Atomic wraps around std::atomic with the sole purpose of making the compare_exchange
43 // operations not alter the expected value. This is more in line with how we typically
44 // use CAS in our code.
45 //
46 // Atomic is a struct without explicitly defined constructors so that it can be
47 // initialized at compile time.
48
49 template<typename T>
50 struct Atomic {
51     // Don't pass a non-default value for the order parameter unless you really know
52     // what you are doing and have thought about it very hard. The cost of seq_cst
53     // is usually not high enough to justify the risk.
54
55     T load(std::memory_order order = std::memory_order_seq_cst) const { return value.load(order); }
56
57     void store(T desired, std::memory_order order = std::memory_order_seq_cst) { value.store(desired, order); }
58
59     bool compareExchangeWeak(T expected, T desired, std::memory_order order = std::memory_order_seq_cst)
60     {
61 #if OS(WINDOWS)
62         // Windows makes strange assertions about the argument to compare_exchange_weak, and anyway,
63         // Windows is X86 so seq_cst is cheap.
64         order = std::memory_order_seq_cst;
65 #endif
66         T expectedOrActual = expected;
67         return value.compare_exchange_weak(expectedOrActual, desired, order);
68     }
69
70     bool compareExchangeStrong(T expected, T desired, std::memory_order order = std::memory_order_seq_cst)
71     {
72 #if OS(WINDOWS)
73         // See above.
74         order = std::memory_order_seq_cst;
75 #endif
76         T expectedOrActual = expected;
77         return value.compare_exchange_strong(expectedOrActual, desired, order);
78     }
79     
80     template<typename U>
81     T exchangeAndAdd(U addend, std::memory_order order = std::memory_order_seq_cst)
82     {
83 #if OS(WINDOWS)
84         // See above.
85         order = std::memory_order_seq_cst;
86 #endif
87         return value.fetch_add(addend, order);
88     }
89     
90     T exchange(T newValue, std::memory_order order = std::memory_order_seq_cst)
91     {
92 #if OS(WINDOWS)
93         // See above.
94         order = std::memory_order_seq_cst;
95 #endif
96         return value.exchange(newValue, order);
97     }
98
99     std::atomic<T> value;
100 };
101
102 // This is a weak CAS function that takes a direct pointer and has no portable fencing guarantees.
103 template<typename T>
104 inline bool weakCompareAndSwap(volatile T* location, T expected, T newValue)
105 {
106     return bitwise_cast<Atomic<T>*>(location)->compareExchangeWeak(expected, newValue, std::memory_order_relaxed);
107 }
108
109 // Just a compiler fence. Has no effect on the hardware, but tells the compiler
110 // not to move things around this call. Should not affect the compiler's ability
111 // to do things like register allocation and code motion over pure operations.
112 inline void compilerFence()
113 {
114 #if OS(WINDOWS) && !COMPILER(GCC_OR_CLANG)
115     _ReadWriteBarrier();
116 #else
117     asm volatile("" ::: "memory");
118 #endif
119 }
120
121 #if CPU(ARM_THUMB2) || CPU(ARM64)
122
123 // Full memory fence. No accesses will float above this, and no accesses will sink
124 // below it.
125 inline void armV7_dmb()
126 {
127     asm volatile("dmb sy" ::: "memory");
128 }
129
130 // Like the above, but only affects stores.
131 inline void armV7_dmb_st()
132 {
133     asm volatile("dmb st" ::: "memory");
134 }
135
136 inline void loadLoadFence() { armV7_dmb(); }
137 inline void loadStoreFence() { armV7_dmb(); }
138 inline void storeLoadFence() { armV7_dmb(); }
139 inline void storeStoreFence() { armV7_dmb_st(); }
140 inline void memoryBarrierAfterLock() { armV7_dmb(); }
141 inline void memoryBarrierBeforeUnlock() { armV7_dmb(); }
142
143 #elif CPU(X86) || CPU(X86_64)
144
145 inline void x86_mfence()
146 {
147 #if OS(WINDOWS)
148     // I think that this does the equivalent of a dummy interlocked instruction,
149     // instead of using the 'mfence' instruction, at least according to MSDN. I
150     // know that it is equivalent for our purposes, but it would be good to
151     // investigate if that is actually better.
152     MemoryBarrier();
153 #else
154     asm volatile("mfence" ::: "memory");
155 #endif
156 }
157
158 inline void loadLoadFence() { compilerFence(); }
159 inline void loadStoreFence() { compilerFence(); }
160 inline void storeLoadFence() { x86_mfence(); }
161 inline void storeStoreFence() { compilerFence(); }
162 inline void memoryBarrierAfterLock() { compilerFence(); }
163 inline void memoryBarrierBeforeUnlock() { compilerFence(); }
164
165 #else
166
167 inline void loadLoadFence() { compilerFence(); }
168 inline void loadStoreFence() { compilerFence(); }
169 inline void storeLoadFence() { compilerFence(); }
170 inline void storeStoreFence() { compilerFence(); }
171 inline void memoryBarrierAfterLock() { compilerFence(); }
172 inline void memoryBarrierBeforeUnlock() { compilerFence(); }
173
174 #endif
175
176 } // namespace WTF
177
178 using WTF::Atomic;
179
180 #endif // Atomics_h