mirror of
https://github.com/libsdl-org/SDL.git
synced 2025-10-01 07:28:30 +00:00
352 lines
9.6 KiB
C
352 lines
9.6 KiB
C
/*
|
|
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
|