initial commit, 4.5 stable

thirdparty/sdl/thread/windows/SDL_syssem.c

@@ -0,0 +1,351 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  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