Updated the atomic API for better use cases
This commit is contained in:
parent
4084438113
commit
1bc8fe69ce
16 changed files with 488 additions and 2758 deletions
|
@ -18,24 +18,34 @@
|
|||
|
||||
Sam Lantinga
|
||||
slouken@libsdl.org
|
||||
|
||||
Contributed by Bob Pendleton, bob@pendleton.com
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file SDL_atomic.h
|
||||
*
|
||||
* Atomic operations.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* At the very minimum spin locks must be implemented. Without spin
|
||||
* locks it is not possible (AFAICT) to emulate the rest of the atomic
|
||||
* operations.
|
||||
* \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.
|
||||
*/
|
||||
|
||||
#ifndef _SDL_atomic_h_
|
||||
|
@ -53,154 +63,138 @@ extern "C" {
|
|||
/* *INDENT-ON* */
|
||||
#endif
|
||||
|
||||
/* Function prototypes */
|
||||
|
||||
/**
|
||||
* \name SDL AtomicLock
|
||||
*
|
||||
* The spin lock functions and type are required and can not be
|
||||
* emulated because they are used in the emulation code.
|
||||
* \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.
|
||||
*/
|
||||
/*@{*/
|
||||
|
||||
typedef volatile Uint32 SDL_SpinLock;
|
||||
typedef int SDL_SpinLock;
|
||||
|
||||
/**
|
||||
* \brief Lock a spin lock by setting it to a none zero value.
|
||||
*
|
||||
* \param lock Points to the lock.
|
||||
* \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);
|
||||
|
||||
/**
|
||||
* \brief Lock a spin lock by setting it to a non-zero value.
|
||||
*
|
||||
* \param lock Points to the lock.
|
||||
*/
|
||||
extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
|
||||
|
||||
/**
|
||||
* \brief Unlock a spin lock by setting it to 0. Always returns immediately
|
||||
* \brief Unlock a spin lock by setting it to 0. Always returns immediately
|
||||
*
|
||||
* \param lock Points to the lock.
|
||||
* \param lock Points to the lock.
|
||||
*/
|
||||
extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
|
||||
|
||||
/*@}*//*SDL AtomicLock*/
|
||||
|
||||
/**
|
||||
* \name 32 bit atomic operations
|
||||
*/
|
||||
/*@{*/
|
||||
/* Platform specific optimized versions of the atomic functions */
|
||||
/* None yet... */
|
||||
|
||||
/**
|
||||
* \brief Check to see if \c *ptr == 0 and set it to 1.
|
||||
*
|
||||
* \return SDL_True if the value pointed to by \c ptr was zero and
|
||||
* SDL_False if it was not zero
|
||||
*
|
||||
* \param ptr Points to the value to be tested and set.
|
||||
* \brief A type representing an atomic integer value. It is a struct
|
||||
* so people don't accidentally use numeric operations on it.
|
||||
*/
|
||||
extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet32(volatile Uint32 * ptr);
|
||||
#ifndef SDL_atomic_t_defined
|
||||
typedef struct { int value; } SDL_atomic_t;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Set the value pointed to by \c ptr to be zero.
|
||||
*
|
||||
* \param ptr Address of the value to be set to zero
|
||||
* \brief Set an atomic variable to a value.
|
||||
*
|
||||
* \return The previous value of the atomic variable.
|
||||
*/
|
||||
extern DECLSPEC void SDLCALL SDL_AtomicClear32(volatile Uint32 * ptr);
|
||||
#ifndef SDL_AtomicSet
|
||||
extern DECLSPEC int SDLCALL SDL_AtomicSet(SDL_atomic_t *a, int value);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Fetch the current value of \c *ptr and then increment that
|
||||
* value in place.
|
||||
*
|
||||
* \return The value before it was incremented.
|
||||
*
|
||||
* \param ptr Address of the value to fetch and increment
|
||||
* \brief Get the value of an atomic variable
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr);
|
||||
#ifndef SDL_AtomicGet
|
||||
extern DECLSPEC int SDLCALL SDL_AtomicGet(SDL_atomic_t *a);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Fetch \c *ptr and then decrement the value in place.
|
||||
*
|
||||
* \return The value before it was decremented.
|
||||
*
|
||||
* \param ptr Address of the value to fetch and decrement
|
||||
* \brief Add to an atomic variable.
|
||||
*
|
||||
* \return The previous value of the atomic variable.
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr);
|
||||
#ifndef SDL_AtomicAdd
|
||||
extern DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_atomic_t *a, int value);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Fetch the current value at \c ptr and then add \c value to \c *ptr.
|
||||
*
|
||||
* \return \c *ptr before the addition took place.
|
||||
*
|
||||
* \param ptr The address of data we are changing.
|
||||
* \param value The value to add to \c *ptr.
|
||||
* \brief Increment an atomic variable used as a reference count.
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value);
|
||||
#ifndef SDL_AtomicIncRef
|
||||
extern DECLSPEC void SDLCALL SDL_AtomicIncRef(SDL_atomic_t *a);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Fetch \c *ptr and then subtract \c value from it.
|
||||
*
|
||||
* \return \c *ptr before the subtraction took place.
|
||||
*
|
||||
* \param ptr The address of the data being changed.
|
||||
* \param value The value to subtract from \c *ptr.
|
||||
* \brief Decrement an atomic variable used as a reference count.
|
||||
*
|
||||
* \return SDL_TRUE if the variable has reached zero after decrementing,
|
||||
* SDL_FALSE otherwise
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value);
|
||||
#ifndef SDL_AtomicDecRef
|
||||
extern DECLSPEC SDL_bool SDLCALL SDL_AtomicDecRef(SDL_atomic_t *a);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Add one to the data pointed to by \c ptr and return that value.
|
||||
*
|
||||
* \return The incremented value.
|
||||
*
|
||||
* \param ptr The address of the data to increment.
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr);
|
||||
* \brief Set an atomic variable to a new value if it is currently an old value.
|
||||
*
|
||||
* \return The previous value of the atomic variable
|
||||
*
|
||||
* \note If you don't know what this function is for, you shouldn't use it!
|
||||
*/
|
||||
#ifndef SDL_AtomicCAS
|
||||
extern DECLSPEC int SDLCALL SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Subtract one from data pointed to by \c ptr and return the new value.
|
||||
*
|
||||
* \return The decremented value.
|
||||
*
|
||||
* \param ptr The address of the data to decrement.
|
||||
* \brief Set a pointer to a value atomically.
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr);
|
||||
#ifndef SDL_AtomicSetPtr
|
||||
extern DECLSPEC void SDLCALL SDL_AtomicSetPtr(void** a, void* value);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Add \c value to the data pointed to by \c ptr and return result.
|
||||
*
|
||||
* \return The sum of \c *ptr and \c value.
|
||||
*
|
||||
* \param ptr The address of the data to be modified.
|
||||
* \param value The value to be added.
|
||||
* \brief Get the value of a pointer atomically.
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value);
|
||||
#ifndef SDL_AtomicGetPtr
|
||||
extern DECLSPEC void* SDLCALL SDL_AtomicGetPtr(void** a);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Subtract \c value from the data pointed to by \c ptr and return the result.
|
||||
*
|
||||
* \return The difference between \c *ptr and \c value.
|
||||
*
|
||||
* \param ptr The address of the data to be modified.
|
||||
* \param value The value to be subtracted.
|
||||
*/
|
||||
extern DECLSPEC Uint32 SDLCALL SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value);
|
||||
|
||||
/*@}*//*32 bit atomic operations*/
|
||||
|
||||
/**
|
||||
* \name 64 bit atomic operations
|
||||
*/
|
||||
/*@{*/
|
||||
#ifdef SDL_HAS_64BIT_TYPE
|
||||
|
||||
extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet64(volatile Uint64 * ptr);
|
||||
extern DECLSPEC void SDLCALL SDL_AtomicClear64(volatile Uint64 * ptr);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value);
|
||||
extern DECLSPEC Uint64 SDLCALL SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value);
|
||||
#endif /* SDL_HAS_64BIT_TYPE */
|
||||
|
||||
/*@}*//*64 bit atomic operations*/
|
||||
* \brief Set a pointer to a new value if it is currently an old value.
|
||||
*
|
||||
* \return The previous value of the pointer
|
||||
*
|
||||
* \note If you don't know what this function is for, you shouldn't use it!
|
||||
*/
|
||||
#ifndef SDL_AtomicCASPtr
|
||||
extern DECLSPEC void* SDLCALL SDL_AtomicCASPtr(void **a, void *oldval, void *newval);
|
||||
#endif
|
||||
|
||||
/* Ends C function definitions when using C++ */
|
||||
#ifdef __cplusplus
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue