From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c | 216 +++++++++++++++++++++ .../SDL-3.2.8/src/thread/generic/SDL_syscond_c.h | 36 ++++ .../SDL-3.2.8/src/thread/generic/SDL_sysmutex.c | 132 +++++++++++++ .../SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h | 21 ++ .../SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c | 194 ++++++++++++++++++ .../SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h | 38 ++++ contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c | 183 +++++++++++++++++ .../SDL-3.2.8/src/thread/generic/SDL_systhread.c | 57 ++++++ .../SDL-3.2.8/src/thread/generic/SDL_systhread_c.h | 24 +++ contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c | 44 +++++ 10 files changed, 945 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_syscond_c.h create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex.c create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_systhread.c create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_systhread_c.h create mode 100644 contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c (limited to 'contrib/SDL-3.2.8/src/thread/generic') diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c new file mode 100644 index 0000000..5fdfe84 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c @@ -0,0 +1,216 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// An implementation of condition variables using semaphores and mutexes +/* + This implementation borrows heavily from the BeOS condition variable + implementation, written by Christopher Tate and Owen Smith. Thanks! + */ + +#include "../generic/SDL_syscond_c.h" + +/* If two implementations are to be compiled into SDL (the active one + * will be chosen at runtime), the function names need to be + * suffixed + */ +#ifndef SDL_THREAD_GENERIC_COND_SUFFIX +#define SDL_CreateCondition_generic SDL_CreateCondition +#define SDL_DestroyCondition_generic SDL_DestroyCondition +#define SDL_SignalCondition_generic SDL_SignalCondition +#define SDL_BroadcastCondition_generic SDL_BroadcastCondition +#endif + +typedef struct SDL_cond_generic +{ + SDL_Semaphore *sem; + SDL_Semaphore *handshake_sem; + SDL_Semaphore *signal_sem; + int num_waiting; + int num_signals; +} SDL_cond_generic; + +// Create a condition variable +SDL_Condition *SDL_CreateCondition_generic(void) +{ + SDL_cond_generic *cond = (SDL_cond_generic *)SDL_calloc(1, sizeof(*cond)); + +#ifndef SDL_THREADS_DISABLED + if (cond) { + cond->sem = SDL_CreateSemaphore(0); + cond->handshake_sem = SDL_CreateSemaphore(0); + cond->signal_sem = SDL_CreateSemaphore(1); + if (!cond->sem || !cond->handshake_sem || !cond->signal_sem) { + SDL_DestroyCondition_generic((SDL_Condition *)cond); + cond = NULL; + } + } +#endif + + return (SDL_Condition *)cond; +} + +// Destroy a condition variable +void SDL_DestroyCondition_generic(SDL_Condition *_cond) +{ + SDL_cond_generic *cond = (SDL_cond_generic *)_cond; + if (cond) { + if (cond->sem) { + SDL_DestroySemaphore(cond->sem); + } + if (cond->handshake_sem) { + SDL_DestroySemaphore(cond->handshake_sem); + } + if (cond->signal_sem) { + SDL_DestroySemaphore(cond->signal_sem); + } + SDL_free(cond); + } +} + +// Restart one of the threads that are waiting on the condition variable +void SDL_SignalCondition_generic(SDL_Condition *_cond) +{ + SDL_cond_generic *cond = (SDL_cond_generic *)_cond; + if (!cond) { + return; + } + +#ifndef SDL_THREADS_DISABLED + /* If there are waiting threads not already signalled, then + signal the condition and wait for the thread to respond. + */ + SDL_WaitSemaphore(cond->signal_sem); + if (cond->num_waiting > cond->num_signals) { + cond->num_signals++; + SDL_SignalSemaphore(cond->sem); + SDL_SignalSemaphore(cond->signal_sem); + SDL_WaitSemaphore(cond->handshake_sem); + } else { + SDL_SignalSemaphore(cond->signal_sem); + } +#endif +} + +// Restart all threads that are waiting on the condition variable +void SDL_BroadcastCondition_generic(SDL_Condition *_cond) +{ + SDL_cond_generic *cond = (SDL_cond_generic *)_cond; + if (!cond) { + return; + } + +#ifndef SDL_THREADS_DISABLED + /* If there are waiting threads not already signalled, then + signal the condition and wait for the thread to respond. + */ + SDL_WaitSemaphore(cond->signal_sem); + if (cond->num_waiting > cond->num_signals) { + const int num_waiting = (cond->num_waiting - cond->num_signals); + cond->num_signals = cond->num_waiting; + for (int i = 0; i < num_waiting; i++) { + SDL_SignalSemaphore(cond->sem); + } + /* Now all released threads are blocked here, waiting for us. + Collect them all (and win fabulous prizes!) :-) + */ + SDL_SignalSemaphore(cond->signal_sem); + for (int i = 0; i < num_waiting; i++) { + SDL_WaitSemaphore(cond->handshake_sem); + } + } else { + SDL_SignalSemaphore(cond->signal_sem); + } +#endif +} + +/* Wait on the condition variable for at most 'timeoutNS' nanoseconds. + The mutex must be locked before entering this function! + The mutex is unlocked during the wait, and locked again after the wait. + +Typical use: + +Thread A: + SDL_LockMutex(lock); + while ( ! condition ) { + SDL_WaitCondition(cond, lock); + } + SDL_UnlockMutex(lock); + +Thread B: + SDL_LockMutex(lock); + ... + condition = true; + ... + SDL_SignalCondition(cond); + SDL_UnlockMutex(lock); + */ +bool SDL_WaitConditionTimeoutNS_generic(SDL_Condition *_cond, SDL_Mutex *mutex, Sint64 timeoutNS) +{ + SDL_cond_generic *cond = (SDL_cond_generic *)_cond; + bool result = true; + + if (!cond || !mutex) { + return true; + } + +#ifndef SDL_THREADS_DISABLED + /* Obtain the protection mutex, and increment the number of waiters. + This allows the signal mechanism to only perform a signal if there + are waiting threads. + */ + SDL_WaitSemaphore(cond->signal_sem); + cond->num_waiting++; + SDL_SignalSemaphore(cond->signal_sem); + + // Unlock the mutex, as is required by condition variable semantics + SDL_UnlockMutex(mutex); + + // Wait for a signal + result = SDL_WaitSemaphoreTimeoutNS(cond->sem, timeoutNS); + + /* Let the signaler know we have completed the wait, otherwise + the signaler can race ahead and get the condition semaphore + if we are stopped between the mutex unlock and semaphore wait, + giving a deadlock. See the following URL for details: + http://web.archive.org/web/20010914175514/http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html#Workshop + */ + SDL_WaitSemaphore(cond->signal_sem); + if (cond->num_signals > 0) { + SDL_SignalSemaphore(cond->handshake_sem); + cond->num_signals--; + } + cond->num_waiting--; + SDL_SignalSemaphore(cond->signal_sem); + + // Lock the mutex, as is required by condition variable semantics + SDL_LockMutex(mutex); +#endif + + return result; +} + +#ifndef SDL_THREAD_GENERIC_COND_SUFFIX +bool SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS) +{ + return SDL_WaitConditionTimeoutNS_generic(cond, mutex, timeoutNS); +} +#endif diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond_c.h new file mode 100644 index 0000000..253c394 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond_c.h @@ -0,0 +1,36 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_syscond_generic_h_ +#define SDL_syscond_generic_h_ + +#ifdef SDL_THREAD_GENERIC_COND_SUFFIX + +SDL_Condition *SDL_CreateCondition_generic(void); +void SDL_DestroyCondition_generic(SDL_Condition *cond); +void SDL_SignalCondition_generic(SDL_Condition *cond); +void SDL_BroadcastCondition_generic(SDL_Condition *cond); +bool SDL_WaitConditionTimeoutNS_generic(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS); + +#endif // SDL_THREAD_GENERIC_COND_SUFFIX + +#endif // SDL_syscond_generic_h_ diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex.c new file mode 100644 index 0000000..e58da67 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex.c @@ -0,0 +1,132 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// An implementation of mutexes using semaphores + +#include "SDL_systhread_c.h" + +struct SDL_Mutex +{ + int recursive; + SDL_ThreadID owner; + SDL_Semaphore *sem; +}; + +SDL_Mutex *SDL_CreateMutex(void) +{ + SDL_Mutex *mutex = (SDL_Mutex *)SDL_calloc(1, sizeof(*mutex)); + +#ifndef SDL_THREADS_DISABLED + if (mutex) { + // Create the mutex semaphore, with initial value 1 + mutex->sem = SDL_CreateSemaphore(1); + mutex->recursive = 0; + mutex->owner = 0; + if (!mutex->sem) { + SDL_free(mutex); + mutex = NULL; + } + } +#endif // !SDL_THREADS_DISABLED + + return mutex; +} + +void SDL_DestroyMutex(SDL_Mutex *mutex) +{ + if (mutex) { + if (mutex->sem) { + SDL_DestroySemaphore(mutex->sem); + } + SDL_free(mutex); + } +} + +void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes +{ +#ifndef SDL_THREADS_DISABLED + if (mutex != NULL) { + SDL_ThreadID this_thread = SDL_GetCurrentThreadID(); + if (mutex->owner == this_thread) { + ++mutex->recursive; + } else { + /* The order of operations is important. + We set the locking thread id after we obtain the lock + so unlocks from other threads will fail. + */ + SDL_WaitSemaphore(mutex->sem); + mutex->owner = this_thread; + mutex->recursive = 0; + } + } +#endif // SDL_THREADS_DISABLED +} + +bool SDL_TryLockMutex(SDL_Mutex *mutex) +{ + bool result = true; +#ifndef SDL_THREADS_DISABLED + if (mutex) { + SDL_ThreadID this_thread = SDL_GetCurrentThreadID(); + if (mutex->owner == this_thread) { + ++mutex->recursive; + } else { + /* The order of operations is important. + We set the locking thread id after we obtain the lock + so unlocks from other threads will fail. + */ + result = SDL_TryWaitSemaphore(mutex->sem); + if (result) { + mutex->owner = this_thread; + mutex->recursive = 0; + } + } + } +#endif // SDL_THREADS_DISABLED + return result; +} + +void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes +{ +#ifndef SDL_THREADS_DISABLED + if (mutex != NULL) { + // If we don't own the mutex, we can't unlock it + if (SDL_GetCurrentThreadID() != mutex->owner) { + SDL_assert(!"Tried to unlock a mutex we don't own!"); + return; // (undefined behavior!) SDL_SetError("mutex not owned by this thread"); + } + + if (mutex->recursive) { + --mutex->recursive; + } else { + /* The order of operations is important. + First reset the owner so another thread doesn't lock + the mutex and set the ownership before we reset it, + then release the lock semaphore. + */ + mutex->owner = 0; + SDL_SignalSemaphore(mutex->sem); + } + } +#endif // SDL_THREADS_DISABLED +} + diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h new file mode 100644 index 0000000..4b0c6f8 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h @@ -0,0 +1,21 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c new file mode 100644 index 0000000..24caf51 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c @@ -0,0 +1,194 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// An implementation of rwlocks using mutexes, condition variables, and atomics. + +#include "SDL_systhread_c.h" + +#include "../generic/SDL_sysrwlock_c.h" + +/* If two implementations are to be compiled into SDL (the active one + * will be chosen at runtime), the function names need to be + * suffixed + */ +// !!! FIXME: this is quite a tapdance with macros and the build system, maybe we can simplify how we do this. --ryan. +#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX +#define SDL_CreateRWLock_generic SDL_CreateRWLock +#define SDL_DestroyRWLock_generic SDL_DestroyRWLock +#define SDL_LockRWLockForReading_generic SDL_LockRWLockForReading +#define SDL_LockRWLockForWriting_generic SDL_LockRWLockForWriting +#define SDL_UnlockRWLock_generic SDL_UnlockRWLock +#endif + +struct SDL_RWLock +{ +#ifdef SDL_THREADS_DISABLED + int unused; +#else + SDL_Mutex *lock; + SDL_Condition *condition; + SDL_ThreadID writer_thread; + SDL_AtomicInt reader_count; + SDL_AtomicInt writer_count; +#endif +}; + +SDL_RWLock *SDL_CreateRWLock_generic(void) +{ + SDL_RWLock *rwlock = (SDL_RWLock *) SDL_calloc(1, sizeof (*rwlock)); + + if (!rwlock) { + return NULL; + } + +#ifndef SDL_THREADS_DISABLED + rwlock->lock = SDL_CreateMutex(); + if (!rwlock->lock) { + SDL_free(rwlock); + return NULL; + } + + rwlock->condition = SDL_CreateCondition(); + if (!rwlock->condition) { + SDL_DestroyMutex(rwlock->lock); + SDL_free(rwlock); + return NULL; + } + + SDL_SetAtomicInt(&rwlock->reader_count, 0); + SDL_SetAtomicInt(&rwlock->writer_count, 0); +#endif + + return rwlock; +} + +void SDL_DestroyRWLock_generic(SDL_RWLock *rwlock) +{ + if (rwlock) { +#ifndef SDL_THREADS_DISABLED + SDL_DestroyMutex(rwlock->lock); + SDL_DestroyCondition(rwlock->condition); +#endif + SDL_free(rwlock); + } +} + +void SDL_LockRWLockForReading_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes +{ +#ifndef SDL_THREADS_DISABLED + if (rwlock) { + // !!! FIXME: these don't have to be atomic, we always gate them behind a mutex. + SDL_LockMutex(rwlock->lock); + SDL_assert(SDL_GetAtomicInt(&rwlock->writer_count) == 0); // shouldn't be able to grab lock if there's a writer! + SDL_AddAtomicInt(&rwlock->reader_count, 1); + SDL_UnlockMutex(rwlock->lock); // other readers can attempt to share the lock. + } +#endif +} + +void SDL_LockRWLockForWriting_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes +{ +#ifndef SDL_THREADS_DISABLED + if (rwlock) { + SDL_LockMutex(rwlock->lock); + while (SDL_GetAtomicInt(&rwlock->reader_count) > 0) { // while something is holding the shared lock, keep waiting. + SDL_WaitCondition(rwlock->condition, rwlock->lock); // release the lock and wait for readers holding the shared lock to release it, regrab the lock. + } + + // we hold the lock! + SDL_AddAtomicInt(&rwlock->writer_count, 1); // we let these be recursive, but the API doesn't require this. It _does_ trust you unlock correctly! + } +#endif +} + +bool SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock) +{ +#ifndef SDL_THREADS_DISABLED + if (rwlock) { + if (!SDL_TryLockMutex(rwlock->lock)) { + // !!! FIXME: there is a small window where a reader has to lock the mutex, and if we hit that, we will return SDL_RWLOCK_TIMEDOUT even though we could have shared the lock. + return false; + } + + SDL_assert(SDL_GetAtomicInt(&rwlock->writer_count) == 0); // shouldn't be able to grab lock if there's a writer! + SDL_AddAtomicInt(&rwlock->reader_count, 1); + SDL_UnlockMutex(rwlock->lock); // other readers can attempt to share the lock. + } +#endif + + return true; +} + +#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX +bool SDL_TryLockRWLockForReading(SDL_RWLock *rwlock) +{ + return SDL_TryLockRWLockForReading_generic(rwlock); +} +#endif + +bool SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock) +{ +#ifndef SDL_THREADS_DISABLED + if (rwlock) { + if (!SDL_TryLockMutex(rwlock->lock)) { + return false; + } + + if (SDL_GetAtomicInt(&rwlock->reader_count) > 0) { // a reader is using the shared lock, treat it as unavailable. + SDL_UnlockMutex(rwlock->lock); + return false; + } + + // we hold the lock! + SDL_AddAtomicInt(&rwlock->writer_count, 1); // we let these be recursive, but the API doesn't require this. It _does_ trust you unlock correctly! + } +#endif + + return true; +} + +#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX +bool SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock) +{ + return SDL_TryLockRWLockForWriting_generic(rwlock); +} +#endif + +void SDL_UnlockRWLock_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes +{ +#ifndef SDL_THREADS_DISABLED + if (rwlock) { + SDL_LockMutex(rwlock->lock); // recursive lock for writers, readers grab lock to make sure things are sane. + + if (SDL_GetAtomicInt(&rwlock->reader_count) > 0) { // we're a reader + SDL_AddAtomicInt(&rwlock->reader_count, -1); + SDL_BroadcastCondition(rwlock->condition); // alert any pending writers to attempt to try to grab the lock again. + } else if (SDL_GetAtomicInt(&rwlock->writer_count) > 0) { // we're a writer + SDL_AddAtomicInt(&rwlock->writer_count, -1); + SDL_UnlockMutex(rwlock->lock); // recursive unlock. + } + + SDL_UnlockMutex(rwlock->lock); + } +#endif +} + diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h new file mode 100644 index 0000000..9589d25 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h @@ -0,0 +1,38 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_sysrwlock_c_h_ +#define SDL_sysrwlock_c_h_ + +#ifdef SDL_THREAD_GENERIC_RWLOCK_SUFFIX + +SDL_RWLock *SDL_CreateRWLock_generic(void); +void SDL_DestroyRWLock_generic(SDL_RWLock *rwlock); +void SDL_LockRWLockForReading_generic(SDL_RWLock *rwlock); +void SDL_LockRWLockForWriting_generic(SDL_RWLock *rwlock); +bool SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock); +bool SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock); +void SDL_UnlockRWLock_generic(SDL_RWLock *rwlock); + +#endif // SDL_THREAD_GENERIC_RWLOCK_SUFFIX + +#endif // SDL_sysrwlock_c_h_ diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c new file mode 100644 index 0000000..dcd6fcc --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c @@ -0,0 +1,183 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// An implementation of semaphores using mutexes and condition variables + +#include "SDL_systhread_c.h" + +#ifdef SDL_THREADS_DISABLED + +SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value) +{ + SDL_SetError("SDL not built with thread support"); + return NULL; +} + +void SDL_DestroySemaphore(SDL_Semaphore *sem) +{ +} + +bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS) +{ + return true; +} + +Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem) +{ + return 0; +} + +void SDL_SignalSemaphore(SDL_Semaphore *sem) +{ + return; +} + +#else + +struct SDL_Semaphore +{ + Uint32 count; + Uint32 waiters_count; + SDL_Mutex *count_lock; + SDL_Condition *count_nonzero; +}; + +SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value) +{ + SDL_Semaphore *sem; + + sem = (SDL_Semaphore *)SDL_malloc(sizeof(*sem)); + if (!sem) { + return NULL; + } + sem->count = initial_value; + sem->waiters_count = 0; + + sem->count_lock = SDL_CreateMutex(); + sem->count_nonzero = SDL_CreateCondition(); + if (!sem->count_lock || !sem->count_nonzero) { + SDL_DestroySemaphore(sem); + return NULL; + } + + return sem; +} + +/* WARNING: + You cannot call this function when another thread is using the semaphore. +*/ +void SDL_DestroySemaphore(SDL_Semaphore *sem) +{ + if (sem) { + sem->count = 0xFFFFFFFF; + while (sem->waiters_count > 0) { + SDL_SignalCondition(sem->count_nonzero); + SDL_Delay(10); + } + SDL_DestroyCondition(sem->count_nonzero); + if (sem->count_lock) { + SDL_LockMutex(sem->count_lock); + SDL_UnlockMutex(sem->count_lock); + SDL_DestroyMutex(sem->count_lock); + } + SDL_free(sem); + } +} + +bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS) +{ + bool result = false; + + if (!sem) { + return true; + } + + if (timeoutNS == 0) { + SDL_LockMutex(sem->count_lock); + if (sem->count > 0) { + --sem->count; + result = true; + } + SDL_UnlockMutex(sem->count_lock); + } else if (timeoutNS < 0) { + SDL_LockMutex(sem->count_lock); + ++sem->waiters_count; + while (sem->count == 0) { + SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, -1); + } + --sem->waiters_count; + --sem->count; + result = true; + SDL_UnlockMutex(sem->count_lock); + } else { + Uint64 stop_time = SDL_GetTicksNS() + timeoutNS; + + SDL_LockMutex(sem->count_lock); + ++sem->waiters_count; + while (sem->count == 0) { + Sint64 waitNS = (Sint64)(stop_time - SDL_GetTicksNS()); + if (waitNS > 0) { + SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, waitNS); + } else { + break; + } + } + --sem->waiters_count; + + if (sem->count > 0) { + --sem->count; + result = true; + } + SDL_UnlockMutex(sem->count_lock); + } + + return result; +} + +Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem) +{ + Uint32 value; + + value = 0; + if (sem) { + SDL_LockMutex(sem->count_lock); + value = sem->count; + SDL_UnlockMutex(sem->count_lock); + } + return value; +} + +void SDL_SignalSemaphore(SDL_Semaphore *sem) +{ + if (!sem) { + return; + } + + SDL_LockMutex(sem->count_lock); + if (sem->waiters_count > 0) { + SDL_SignalCondition(sem->count_nonzero); + } + ++sem->count; + SDL_UnlockMutex(sem->count_lock); +} + +#endif // SDL_THREADS_DISABLED diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread.c new file mode 100644 index 0000000..ecfa4e1 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread.c @@ -0,0 +1,57 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// Thread management routines for SDL + +#include "../SDL_systhread.h" + +bool SDL_SYS_CreateThread(SDL_Thread *thread, + SDL_FunctionPointer pfnBeginThread, + SDL_FunctionPointer pfnEndThread) +{ + return SDL_SetError("Threads are not supported on this platform"); +} + +void SDL_SYS_SetupThread(const char *name) +{ + return; +} + +SDL_ThreadID SDL_GetCurrentThreadID(void) +{ + return 0; +} + +bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority) +{ + return true; +} + +void SDL_SYS_WaitThread(SDL_Thread *thread) +{ + return; +} + +void SDL_SYS_DetachThread(SDL_Thread *thread) +{ + return; +} diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread_c.h new file mode 100644 index 0000000..9ba55fd --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread_c.h @@ -0,0 +1,24 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +// Stub until we implement threads on this platform +typedef int SYS_ThreadHandle; diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c new file mode 100644 index 0000000..b8ebafe --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c @@ -0,0 +1,44 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_internal.h" +#include "../SDL_thread_c.h" + +void SDL_SYS_InitTLSData(void) +{ + SDL_Generic_InitTLSData(); +} + +SDL_TLSData *SDL_SYS_GetTLSData(void) +{ + return SDL_Generic_GetTLSData(); +} + +bool SDL_SYS_SetTLSData(SDL_TLSData *data) +{ + return SDL_Generic_SetTLSData(data); +} + +void SDL_SYS_QuitTLSData(void) +{ + SDL_Generic_QuitTLSData(); +} + -- cgit v1.2.3