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/windows/SDL_syssem.c | 351 ++++++++++++++++++++++ 1 file changed, 351 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/thread/windows/SDL_syssem.c (limited to 'contrib/SDL-3.2.8/src/thread/windows/SDL_syssem.c') diff --git a/contrib/SDL-3.2.8/src/thread/windows/SDL_syssem.c b/contrib/SDL-3.2.8/src/thread/windows/SDL_syssem.c new file mode 100644 index 0000000..ba35add --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/windows/SDL_syssem.c @@ -0,0 +1,351 @@ +/* + 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" + +#ifdef SDL_THREAD_WINDOWS + +/** + * Semaphore functions using the Win32 API + * There are two implementations available based on: + * - Kernel Semaphores. Available on all OS versions. (kern) + * Heavy-weight inter-process kernel objects. + * - Atomics and WaitOnAddress API. (atom) + * Faster due to significantly less context switches. + * Requires Windows 8 or newer. + * which are chosen at runtime. + */ + +#include "../../core/windows/SDL_windows.h" + +typedef SDL_Semaphore *(*pfnSDL_CreateSemaphore)(Uint32); +typedef void (*pfnSDL_DestroySemaphore)(SDL_Semaphore *); +typedef bool (*pfnSDL_WaitSemaphoreTimeoutNS)(SDL_Semaphore *, Sint64); +typedef Uint32 (*pfnSDL_GetSemaphoreValue)(SDL_Semaphore *); +typedef void (*pfnSDL_SignalSemaphore)(SDL_Semaphore *); + +typedef struct SDL_semaphore_impl_t +{ + pfnSDL_CreateSemaphore Create; + pfnSDL_DestroySemaphore Destroy; + pfnSDL_WaitSemaphoreTimeoutNS WaitTimeoutNS; + pfnSDL_GetSemaphoreValue Value; + pfnSDL_SignalSemaphore Signal; +} SDL_sem_impl_t; + +// Implementation will be chosen at runtime based on available Kernel features +static SDL_sem_impl_t SDL_sem_impl_active = { 0 }; + +/** + * Atomic + WaitOnAddress implementation + */ + +// APIs not available on WinPhone 8.1 +// https://www.microsoft.com/en-us/download/details.aspx?id=47328 + +typedef BOOL(WINAPI *pfnWaitOnAddress)(volatile VOID *, PVOID, SIZE_T, DWORD); +typedef VOID(WINAPI *pfnWakeByAddressSingle)(PVOID); + +static pfnWaitOnAddress pWaitOnAddress = NULL; +static pfnWakeByAddressSingle pWakeByAddressSingle = NULL; + +typedef struct SDL_semaphore_atom +{ + LONG count; +} SDL_sem_atom; + +static SDL_Semaphore *SDL_CreateSemaphore_atom(Uint32 initial_value) +{ + SDL_sem_atom *sem; + + sem = (SDL_sem_atom *)SDL_malloc(sizeof(*sem)); + if (sem) { + sem->count = initial_value; + } + return (SDL_Semaphore *)sem; +} + +static void SDL_DestroySemaphore_atom(SDL_Semaphore *sem) +{ + SDL_free(sem); +} + +static bool SDL_WaitSemaphoreTimeoutNS_atom(SDL_Semaphore *_sem, Sint64 timeoutNS) +{ + SDL_sem_atom *sem = (SDL_sem_atom *)_sem; + LONG count; + Uint64 now; + Uint64 deadline; + DWORD timeout_eff; + + if (!sem) { + return true; + } + + if (timeoutNS == 0) { + count = sem->count; + if (count == 0) { + return false; + } + + if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) { + return true; + } + + return false; + } + + if (timeoutNS < 0) { + for (;;) { + count = sem->count; + while (count == 0) { + if (!pWaitOnAddress(&sem->count, &count, sizeof(sem->count), INFINITE)) { + return false; + } + count = sem->count; + } + + if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) { + return true; + } + } + } + + /** + * WaitOnAddress is subject to spurious and stolen wakeups so we + * need to recalculate the effective timeout before every wait + */ + now = SDL_GetTicksNS(); + deadline = now + timeoutNS; + + for (;;) { + count = sem->count; + // If no semaphore is available we need to wait + while (count == 0) { + now = SDL_GetTicksNS(); + if (deadline > now) { + timeout_eff = (DWORD)SDL_NS_TO_MS(deadline - now); + } else { + return false; + } + if (!pWaitOnAddress(&sem->count, &count, sizeof(count), timeout_eff)) { + return false; + } + count = sem->count; + } + + // Actually the semaphore is only consumed if this succeeds + // If it doesn't we need to do everything again + if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) { + return true; + } + } +} + +static Uint32 SDL_GetSemaphoreValue_atom(SDL_Semaphore *_sem) +{ + SDL_sem_atom *sem = (SDL_sem_atom *)_sem; + + if (!sem) { + return 0; + } + + return (Uint32)sem->count; +} + +static void SDL_SignalSemaphore_atom(SDL_Semaphore *_sem) +{ + SDL_sem_atom *sem = (SDL_sem_atom *)_sem; + + if (!sem) { + return; + } + + InterlockedIncrement(&sem->count); + pWakeByAddressSingle(&sem->count); +} + +static const SDL_sem_impl_t SDL_sem_impl_atom = { + &SDL_CreateSemaphore_atom, + &SDL_DestroySemaphore_atom, + &SDL_WaitSemaphoreTimeoutNS_atom, + &SDL_GetSemaphoreValue_atom, + &SDL_SignalSemaphore_atom, +}; + +/** + * Fallback Semaphore implementation using Kernel Semaphores + */ + +typedef struct SDL_semaphore_kern +{ + HANDLE id; + LONG count; +} SDL_sem_kern; + +// Create a semaphore +static SDL_Semaphore *SDL_CreateSemaphore_kern(Uint32 initial_value) +{ + SDL_sem_kern *sem; + + // Allocate sem memory + sem = (SDL_sem_kern *)SDL_malloc(sizeof(*sem)); + if (sem) { + // Create the semaphore, with max value 32K + sem->id = CreateSemaphore(NULL, initial_value, 32 * 1024, NULL); + sem->count = initial_value; + if (!sem->id) { + SDL_SetError("Couldn't create semaphore"); + SDL_free(sem); + sem = NULL; + } + } + return (SDL_Semaphore *)sem; +} + +// Free the semaphore +static void SDL_DestroySemaphore_kern(SDL_Semaphore *_sem) +{ + SDL_sem_kern *sem = (SDL_sem_kern *)_sem; + if (sem) { + if (sem->id) { + CloseHandle(sem->id); + sem->id = 0; + } + SDL_free(sem); + } +} + +static bool SDL_WaitSemaphoreTimeoutNS_kern(SDL_Semaphore *_sem, Sint64 timeoutNS) +{ + SDL_sem_kern *sem = (SDL_sem_kern *)_sem; + DWORD dwMilliseconds; + + if (!sem) { + return true; + } + + if (timeoutNS < 0) { + dwMilliseconds = INFINITE; + } else { + dwMilliseconds = (DWORD)SDL_NS_TO_MS(timeoutNS); + } + switch (WaitForSingleObjectEx(sem->id, dwMilliseconds, FALSE)) { + case WAIT_OBJECT_0: + InterlockedDecrement(&sem->count); + return true; + default: + return false; + } +} + +// Returns the current count of the semaphore +static Uint32 SDL_GetSemaphoreValue_kern(SDL_Semaphore *_sem) +{ + SDL_sem_kern *sem = (SDL_sem_kern *)_sem; + if (!sem) { + return 0; + } + return (Uint32)sem->count; +} + +static void SDL_SignalSemaphore_kern(SDL_Semaphore *_sem) +{ + SDL_sem_kern *sem = (SDL_sem_kern *)_sem; + + if (!sem) { + return; + } + + /* Increase the counter in the first place, because + * after a successful release the semaphore may + * immediately get destroyed by another thread which + * is waiting for this semaphore. + */ + InterlockedIncrement(&sem->count); + if (ReleaseSemaphore(sem->id, 1, NULL) == FALSE) { + InterlockedDecrement(&sem->count); // restore + } +} + +static const SDL_sem_impl_t SDL_sem_impl_kern = { + &SDL_CreateSemaphore_kern, + &SDL_DestroySemaphore_kern, + &SDL_WaitSemaphoreTimeoutNS_kern, + &SDL_GetSemaphoreValue_kern, + &SDL_SignalSemaphore_kern, +}; + +/** + * Runtime selection and redirection + */ + +SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value) +{ + if (!SDL_sem_impl_active.Create) { + // Default to fallback implementation + const SDL_sem_impl_t *impl = &SDL_sem_impl_kern; + + if (!SDL_GetHintBoolean(SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL, false)) { + /* We already statically link to features from this Api + * Set (e.g. WaitForSingleObject). Dynamically loading + * API Sets is not explicitly documented but according to + * Microsoft our specific use case is legal and correct: + * https://github.com/microsoft/STL/pull/593#issuecomment-655799859 + */ + HMODULE synch120 = GetModuleHandle(TEXT("api-ms-win-core-synch-l1-2-0.dll")); + if (synch120) { + // Try to load required functions provided by Win 8 or newer + pWaitOnAddress = (pfnWaitOnAddress)GetProcAddress(synch120, "WaitOnAddress"); + pWakeByAddressSingle = (pfnWakeByAddressSingle)GetProcAddress(synch120, "WakeByAddressSingle"); + + if (pWaitOnAddress && pWakeByAddressSingle) { + impl = &SDL_sem_impl_atom; + } + } + } + + // Copy instead of using pointer to save one level of indirection + SDL_copyp(&SDL_sem_impl_active, impl); + } + return SDL_sem_impl_active.Create(initial_value); +} + +void SDL_DestroySemaphore(SDL_Semaphore *sem) +{ + SDL_sem_impl_active.Destroy(sem); +} + +bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS) +{ + return SDL_sem_impl_active.WaitTimeoutNS(sem, timeoutNS); +} + +Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem) +{ + return SDL_sem_impl_active.Value(sem); +} + +void SDL_SignalSemaphore(SDL_Semaphore *sem) +{ + SDL_sem_impl_active.Signal(sem); +} + +#endif // SDL_THREAD_WINDOWS -- cgit v1.2.3