early-access version 1667

externals/SDL/src/thread/windows/SDL_syscond_srw.c

@@ -0,0 +1,282 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2021 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"
+
+#include "SDL_hints.h"
+#include "SDL_thread.h"
+
+#include "../generic/SDL_syscond_c.h"
+#include "SDL_sysmutex_c.h"
+
+typedef SDL_cond * (*pfnSDL_CreateCond)(void);
+typedef void (*pfnSDL_DestroyCond)(SDL_cond *);
+typedef int (*pfnSDL_CondSignal)(SDL_cond *);
+typedef int (*pfnSDL_CondBroadcast)(SDL_cond *);
+typedef int (*pfnSDL_CondWait)(SDL_cond *, SDL_mutex *);
+typedef int (*pfnSDL_CondWaitTimeout)(SDL_cond *, SDL_mutex *, Uint32);
+
+typedef struct SDL_cond_impl_t
+{
+    pfnSDL_CreateCond       Create;
+    pfnSDL_DestroyCond      Destroy;
+    pfnSDL_CondSignal       Signal;
+    pfnSDL_CondBroadcast    Broadcast;
+    pfnSDL_CondWait         Wait;
+    pfnSDL_CondWaitTimeout  WaitTimeout;
+} SDL_cond_impl_t;
+
+/* Implementation will be chosen at runtime based on available Kernel features */
+static SDL_cond_impl_t SDL_cond_impl_active = {0};
+
+
+/**
+ * Native Windows Condition Variable (SRW Locks)
+ */
+
+#ifndef CONDITION_VARIABLE_INIT
+#define CONDITION_VARIABLE_INIT {0}
+typedef struct CONDITION_VARIABLE {
+    PVOID Ptr;
+} CONDITION_VARIABLE, *PCONDITION_VARIABLE;
+#endif
+
+#if __WINRT__
+#define pWakeConditionVariable WakeConditionVariable
+#define pWakeAllConditionVariable WakeAllConditionVariable
+#define pSleepConditionVariableSRW SleepConditionVariableSRW
+#else
+typedef VOID(WINAPI *pfnWakeConditionVariable)(PCONDITION_VARIABLE);
+typedef VOID(WINAPI *pfnWakeAllConditionVariable)(PCONDITION_VARIABLE);
+typedef BOOL(WINAPI *pfnSleepConditionVariableSRW)(PCONDITION_VARIABLE, PSRWLOCK, DWORD, ULONG);
+
+static pfnWakeConditionVariable pWakeConditionVariable = NULL;
+static pfnWakeAllConditionVariable pWakeAllConditionVariable = NULL;
+static pfnSleepConditionVariableSRW pSleepConditionVariableSRW = NULL;
+#endif
+
+typedef struct SDL_cond_srw
+{
+    CONDITION_VARIABLE cond;
+} SDL_cond_srw;
+
+
+static SDL_cond *
+SDL_CreateCond_srw(void)
+{
+    SDL_cond_srw *cond;
+
+    /* Relies on CONDITION_VARIABLE_INIT == 0. */
+    cond = (SDL_cond_srw *) SDL_calloc(1, sizeof(*cond));
+    if (!cond) {
+        SDL_OutOfMemory();
+    }
+
+    return (SDL_cond *)cond;
+}
+
+static void
+SDL_DestroyCond_srw(SDL_cond * cond)
+{
+    if (cond) {
+        /* There are no kernel allocated resources */
+        SDL_free(cond);
+    }
+}
+
+static int
+SDL_CondSignal_srw(SDL_cond * _cond)
+{
+    SDL_cond_srw *cond = (SDL_cond_srw *)_cond;
+    if (!cond) {
+        return SDL_SetError("Passed a NULL condition variable");
+    }
+
+    pWakeConditionVariable(&cond->cond);
+
+    return 0;
+}
+
+static int
+SDL_CondBroadcast_srw(SDL_cond * _cond)
+{
+    SDL_cond_srw *cond = (SDL_cond_srw *)_cond;
+    if (!cond) {
+        return SDL_SetError("Passed a NULL condition variable");
+    }
+
+    pWakeAllConditionVariable(&cond->cond);
+
+    return 0;
+}
+
+static int
+SDL_CondWaitTimeout_srw(SDL_cond * _cond, SDL_mutex * _mutex, Uint32 ms)
+{
+    SDL_cond_srw *cond = (SDL_cond_srw *)_cond;
+    SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+    DWORD timeout;
+    int ret;
+
+    if (!cond) {
+        return SDL_SetError("Passed a NULL condition variable");
+    }
+    if (!mutex) {
+        return SDL_SetError("Passed a NULL mutex");
+    }
+
+    if (mutex->count != 1 || mutex->owner != GetCurrentThreadId()) {
+        return SDL_SetError("Passed mutex is not locked or locked recursively");
+    }
+
+    if (ms == SDL_MUTEX_MAXWAIT) {
+        timeout = INFINITE;
+    } else {
+        timeout = (DWORD) ms;
+    }
+
+    /* The mutex must be updated to the released state */
+    mutex->count = 0;
+    mutex->owner = 0;
+
+    if (pSleepConditionVariableSRW(&cond->cond, &mutex->srw, timeout, 0) == FALSE) {
+        if (GetLastError() == ERROR_TIMEOUT) {
+            ret = SDL_MUTEX_TIMEDOUT;
+        } else {
+            ret = SDL_SetError("SleepConditionVariableSRW() failed");
+        }
+    } else {
+        ret = 0;
+    }
+
+    /* The mutex is owned by us again, regardless of status of the wait */
+    SDL_assert(mutex->count == 0 && mutex->owner == 0);
+    mutex->count = 1;
+    mutex->owner = GetCurrentThreadId();
+
+    return ret;
+}
+
+static int
+SDL_CondWait_srw(SDL_cond * cond, SDL_mutex * mutex) {
+    return SDL_CondWaitTimeout_srw(cond, mutex, SDL_MUTEX_MAXWAIT);
+}
+
+static const SDL_cond_impl_t SDL_cond_impl_srw =
+{
+    &SDL_CreateCond_srw,
+    &SDL_DestroyCond_srw,
+    &SDL_CondSignal_srw,
+    &SDL_CondBroadcast_srw,
+    &SDL_CondWait_srw,
+    &SDL_CondWaitTimeout_srw,
+};
+
+/**
+ * Generic Condition Variable implementation using SDL_mutex and SDL_sem
+ */
+
+static const SDL_cond_impl_t SDL_cond_impl_generic =
+{
+    &SDL_CreateCond_generic,
+    &SDL_DestroyCond_generic,
+    &SDL_CondSignal_generic,
+    &SDL_CondBroadcast_generic,
+    &SDL_CondWait_generic,
+    &SDL_CondWaitTimeout_generic,
+};
+
+
+SDL_cond *
+SDL_CreateCond(void)
+{
+    if (SDL_cond_impl_active.Create == NULL) {
+        /* Default to generic implementation, works with all mutex implementations */
+        const SDL_cond_impl_t * impl = &SDL_cond_impl_generic;
+
+        if (SDL_mutex_impl_active.Type == SDL_MUTEX_INVALID) {
+            /* The mutex implementation isn't decided yet, trigger it */
+            SDL_mutex *mutex = SDL_CreateMutex();
+            if (!mutex) {
+                return NULL;
+            }
+            SDL_DestroyMutex(mutex);
+
+            SDL_assert(SDL_mutex_impl_active.Type != SDL_MUTEX_INVALID);
+        }
+
+        /* It is required SRW Locks are used */
+        if (SDL_mutex_impl_active.Type == SDL_MUTEX_SRW) {
+#if __WINRT__
+            /* Link statically on this platform */
+            impl = &SDL_cond_impl_srw;
+#else
+            HMODULE kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
+            if (kernel32) {
+                pWakeConditionVariable = (pfnWakeConditionVariable) GetProcAddress(kernel32, "WakeConditionVariable");
+                pWakeAllConditionVariable = (pfnWakeAllConditionVariable) GetProcAddress(kernel32, "WakeAllConditionVariable");
+                pSleepConditionVariableSRW = (pfnSleepConditionVariableSRW) GetProcAddress(kernel32, "SleepConditionVariableSRW");
+                if (pWakeConditionVariable && pWakeAllConditionVariable && pSleepConditionVariableSRW) {
+                    /* Use the Windows provided API */
+                    impl = &SDL_cond_impl_srw;
+                }
+            }
+            if (!(kernel32 && pWakeConditionVariable && pWakeAllConditionVariable && pSleepConditionVariableSRW)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_SYSTEM, "Could not load required imports for SRW Condition Variables although SRW Locks are used!");
+            }
+#endif
+        }
+
+        SDL_memcpy(&SDL_cond_impl_active, impl, sizeof(SDL_cond_impl_active));
+    }
+    return SDL_cond_impl_active.Create();
+}
+
+void
+SDL_DestroyCond(SDL_cond * cond)
+{
+    SDL_cond_impl_active.Destroy(cond);
+}
+
+int
+SDL_CondSignal(SDL_cond * cond)
+{
+    return SDL_cond_impl_active.Signal(cond);
+}
+
+int
+SDL_CondBroadcast(SDL_cond * cond)
+{
+    return SDL_cond_impl_active.Broadcast(cond);
+}
+
+int
+SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
+{
+    return SDL_cond_impl_active.WaitTimeout(cond, mutex, ms);
+}
+
+int
+SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
+{
+    return SDL_cond_impl_active.Wait(cond, mutex);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

externals/SDL/src/thread/windows/SDL_sysmutex.c

@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2021 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
@@ -22,26 +22,166 @@
 
 #if SDL_THREAD_WINDOWS
 
-/* Mutex functions using the Win32 API */
-
-#include "../../core/windows/SDL_windows.h"
-
-#include "SDL_mutex.h"
+/**
+ * Mutex functions using the Win32 API
+ * There are two implementations available based on:
+ * - Critical Sections. Available on all OS versions since Windows XP.
+ * - Slim Reader/Writer Locks. Requires Windows 7 or newer.
+ * which are chosen at runtime.
+ */
 
 
-struct SDL_mutex
+#include "SDL_hints.h"
+
+#include "SDL_sysmutex_c.h"
+
+
+/* Implementation will be chosen at runtime based on available Kernel features */
+SDL_mutex_impl_t SDL_mutex_impl_active = {0};
+
+
+/**
+ * Implementation based on Slim Reader/Writer (SRW) Locks for Win 7 and newer.
+ */
+
+#if __WINRT__
+/* Functions are guaranteed to be available */
+#define pReleaseSRWLockExclusive ReleaseSRWLockExclusive
+#define pAcquireSRWLockExclusive AcquireSRWLockExclusive
+#define pTryAcquireSRWLockExclusive TryAcquireSRWLockExclusive
+#else
+typedef VOID(WINAPI *pfnReleaseSRWLockExclusive)(PSRWLOCK);
+typedef VOID(WINAPI *pfnAcquireSRWLockExclusive)(PSRWLOCK);
+typedef BOOLEAN(WINAPI *pfnTryAcquireSRWLockExclusive)(PSRWLOCK);
+static pfnReleaseSRWLockExclusive pReleaseSRWLockExclusive = NULL;
+static pfnAcquireSRWLockExclusive pAcquireSRWLockExclusive = NULL;
+static pfnTryAcquireSRWLockExclusive pTryAcquireSRWLockExclusive = NULL;
+#endif
+
+static SDL_mutex *
+SDL_CreateMutex_srw(void)
 {
-    CRITICAL_SECTION cs;
+    SDL_mutex_srw *mutex;
+
+    /* Relies on SRWLOCK_INIT == 0. */
+    mutex = (SDL_mutex_srw *) SDL_calloc(1, sizeof(*mutex));
+    if (!mutex) {
+        SDL_OutOfMemory();
+    }
+
+    return (SDL_mutex *)mutex;
+}
+
+static void
+SDL_DestroyMutex_srw(SDL_mutex * mutex)
+{
+    if (mutex) {
+        /* There are no kernel allocated resources */
+        SDL_free(mutex);
+    }
+}
+
+static int
+SDL_LockMutex_srw(SDL_mutex * _mutex)
+{
+    SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+    DWORD this_thread;
+
+    if (mutex == NULL) {
+        return SDL_SetError("Passed a NULL mutex");
+    }
+
+    this_thread = GetCurrentThreadId();
+    if (mutex->owner == this_thread) {
+        ++mutex->count;
+    } 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.
+         */
+        pAcquireSRWLockExclusive(&mutex->srw);
+        SDL_assert(mutex->count == 0 && mutex->owner == 0);
+        mutex->owner = this_thread;
+        mutex->count = 1;
+    }
+    return 0;
+}
+
+static int
+SDL_TryLockMutex_srw(SDL_mutex * _mutex)
+{
+    SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+    DWORD this_thread;
+    int retval = 0;
+
+    if (mutex == NULL) {
+        return SDL_SetError("Passed a NULL mutex");
+    }
+
+    this_thread = GetCurrentThreadId();
+    if (mutex->owner == this_thread) {
+        ++mutex->count;
+    } else {
+        if (pTryAcquireSRWLockExclusive(&mutex->srw) != 0) {
+            SDL_assert(mutex->count == 0 && mutex->owner == 0);
+            mutex->owner = this_thread;
+            mutex->count = 1;
+        } else {
+            retval = SDL_MUTEX_TIMEDOUT;
+        }
+    }
+    return retval;
+}
+
+static int
+SDL_UnlockMutex_srw(SDL_mutex * _mutex)
+{
+    SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+
+    if (mutex == NULL) {
+        return SDL_SetError("Passed a NULL mutex");
+    }
+
+    if (mutex->owner == GetCurrentThreadId()) {
+        if (--mutex->count == 0) {
+            mutex->owner = 0;
+            pReleaseSRWLockExclusive(&mutex->srw);
+        }
+    } else {
+        return SDL_SetError("mutex not owned by this thread");
+    }
+
+    return 0;
+}
+
+static const SDL_mutex_impl_t SDL_mutex_impl_srw =
+{
+    &SDL_CreateMutex_srw,
+    &SDL_DestroyMutex_srw,
+    &SDL_LockMutex_srw,
+    &SDL_TryLockMutex_srw,
+    &SDL_UnlockMutex_srw,
+    SDL_MUTEX_SRW,
 };
 
-/* Create a mutex */
-SDL_mutex *
-SDL_CreateMutex(void)
+
+/**
+ * Fallback Mutex implementation using Critical Sections (before Win 7)
+ */
+
+typedef struct SDL_mutex_cs
 {
-    SDL_mutex *mutex;
+    CRITICAL_SECTION cs;
+} SDL_mutex_cs;
+
+/* Create a mutex */
+static SDL_mutex *
+SDL_CreateMutex_cs(void)
+{
+    SDL_mutex_cs *mutex;
 
     /* Allocate mutex memory */
-    mutex = (SDL_mutex *) SDL_malloc(sizeof(*mutex));
+    mutex = (SDL_mutex_cs *) SDL_malloc(sizeof(*mutex));
     if (mutex) {
         /* Initialize */
         /* On SMP systems, a non-zero spin count generally helps performance */
@@ -53,13 +193,14 @@ SDL_CreateMutex(void)
     } else {
         SDL_OutOfMemory();
     }
-    return (mutex);
+    return (SDL_mutex *)mutex;
 }
 
 /* Free the mutex */
-void
-SDL_DestroyMutex(SDL_mutex * mutex)
+static void
+SDL_DestroyMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     if (mutex) {
         DeleteCriticalSection(&mutex->cs);
         SDL_free(mutex);
@@ -67,21 +208,23 @@ SDL_DestroyMutex(SDL_mutex * mutex)
 }
 
 /* Lock the mutex */
-int
-SDL_LockMutex(SDL_mutex * mutex)
+static int
+SDL_LockMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     if (mutex == NULL) {
         return SDL_SetError("Passed a NULL mutex");
     }
 
     EnterCriticalSection(&mutex->cs);
-    return (0);
+    return 0;
 }
 
 /* TryLock the mutex */
-int
-SDL_TryLockMutex(SDL_mutex * mutex)
+static int
+SDL_TryLockMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     int retval = 0;
     if (mutex == NULL) {
         return SDL_SetError("Passed a NULL mutex");
@@ -94,15 +237,84 @@ SDL_TryLockMutex(SDL_mutex * mutex)
 }
 
 /* Unlock the mutex */
-int
-SDL_UnlockMutex(SDL_mutex * mutex)
+static int
+SDL_UnlockMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     if (mutex == NULL) {
         return SDL_SetError("Passed a NULL mutex");
     }
 
     LeaveCriticalSection(&mutex->cs);
-    return (0);
+    return 0;
+}
+
+static const SDL_mutex_impl_t SDL_mutex_impl_cs =
+{
+    &SDL_CreateMutex_cs,
+    &SDL_DestroyMutex_cs,
+    &SDL_LockMutex_cs,
+    &SDL_TryLockMutex_cs,
+    &SDL_UnlockMutex_cs,
+    SDL_MUTEX_CS,
+};
+
+
+/**
+ * Runtime selection and redirection
+ */
+
+SDL_mutex *
+SDL_CreateMutex(void)
+{
+    if (SDL_mutex_impl_active.Create == NULL) {
+        /* Default to fallback implementation */
+        const SDL_mutex_impl_t * impl = &SDL_mutex_impl_cs;
+
+        if (!SDL_GetHintBoolean(SDL_HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS, SDL_FALSE)) {
+#if __WINRT__
+            /* Link statically on this platform */
+            impl = &SDL_mutex_impl_srw;
+#else
+            /* Try faster implementation for Windows 7 and newer */
+            HMODULE kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
+            if (kernel32) {
+                /* Requires Vista: */
+                pReleaseSRWLockExclusive = (pfnReleaseSRWLockExclusive) GetProcAddress(kernel32, "ReleaseSRWLockExclusive");
+                pAcquireSRWLockExclusive = (pfnAcquireSRWLockExclusive) GetProcAddress(kernel32, "AcquireSRWLockExclusive");
+                /* Requires 7: */
+                pTryAcquireSRWLockExclusive = (pfnTryAcquireSRWLockExclusive) GetProcAddress(kernel32, "TryAcquireSRWLockExclusive");
+                if (pReleaseSRWLockExclusive && pAcquireSRWLockExclusive && pTryAcquireSRWLockExclusive) {
+                    impl = &SDL_mutex_impl_srw;
+                }
+            }
+#endif
+        }
+
+        /* Copy instead of using pointer to save one level of indirection */
+        SDL_memcpy(&SDL_mutex_impl_active, impl, sizeof(SDL_mutex_impl_active));
+    }
+    return SDL_mutex_impl_active.Create();
+}
+
+void
+SDL_DestroyMutex(SDL_mutex * mutex) {
+    SDL_mutex_impl_active.Destroy(mutex);
+}
+
+int
+SDL_LockMutex(SDL_mutex * mutex) {
+    return SDL_mutex_impl_active.Lock(mutex);
+}
+
+int
+SDL_TryLockMutex(SDL_mutex * mutex) {
+    return SDL_mutex_impl_active.TryLock(mutex);
+}
+
+int
+SDL_UnlockMutex(SDL_mutex * mutex) {
+    return SDL_mutex_impl_active.Unlock(mutex);
 }
 
 #endif /* SDL_THREAD_WINDOWS */

externals/SDL/src/thread/windows/SDL_sysmutex_c.h

@@ -0,0 +1,69 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2021 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"
+
+#include "../../core/windows/SDL_windows.h"
+
+#include "SDL_mutex.h"
+
+typedef SDL_mutex * (*pfnSDL_CreateMutex)(void);
+typedef int (*pfnSDL_LockMutex)(SDL_mutex *);
+typedef int (*pfnSDL_TryLockMutex)(SDL_mutex *);
+typedef int (*pfnSDL_UnlockMutex)(SDL_mutex *);
+typedef void (*pfnSDL_DestroyMutex)(SDL_mutex *);
+
+typedef enum
+{
+    SDL_MUTEX_INVALID = 0,
+    SDL_MUTEX_SRW,
+    SDL_MUTEX_CS,
+} SDL_MutexType;
+
+typedef struct SDL_mutex_impl_t
+{
+    pfnSDL_CreateMutex  Create;
+    pfnSDL_DestroyMutex Destroy;
+    pfnSDL_LockMutex    Lock;
+    pfnSDL_TryLockMutex TryLock;
+    pfnSDL_UnlockMutex  Unlock;
+    /* Needed by SDL_cond: */
+    SDL_MutexType       Type;
+} SDL_mutex_impl_t;
+
+extern SDL_mutex_impl_t SDL_mutex_impl_active;
+
+
+#ifndef SRWLOCK_INIT
+#define SRWLOCK_INIT {0}
+typedef struct _SRWLOCK {
+    PVOID Ptr;
+} SRWLOCK, *PSRWLOCK;
+#endif
+
+typedef struct SDL_mutex_srw
+{
+    SRWLOCK srw;
+    /* SRW Locks are not recursive, that has to be handled by SDL: */
+    DWORD count;
+    DWORD owner;
+} SDL_mutex_srw;
+
+/* vi: set ts=4 sw=4 expandtab: */

externals/SDL/src/thread/windows/SDL_syssem.c

@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2021 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
@@ -22,27 +22,256 @@
 
 #if SDL_THREAD_WINDOWS
 
-/* Semaphore functions using the Win32 API */
+/**
+ * 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"
 
+#include "SDL_hints.h"
 #include "SDL_thread.h"
+#include "SDL_timer.h"
 
-struct SDL_semaphore
+typedef SDL_sem * (*pfnSDL_CreateSemaphore)(Uint32);
+typedef void (*pfnSDL_DestroySemaphore)(SDL_sem *);
+typedef int (*pfnSDL_SemWaitTimeout)(SDL_sem *, Uint32);
+typedef int (*pfnSDL_SemTryWait)(SDL_sem *);
+typedef int (*pfnSDL_SemWait)(SDL_sem *);
+typedef Uint32 (*pfnSDL_SemValue)(SDL_sem *);
+typedef int (*pfnSDL_SemPost)(SDL_sem *);
+
+typedef struct SDL_semaphore_impl_t
+{
+    pfnSDL_CreateSemaphore  Create;
+    pfnSDL_DestroySemaphore Destroy;
+    pfnSDL_SemWaitTimeout   WaitTimeout;
+    pfnSDL_SemTryWait       TryWait;
+    pfnSDL_SemWait          Wait;
+    pfnSDL_SemValue         Value;
+    pfnSDL_SemPost          Post;
+} 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 */
+
+#if (HAVE_WINAPIFAMILY_H) && defined(WINAPI_FAMILY_PHONE_APP)
+#define SDL_WINAPI_FAMILY_PHONE (WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
+#else
+#define SDL_WINAPI_FAMILY_PHONE 0
+#endif
+
+#if !SDL_WINAPI_FAMILY_PHONE
+#if __WINRT__
+/* Functions are guaranteed to be available */
+#define pWaitOnAddress WaitOnAddress
+#define pWakeByAddressSingle WakeByAddressSingle
+#else
+typedef BOOL(WINAPI *pfnWaitOnAddress)(volatile VOID*, PVOID, SIZE_T, DWORD);
+typedef VOID(WINAPI *pfnWakeByAddressSingle)(PVOID);
+
+static pfnWaitOnAddress pWaitOnAddress = NULL;
+static pfnWakeByAddressSingle pWakeByAddressSingle = NULL;
+#endif
+
+typedef struct SDL_semaphore_atom
+{
+    LONG count;
+} SDL_sem_atom;
+
+static SDL_sem *
+SDL_CreateSemaphore_atom(Uint32 initial_value)
+{
+    SDL_sem_atom *sem;
+
+    sem = (SDL_sem_atom *) SDL_malloc(sizeof(*sem));
+    if (sem) {
+        sem->count = initial_value;
+    } else {
+        SDL_OutOfMemory();
+    }
+    return (SDL_sem *)sem;
+}
+
+static void
+SDL_DestroySemaphore_atom(SDL_sem * sem)
+{
+    if (sem) {
+        SDL_free(sem);
+    }
+}
+
+static int
+SDL_SemTryWait_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+    LONG count;
+
+    if (!sem) {
+        return SDL_SetError("Passed a NULL sem");
+    }
+
+    count = sem->count;
+    if (count == 0) {
+        return SDL_MUTEX_TIMEDOUT;
+    }
+
+    if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
+        return 0;
+    }
+
+    return SDL_MUTEX_TIMEDOUT;
+}
+
+static int
+SDL_SemWait_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+    LONG count;
+
+    if (!sem) {
+        return SDL_SetError("Passed a NULL sem");
+    }
+
+    for (;;) {
+        count = sem->count;
+        while (count == 0) {
+            if (pWaitOnAddress(&sem->count, &count, sizeof(sem->count), INFINITE) == FALSE) {
+                return SDL_SetError("WaitOnAddress() failed");
+            }
+            count = sem->count;
+        }
+
+        if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
+            return 0;
+        }
+    }
+}
+
+static int
+SDL_SemWaitTimeout_atom(SDL_sem * _sem, Uint32 timeout)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+    LONG count;
+    Uint32 now;
+    Uint32 deadline;
+    DWORD timeout_eff;
+
+    if (timeout == SDL_MUTEX_MAXWAIT) {
+        return SDL_SemWait_atom(_sem);
+    }
+
+    if (!sem) {
+        return SDL_SetError("Passed a NULL sem");
+    }
+
+    /**
+     * WaitOnAddress is subject to spurious and stolen wakeups so we
+     * need to recalculate the effective timeout before every wait
+     */
+    now = SDL_GetTicks();
+    deadline = now + (DWORD) timeout;
+
+    for (;;) {
+        count = sem->count;
+        /* If no semaphore is available we need to wait */
+        while (count == 0) {
+            now = SDL_GetTicks();
+            if (deadline > now) {
+                timeout_eff = deadline - now;
+            } else {
+                return SDL_MUTEX_TIMEDOUT;
+            }
+            if (pWaitOnAddress(&sem->count, &count, sizeof(count), timeout_eff) == FALSE) {
+                if (GetLastError() == ERROR_TIMEOUT) {
+                    return SDL_MUTEX_TIMEDOUT;
+                }
+                return SDL_SetError("WaitOnAddress() failed");
+            }
+            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 0;
+        }
+    }
+}
+
+static Uint32
+SDL_SemValue_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+
+    if (!sem) {
+        SDL_SetError("Passed a NULL sem");
+        return 0;
+    }
+
+    return (Uint32)sem->count;
+}
+
+static int
+SDL_SemPost_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+
+    if (!sem) {
+        return SDL_SetError("Passed a NULL sem");
+    }
+
+    InterlockedIncrement(&sem->count);
+    pWakeByAddressSingle(&sem->count);
+
+    return 0;
+}
+
+static const SDL_sem_impl_t SDL_sem_impl_atom =
+{
+    &SDL_CreateSemaphore_atom,
+    &SDL_DestroySemaphore_atom,
+    &SDL_SemWaitTimeout_atom,
+    &SDL_SemTryWait_atom,
+    &SDL_SemWait_atom,
+    &SDL_SemValue_atom,
+    &SDL_SemPost_atom,
+};
+#endif /* !SDL_WINAPI_FAMILY_PHONE */
+
+
+/**
+ * Fallback Semaphore implementation using Kernel Semaphores
+ */
+
+typedef struct SDL_semaphore_kern
 {
     HANDLE id;
     LONG count;
-};
-
+} SDL_sem_kern;
 
 /* Create a semaphore */
-SDL_sem *
-SDL_CreateSemaphore(Uint32 initial_value)
+static SDL_sem *
+SDL_CreateSemaphore_kern(Uint32 initial_value)
 {
-    SDL_sem *sem;
+    SDL_sem_kern *sem;
 
     /* Allocate sem memory */
-    sem = (SDL_sem *) SDL_malloc(sizeof(*sem));
+    sem = (SDL_sem_kern *) SDL_malloc(sizeof(*sem));
     if (sem) {
         /* Create the semaphore, with max value 32K */
 #if __WINRT__
@@ -59,13 +288,14 @@ SDL_CreateSemaphore(Uint32 initial_value)
     } else {
         SDL_OutOfMemory();
     }
-    return (sem);
+    return (SDL_sem *)sem;
 }
 
 /* Free the semaphore */
-void
-SDL_DestroySemaphore(SDL_sem * sem)
+static void
+SDL_DestroySemaphore_kern(SDL_sem * _sem)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     if (sem) {
         if (sem->id) {
             CloseHandle(sem->id);
@@ -75,9 +305,10 @@ SDL_DestroySemaphore(SDL_sem * sem)
     }
 }
 
-int
-SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+static int
+SDL_SemWaitTimeout_kern(SDL_sem * _sem, Uint32 timeout)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     int retval;
     DWORD dwMilliseconds;
 
@@ -105,22 +336,23 @@ SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
     return retval;
 }
 
-int
-SDL_SemTryWait(SDL_sem * sem)
+static int
+SDL_SemTryWait_kern(SDL_sem * sem)
 {
-    return SDL_SemWaitTimeout(sem, 0);
+    return SDL_SemWaitTimeout_kern(sem, 0);
 }
 
-int
-SDL_SemWait(SDL_sem * sem)
+static int
+SDL_SemWait_kern(SDL_sem * sem)
 {
-    return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
+    return SDL_SemWaitTimeout_kern(sem, SDL_MUTEX_MAXWAIT);
 }
 
 /* Returns the current count of the semaphore */
-Uint32
-SDL_SemValue(SDL_sem * sem)
+static Uint32
+SDL_SemValue_kern(SDL_sem * _sem)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     if (!sem) {
         SDL_SetError("Passed a NULL sem");
         return 0;
@@ -128,9 +360,10 @@ SDL_SemValue(SDL_sem * sem)
     return (Uint32)sem->count;
 }
 
-int
-SDL_SemPost(SDL_sem * sem)
+static int
+SDL_SemPost_kern(SDL_sem * _sem)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     if (!sem) {
         return SDL_SetError("Passed a NULL sem");
     }
@@ -147,6 +380,97 @@ SDL_SemPost(SDL_sem * sem)
     return 0;
 }
 
+static const SDL_sem_impl_t SDL_sem_impl_kern =
+{
+    &SDL_CreateSemaphore_kern,
+    &SDL_DestroySemaphore_kern,
+    &SDL_SemWaitTimeout_kern,
+    &SDL_SemTryWait_kern,
+    &SDL_SemWait_kern,
+    &SDL_SemValue_kern,
+    &SDL_SemPost_kern,
+};
+
+
+/**
+ * Runtime selection and redirection
+ */
+
+SDL_sem *
+SDL_CreateSemaphore(Uint32 initial_value)
+{
+    if (SDL_sem_impl_active.Create == NULL) {
+        /* Default to fallback implementation */
+        const SDL_sem_impl_t * impl = &SDL_sem_impl_kern;
+
+#if !SDL_WINAPI_FAMILY_PHONE
+        if (!SDL_GetHintBoolean(SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL, SDL_FALSE)) {
+#if __WINRT__
+            /* Link statically on this platform */
+            impl = &SDL_sem_impl_atom;
+#else
+            /* 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;
+                }
+            }
+#endif
+        }
+#endif
+
+        /* Copy instead of using pointer to save one level of indirection */
+        SDL_memcpy(&SDL_sem_impl_active, impl, sizeof(SDL_sem_impl_active));
+    }
+    return SDL_sem_impl_active.Create(initial_value);
+}
+
+void
+SDL_DestroySemaphore(SDL_sem * sem)
+{
+    SDL_sem_impl_active.Destroy(sem);
+}
+
+int
+SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+{
+    return SDL_sem_impl_active.WaitTimeout(sem, timeout);
+}
+
+int
+SDL_SemTryWait(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.TryWait(sem);
+}
+
+int
+SDL_SemWait(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.Wait(sem);
+}
+
+Uint32
+SDL_SemValue(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.Value(sem);
+}
+
+int
+SDL_SemPost(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.Post(sem);
+}
+
 #endif /* SDL_THREAD_WINDOWS */
 
 /* vi: set ts=4 sw=4 expandtab: */

externals/SDL/src/thread/windows/SDL_systhread.c

@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2021 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
@@ -163,14 +163,14 @@ SDL_SYS_SetupThread(const char *name)
         static HMODULE kernel32 = 0;
 
         if (!kernel32) {
-            kernel32 = LoadLibraryW(L"kernel32.dll");
+            kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
             if (kernel32) {
                 pSetThreadDescription = (pfnSetThreadDescription) GetProcAddress(kernel32, "SetThreadDescription");
             }
         }
 
         if (pSetThreadDescription != NULL) {
-            WCHAR *strw = WIN_UTF8ToString(name);
+            WCHAR *strw = WIN_UTF8ToStringW(name);
             if (strw) {
                 pSetThreadDescription(GetCurrentThread(), strw);
                 SDL_free(strw);

externals/SDL/src/thread/windows/SDL_systhread_c.h

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

externals/SDL/src/thread/windows/SDL_systls.c

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