The new, cleaner, version of the atomic operations. The dummy code is what you...

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 */
 
-/* 32 bit atomic operations */
-
 /**
- * \fn int SDL_AtomicExchange32(volatile Uint32 * ptr, Uint32 value)
+ * SDL AtomicLock.
  * 
- * \brief Atomically exchange two 32 bit values.
- *
- * \return the value point to by ptr.
+ * 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);
  *
- * \param ptr points to the value to be fetched from *ptr.  
- * \param value is value to be stored at *ptr.
+ * \brief Lock a spin lock by setting it to a none zero value.
  *
- * The current value stored at *ptr is returned and it is replaced
- * with value. This function can be used to implement SDL_TestThenSet.
+ * \param lock points to the lock.
  *
  */
-extern DECLSPEC Uint32 SDLCALL SDL_AtomicExchange32(volatile Uint32 * ptr, Uint32 value);
+extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
 
 /**
- * \fn int SDL_AtomicCompareThenSet32(volatile Uint32 * ptr, Uint32 oldvalue, Uint32 newvalue)
- *
- * \brief If *ptr == oldvalue then replace the contents of *ptr by new value. 
+ * \fn  void SDL_AtomicUnlock(SDL_SpinLock *lock);
  *
- * \return true if the newvalue was stored.
+ * \brief Unlock a spin lock by setting it to 0. Always returns immediately
  *
- * \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.
+ * \param lock points to the lock.
  *
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareThenSet32(volatile Uint32 * ptr,
-                                                            Uint32 oldvalue, Uint32 newvalue);
+extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
+
+/* 32 bit atomic operations */
+
 /**
  * \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);