Mercurial > sdl-ios-xcode

comparison src/thread/generic/SDL_syssem.c @ 0:74212992fb08

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