The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.

The linux code appears to be complete and *should* be the base of all Unix and GCC based versions. The macosx and win32 versions
are currently just copies of the dummy code. I will begin working on the windows version as soon as this check in is done. I
need someone to work on the Mac OS X version.

I'm afraid that this check in will break QNX (Sorry!)

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%403802

include/SDL_atomic.h

@@ -18,6 +18,8 @@
 
     Sam Lantinga
     slouken@libsdl.org
+
+    Contributed by Bob Pendleton, bob@pendleton.com
  */
 
 /**
@@ -46,48 +48,50 @@ extern "C" {
  * 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.
+ * available atomic operations.
+ *
+ * At the very minimum spin locks must be implemented. Without spin
+ * locks it is not possible (AFAICT) to emulate the rest of the atomic
+ * operations.
  */
 
 /* Function prototypes */
 
+/**
+ * SDL AtomicLock.
+ * 
+ * The spin lock functions and type are required and can not be
+ * emulated because they are used in the emulation code.
+ */
+
+typedef volatile Uint32 SDL_SpinLock;
+
+/**
+ * \fn  void SDL_AtomicLock(SDL_SpinLock *lock);
+ *
+ * \brief Lock a spin lock by setting it to a none zero value.
+ *
+ * \param lock points to the lock.
+ *
+ */
+extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
+
+/**
+ * \fn  void SDL_AtomicUnlock(SDL_SpinLock *lock);
+ *
+ * \brief Unlock a spin lock by setting it to 0. Always returns immediately
+ *
+ * \param lock points to the lock.
+ *
+ */
+extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
+
 /* 32 bit atomic operations */
 
-/**
- * \fn int SDL_AtomicExchange32(volatile Uint32 * ptr, Uint32 value)
- *
- * \brief Atomically exchange two 32 bit values.
- *
- * \return the value point to by ptr.
- *
- * \param ptr points to the value to be fetched from *ptr.  
- * \param value is value to be stored at *ptr.
- *
- * The current value stored at *ptr is returned and it is replaced
- * with value. This function can be used to implement SDL_TestThenSet.
- *
- */
-extern DECLSPEC Uint32 SDLCALL SDL_AtomicExchange32(volatile Uint32 * ptr, Uint32 value);
-
-/**
- * \fn int SDL_AtomicCompareThenSet32(volatile Uint32 * ptr, Uint32 oldvalue, Uint32 newvalue)
- *
- * \brief If *ptr == oldvalue then replace the contents of *ptr by new value. 
- *
- * \return true if the newvalue was stored.
- *
- * \param *ptr is the value to be compared and replaced.
- * \param oldvalue is value to be compared to *ptr.
- * \param newvalue is value to be stored at *ptr.
- *
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareThenSet32(volatile Uint32 * ptr,
-                                                            Uint32 oldvalue, Uint32 newvalue);
 /**
  * \fn  SDL_bool SDL_AtomicTestThenSet32(volatile Uint32 * ptr);
  *
- * \brief Check to see if *ptr == 0 and set it to non-zero.
+ * \brief Check to see if *ptr == 0 and set it to 1.
  *
  * \return SDL_True if the value pointed to by ptr was zero and
  * SDL_False if it was not zero
@@ -211,9 +215,6 @@ extern DECLSPEC Uint32 SDLCALL SDL_AtomicSubtractThenFetch32(volatile Uint32 * p
 /* 64 bit atomic operations */
 #ifdef SDL_HAS_64BIT_TYPE
 
-extern DECLSPEC Uint64 SDLCALL SDL_AtomicExchange64(volatile Uint64 * ptr, Uint64 value);
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareThenSet64(volatile Uint64 * ptr,
-                                                            Uint64 oldvalue, Uint64 newvalue);
 extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet64(volatile Uint64 * ptr);
 extern DECLSPEC void SDLCALL SDL_AtomicClear64(volatile Uint64 * ptr);
 extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr);

test/testatomic.c

@@ -29,21 +29,18 @@ main(int argc, char **argv)
    volatile Uint64 val64 = 0;
    Uint64 ret64 = 0;
 
+   SDL_SpinLock lock = 0;
+
    SDL_bool tfret = SDL_FALSE;
 
-   printf("32 bit -----------------------------------------\n\n");
+   printf("\nspin lock---------------------------------------\n\n");
 
-   ret32 = SDL_AtomicExchange32(&val32, 10);
-   printf("Exchange32           ret=%d val=%d\n", ret32, val32);
-   ret32 = SDL_AtomicExchange32(&val32, 0);
-   printf("Exchange32           ret=%d val=%d\n", ret32, val32);
+   SDL_AtomicLock(&lock);
+   printf("AtomicLock                   lock=%d\n", lock);
+   SDL_AtomicUnlock(&lock);
+   printf("AtomicUnlock                 lock=%d\n", lock);
 
-   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);
+   printf("\n32 bit -----------------------------------------\n\n");
 
    val32 = 0;
    tfret = SDL_AtomicTestThenSet32(&val32);
@@ -79,19 +76,7 @@ main(int argc, char **argv)
    printf("SubtractThenFetch32  ret=%d val=%d\n", ret32, val32);
 
 #ifdef SDL_HAS_64BIT_TYPE
-   printf("64 bit -----------------------------------------\n\n");
-
-   ret64 = SDL_AtomicExchange64(&val64, 10);
-   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);
+   printf("\n64 bit -----------------------------------------\n\n");
 
    val64 = 0;
    tfret = SDL_AtomicTestThenSet64(&val64);