This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_syssem.c
228 lines (188 loc) · 4.59 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@devolution.com
*/
#ifdef SAVE_RCSID
static char rcsid =
25
"@(#) $Id: SDL_syssem.c,v 1.2 2001/04/26 16:50:18 hercules Exp $";
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#endif
/* An implementation of semaphores using mutexes and condition variables */
#include <stdlib.h>
#include "SDL_error.h"
#include "SDL_timer.h"
#include "SDL_thread.h"
#include "SDL_systhread_c.h"
#ifdef DISABLE_THREADS
40
41
SDL_sem *
SDL_CreateSemaphore(Uint32 initial_value)
42
{
43
44
SDL_SetError("SDL not configured with thread support");
return (SDL_sem *) 0;
45
46
}
47
48
void
SDL_DestroySemaphore(SDL_sem * sem)
49
{
50
return;
51
52
}
53
54
int
SDL_SemTryWait(SDL_sem * sem)
55
{
56
57
SDL_SetError("SDL not configured with thread support");
return -1;
58
59
}
60
61
int
SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
62
{
63
64
SDL_SetError("SDL not configured with thread support");
return -1;
65
66
}
67
68
int
SDL_SemWait(SDL_sem * sem)
69
{
70
71
SDL_SetError("SDL not configured with thread support");
return -1;
72
73
}
74
75
Uint32
SDL_SemValue(SDL_sem * sem)
76
{
77
return 0;
78
79
}
80
81
int
SDL_SemPost(SDL_sem * sem)
82
{
83
84
SDL_SetError("SDL not configured with thread support");
return -1;
85
86
87
88
89
90
}
#else
struct SDL_semaphore
{
91
92
93
94
Uint32 count;
Uint32 waiters_count;
SDL_mutex *count_lock;
SDL_cond *count_nonzero;
95
96
};
97
98
SDL_sem *
SDL_CreateSemaphore(Uint32 initial_value)
99
{
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
SDL_sem *sem;
sem = (SDL_sem *) malloc(sizeof(*sem));
if (!sem) {
SDL_OutOfMemory();
return (0);
}
sem->count = initial_value;
sem->waiters_count = 0;
sem->count_lock = SDL_CreateMutex();
sem->count_nonzero = SDL_CreateCond();
if (!sem->count_lock || !sem->count_nonzero) {
SDL_DestroySemaphore(sem);
return (0);
}
return (sem);
118
119
120
121
122
}
/* WARNING:
You cannot call this function when another thread is using the semaphore.
*/
123
124
void
SDL_DestroySemaphore(SDL_sem * sem)
125
{
126
127
128
129
130
131
132
133
134
135
136
137
if (sem) {
sem->count = 0xFFFFFFFF;
while (sem->waiters_count > 0) {
SDL_CondSignal(sem->count_nonzero);
SDL_Delay(10);
}
SDL_DestroyCond(sem->count_nonzero);
SDL_mutexP(sem->count_lock);
SDL_mutexV(sem->count_lock);
SDL_DestroyMutex(sem->count_lock);
free(sem);
}
138
139
}
140
141
int
SDL_SemTryWait(SDL_sem * sem)
142
{
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
int retval;
if (!sem) {
SDL_SetError("Passed a NULL semaphore");
return -1;
}
retval = SDL_MUTEX_TIMEDOUT;
SDL_LockMutex(sem->count_lock);
if (sem->count > 0) {
--sem->count;
retval = 0;
}
SDL_UnlockMutex(sem->count_lock);
return retval;
159
160
}
161
162
int
SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
163
{
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
int retval;
if (!sem) {
SDL_SetError("Passed a NULL semaphore");
return -1;
}
/* A timeout of 0 is an easy case */
if (timeout == 0) {
return SDL_SemTryWait(sem);
}
SDL_LockMutex(sem->count_lock);
++sem->waiters_count;
retval = 0;
while ((sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT)) {
retval = SDL_CondWaitTimeout(sem->count_nonzero,
sem->count_lock, timeout);
}
--sem->waiters_count;
--sem->count;
SDL_UnlockMutex(sem->count_lock);
return retval;
188
189
}
190
191
int
SDL_SemWait(SDL_sem * sem)
192
{
193
return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
194
195
}
196
197
Uint32
SDL_SemValue(SDL_sem * sem)
198
{
199
200
201
202
203
204
205
206
207
Uint32 value;
value = 0;
if (sem) {
SDL_LockMutex(sem->count_lock);
value = sem->count;
SDL_UnlockMutex(sem->count_lock);
}
return value;
208
209
}
210
211
int
SDL_SemPost(SDL_sem * sem)
212
{
213
214
215
216
217
218
219
220
221
222
223
224
225
if (!sem) {
SDL_SetError("Passed a NULL semaphore");
return -1;
}
SDL_LockMutex(sem->count_lock);
if (sem->waiters_count > 0) {
SDL_CondSignal(sem->count_nonzero);
}
++sem->count;
SDL_UnlockMutex(sem->count_lock);
return 0;
226
227
228
}
#endif /* DISABLE_THREADS */