Add SDL_mutex implementation using Windows Slim Reader/Writer Locks Keep Critical Section impl for Windows XP/Vista - choose at runtime

v2: - Add SRW definitions as suggested by Ozkan Sezer
      Allows building against older platform headers.
    - Rename "hidden" function parameter `mutex_` to `_mutex`

v3: - Use GetModuleHandle instead of LoadLibrary
    - Fix typo in comment
This commit is contained in:
Joel Linn 2020-12-23 13:33:36 -08:00
parent 090fffac6a
commit 548cb90893
2 changed files with 259 additions and 19 deletions

View File

@ -1196,6 +1196,20 @@ extern "C" {
*/
#define SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING "SDL_WINDOWS_DISABLE_THREAD_NAMING"
/**
* \brief Force SDL to use Critical Sections for mutexes on Windows.
* On Windows 7 and newer, Slim Reader/Writer Locks are available.
* They offer better performance, allocate no kernel ressources and
* use less memory. SDL will fall back to Critical Sections on older
* OS versions or if forced to by this hint.
*
* This variable can be set to the following values:
* "0" - Use SRW Locks when available. If not, fall back to Critical Sections. (default)
* "1" - Force the use of Critical Sections in all cases.
*
*/
#define SDL_HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS "SDL_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS"
/**
* \brief Tell SDL which Dispmanx layer to use on a Raspberry PI
*

View File

@ -22,26 +22,186 @@
#if SDL_THREAD_WINDOWS
/* Mutex functions using the Win32 API */
/**
* 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.
*/
#include "../../core/windows/SDL_windows.h"
#include "SDL_hints.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 *);
struct SDL_mutex
typedef struct SDL_mutex_impl_t
{
CRITICAL_SECTION cs;
pfnSDL_CreateMutex Create;
pfnSDL_DestroyMutex Destroy;
pfnSDL_LockMutex Lock;
pfnSDL_TryLockMutex TryLock;
pfnSDL_UnlockMutex Unlock;
} SDL_mutex_impl_t;
/* Implementation will be chosen at runtime based on available Kernel features */
static SDL_mutex_impl_t SDL_mutex_impl_active = {0};
/**
* Implementation based on Slim Reader/Writer (SRW) Locks for Win 7 and newer.
*/
#ifndef SRWLOCK_INIT
#define SRWLOCK_INIT {0}
typedef struct _SRWLOCK {
PVOID Ptr;
} SRWLOCK, *PSRWLOCK;
#endif
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;
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;
static SDL_mutex *
SDL_CreateMutex_srw(void)
{
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);
mutex->owner = this_thread;
++mutex->count;
}
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) {
mutex->owner = this_thread;
++mutex->count;
} 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,
};
/* 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 +213,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 +228,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 +257,78 @@ 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,
};
/**
* 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)) {
/* Try faster implementation for Windows 7 and newer */
HMODULE kernel32 = GetModuleHandleW(L"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;
}
}
}
/* 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 */