SDL/SDL_syssem.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002  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@libsdl.org
  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 "SDL_error.h"
  31 #include "SDL_thread.h"
  32 #include "SDL_systhread_c.h"
  33
  34 #ifdef __AROS__
  35 #include "SDL_timer.h"
  36 #include <stdlib.h>
  37 #endif
  38
  39 struct SDL_semaphore
  40 {
  41         struct SignalSemaphore Sem;
  42         Uint32 count;
  43         Uint32 waiters_count;
  44         SDL_mutex *count_lock;
  45         SDL_cond *count_nonzero;
  46 };
  47
  48 #undef D
  49
  50 #define D(x)
  51
  52 SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
  53 {
  54         SDL_sem *sem;
  55
  56         sem = (SDL_sem *)malloc(sizeof(*sem));
  57
  58         if ( ! sem ) {
  59                 SDL_OutOfMemory();
  60                 return(0);
  61         }
  62
  63         D(bug("Creating semaphore %lx...\n",sem));
  64
  65         memset(sem,0,sizeof(*sem));
  66
  67         InitSemaphore(&sem->Sem);
  68
  69         return(sem);
  70 }
  71
  72 void SDL_DestroySemaphore(SDL_sem *sem)
  73 {
  74         D(bug("Destroying semaphore %lx...\n",sem));
  75
  76         if ( sem ) {
  77 // Condizioni per liberare i task in attesa?
  78                 free(sem);
  79         }
  80 }
  81
  82 int SDL_SemTryWait(SDL_sem *sem)
  83 {
  84         if ( ! sem ) {
  85                 SDL_SetError("Passed a NULL semaphore");
  86                 return -1;
  87         }
  88
  89         D(bug("TryWait semaphore...%lx\n",sem));
  90
  91         ObtainSemaphore(&sem->Sem);
  92 //      ReleaseSemaphore(&sem->Sem);
  93
  94         return 1;
  95 }
  96
  97 int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
  98 {
  99         int retval;
 100
 101
 102         if ( ! sem ) {
 103                 SDL_SetError("Passed a NULL semaphore");
 104                 return -1;
 105         }
 106
 107         D(bug("WaitTimeout (%ld) semaphore...%lx\n",timeout,sem));
 108
 109         /* A timeout of 0 is an easy case */
 110         if ( timeout == 0 ) {
 111                 return SDL_SemTryWait(sem);
 112         }
 113 /*
 114         SDL_LockMutex(sem->count_lock);
 115         ++sem->waiters_count;
 116         retval = 0;
 117         while ( (sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT) ) {
 118                 retval = SDL_CondWaitTimeout(sem->count_nonzero,
 119                                              sem->count_lock, timeout);
 120         }
 121         --sem->waiters_count;
 122         --sem->count;
 123         SDL_UnlockMutex(sem->count_lock);
 124 */
 125         if(!(retval=AttemptSemaphore(&sem->Sem)))
 126         {
 127                 SDL_Delay(timeout);
 128                 retval=AttemptSemaphore(&sem->Sem);
 129         }
 130
 131         if(retval==TRUE)
 132         {
 133 //              ReleaseSemaphore(&sem->Sem);
 134                 retval=1;
 135         }
 136
 137         return retval;
 138 }
 139
 140 int SDL_SemWait(SDL_sem *sem)
 141 {
 142         ObtainSemaphore(&sem->Sem);
 143         return 0;
 144 //      return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
 145 }
 146
 147 Uint32 SDL_SemValue(SDL_sem *sem)
 148 {
 149         Uint32 value;
 150
 151         value = 0;
 152         if ( sem ) {
 153                 #ifdef WARPOS
 154                 value = sem->Sem.ssppc_SS.ss_NestCount;
 155                 #else
 156                 value = sem->Sem.ss_NestCount;
 157                 #endif
 158 //              SDL_UnlockMutex(sem->count_lock);
 159         }
 160         return value;
 161 }
 162
 163 int SDL_SemPost(SDL_sem *sem)
 164 {
 165         if ( ! sem ) {
 166                 SDL_SetError("Passed a NULL semaphore");
 167                 return -1;
 168         }
 169         D(bug("SemPost semaphore...%lx\n",sem));
 170
 171         ReleaseSemaphore(&sem->Sem);
 172 #if 0
 173         SDL_LockMutex(sem->count_lock);
 174         if ( sem->waiters_count > 0 ) {
 175                 SDL_CondSignal(sem->count_nonzero);
 176         }
 177         ++sem->count;
 178         SDL_UnlockMutex(sem->count_lock);
 179 #endif
 180         return 0;
 181 }
 182