dad8f05067
/test/testatomic.c performs absolutely basic tests to show that the function work as expected. Need a second test to do more detailed tests. /include/SDL_atomic.h provides declarations for all included functions. /src/atomic/linux/SDL_atomic.c provided all the functions. On a generic built the 64 bit functions work, but they are emulated. On a build for -march=pentium and above the 64 bit functions use native instructions /src/atomic/dummy/SDL_atomic.c emulates all the operations using SDL_mutex.h. /src/atomic/win32/SDL_atomic.c is a copy of dummy /src/atomic/macosx/SDL_atomic.s is a copy of dummy These versions of SDL_atomic.c provide a frame work for building the library with a mixture of native and emulated functions. This allows the whole library to be provided on all platforms. (I hope.) I hope this fits with the SDL philosophy of either providing a common subset or emulating when the platform is missing a feature. I have not added dummy, macosx, or win32 to the build. They are there as place holders for future work. I have modified congifure.in to compile sources in /src/atomic/linux. (The SDL configure.in file is an amazing piece of work and I hope I didn't mess it up. :-) --HG-- extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%403671
1002 lines
18 KiB
C
1002 lines
18 KiB
C
/*
|
|
SDL - Simple DirectMedia Layer
|
|
Copyright (C) 1997-2009 Sam Lantinga
|
|
|
|
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
|
|
*/
|
|
|
|
#include "SDL_stdinc.h"
|
|
#include "SDL_atomic.h"
|
|
|
|
/*
|
|
This file provides 8, 16, 32, and 64 bit atomic operations. If the
|
|
operations are provided by the native hardware and operating system
|
|
they are used. If they are not then the operations are emulated
|
|
using the SDL mutex operations.
|
|
*/
|
|
|
|
/*
|
|
First, detect whether the operations are supported and create
|
|
#defines that indicate that they do exist. The goal is to have all
|
|
the system dependent code in the top part of the file so that the
|
|
bottom can be use unchanged across all platforms.
|
|
|
|
Second, #define all the operations in each size class that are
|
|
supported. Doing this allows supported operations to be used along
|
|
side of emulated operations.
|
|
*/
|
|
|
|
/*
|
|
Emmulated version.
|
|
|
|
Assume there is no support for atomic operations. All such
|
|
operations are implemented using SDL mutex operations.
|
|
*/
|
|
|
|
#ifdef EMULATED_ATOMIC_OPERATIONS
|
|
#undef EMULATED_ATOMIC_OPERATIONS
|
|
#endif
|
|
|
|
#ifdef EMULATED_ATOMIC_OPERATIONS
|
|
#define HAVE_ALL_8_BIT_OPS
|
|
|
|
#define nativeExchange8(ptr, value) ()
|
|
#define nativeCompareThenSet8(ptr, oldvalue, newvalue) ()
|
|
#define nativeTestThenSet8(ptr) ()
|
|
#define nativeClear8(ptr) ()
|
|
#define nativeFetchThenIncrement8(ptr) ()
|
|
#define nativeFetchThenDecrement8(ptr) ()
|
|
#define nativeFetchThenAdd8(ptr, value) ()
|
|
#define nativeFetchThenSubtract8(ptr, value) ()
|
|
#define nativeIncrementThenFetch8(ptr) ()
|
|
#define nativeDecrementThenFetch8(ptr) ()
|
|
#define nativeAddThenFetch8(ptr, value) ()
|
|
#define nativeSubtractThenFetch8(ptr, value) ()
|
|
#endif
|
|
|
|
#ifdef EMULATED_ATOMIC_OPERATIONS
|
|
#define HAVE_ALL_16_BIT_OPS
|
|
|
|
#define nativeExchange16(ptr, value) ()
|
|
#define nativeCompareThenSet16(ptr, oldvalue, newvalue) ()
|
|
#define nativeTestThenSet16(ptr) ()
|
|
#define nativeClear16(ptr) ()
|
|
#define nativeFetchThenIncrement16(ptr) ()
|
|
#define nativeFetchThenDecrement16(ptr) ()
|
|
#define nativeFetchThenAdd16(ptr, value) ()
|
|
#define nativeFetchThenSubtract16(ptr, value) ()
|
|
#define nativeIncrementThenFetch16(ptr) ()
|
|
#define nativeDecrementThenFetch16(ptr) ()
|
|
#define nativeAddThenFetch16(ptr, value) ()
|
|
#define nativeSubtractThenFetch16(ptr, value) ()
|
|
#endif
|
|
|
|
#ifdef EMULATED_ATOMIC_OPERATIONS
|
|
#define HAVE_ALL_32_BIT_OPS
|
|
|
|
#define nativeExchange32(ptr, value) ()
|
|
#define nativeCompareThenSet32(ptr, oldvalue, newvalue) ()
|
|
#define nativeTestThenSet32(ptr) ()
|
|
#define nativeClear32(ptr) ()
|
|
#define nativeFetchThenIncrement32(ptr) ()
|
|
#define nativeFetchThenDecrement32(ptr) ()
|
|
#define nativeFetchThenAdd32(ptr, value) ()
|
|
#define nativeFetchThenSubtract32(ptr, value) ()
|
|
#define nativeIncrementThenFetch32(ptr) ()
|
|
#define nativeDecrementThenFetch32(ptr) ()
|
|
#define nativeAddThenFetch32(ptr, value) ()
|
|
#define nativeSubtractThenFetch32(ptr, value) ()
|
|
#endif
|
|
|
|
#ifdef EMULATED_ATOMIC_OPERATIONS
|
|
#define HAVE_ALL_64_BIT_OPS
|
|
|
|
#define nativeExchange64(ptr, value) ()
|
|
#define nativeCompareThenSet64(ptr, oldvalue, newvalue) ()
|
|
#define nativeTestThenSet64(ptr) ()
|
|
#define nativeClear64(ptr) ()
|
|
#define nativeFetchThenIncrement64(ptr) ()
|
|
#define nativeFetchThenDecrement64(ptr) ()
|
|
#define nativeFetchThenAdd64(ptr, value) ()
|
|
#define nativeFetchThenSubtract64(ptr, value) ()
|
|
#define nativeIncrementThenFetch64(ptr) ()
|
|
#define nativeDecrementThenFetch64(ptr) ()
|
|
#define nativeAddThenFetch64(ptr, value) ()
|
|
#define nativeSubtractThenFetch64(ptr, value) ()
|
|
#endif
|
|
|
|
/*
|
|
If any of the operations are not provided then we must emulate some of
|
|
them.
|
|
*/
|
|
|
|
#if !defined(HAVE_ALL_8_BIT_OPS) || !defined(HAVE_ALL_16_BIT_OPS) || !defined(HAVE_ALL_32_BIT_OPS) || !defined(HAVE_ALL_64_BIT_OPS)
|
|
|
|
#include "SDL_mutex.h"
|
|
#include "SDL_error.h"
|
|
|
|
static SDL_mutex * lock = NULL;
|
|
|
|
static __inline__ void
|
|
privateWaitLock()
|
|
{
|
|
if(NULL == lock)
|
|
{
|
|
lock = SDL_CreateMutex();
|
|
if (NULL == lock)
|
|
{
|
|
SDL_SetError("SDL_atomic.c: can't create a mutex");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (-1 == SDL_LockMutex(lock))
|
|
{
|
|
SDL_SetError("SDL_atomic.c: can't lock mutex");
|
|
}
|
|
}
|
|
|
|
static __inline__ void
|
|
privateUnlock()
|
|
{
|
|
if (-1 == SDL_UnlockMutex(lock))
|
|
{
|
|
SDL_SetError("SDL_atomic.c: can't unlock mutex");
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
/* 8 bit atomic operations */
|
|
|
|
Uint8
|
|
SDL_AtomicExchange8(Uint8 * ptr, Uint8 value)
|
|
{
|
|
#ifdef nativeExchange8
|
|
return nativeExchange8(ptr, value);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
*ptr = value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicCompareThenSet8(Uint8 * ptr, Uint8 oldvalue, Uint8 newvalue)
|
|
{
|
|
#ifdef nativeCompareThenSet8
|
|
return (SDL_bool)nativeCompareThenSet8(ptr, oldvalue, newvalue);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == oldvalue);
|
|
if (result)
|
|
{
|
|
*ptr = newvalue;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicTestThenSet8(Uint8 * ptr)
|
|
{
|
|
#ifdef nativeTestThenSet8
|
|
return (SDL_bool)nativeTestThenSet8(ptr);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == 0);
|
|
if (result)
|
|
{
|
|
*ptr = 1;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
SDL_AtomicClear8(Uint8 * ptr)
|
|
{
|
|
#ifdef nativeClear8
|
|
nativeClear8(ptr);
|
|
#else
|
|
privateWaitLock();
|
|
*ptr = 0;
|
|
privateUnlock();
|
|
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicFetchThenIncrement8(Uint8 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenIncrement8
|
|
return nativeFetchThenIncrement8(ptr);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicFetchThenDecrement8(Uint8 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenDecrement8
|
|
return nativeFetchThenDecrement8(ptr);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr) -= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicFetchThenAdd8(Uint8 * ptr, Uint8 value)
|
|
{
|
|
#ifdef nativeFetchThenAdd8
|
|
return nativeFetchThenAdd8(ptr, value);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicFetchThenSubtract8(Uint8 * ptr, Uint8 value)
|
|
{
|
|
#ifdef nativeFetchThenSubtract8
|
|
return nativeFetchThenSubtract8(ptr, value);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)-= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicIncrementThenFetch8(Uint8 * ptr)
|
|
{
|
|
#ifdef nativeIncrementThenFetch8
|
|
return nativeIncrementThenFetch8(ptr);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicDecrementThenFetch8(Uint8 * ptr)
|
|
{
|
|
#ifdef nativeDecrementThenFetch8
|
|
return nativeDecrementThenFetch8(ptr);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicAddThenFetch8(Uint8 * ptr, Uint8 value)
|
|
{
|
|
#ifdef nativeAddThenFetch8
|
|
return nativeAddThenFetch8(ptr, value);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint8
|
|
SDL_AtomicSubtractThenFetch8(Uint8 * ptr, Uint8 value)
|
|
{
|
|
#ifdef nativeSubtractThenFetch8
|
|
return nativeSubtractThenFetch8(ptr, value);
|
|
#else
|
|
Uint8 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
/* 16 bit atomic operations */
|
|
|
|
Uint16
|
|
SDL_AtomicExchange16(Uint16 * ptr, Uint16 value)
|
|
{
|
|
#ifdef nativeExchange16
|
|
return nativeExchange16(ptr, value);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
*ptr = value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicCompareThenSet16(Uint16 * ptr, Uint16 oldvalue, Uint16 newvalue)
|
|
{
|
|
#ifdef nativeCompareThenSet16
|
|
return (SDL_bool)nativeCompareThenSet16(ptr, oldvalue, newvalue);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == oldvalue);
|
|
if (result)
|
|
{
|
|
*ptr = newvalue;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicTestThenSet16(Uint16 * ptr)
|
|
{
|
|
#ifdef nativeTestThenSet16
|
|
return (SDL_bool)nativeTestThenSet16(ptr);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == 0);
|
|
if (result)
|
|
{
|
|
*ptr = 1;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
SDL_AtomicClear16(Uint16 * ptr)
|
|
{
|
|
#ifdef nativeClear16
|
|
nativeClear16(ptr);
|
|
#else
|
|
privateWaitLock();
|
|
*ptr = 0;
|
|
privateUnlock();
|
|
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicFetchThenIncrement16(Uint16 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenIncrement16
|
|
return nativeFetchThenIncrement16(ptr);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicFetchThenDecrement16(Uint16 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenDecrement16
|
|
return nativeFetchThenDecrement16(ptr);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr) -= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicFetchThenAdd16(Uint16 * ptr, Uint16 value)
|
|
{
|
|
#ifdef nativeFetchThenAdd16
|
|
return nativeFetchThenAdd16(ptr, value);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicFetchThenSubtract16(Uint16 * ptr, Uint16 value)
|
|
{
|
|
#ifdef nativeFetchThenSubtract16
|
|
return nativeFetchThenSubtract16(ptr, value);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)-= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicIncrementThenFetch16(Uint16 * ptr)
|
|
{
|
|
#ifdef nativeIncrementThenFetch16
|
|
return nativeIncrementThenFetch16(ptr);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicDecrementThenFetch16(Uint16 * ptr)
|
|
{
|
|
#ifdef nativeDecrementThenFetch16
|
|
return nativeDecrementThenFetch16(ptr);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicAddThenFetch16(Uint16 * ptr, Uint16 value)
|
|
{
|
|
#ifdef nativeAddThenFetch16
|
|
return nativeAddThenFetch16(ptr, value);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint16
|
|
SDL_AtomicSubtractThenFetch16(Uint16 * ptr, Uint16 value)
|
|
{
|
|
#ifdef nativeSubtractThenFetch16
|
|
return nativeSubtractThenFetch16(ptr, value);
|
|
#else
|
|
Uint16 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
/* 32 bit atomic operations */
|
|
|
|
Uint32
|
|
SDL_AtomicExchange32(Uint32 * ptr, Uint32 value)
|
|
{
|
|
#ifdef nativeExchange32
|
|
return nativeExchange32(ptr, value);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
*ptr = value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicCompareThenSet32(Uint32 * ptr, Uint32 oldvalue, Uint32 newvalue)
|
|
{
|
|
#ifdef nativeCompareThenSet32
|
|
return (SDL_bool)nativeCompareThenSet32(ptr, oldvalue, newvalue);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == oldvalue);
|
|
if (result)
|
|
{
|
|
*ptr = newvalue;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicTestThenSet32(Uint32 * ptr)
|
|
{
|
|
#ifdef nativeTestThenSet32
|
|
return (SDL_bool)nativeTestThenSet32(ptr);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == 0);
|
|
if (result)
|
|
{
|
|
*ptr = 1;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
SDL_AtomicClear32(Uint32 * ptr)
|
|
{
|
|
#ifdef nativeClear32
|
|
nativeClear32(ptr);
|
|
#else
|
|
privateWaitLock();
|
|
*ptr = 0;
|
|
privateUnlock();
|
|
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicFetchThenIncrement32(Uint32 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenIncrement32
|
|
return nativeFetchThenIncrement32(ptr);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicFetchThenDecrement32(Uint32 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenDecrement32
|
|
return nativeFetchThenDecrement32(ptr);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr) -= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicFetchThenAdd32(Uint32 * ptr, Uint32 value)
|
|
{
|
|
#ifdef nativeFetchThenAdd32
|
|
return nativeFetchThenAdd32(ptr, value);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicFetchThenSubtract32(Uint32 * ptr, Uint32 value)
|
|
{
|
|
#ifdef nativeFetchThenSubtract32
|
|
return nativeFetchThenSubtract32(ptr, value);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)-= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicIncrementThenFetch32(Uint32 * ptr)
|
|
{
|
|
#ifdef nativeIncrementThenFetch32
|
|
return nativeIncrementThenFetch32(ptr);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicDecrementThenFetch32(Uint32 * ptr)
|
|
{
|
|
#ifdef nativeDecrementThenFetch32
|
|
return nativeDecrementThenFetch32(ptr);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicAddThenFetch32(Uint32 * ptr, Uint32 value)
|
|
{
|
|
#ifdef nativeAddThenFetch32
|
|
return nativeAddThenFetch32(ptr, value);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint32
|
|
SDL_AtomicSubtractThenFetch32(Uint32 * ptr, Uint32 value)
|
|
{
|
|
#ifdef nativeSubtractThenFetch32
|
|
return nativeSubtractThenFetch32(ptr, value);
|
|
#else
|
|
Uint32 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
/* 64 bit atomic operations */
|
|
#ifdef SDL_HAS_64BIT_TYPE
|
|
|
|
Uint64
|
|
SDL_AtomicExchange64(Uint64 * ptr, Uint64 value)
|
|
{
|
|
#ifdef nativeExchange64
|
|
return nativeExchange64(ptr, value);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
*ptr = value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicCompareThenSet64(Uint64 * ptr, Uint64 oldvalue, Uint64 newvalue)
|
|
{
|
|
#ifdef nativeCompareThenSet64
|
|
return (SDL_bool)nativeCompareThenSet64(ptr, oldvalue, newvalue);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == oldvalue);
|
|
if (result)
|
|
{
|
|
*ptr = newvalue;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
SDL_bool
|
|
SDL_AtomicTestThenSet64(Uint64 * ptr)
|
|
{
|
|
#ifdef nativeTestThenSet64
|
|
return (SDL_bool)nativeTestThenSet64(ptr);
|
|
#else
|
|
SDL_bool result = SDL_FALSE;
|
|
|
|
privateWaitLock();
|
|
result = (*ptr == 0);
|
|
if (result)
|
|
{
|
|
*ptr = 1;
|
|
}
|
|
privateUnlock();
|
|
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
SDL_AtomicClear64(Uint64 * ptr)
|
|
{
|
|
#ifdef nativeClear64
|
|
nativeClear64(ptr);
|
|
#else
|
|
privateWaitLock();
|
|
*ptr = 0;
|
|
privateUnlock();
|
|
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicFetchThenIncrement64(Uint64 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenIncrement64
|
|
return nativeFetchThenIncrement64(ptr);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicFetchThenDecrement64(Uint64 * ptr)
|
|
{
|
|
#ifdef nativeFetchThenDecrement64
|
|
return nativeFetchThenDecrement64(ptr);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr) -= 1;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicFetchThenAdd64(Uint64 * ptr, Uint64 value)
|
|
{
|
|
#ifdef nativeFetchThenAdd64
|
|
return nativeFetchThenAdd64(ptr, value);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)+= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicFetchThenSubtract64(Uint64 * ptr, Uint64 value)
|
|
{
|
|
#ifdef nativeFetchThenSubtract64
|
|
return nativeFetchThenSubtract64(ptr, value);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
tmp = *ptr;
|
|
(*ptr)-= value;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicIncrementThenFetch64(Uint64 * ptr)
|
|
{
|
|
#ifdef nativeIncrementThenFetch64
|
|
return nativeIncrementThenFetch64(ptr);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicDecrementThenFetch64(Uint64 * ptr)
|
|
{
|
|
#ifdef nativeDecrementThenFetch64
|
|
return nativeDecrementThenFetch64(ptr);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= 1;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicAddThenFetch64(Uint64 * ptr, Uint64 value)
|
|
{
|
|
#ifdef nativeAddThenFetch64
|
|
return nativeAddThenFetch64(ptr, value);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)+= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
|
|
Uint64
|
|
SDL_AtomicSubtractThenFetch64(Uint64 * ptr, Uint64 value)
|
|
{
|
|
#ifdef nativeSubtractThenFetch64
|
|
return nativeSubtractThenFetch64(ptr, value);
|
|
#else
|
|
Uint64 tmp = 0;;
|
|
|
|
privateWaitLock();
|
|
(*ptr)-= value;
|
|
tmp = *ptr;
|
|
privateUnlock();
|
|
|
|
return tmp;
|
|
#endif
|
|
}
|
|
#endif
|
|
|