Sync SDL3 header -> wiki

SDL3/SDL_AtomicInt.md

@@ -15,12 +15,34 @@ typedef struct SDL_AtomicInt { int value; } SDL_AtomicInt;
 
 ## Remarks
 
-It is a struct so people don't accidentally use numeric operations on it.
+This can be used to manage a value that is synchronized across multiple
+CPUs without a race condition; when an app sets a value with
+[SDL_AtomicSet](SDL_AtomicSet) all other threads, regardless of the CPU it
+is running on, will see that value when retrieved with
+[SDL_AtomicGet](SDL_AtomicGet), regardless of CPU caches, etc.
+
+This is also useful for atomic compare-and-swap operations: a thread can
+change the value as long as its current value matches expectations. When
+done in a loop, one can guarantee data consistency across threads without a
+lock (but the usual warnings apply: if you don't know what you're doing, or
+you don't do it carefully, you can confidently cause any number of
+disasters with this, so in most cases, you _should_ use a mutex instead of
+this!).
+
+This is a struct so people don't accidentally use numeric operations on it
+directly. You have to use [SDL_Atomic](SDL_Atomic)* functions.
 
 ## Version
 
 This struct is available since SDL 3.0.0.
 
+## See Also
+
+* [SDL_AtomicCompareAndSwap](SDL_AtomicCompareAndSwap)
+* [SDL_AtomicGet](SDL_AtomicGet)
+* [SDL_AtomicSet](SDL_AtomicSet)
+* [SDL_AtomicAdd](SDL_AtomicAdd)
+
 ----
 [CategoryAPI](CategoryAPI), [CategoryAPIStruct](CategoryAPIStruct)
 

SDL3/SDL_CPUPauseInstruction.md

@@ -0,0 +1,37 @@
+###### (This is the documentation for SDL3, which is under heavy development and the API is changing! [SDL2](https://wiki.libsdl.org/SDL2/) is the current stable version!)
+# SDL_CPUPauseInstruction
+
+A macro to insert a CPU-specific "pause" instruction into the program.
+
+## Header File
+
+Defined in [<SDL3/SDL_atomic.h>](https://github.com/libsdl-org/SDL/blob/main/include/SDL3/SDL_atomic.h)
+
+## Syntax
+
+```c
+#define SDL_CPUPauseInstruction() DoACPUPauseInACompilerAndArchitectureSpecificWay
+```
+
+## Remarks
+
+This can be useful in busy-wait loops, as it serves as a hint to the CPU as
+to the program's intent; some CPUs can use this to do more efficient
+processing. On some platforms, this doesn't do anything, so using this
+macro might just be a harmless no-op.
+
+Note that if you are busy-waiting, there are often more-efficient
+approaches with other synchronization primitives: mutexes, semaphores,
+condition variables, etc.
+
+## Thread Safety
+
+This macro is safe to use from any thread.
+
+## Version
+
+This macro is available since SDL 3.0.0.
+
+----
+[CategoryAPI](CategoryAPI), [CategoryAPIMacro](CategoryAPIMacro)
+

SDL3/SDL_SpinLock.md

@@ -0,0 +1,36 @@
+###### (This is the documentation for SDL3, which is under heavy development and the API is changing! [SDL2](https://wiki.libsdl.org/SDL2/) is the current stable version!)
+# SDL_SpinLock
+
+An atomic spinlock.
+
+## Header File
+
+Defined in [<SDL3/SDL_atomic.h>](https://github.com/libsdl-org/SDL/blob/main/include/SDL3/SDL_atomic.h)
+
+## Syntax
+
+```c
+typedef int SDL_SpinLock;
+```
+
+## Remarks
+
+The atomic locks are efficient spinlocks using CPU instructions, but are
+vulnerable to starvation and can spin forever if a thread holding a lock
+has been terminated. For this reason you should minimize the code executed
+inside an atomic lock and never do expensive things like API or system
+calls while holding them.
+
+They are also vulnerable to starvation if the thread holding the lock is
+lower priority than other threads and doesn't get scheduled. In general you
+should use mutexes instead, since they have better performance and
+contention behavior.
+
+The atomic locks are not safe to lock recursively.
+
+Porting Note: The spin lock functions and type are required and can not be
+emulated because they are used in the atomic emulation code.
+
+----
+[CategoryAPI](CategoryAPI), [CategoryAPIDatatype](CategoryAPIDatatype)
+