1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2006 Sam Lantinga 4 5 This library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public 7 License as published by the Free Software Foundation; either 8 version 2.1 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 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 19 Sam Lantinga 20 slouken (at) libsdl.org 21 */ 22 #include "SDL_config.h" 23 24 /* An implementation of condition variables using semaphores and mutexes */ 25 /* 26 This implementation borrows heavily from the BeOS condition variable 27 implementation, written by Christopher Tate and Owen Smith. Thanks! 28 */ 29 30 #include "SDL_thread.h" 31 32 struct SDL_cond 33 { 34 SDL_mutex *lock; 35 int waiting; 36 int signals; 37 SDL_sem *wait_sem; 38 SDL_sem *wait_done; 39 }; 40 41 /* Create a condition variable */ 42 SDL_cond * SDL_CreateCond(void) 43 { 44 SDL_cond *cond; 45 46 cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond)); 47 if ( cond ) { 48 cond->lock = SDL_CreateMutex(); 49 cond->wait_sem = SDL_CreateSemaphore(0); 50 cond->wait_done = SDL_CreateSemaphore(0); 51 cond->waiting = cond->signals = 0; 52 if ( ! cond->lock || ! cond->wait_sem || ! cond->wait_done ) { 53 SDL_DestroyCond(cond); 54 cond = NULL; 55 } 56 } else { 57 SDL_OutOfMemory(); 58 } 59 return(cond); 60 } 61 62 /* Destroy a condition variable */ 63 void SDL_DestroyCond(SDL_cond *cond) 64 { 65 if ( cond ) { 66 if ( cond->wait_sem ) { 67 SDL_DestroySemaphore(cond->wait_sem); 68 } 69 if ( cond->wait_done ) { 70 SDL_DestroySemaphore(cond->wait_done); 71 } 72 if ( cond->lock ) { 73 SDL_DestroyMutex(cond->lock); 74 } 75 SDL_free(cond); 76 } 77 } 78 79 /* Restart one of the threads that are waiting on the condition variable */ 80 int SDL_CondSignal(SDL_cond *cond) 81 { 82 if ( ! cond ) { 83 SDL_SetError("Passed a NULL condition variable"); 84 return -1; 85 } 86 87 /* If there are waiting threads not already signalled, then 88 signal the condition and wait for the thread to respond. 89 */ 90 SDL_LockMutex(cond->lock); 91 if ( cond->waiting > cond->signals ) { 92 ++cond->signals; 93 SDL_SemPost(cond->wait_sem); 94 SDL_UnlockMutex(cond->lock); 95 SDL_SemWait(cond->wait_done); 96 } else { 97 SDL_UnlockMutex(cond->lock); 98 } 99 100 return 0; 101 } 102 103 /* Restart all threads that are waiting on the condition variable */ 104 int SDL_CondBroadcast(SDL_cond *cond) 105 { 106 if ( ! cond ) { 107 SDL_SetError("Passed a NULL condition variable"); 108 return -1; 109 } 110 111 /* If there are waiting threads not already signalled, then 112 signal the condition and wait for the thread to respond. 113 */ 114 SDL_LockMutex(cond->lock); 115 if ( cond->waiting > cond->signals ) { 116 int i, num_waiting; 117 118 num_waiting = (cond->waiting - cond->signals); 119 cond->signals = cond->waiting; 120 for ( i=0; i<num_waiting; ++i ) { 121 SDL_SemPost(cond->wait_sem); 122 } 123 /* Now all released threads are blocked here, waiting for us. 124 Collect them all (and win fabulous prizes!) :-) 125 */ 126 SDL_UnlockMutex(cond->lock); 127 for ( i=0; i<num_waiting; ++i ) { 128 SDL_SemWait(cond->wait_done); 129 } 130 } else { 131 SDL_UnlockMutex(cond->lock); 132 } 133 134 return 0; 135 } 136 137 /* Wait on the condition variable for at most 'ms' milliseconds. 138 The mutex must be locked before entering this function! 139 The mutex is unlocked during the wait, and locked again after the wait. 140 141 Typical use: 142 143 Thread A: 144 SDL_LockMutex(lock); 145 while ( ! condition ) { 146 SDL_CondWait(cond); 147 } 148 SDL_UnlockMutex(lock); 149 150 Thread B: 151 SDL_LockMutex(lock); 152 ... 153 condition = true; 154 ... 155 SDL_UnlockMutex(lock); 156 */ 157 int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms) 158 { 159 int retval; 160 161 if ( ! cond ) { 162 SDL_SetError("Passed a NULL condition variable"); 163 return -1; 164 } 165 166 /* Obtain the protection mutex, and increment the number of waiters. 167 This allows the signal mechanism to only perform a signal if there 168 are waiting threads. 169 */ 170 SDL_LockMutex(cond->lock); 171 ++cond->waiting; 172 SDL_UnlockMutex(cond->lock); 173 174 /* Unlock the mutex, as is required by condition variable semantics */ 175 SDL_UnlockMutex(mutex); 176 177 /* Wait for a signal */ 178 if ( ms == SDL_MUTEX_MAXWAIT ) { 179 retval = SDL_SemWait(cond->wait_sem); 180 } else { 181 retval = SDL_SemWaitTimeout(cond->wait_sem, ms); 182 } 183 184 /* Let the signaler know we have completed the wait, otherwise 185 the signaler can race ahead and get the condition semaphore 186 if we are stopped between the mutex unlock and semaphore wait, 187 giving a deadlock. See the following URL for details: 188 http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html 189 */ 190 SDL_LockMutex(cond->lock); 191 if ( cond->signals > 0 ) { 192 /* If we timed out, we need to eat a condition signal */ 193 if ( retval > 0 ) { 194 SDL_SemWait(cond->wait_sem); 195 } 196 /* We always notify the signal thread that we are done */ 197 SDL_SemPost(cond->wait_done); 198 199 /* Signal handshake complete */ 200 --cond->signals; 201 } 202 --cond->waiting; 203 SDL_UnlockMutex(cond->lock); 204 205 /* Lock the mutex, as is required by condition variable semantics */ 206 SDL_LockMutex(mutex); 207 208 return retval; 209 } 210 211 /* Wait on the condition variable forever */ 212 int SDL_CondWait(SDL_cond *cond, SDL_mutex *mutex) 213 { 214 return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT); 215 } 216
