We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

[patch] 0004 Add SDL_sem implementation using Atomics and WaitOnAddress API.

0004-Add-SDL_sem-implementation-using-Atomics-and-WaitOnA.patch (text/plain), 11.48 KB, created by Joel Linn on 2020-12-10 10:00:22 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Joel Linn

Created: 2020-12-10 10:00:22 UTC

Size: 11.48 KB

patch

obsolete

>From 0e7e64301dbc4ab9ae07165c5975f5c297bcc125 Mon Sep 17 00:00:00 2001
>From: Joel Linn <jl@conductive.de>
>Date: Tue, 8 Dec 2020 02:18:29 +0100
>Subject: [PATCH 4/4] Add SDL_sem implementation using Atomics and
> WaitOnAddress API.
>
>Keep Semaphore Kernel Obejct impl for Windows 7 and older - choose at runtime
>---
> include/SDL_hints.h             |  16 ++
> src/thread/windows/SDL_syssem.c | 338 +++++++++++++++++++++++++++++---
> 2 files changed, 332 insertions(+), 22 deletions(-)
>
>diff --git a/include/SDL_hints.h b/include/SDL_hints.h
>index b73b06e28..4efbe7a67 100644
>--- a/include/SDL_hints.h
>+++ b/include/SDL_hints.h
>@@ -1173,6 +1173,22 @@ extern "C" {
>  */
> #define SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING "SDL_WINDOWS_DISABLE_THREAD_NAMING"
> 
>+/**
>+ * \brief Force SDL to use Kernel Semaphores on Windows.
>+ *        Kernel Semaphores are inter-process and require a context
>+ *        switch on every interaction. On Windows 8 and newer, the
>+ *        WaitOnAddress API is available. Using that and atomics to
>+ *        implement semaphores increases performance.
>+ *        SDL will fall back to Kernel Objects on older OS versions
>+ *        or if forced to by this hint.
>+ *
>+ *  This variable can be set to the following values:
>+ *    "0"       - Use Atomics and WaitOnAddress API when available. If not, fall back to Kernel Objects. (default)
>+ *    "1"       - Force the use of Kernel Objects in all cases.
>+ *
>+ */
>+#define SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL "SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL"
>+
> /**
>  * \brief Tell SDL which Dispmanx layer to use on a Raspberry PI
>  *
>diff --git a/src/thread/windows/SDL_syssem.c b/src/thread/windows/SDL_syssem.c
>index 217ea32c7..06507f80c 100644
>--- a/src/thread/windows/SDL_syssem.c
>+++ b/src/thread/windows/SDL_syssem.c
>@@ -22,27 +22,239 @@
> 
> #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"
> 
>-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
>+ */
>+
>+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
> {
>-    HANDLE id;
>     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_SemWaitTimeout_atom(SDL_sem * _sem, Uint32 timeout)
>+{
>+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
>+    int 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 int
>+SDL_SemTryWait_atom(SDL_sem * _sem)
>+{
>+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
>+    int 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;
>+    int count;
>+
>+    if (!sem) {
>+        return SDL_SetError("Passed a NULL sem");
>+    }
>+    
>+    for (;;) {
>+        count = sem->count;
>+        while (count == 0) {
>+            if (pWaitOnAddress(&sem->count, &count, sizeof(count), INFINITE) == FALSE) {
>+                return SDL_SetError("WaitOnAddress() failed");
>+            }
>+            count = sem->count;
>+        }
>+    
>+        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;
>+    Uint32 count;
>+
>+    if (!sem) {
>+        SDL_SetError("Passed a NULL sem");
>+        return 0;
>+    }
>+
>+    return 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,
> };
> 
> 
>+/**
>+ * 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 +271,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 +288,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 +319,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 +343,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 +363,84 @@ 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_GetHintBoolean(SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL, SDL_FALSE)) {
>+            HMODULE synch120 = LoadLibraryW(L"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_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: */
>-- 
>2.29.2.windows.1
>

Actions: View | Diff

Attachments on bug 5389: 4565 | 4566 | 4567 | 4568 | 4569 | 4570 | 4577 | 4584

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.