This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_atomic.h
269 lines (233 loc) · 8.17 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
/**
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
* \file SDL_atomic.h
*
* Atomic operations.
*
* IMPORTANT:
* If you are not an expert in concurrent lockless programming, you should
* only be using the atomic lock and reference counting functions in this
* file. In all other cases you should be protecting your data structures
* with full mutexes.
*
* The list of "safe" functions to use are:
* SDL_AtomicLock()
* SDL_AtomicUnlock()
* SDL_AtomicIncRef()
* SDL_AtomicDecRef()
*
* Seriously, here be dragons!
*
* These operations may, or may not, actually be implemented using
* processor specific atomic operations. When possible they are
* implemented as true processor specific atomic operations. When that
* is not possible the are implemented using locks that *do* use the
* available atomic operations.
*
* All of the atomic operations that modify memory are full memory barriers.
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
*/
#ifndef _SDL_atomic_h_
#define _SDL_atomic_h_
#include "SDL_stdinc.h"
#include "SDL_platform.h"
#include "begin_code.h"
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
/* *INDENT-OFF* */
extern "C" {
/* *INDENT-ON* */
#endif
66
/**
67
68
69
70
71
72
73
74
75
76
77
78
79
* \name SDL AtomicLock
*
* The atomic locks are efficient spinlocks using CPU instructions,
* but are vulnerable to starvation and can spin forever if a thread
* holding a lock has been terminated. For this reason you should
* minimize the code executed inside an atomic lock and never do
* expensive things like API or system calls while holding them.
*
* The atomic locks are not safe to lock recursively.
*
* Porting Note:
* The spin lock functions and type are required and can not be
* emulated because they are used in the atomic emulation code.
80
*/
81
/*@{*/
82
83
84
85
86
87
88
89
90
91
92
typedef int SDL_SpinLock;
/**
* \brief Try to lock a spin lock by setting it to a non-zero value.
*
* \param lock Points to the lock.
*
* \return SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already held.
*/
extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTryLock(SDL_SpinLock *lock);
93
94
/**
95
96
97
* \brief Lock a spin lock by setting it to a non-zero value.
*
* \param lock Points to the lock.
98
*/
99
extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
100
101
/**
102
* \brief Unlock a spin lock by setting it to 0. Always returns immediately
103
*
104
* \param lock Points to the lock.
105
*/
106
107
extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
108
/*@}*//*SDL AtomicLock*/
109
110
/* Platform specific optimized versions of the atomic functions */
111
112
113
114
#if defined(__WIN32__) && defined(_INC_WINDOWS)
/* Don't include windows.h, since it may hose code that isn't expecting it,
but if someone has already included it, this is fair game... */
#if 0
115
116
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
117
#endif
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
#define SDL_AtomicSet(a, v) InterlockedExchange(&(a)->value, v)
#define SDL_AtomicGet(a) ((a)->value)
#define SDL_AtomicAdd(a, v) InterlockedAdd(&(a)->value, v)
#define SDL_AtomicCAS(a, oldval, newval) (InterlockedCompareExchange(&(a)->value, newval, oldval) == (oldval))
#define SDL_AtomicSetPtr(a, v) InterlockedExchangePointer(a, v)
#define SDL_AtomicGetPtr(a) (*(a))
#define SDL_AtomicCASPtr(a, oldval, newval) (InterlockedCompareExchangePointer(a, newval, oldval) == (oldval))
#elif defined(__MACOSX__)
#include <libkern/OSAtomic.h>
#define SDL_AtomicSet(a, v) \
({ \
int oldvalue; \
\
do { \
oldvalue = (a)->value; \
} while (!OSAtomicCompareAndSwap32Barrier(oldvalue, v, &(a)->value)); \
\
oldvalue; \
})
#define SDL_AtomicGet(a) ((a)->value)
#define SDL_AtomicAdd(a, v) \
({ \
int oldvalue; \
\
do { \
oldvalue = (a)->value; \
} while (!OSAtomicCompareAndSwap32Barrier(oldvalue, oldvalue+v, &(a)->value)); \
\
oldvalue; \
})
#define SDL_AtomicCAS(a, oldval, newval) OSAtomicCompareAndSwap32Barrier(oldval, newval, &(a)->value)
#define SDL_AtomicSetPtr(a, v) (*(a) = v, OSMemoryBarrier())
#define SDL_AtomicGetPtr(a) (*(a))
#if SIZEOF_VOIDP == 4
#define SDL_AtomicCASPtr(a, oldval, newval) OSAtomicCompareAndSwap32Barrier((int32_t)(oldval), (int32_t)(newval), (int32_t*)(a))
#elif SIZEOF_VOIDP == 8
#define SDL_AtomicCASPtr(a, oldval, newval) OSAtomicCompareAndSwap64Barrier((int64_t)(oldval), (int64_t)(newval), (int64_t*)(a))
#endif
#elif defined(HAVE_GCC_ATOMICS)
#define SDL_AtomicSet(a, v) __sync_lock_test_and_set(&(a)->value, v)
#define SDL_AtomicGet(a) ((a)->value)
#define SDL_AtomicAdd(a, v) __sync_fetch_and_add(&(a)->value, v)
#define SDL_AtomicCAS(a, oldval, newval) __sync_bool_compare_and_swap(&(a)->value, oldval, newval)
#define SDL_AtomicSetPtr(a, v) (*(a) = v, __sync_synchronize())
#define SDL_AtomicGetPtr(a) (*(a))
#define SDL_AtomicCASPtr(a, oldval, newval) __sync_bool_compare_and_swap(a, oldval, newval)
#endif
171
172
/**
173
174
* \brief A type representing an atomic integer value. It is a struct
* so people don't accidentally use numeric operations on it.
175
*/
176
177
178
#ifndef SDL_atomic_t_defined
typedef struct { int value; } SDL_atomic_t;
#endif
179
180
/**
181
182
183
* \brief Set an atomic variable to a value.
*
* \return The previous value of the atomic variable.
184
*/
185
186
187
#ifndef SDL_AtomicSet
extern DECLSPEC int SDLCALL SDL_AtomicSet(SDL_atomic_t *a, int value);
#endif
188
189
/**
190
* \brief Get the value of an atomic variable
191
*/
192
193
194
#ifndef SDL_AtomicGet
extern DECLSPEC int SDLCALL SDL_AtomicGet(SDL_atomic_t *a);
#endif
195
196
/**
197
198
199
* \brief Add to an atomic variable.
*
* \return The previous value of the atomic variable.
200
*/
201
202
203
#ifndef SDL_AtomicAdd
extern DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_atomic_t *a, int value);
#endif
204
205
/**
206
* \brief Increment an atomic variable used as a reference count.
207
*/
208
209
210
#ifndef SDL_AtomicIncRef
extern DECLSPEC void SDLCALL SDL_AtomicIncRef(SDL_atomic_t *a);
#endif
211
212
/**
213
214
215
216
* \brief Decrement an atomic variable used as a reference count.
*
* \return SDL_TRUE if the variable has reached zero after decrementing,
* SDL_FALSE otherwise
217
*/
218
219
220
#ifndef SDL_AtomicDecRef
extern DECLSPEC SDL_bool SDLCALL SDL_AtomicDecRef(SDL_atomic_t *a);
#endif
221
222
/**
223
224
* \brief Set an atomic variable to a new value if it is currently an old value.
*
225
* \return SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
226
227
228
229
*
* \note If you don't know what this function is for, you shouldn't use it!
*/
#ifndef SDL_AtomicCAS
230
extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval);
231
#endif
232
233
/**
234
* \brief Set a pointer to a value atomically.
235
*/
236
237
238
#ifndef SDL_AtomicSetPtr
extern DECLSPEC void SDLCALL SDL_AtomicSetPtr(void** a, void* value);
#endif
239
240
/**
241
* \brief Get the value of a pointer atomically.
242
*/
243
244
245
#ifndef SDL_AtomicGetPtr
extern DECLSPEC void* SDLCALL SDL_AtomicGetPtr(void** a);
#endif
246
247
/**
248
249
* \brief Set a pointer to a new value if it is currently an old value.
*
250
* \return SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
251
252
253
254
*
* \note If you don't know what this function is for, you shouldn't use it!
*/
#ifndef SDL_AtomicCASPtr
255
extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCASPtr(void **a, void *oldval, void *newval);
256
#endif
257
258
259
260
261
262
263
264
265
266
267
268
269
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
/* *INDENT-OFF* */
}
/* *INDENT-ON* */
#endif
#include "close_code.h"
#endif /* _SDL_atomic_h_ */
/* vi: set ts=4 sw=4 expandtab: */