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@libsdl.org

    21 */

    22 #include "SDL_config.h"

    23 

    24 /* An implementation of semaphores using mutexes and condition variables */

    25 

    26 #include "SDL_timer.h"

    27 #include "SDL_thread.h"

    28 #include "SDL_systhread_c.h"

    29 

    30 

    31 #if SDL_THREADS_DISABLED

    32 

    33 SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)

    34 {

    35 	SDL_SetError("SDL not configured with thread support");

    36 	return (SDL_sem *)0;

    37 }

    38 

    39 void SDL_DestroySemaphore(SDL_sem *sem)

    40 {

    41 	return;

    42 }

    43 

    44 int SDL_SemTryWait(SDL_sem *sem)

    45 {

    46 	SDL_SetError("SDL not configured with thread support");

    47 	return -1;

    48 }

    49 

    50 int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)

    51 {

    52 	SDL_SetError("SDL not configured with thread support");

    53 	return -1;

    54 }

    55 

    56 int SDL_SemWait(SDL_sem *sem)

    57 {

    58 	SDL_SetError("SDL not configured with thread support");

    59 	return -1;

    60 }

    61 

    62 Uint32 SDL_SemValue(SDL_sem *sem)

    63 {

    64 	return 0;

    65 }

    66 

    67 int SDL_SemPost(SDL_sem *sem)

    68 {

    69 	SDL_SetError("SDL not configured with thread support");

    70 	return -1;

    71 }

    72 

    73 #else

    74 

    75 struct SDL_semaphore

    76 {

    77 	Uint32 count;

    78 	Uint32 waiters_count;

    79 	SDL_mutex *count_lock;

    80 	SDL_cond *count_nonzero;

    81 };

    82 

    83 SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)

    84 {

    85 	SDL_sem *sem;

    86 

    87 	sem = (SDL_sem *)SDL_malloc(sizeof(*sem));

    88 	if ( ! sem ) {

    89 		SDL_OutOfMemory();

    90 		return NULL;

    91 	}

    92 	sem->count = initial_value;

    93 	sem->waiters_count = 0;

    94 

    95 	sem->count_lock = SDL_CreateMutex();

    96 	sem->count_nonzero = SDL_CreateCond();

    97 	if ( ! sem->count_lock || ! sem->count_nonzero ) {

    98 		SDL_DestroySemaphore(sem);

    99 		return NULL;

   100 	}

   101 

   102 	return sem;

   103 }

   104 

   105 /* WARNING:

   106    You cannot call this function when another thread is using the semaphore.

   107 */

   108 void SDL_DestroySemaphore(SDL_sem *sem)

   109 {

   110 	if ( sem ) {

   111 		sem->count = 0xFFFFFFFF;

   112 		while ( sem->waiters_count > 0) {

   113 			SDL_CondSignal(sem->count_nonzero);

   114 			SDL_Delay(10);

   115 		}

   116 		SDL_DestroyCond(sem->count_nonzero);

   117 		if ( sem->count_lock ) {

   118 			SDL_mutexP(sem->count_lock);

   119 			SDL_mutexV(sem->count_lock);

   120 			SDL_DestroyMutex(sem->count_lock);

   121 		}

   122 		SDL_free(sem);

   123 	}

   124 }

   125 

   126 int SDL_SemTryWait(SDL_sem *sem)

   127 {

   128 	int retval;

   129 

   130 	if ( ! sem ) {

   131 		SDL_SetError("Passed a NULL semaphore");

   132 		return -1;

   133 	}

   134 

   135 	retval = SDL_MUTEX_TIMEDOUT;

   136 	SDL_LockMutex(sem->count_lock);

   137 	if ( sem->count > 0 ) {

   138 		--sem->count;

   139 		retval = 0;

   140 	}

   141 	SDL_UnlockMutex(sem->count_lock);

   142 

   143 	return retval;

   144 }

   145 

   146 int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)

   147 {

   148 	int retval;

   149 

   150 	if ( ! sem ) {

   151 		SDL_SetError("Passed a NULL semaphore");

   152 		return -1;

   153 	}

   154 

   155 	/* A timeout of 0 is an easy case */

   156 	if ( timeout == 0 ) {

   157 		return SDL_SemTryWait(sem);

   158 	}

   159 

   160 	SDL_LockMutex(sem->count_lock);

   161 	++sem->waiters_count;

   162 	retval = 0;

   163 	while ( (sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT) ) {

   164 		retval = SDL_CondWaitTimeout(sem->count_nonzero,

   165 		                             sem->count_lock, timeout);

   166 	}

   167 	--sem->waiters_count;

   168 	--sem->count;

   169 	SDL_UnlockMutex(sem->count_lock);

   170 

   171 	return retval;

   172 }

   173 

   174 int SDL_SemWait(SDL_sem *sem)

   175 {

   176 	return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);

   177 }

   178 

   179 Uint32 SDL_SemValue(SDL_sem *sem)

   180 {

   181 	Uint32 value;

   182 	

   183 	value = 0;

   184 	if ( sem ) {

   185 		SDL_LockMutex(sem->count_lock);

   186 		value = sem->count;

   187 		SDL_UnlockMutex(sem->count_lock);

   188 	}

   189 	return value;

   190 }

   191 

   192 int SDL_SemPost(SDL_sem *sem)

   193 {

   194 	if ( ! sem ) {

   195 		SDL_SetError("Passed a NULL semaphore");

   196 		return -1;

   197 	}

   198 

   199 	SDL_LockMutex(sem->count_lock);

   200 	if ( sem->waiters_count > 0 ) {

   201 		SDL_CondSignal(sem->count_nonzero);

   202 	}

   203 	++sem->count;

   204 	SDL_UnlockMutex(sem->count_lock);

   205 

   206 	return 0;

   207 }

   208 

   209 #endif /* SDL_THREADS_DISABLED */