Mercurial > sdl-ios-xcode
changeset 3202:3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
/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. :-)
| author | Bob Pendleton <bob@pendleton.com> |
|---|---|
| date | Mon, 29 Jun 2009 19:54:43 +0000 |
| parents | c297230efc75 |
| children | 790cbbda6429 |
| files | include/SDL_atomic.h src/atomic/dummy/SDL_atomic.c src/atomic/linux/SDL_atomic.c src/atomic/macosx/SDL_atomic.c src/atomic/win32/SDL_atomic.c test/testatomic.c |
| diffstat | 6 files changed, 3776 insertions(+), 160 deletions(-) [+] |
line wrap: on
line diff
--- a/include/SDL_atomic.h Wed Jun 24 22:24:23 2009 +0000 +++ b/include/SDL_atomic.h Mon Jun 29 19:54:43 2009 +0000 @@ -29,7 +29,6 @@ #ifndef _SDL_atomic_h_ #define _SDL_atomic_h_ - #include "SDL_stdinc.h" #include "SDL_platform.h" @@ -42,72 +41,51 @@ /* *INDENT-ON* */ #endif -/* *INDENT-OFF* */ /** - * \def SDL_AtomicBusyWait32 (ptr) - * - * \brief Implements a simple busy wait for use with - * SDL_AtomicTestThenSet and SDL_AtomicClear. - * - * Note: This can be an infinite loop. - * - */ -#define SDL_AtomicBusyWait32(ptr) \ - { \ - while (!SDL_AtomicTestThenSet32(ptr) \ - { \ - }; \ - }; - -/** - * \def SDL_AtomicWait32(ptr) - * - * \brief A safer way to wait for a test-then-set lock to be cleared. - * - * This assumes that the SDL_Sleep(0) call acts as a thread_yeild - * operation. - * + * 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. In rare cases they may be implemented + * using SDL's mutex fuctions. */ -#define SDL_AtomicWait32(ptr) \ - { \ - while (!SDL_AtomicTestThenSet32(ptr) \ - { \ - SDL_Sleep(0); \ - }; \ - }; - -/** - * \def SDL_AtomicBusyWait64(ptr) - * - * \brief 64 bit version of busy wait - * - * \sa SDL_AtomicBusyWait32 - */ -#define SDL_AtomicBusyWait64(ptr) \ - { \ - while (!SDL_AtomicTestThenSet64(ptr) \ - { \ - }; \ - }; - -/** - * \def SDL_AtomicWait64(ptr) - * - * \brief 64 bit version of SDL_AtomicWait32 - * - * \sa SDL_AtomicWait32 - */ -#define SDL_AtomicWait64(ptr) \ - { \ - while (!SDL_AtomicTestThenSet64(ptr) \ - { \ - SDL_Sleep(0); \ - }; \ - }; -/* *INDENT-ON* */ /* Function prototypes */ +/* 8 bit atomic operations */ + +extern DECLSPEC Uint8 SDLCALL SDL_AtomicExchange8(Uint8 * ptr, Uint8 value); +extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareThenSet8(Uint8 * ptr, + Uint8 oldvalue, Uint8 newvalue); +extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet8(Uint8 * ptr); +extern DECLSPEC void SDLCALL SDL_AtomicClear8(Uint8 * ptr); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicFetchThenIncrement8(Uint8 * ptr); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicFetchThenDecrement8(Uint8 * ptr); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicFetchThenAdd8(Uint8 * ptr, Uint8 value); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicFetchThenSubtract8(Uint8 * ptr, Uint8 value); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicIncrementThenFetch8(Uint8 * ptr); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicDecrementThenFetch8(Uint8 * ptr); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicAddThenFetch8(Uint8 * ptr, Uint8 value); +extern DECLSPEC Uint8 SDLCALL SDL_AtomicSubtractThenFetch8(Uint8 * ptr, Uint8 value); + +/* 16 bit atomic operations */ + +extern DECLSPEC Uint16 SDLCALL SDL_AtomicExchange16(Uint16 * ptr, Uint16 value); +extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareThenSet16(Uint16 * ptr, + Uint16 oldvalue, Uint16 newvalue); +extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet16(Uint16 * ptr); +extern DECLSPEC void SDLCALL SDL_AtomicClear16(Uint16 * ptr); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicFetchThenIncrement16(Uint16 * ptr); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicFetchThenDecrement16(Uint16 * ptr); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicFetchThenAdd16(Uint16 * ptr, Uint16 value); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicFetchThenSubtract16(Uint16 * ptr, Uint16 value); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicIncrementThenFetch16(Uint16 * ptr); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicDecrementThenFetch16(Uint16 * ptr); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicAddThenFetch16(Uint16 * ptr, Uint16 value); +extern DECLSPEC Uint16 SDLCALL SDL_AtomicSubtractThenFetch16(Uint16 * ptr, Uint16 value); + +/* 32 bit atomic operations */ + /** * \fn int SDL_AtomicExchange32(Uint32 * ptr, Uint32 value) * @@ -252,6 +230,7 @@ */ extern DECLSPEC Uint32 SDLCALL SDL_AtomicSubtractThenFetch32(Uint32 * ptr, Uint32 value); +/* 64 bit atomic operations */ #ifdef SDL_HAS_64BIT_TYPE extern DECLSPEC Uint64 SDLCALL SDL_AtomicExchange64(Uint64 * ptr, Uint64 value); @@ -267,7 +246,7 @@ extern DECLSPEC Uint64 SDLCALL SDL_AtomicDecrementThenFetch64(Uint64 * ptr); extern DECLSPEC Uint64 SDLCALL SDL_AtomicAddThenFetch64(Uint64 * ptr, Uint64 value); extern DECLSPEC Uint64 SDLCALL SDL_AtomicSubtractThenFetch64(Uint64 * ptr, Uint64 value); -#endif +#endif /* SDL_HAS_64BIT_TYPE */ /* Ends C function definitions when using C++ */ #ifdef __cplusplus
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/atomic/dummy/SDL_atomic.c Mon Jun 29 19:54:43 2009 +0000 @@ -0,0 +1,1002 @@ +/* + 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 +
--- a/src/atomic/linux/SDL_atomic.c Wed Jun 24 22:24:23 2009 +0000 +++ b/src/atomic/linux/SDL_atomic.c Mon Jun 29 19:54:43 2009 +0000 @@ -20,154 +20,955 @@ slouken@libsdl.org */ -#include "SDL.h" -#include "SDL_config.h" +#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. +*/ + +/* + Linux version. + + Test for gnu C builtin support for atomic operations. The only way + I know of is to check to see if the + __GCC_HAVE_SYNC_COMPARE_AND_SWAP_* macros are defined. + */ + +#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 +#define HAVE_ALL_8_BIT_OPS + +#define nativeExchange8(ptr, value) (__sync_lock_test_and_set(ptr, value)) +#define nativeCompareThenSet8(ptr, oldvalue, newvalue) (oldvalue == __sync_val_compare_and_swap(ptr, oldvalue, newvalue)) +#define nativeTestThenSet8(ptr) (0 == __sync_lock_test_and_set(ptr, 1)) +#define nativeClear8(ptr) (__sync_lock_release(ptr)) +#define nativeFetchThenIncrement8(ptr) (__sync_fetch_and_add(ptr, 1)) +#define nativeFetchThenDecrement8(ptr) (__sync_fetch_and_sub(ptr, 1)) +#define nativeFetchThenAdd8(ptr, value) (__sync_fetch_and_add(ptr, value)) +#define nativeFetchThenSubtract8(ptr, value) (__sync_fetch_and_sub(ptr, value)) +#define nativeIncrementThenFetch8(ptr) (__sync_add_and_fetch(ptr, 1)) +#define nativeDecrementThenFetch8(ptr) (__sync_sub_and_fetch(ptr, 1)) +#define nativeAddThenFetch8(ptr, value) (__sync_add_and_fetch(ptr, value)) +#define nativeSubtractThenFetch8(ptr, value) (__sync_sub_and_fetch(ptr, value)) +#endif + +#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 +#define HAVE_ALL_16_BIT_OPS + +#define nativeExchange16(ptr, value) (__sync_lock_test_and_set(ptr, value)) +#define nativeCompareThenSet16(ptr, oldvalue, newvalue) (oldvalue == __sync_val_compare_and_swap(ptr, oldvalue, newvalue)) +#define nativeTestThenSet16(ptr) (0 == __sync_lock_test_and_set(ptr, 1)) +#define nativeClear16(ptr) (__sync_lock_release(ptr)) +#define nativeFetchThenIncrement16(ptr) (__sync_fetch_and_add(ptr, 1)) +#define nativeFetchThenDecrement16(ptr) (__sync_fetch_and_sub(ptr, 1)) +#define nativeFetchThenAdd16(ptr, value) (__sync_fetch_and_add(ptr, value)) +#define nativeFetchThenSubtract16(ptr, value) (__sync_fetch_and_sub(ptr, value)) +#define nativeIncrementThenFetch16(ptr) (__sync_add_and_fetch(ptr, 1)) +#define nativeDecrementThenFetch16(ptr) (__sync_sub_and_fetch(ptr, 1)) +#define nativeAddThenFetch16(ptr, value) (__sync_add_and_fetch(ptr, value)) +#define nativeSubtractThenFetch16(ptr, value) (__sync_sub_and_fetch(ptr, value)) +#endif + +#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 +#define HAVE_ALL_32_BIT_OPS + +#define nativeExchange32(ptr, value) (__sync_lock_test_and_set(ptr, value)) +#define nativeCompareThenSet32(ptr, oldvalue, newvalue) (oldvalue == __sync_val_compare_and_swap(ptr, oldvalue, newvalue)) +#define nativeTestThenSet32(ptr) (0 == __sync_lock_test_and_set(ptr, 1)) +#define nativeClear32(ptr) (__sync_lock_release(ptr)) +#define nativeFetchThenIncrement32(ptr) (__sync_fetch_and_add(ptr, 1)) +#define nativeFetchThenDecrement32(ptr) (__sync_fetch_and_sub(ptr, 1)) +#define nativeFetchThenAdd32(ptr, value) (__sync_fetch_and_add(ptr, value)) +#define nativeFetchThenSubtract32(ptr, value) (__sync_fetch_and_sub(ptr, value)) +#define nativeIncrementThenFetch32(ptr) (__sync_add_and_fetch(ptr, 1)) +#define nativeDecrementThenFetch32(ptr) (__sync_sub_and_fetch(ptr, 1)) +#define nativeAddThenFetch32(ptr, value) (__sync_add_and_fetch(ptr, value)) +#define nativeSubtractThenFetch32(ptr, value) (__sync_sub_and_fetch(ptr, value)) +#endif + +#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 +#define HAVE_ALL_64_BIT_OPS + +#define nativeExchange64(ptr, value) (__sync_lock_test_and_set(ptr, value)) +#define nativeCompareThenSet64(ptr, oldvalue, newvalue) (oldvalue == __sync_val_compare_and_swap(ptr, oldvalue, newvalue)) +#define nativeTestThenSet64(ptr) (0 == __sync_lock_test_and_set(ptr, 1)) +#define nativeClear64(ptr) (__sync_lock_release(ptr)) +#define nativeFetchThenIncrement64(ptr) (__sync_fetch_and_add(ptr, 1)) +#define nativeFetchThenDecrement64(ptr) (__sync_fetch_and_sub(ptr, 1)) +#define nativeFetchThenAdd64(ptr, value) (__sync_fetch_and_add(ptr, value)) +#define nativeFetchThenSubtract64(ptr, value) (__sync_fetch_and_sub(ptr, value)) +#define nativeIncrementThenFetch64(ptr) (__sync_add_and_fetch(ptr, 1)) +#define nativeDecrementThenFetch64(ptr) (__sync_sub_and_fetch(ptr, 1)) +#define nativeAddThenFetch64(ptr, value) (__sync_add_and_fetch(ptr, value)) +#define nativeSubtractThenFetch64(ptr, value) (__sync_sub_and_fetch(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) + +static Uint32 lock = 0; + +#define privateWaitLock() \ + while (nativeTestThenSet32(&lock)) \ + { \ + }; + +#define privateUnlock() (nativeClear32(&lock)) +#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) { - return __sync_lock_test_and_set(ptr, 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) { - return (SDL_bool)__sync_bool_compare_and_swap(ptr, oldvalue, 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) { - return (SDL_bool)(0 == __sync_lock_test_and_set(ptr, 1)); +#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) { - __sync_lock_release(ptr); +#ifdef nativeClear32 + nativeClear32(ptr); +#else + privateWaitLock(); + *ptr = 0; + privateUnlock(); + + return; +#endif } Uint32 SDL_AtomicFetchThenIncrement32(Uint32 * ptr) { - return __sync_fetch_and_add(ptr, 1); +#ifdef nativeFetchThenIncrement32 + return nativeFetchThenIncrement32(ptr); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)+= 1; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicFetchThenDecrement32(Uint32 * ptr) { - return __sync_fetch_and_sub(ptr, 1); +#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) { - return __sync_fetch_and_add(ptr, 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) { - return __sync_fetch_and_sub(ptr, 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) { - return __sync_add_and_fetch(ptr, 1); +#ifdef nativeIncrementThenFetch32 + return nativeIncrementThenFetch32(ptr); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + (*ptr)+= 1; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicDecrementThenFetch32(Uint32 * ptr) { - return __sync_sub_and_fetch(ptr, 1); +#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) { - return __sync_add_and_fetch(ptr, 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) { - return __sync_sub_and_fetch(ptr, value); +#ifdef nativeSubtractThenFetch32 + return nativeSubtractThenFetch32(ptr, value); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + (*ptr)-= value; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } -/* #ifdef SDL_HAS_64BIT_TYPE */ -#if 0 +/* 64 bit atomic operations */ +#ifdef SDL_HAS_64BIT_TYPE Uint64 SDL_AtomicExchange64(Uint64 * ptr, Uint64 value) { - return __sync_lock_test_and_set(ptr, 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) { - return (SDL_bool)__sync_bool_compare_and_swap(ptr, oldvalue, 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) { - return (SDL_bool)(0 == __sync_lock_test_and_set(ptr, 1)); +#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) { - __sync_lock_release(ptr); +#ifdef nativeClear64 + nativeClear64(ptr); +#else + privateWaitLock(); + *ptr = 0; + privateUnlock(); + + return; +#endif } Uint64 SDL_AtomicFetchThenIncrement64(Uint64 * ptr) { - return __sync_fetch_and_add(ptr, 1); +#ifdef nativeFetchThenIncrement64 + return nativeFetchThenIncrement64(ptr); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)+= 1; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicFetchThenDecrement64(Uint64 * ptr) { - return __sync_fetch_and_sub(ptr, 1); +#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) { - return __sync_fetch_and_add(ptr, 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) { - return __sync_fetch_and_sub(ptr, 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) { - return __sync_add_and_fetch(ptr, 1); +#ifdef nativeIncrementThenFetch64 + return nativeIncrementThenFetch64(ptr); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + (*ptr)+= 1; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicDecrementThenFetch64(Uint64 * ptr) { - return __sync_sub_and_fetch(ptr, 1); +#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) { - return __sync_add_and_fetch(ptr, 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) { - return __sync_sub_and_fetch(ptr, value); +#ifdef nativeSubtractThenFetch64 + return nativeSubtractThenFetch64(ptr, value); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + (*ptr)-= value; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } #endif +
--- a/src/atomic/macosx/SDL_atomic.c Wed Jun 24 22:24:23 2009 +0000 +++ b/src/atomic/macosx/SDL_atomic.c Mon Jun 29 19:54:43 2009 +0000 @@ -20,157 +20,983 @@ slouken@libsdl.org */ -#ifdef SDL_ATOMIC_LINUX +#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(); -#include "SDL.h" -#include "SDL_config.h" -#include "SDL_atomic.h" + 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) { - return 0; +#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) { - return SDL_false; +#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) { - return SDL_false; +#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) { - return 0; +#ifdef nativeFetchThenIncrement32 + return nativeFetchThenIncrement32(ptr); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)+= 1; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicFetchThenDecrement32(Uint32 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; +#ifdef nativeFetchThenSubtract32 + return nativeFetchThenSubtract32(ptr, value); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)-= value; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicIncrementThenFetch32(Uint32 * ptr) { - return 0; +#ifdef nativeIncrementThenFetch32 + return nativeIncrementThenFetch32(ptr); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + (*ptr)+= 1; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicDecrementThenFetch32(Uint32 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; +#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) { - return 0; +#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) +SDL_AtomicCompareThenSet64(Uint64 * ptr, Uint64 oldvalue, Uint64 newvalue) { - return SDL_false; +#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) { - return SDL_false; +#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) { - return 0; +#ifdef nativeFetchThenIncrement64 + return nativeFetchThenIncrement64(ptr); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)+= 1; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicFetchThenDecrement64(Uint64 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; +#ifdef nativeFetchThenSubtract64 + return nativeFetchThenSubtract64(ptr, value); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)-= value; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicIncrementThenFetch64(Uint64 * ptr) { - return 0; +#ifdef nativeIncrementThenFetch64 + return nativeIncrementThenFetch64(ptr); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + (*ptr)+= 1; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicDecrementThenFetch64(Uint64 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; -} +#ifdef nativeSubtractThenFetch64 + return nativeSubtractThenFetch64(ptr, value); +#else + Uint64 tmp = 0;; + privateWaitLock(); + (*ptr)-= value; + tmp = *ptr; + privateUnlock(); + + return tmp; #endif +} #endif +
--- a/src/atomic/win32/SDL_atomic.c Wed Jun 24 22:24:23 2009 +0000 +++ b/src/atomic/win32/SDL_atomic.c Mon Jun 29 19:54:43 2009 +0000 @@ -20,157 +20,983 @@ slouken@libsdl.org */ -#ifdef SDL_ATOMIC_LINUX +#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(); -#include "SDL.h" -#include "SDL_config.h" -#include "SDL_atomic.h" + 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) { - return 0; +#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) { - return SDL_false; +#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) { - return SDL_false; +#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) { - return 0; +#ifdef nativeFetchThenIncrement32 + return nativeFetchThenIncrement32(ptr); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)+= 1; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicFetchThenDecrement32(Uint32 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; +#ifdef nativeFetchThenSubtract32 + return nativeFetchThenSubtract32(ptr, value); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)-= value; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicIncrementThenFetch32(Uint32 * ptr) { - return 0; +#ifdef nativeIncrementThenFetch32 + return nativeIncrementThenFetch32(ptr); +#else + Uint32 tmp = 0;; + + privateWaitLock(); + (*ptr)+= 1; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } Uint32 SDL_AtomicDecrementThenFetch32(Uint32 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; +#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) { - return 0; +#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) +SDL_AtomicCompareThenSet64(Uint64 * ptr, Uint64 oldvalue, Uint64 newvalue) { - return SDL_false; +#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) { - return SDL_false; +#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) { - return 0; +#ifdef nativeFetchThenIncrement64 + return nativeFetchThenIncrement64(ptr); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)+= 1; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicFetchThenDecrement64(Uint64 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; +#ifdef nativeFetchThenSubtract64 + return nativeFetchThenSubtract64(ptr, value); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + tmp = *ptr; + (*ptr)-= value; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicIncrementThenFetch64(Uint64 * ptr) { - return 0; +#ifdef nativeIncrementThenFetch64 + return nativeIncrementThenFetch64(ptr); +#else + Uint64 tmp = 0;; + + privateWaitLock(); + (*ptr)+= 1; + tmp = *ptr; + privateUnlock(); + + return tmp; +#endif } Uint64 SDL_AtomicDecrementThenFetch64(Uint64 * ptr) { - return 0; +#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) { - return 0; +#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) { - return 0; -} +#ifdef nativeSubtractThenFetch64 + return nativeSubtractThenFetch64(ptr, value); +#else + Uint64 tmp = 0;; + privateWaitLock(); + (*ptr)-= value; + tmp = *ptr; + privateUnlock(); + + return tmp; #endif +} #endif +
--- a/test/testatomic.c Wed Jun 24 22:24:23 2009 +0000 +++ b/test/testatomic.c Mon Jun 29 19:54:43 2009 +0000 @@ -1,50 +1,232 @@ #include "SDL.h" /* - Absolutely basic test just to see if we get the expected value after - calling each function. + Absolutely basic tests just to see if we get the expected value + after calling each function. */ +char * +tf(SDL_bool tf) +{ + static char *t = "true"; + static char *f = "false"; + + if (tf) + { + return t; + } + + return f; +} + int main(int argc, char **argv) { + Uint8 val8 = 0; + Uint8 ret8 = 0; + + Uint16 val16 = 0; + Uint16 ret16 = 0; + Uint32 val32 = 0; Uint32 ret32 = 0; Uint64 val64 = 0; Uint64 ret64 = 0; - SDL_bool tfval = SDL_FALSE; + SDL_bool tfret = SDL_FALSE; + + + printf("8 bit -----------------------------------------\n\n"); + + ret8 = SDL_AtomicExchange8(&val8, 10); + printf("Exchange8 ret=%d val=%d\n", ret8, val8); + ret8 = SDL_AtomicExchange8(&val8, 0); + printf("Exchange8 ret=%d val=%d\n", ret8, val8); + + val8 = 10; + tfret = SDL_AtomicCompareThenSet8(&val8, 10, 20); + printf("CompareThenSet8 tfret=%s val=%d\n", tf(tfret), val8); + val8 = 10; + tfret = SDL_AtomicCompareThenSet8(&val8, 0, 20); + printf("CompareThenSet8 tfret=%s val=%d\n", tf(tfret), val8); + + val8 = 0; + tfret = SDL_AtomicTestThenSet8(&val8); + printf("TestThenSet8 tfret=%s val=%d\n", tf(tfret), val8); + tfret = SDL_AtomicTestThenSet8(&val8); + printf("TestThenSet8 tfret=%s val=%d\n", tf(tfret), val8); + + SDL_AtomicClear8(&val8); + printf("Clear8 val=%d\n", val8); + + ret8 = SDL_AtomicFetchThenIncrement8(&val8); + printf("FetchThenIncrement8 ret=%d val=%d\n", ret8, val8); + + ret8 = SDL_AtomicFetchThenDecrement8(&val8); + printf("FetchThenDecrement8 ret=%d val=%d\n", ret8, val8); + + ret8 = SDL_AtomicFetchThenAdd8(&val8, 10); + printf("FetchThenAdd8 ret=%d val=%d\n", ret8, val8); + + ret8 = SDL_AtomicFetchThenSubtract8(&val8, 10); + printf("FetchThenSubtract8 ret=%d val=%d\n", ret8, val8); + + ret8 = SDL_AtomicIncrementThenFetch8(&val8); + printf("IncrementThenFetch8 ret=%d val=%d\n", ret8, val8); + + ret8 = SDL_AtomicDecrementThenFetch8(&val8); + printf("DecrementThenFetch8 ret=%d val=%d\n", ret8, val8); + + ret8 = SDL_AtomicAddThenFetch8(&val8, 10); + printf("AddThenFetch8 ret=%d val=%d\n", ret8, val8); + + ret8 = SDL_AtomicSubtractThenFetch8(&val8, 10); + printf("SubtractThenFetch8 ret=%d val=%d\n", ret8, val8); + + + printf("16 bit -----------------------------------------\n\n"); + + ret16 = SDL_AtomicExchange16(&val16, 10); + printf("Exchange16 ret=%d val=%d\n", ret16, val16); + ret16 = SDL_AtomicExchange16(&val16, 0); + printf("Exchange16 ret=%d val=%d\n", ret16, val16); + + val16 = 10; + tfret = SDL_AtomicCompareThenSet16(&val16, 10, 20); + printf("CompareThenSet16 tfret=%s val=%d\n", tf(tfret), val16); + val16 = 10; + tfret = SDL_AtomicCompareThenSet16(&val16, 0, 20); + printf("CompareThenSet16 tfret=%s val=%d\n", tf(tfret), val16); + + val16 = 0; + tfret = SDL_AtomicTestThenSet16(&val16); + printf("TestThenSet16 tfret=%s val=%d\n", tf(tfret), val16); + tfret = SDL_AtomicTestThenSet16(&val16); + printf("TestThenSet16 tfret=%s val=%d\n", tf(tfret), val16); + + SDL_AtomicClear16(&val16); + printf("Clear16 val=%d\n", val16); + + ret16 = SDL_AtomicFetchThenIncrement16(&val16); + printf("FetchThenIncrement16 ret=%d val=%d\n", ret16, val16); + + ret16 = SDL_AtomicFetchThenDecrement16(&val16); + printf("FetchThenDecrement16 ret=%d val=%d\n", ret16, val16); + + ret16 = SDL_AtomicFetchThenAdd16(&val16, 10); + printf("FetchThenAdd16 ret=%d val=%d\n", ret16, val16); + + ret16 = SDL_AtomicFetchThenSubtract16(&val16, 10); + printf("FetchThenSubtract16 ret=%d val=%d\n", ret16, val16); + + ret16 = SDL_AtomicIncrementThenFetch16(&val16); + printf("IncrementThenFetch16 ret=%d val=%d\n", ret16, val16); + + ret16 = SDL_AtomicDecrementThenFetch16(&val16); + printf("DecrementThenFetch16 ret=%d val=%d\n", ret16, val16); + + ret16 = SDL_AtomicAddThenFetch16(&val16, 10); + printf("AddThenFetch16 ret=%d val=%d\n", ret16, val16); + + ret16 = SDL_AtomicSubtractThenFetch16(&val16, 10); + printf("SubtractThenFetch16 ret=%d val=%d\n", ret16, val16); + + printf("32 bit -----------------------------------------\n\n"); ret32 = SDL_AtomicExchange32(&val32, 10); - tfval = SDL_AtomicCompareThenSet32(&val32, 10, 20); - tfval = SDL_AtomicTestThenSet32(&val32); + printf("Exchange32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicExchange32(&val32, 0); + printf("Exchange32 ret=%d val=%d\n", ret32, val32); + + val32 = 10; + tfret = SDL_AtomicCompareThenSet32(&val32, 10, 20); + printf("CompareThenSet32 tfret=%s val=%d\n", tf(tfret), val32); + val32 = 10; + tfret = SDL_AtomicCompareThenSet32(&val32, 0, 20); + printf("CompareThenSet32 tfret=%s val=%d\n", tf(tfret), val32); + + val32 = 0; + tfret = SDL_AtomicTestThenSet32(&val32); + printf("TestThenSet32 tfret=%s val=%d\n", tf(tfret), val32); + tfret = SDL_AtomicTestThenSet32(&val32); + printf("TestThenSet32 tfret=%s val=%d\n", tf(tfret), val32); + SDL_AtomicClear32(&val32); + printf("Clear32 val=%d\n", val32); + ret32 = SDL_AtomicFetchThenIncrement32(&val32); + printf("FetchThenIncrement32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicFetchThenDecrement32(&val32); + printf("FetchThenDecrement32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicFetchThenAdd32(&val32, 10); + printf("FetchThenAdd32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicFetchThenSubtract32(&val32, 10); + printf("FetchThenSubtract32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicIncrementThenFetch32(&val32); + printf("IncrementThenFetch32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicDecrementThenFetch32(&val32); + printf("DecrementThenFetch32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicAddThenFetch32(&val32, 10); + printf("AddThenFetch32 ret=%d val=%d\n", ret32, val32); + ret32 = SDL_AtomicSubtractThenFetch32(&val32, 10); + printf("SubtractThenFetch32 ret=%d val=%d\n", ret32, val32); -/* #ifdef SDL_HAS_64BIT_TYPE */ -#if 0 +#ifdef SDL_HAS_64BIT_TYPE + printf("64 bit -----------------------------------------\n\n"); ret64 = SDL_AtomicExchange64(&val64, 10); - tfval = SDL_AtomicCompareThenSet64(&val64, 10, 20); - tfval = SDL_AtomicTestThenSet64(&val64); + printf("Exchange64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicExchange64(&val64, 0); + printf("Exchange64 ret=%lld val=%lld\n", ret64, val64); + + val64 = 10; + tfret = SDL_AtomicCompareThenSet64(&val64, 10, 20); + printf("CompareThenSet64 tfret=%s val=%lld\n", tf(tfret), val64); + val64 = 10; + tfret = SDL_AtomicCompareThenSet64(&val64, 0, 20); + printf("CompareThenSet64 tfret=%s val=%lld\n", tf(tfret), val64); + + val64 = 0; + tfret = SDL_AtomicTestThenSet64(&val64); + printf("TestThenSet64 tfret=%s val=%lld\n", tf(tfret), val64); + tfret = SDL_AtomicTestThenSet64(&val64); + printf("TestThenSet64 tfret=%s val=%lld\n", tf(tfret), val64); + SDL_AtomicClear64(&val64); + printf("Clear64 val=%lld\n", val64); + ret64 = SDL_AtomicFetchThenIncrement64(&val64); + printf("FetchThenIncrement64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicFetchThenDecrement64(&val64); + printf("FetchThenDecrement64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicFetchThenAdd64(&val64, 10); + printf("FetchThenAdd64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicFetchThenSubtract64(&val64, 10); + printf("FetchThenSubtract64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicIncrementThenFetch64(&val64); + printf("IncrementThenFetch64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicDecrementThenFetch64(&val64); + printf("DecrementThenFetch64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicAddThenFetch64(&val64, 10); + printf("AddThenFetch64 ret=%lld val=%lld\n", ret64, val64); + ret64 = SDL_AtomicSubtractThenFetch64(&val64, 10); + printf("SubtractThenFetch64 ret=%lld val=%lld\n", ret64, val64); #endif return 0;