Atlas - SDL_syssem.c
Home / ext / SDL / src / thread / generic
Lines: 1 | Size: 4537 bytes
[Download] [Show on GitHub] [Search similar files] [Raw] [Raw (proxy)] 
[FILE BEGIN]
1/*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2025 Sam Lantinga <[email protected]>
4
5  This software is provided 'as-is', without any express or implied
6  warranty.  In no event will the authors be held liable for any damages
7  arising from the use of this software.
8
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12
13  1. The origin of this software must not be misrepresented; you must not
14     claim that you wrote the original software. If you use this software
15     in a product, an acknowledgment in the product documentation would be
16     appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18     misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20*/
21#include "SDL_internal.h"
22
23// An implementation of semaphores using mutexes and condition variables
24
25#include "SDL_systhread_c.h"
26
27#ifdef SDL_THREADS_DISABLED
28
29SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value)
30{
31    SDL_SetError("SDL not built with thread support");
32    return NULL;
33}
34
35void SDL_DestroySemaphore(SDL_Semaphore *sem)
36{
37}
38
39bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
40{
41    return true;
42}
43
44Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
45{
46    return 0;
47}
48
49void SDL_SignalSemaphore(SDL_Semaphore *sem)
50{
51    return;
52}
53
54#else
55
56struct SDL_Semaphore
57{
58    Uint32 count;
59    Uint32 waiters_count;
60    SDL_Mutex *count_lock;
61    SDL_Condition *count_nonzero;
62};
63
64SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value)
65{
66    SDL_Semaphore *sem;
67
68    sem = (SDL_Semaphore *)SDL_malloc(sizeof(*sem));
69    if (!sem) {
70        return NULL;
71    }
72    sem->count = initial_value;
73    sem->waiters_count = 0;
74
75    sem->count_lock = SDL_CreateMutex();
76    sem->count_nonzero = SDL_CreateCondition();
77    if (!sem->count_lock || !sem->count_nonzero) {
78        SDL_DestroySemaphore(sem);
79        return NULL;
80    }
81
82    return sem;
83}
84
85/* WARNING:
86   You cannot call this function when another thread is using the semaphore.
87*/
88void SDL_DestroySemaphore(SDL_Semaphore *sem)
89{
90    if (sem) {
91        sem->count = 0xFFFFFFFF;
92        while (sem->waiters_count > 0) {
93            SDL_SignalCondition(sem->count_nonzero);
94            SDL_Delay(10);
95        }
96        SDL_DestroyCondition(sem->count_nonzero);
97        if (sem->count_lock) {
98            SDL_LockMutex(sem->count_lock);
99            SDL_UnlockMutex(sem->count_lock);
100            SDL_DestroyMutex(sem->count_lock);
101        }
102        SDL_free(sem);
103    }
104}
105
106bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
107{
108    bool result = false;
109
110    if (!sem) {
111        return true;
112    }
113
114    if (timeoutNS == 0) {
115        SDL_LockMutex(sem->count_lock);
116        if (sem->count > 0) {
117            --sem->count;
118            result = true;
119        }
120        SDL_UnlockMutex(sem->count_lock);
121    } else if (timeoutNS < 0) {
122        SDL_LockMutex(sem->count_lock);
123        ++sem->waiters_count;
124        while (sem->count == 0) {
125            SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, -1);
126        }
127        --sem->waiters_count;
128        --sem->count;
129        result = true;
130        SDL_UnlockMutex(sem->count_lock);
131    } else {
132        Uint64 stop_time = SDL_GetTicksNS() + timeoutNS;
133
134        SDL_LockMutex(sem->count_lock);
135        ++sem->waiters_count;
136        while (sem->count == 0) {
137            Sint64 waitNS = (Sint64)(stop_time - SDL_GetTicksNS());
138            if (waitNS > 0) {
139                SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, waitNS);
140            } else {
141                break;
142            }
143        }
144        --sem->waiters_count;
145
146        if (sem->count > 0) {
147            --sem->count;
148            result = true;
149        }
150        SDL_UnlockMutex(sem->count_lock);
151    }
152
153    return result;
154}
155
156Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
157{
158    Uint32 value;
159
160    value = 0;
161    if (sem) {
162        SDL_LockMutex(sem->count_lock);
163        value = sem->count;
164        SDL_UnlockMutex(sem->count_lock);
165    }
166    return value;
167}
168
169void SDL_SignalSemaphore(SDL_Semaphore *sem)
170{
171    if (!sem) {
172        return;
173    }
174
175    SDL_LockMutex(sem->count_lock);
176    if (sem->waiters_count > 0) {
177        SDL_SignalCondition(sem->count_nonzero);
178    }
179    ++sem->count;
180    SDL_UnlockMutex(sem->count_lock);
181}
182
183#endif // SDL_THREADS_DISABLED
184
[FILE END]
(C) 2025 0x4248
(C) 2025 4248 Media and 4248 Systems, All part of 0x4248
See LICENCE files for more information. Not all files are by 0x4248 always check Licencing.