aboutsummaryrefslogtreecommitdiffstats
path: root/distrib/sdl-1.2.15/src/thread/pthread
diff options
context:
space:
mode:
Diffstat (limited to 'distrib/sdl-1.2.15/src/thread/pthread')
-rw-r--r--distrib/sdl-1.2.15/src/thread/pthread/SDL_syscond.c155
-rw-r--r--distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex.c153
-rw-r--r--distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex_c.h31
-rw-r--r--distrib/sdl-1.2.15/src/thread/pthread/SDL_syssem.c190
-rw-r--r--distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread.c120
-rw-r--r--distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread_c.h26
6 files changed, 675 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/src/thread/pthread/SDL_syscond.c b/distrib/sdl-1.2.15/src/thread/pthread/SDL_syscond.c
new file mode 100644
index 0000000..15bce96
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/thread/pthread/SDL_syscond.c
@@ -0,0 +1,155 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include "SDL_thread.h"
+#include "SDL_sysmutex_c.h"
+
+struct SDL_cond
+{
+ pthread_cond_t cond;
+};
+
+/* Create a condition variable */
+SDL_cond * SDL_CreateCond(void)
+{
+ SDL_cond *cond;
+
+ cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond));
+ if ( cond ) {
+ if ( pthread_cond_init(&cond->cond, NULL) < 0 ) {
+ SDL_SetError("pthread_cond_init() failed");
+ SDL_free(cond);
+ cond = NULL;
+ }
+ }
+ return(cond);
+}
+
+/* Destroy a condition variable */
+void SDL_DestroyCond(SDL_cond *cond)
+{
+ if ( cond ) {
+ pthread_cond_destroy(&cond->cond);
+ SDL_free(cond);
+ }
+}
+
+/* Restart one of the threads that are waiting on the condition variable */
+int SDL_CondSignal(SDL_cond *cond)
+{
+ int retval;
+
+ if ( ! cond ) {
+ SDL_SetError("Passed a NULL condition variable");
+ return -1;
+ }
+
+ retval = 0;
+ if ( pthread_cond_signal(&cond->cond) != 0 ) {
+ SDL_SetError("pthread_cond_signal() failed");
+ retval = -1;
+ }
+ return retval;
+}
+
+/* Restart all threads that are waiting on the condition variable */
+int SDL_CondBroadcast(SDL_cond *cond)
+{
+ int retval;
+
+ if ( ! cond ) {
+ SDL_SetError("Passed a NULL condition variable");
+ return -1;
+ }
+
+ retval = 0;
+ if ( pthread_cond_broadcast(&cond->cond) != 0 ) {
+ SDL_SetError("pthread_cond_broadcast() failed");
+ retval = -1;
+ }
+ return retval;
+}
+
+int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms)
+{
+ int retval;
+ struct timeval delta;
+ struct timespec abstime;
+
+ if ( ! cond ) {
+ SDL_SetError("Passed a NULL condition variable");
+ return -1;
+ }
+
+ gettimeofday(&delta, NULL);
+
+ abstime.tv_sec = delta.tv_sec + (ms/1000);
+ abstime.tv_nsec = (delta.tv_usec + (ms%1000) * 1000) * 1000;
+ if ( abstime.tv_nsec > 1000000000 ) {
+ abstime.tv_sec += 1;
+ abstime.tv_nsec -= 1000000000;
+ }
+
+ tryagain:
+ retval = pthread_cond_timedwait(&cond->cond, &mutex->id, &abstime);
+ switch (retval) {
+ case EINTR:
+ goto tryagain;
+ break;
+ case ETIMEDOUT:
+ retval = SDL_MUTEX_TIMEDOUT;
+ break;
+ case 0:
+ break;
+ default:
+ SDL_SetError("pthread_cond_timedwait() failed");
+ retval = -1;
+ break;
+ }
+ return retval;
+}
+
+/* Wait on the condition variable, unlocking the provided mutex.
+ The mutex must be locked before entering this function!
+ */
+int SDL_CondWait(SDL_cond *cond, SDL_mutex *mutex)
+{
+ int retval;
+
+ if ( ! cond ) {
+ SDL_SetError("Passed a NULL condition variable");
+ return -1;
+ }
+
+ retval = 0;
+ if ( pthread_cond_wait(&cond->cond, &mutex->id) != 0 ) {
+ SDL_SetError("pthread_cond_wait() failed");
+ retval = -1;
+ }
+ return retval;
+}
diff --git a/distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex.c b/distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex.c
new file mode 100644
index 0000000..c3b8ce2
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex.c
@@ -0,0 +1,153 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include <pthread.h>
+
+#include "SDL_thread.h"
+
+#if !SDL_THREAD_PTHREAD_RECURSIVE_MUTEX && \
+ !SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
+#define FAKE_RECURSIVE_MUTEX
+#endif
+
+struct SDL_mutex {
+ pthread_mutex_t id;
+#if FAKE_RECURSIVE_MUTEX
+ int recursive;
+ pthread_t owner;
+#endif
+};
+
+SDL_mutex *SDL_CreateMutex (void)
+{
+ SDL_mutex *mutex;
+ pthread_mutexattr_t attr;
+
+ /* Allocate the structure */
+ mutex = (SDL_mutex *)SDL_calloc(1, sizeof(*mutex));
+ if ( mutex ) {
+ pthread_mutexattr_init(&attr);
+#if SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+#elif SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
+ pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
+#else
+ /* No extra attributes necessary */
+#endif
+ if ( pthread_mutex_init(&mutex->id, &attr) != 0 ) {
+ SDL_SetError("pthread_mutex_init() failed");
+ SDL_free(mutex);
+ mutex = NULL;
+ }
+ } else {
+ SDL_OutOfMemory();
+ }
+ return(mutex);
+}
+
+void SDL_DestroyMutex(SDL_mutex *mutex)
+{
+ if ( mutex ) {
+ pthread_mutex_destroy(&mutex->id);
+ SDL_free(mutex);
+ }
+}
+
+/* Lock the mutex */
+int SDL_mutexP(SDL_mutex *mutex)
+{
+ int retval;
+#if FAKE_RECURSIVE_MUTEX
+ pthread_t this_thread;
+#endif
+
+ if ( mutex == NULL ) {
+ SDL_SetError("Passed a NULL mutex");
+ return -1;
+ }
+
+ retval = 0;
+#if FAKE_RECURSIVE_MUTEX
+ this_thread = pthread_self();
+ if ( mutex->owner == this_thread ) {
+ ++mutex->recursive;
+ } else {
+ /* The order of operations is important.
+ We set the locking thread id after we obtain the lock
+ so unlocks from other threads will fail.
+ */
+ if ( pthread_mutex_lock(&mutex->id) == 0 ) {
+ mutex->owner = this_thread;
+ mutex->recursive = 0;
+ } else {
+ SDL_SetError("pthread_mutex_lock() failed");
+ retval = -1;
+ }
+ }
+#else
+ if ( pthread_mutex_lock(&mutex->id) < 0 ) {
+ SDL_SetError("pthread_mutex_lock() failed");
+ retval = -1;
+ }
+#endif
+ return retval;
+}
+
+int SDL_mutexV(SDL_mutex *mutex)
+{
+ int retval;
+
+ if ( mutex == NULL ) {
+ SDL_SetError("Passed a NULL mutex");
+ return -1;
+ }
+
+ retval = 0;
+#if FAKE_RECURSIVE_MUTEX
+ /* We can only unlock the mutex if we own it */
+ if ( pthread_self() == mutex->owner ) {
+ if ( mutex->recursive ) {
+ --mutex->recursive;
+ } else {
+ /* The order of operations is important.
+ First reset the owner so another thread doesn't lock
+ the mutex and set the ownership before we reset it,
+ then release the lock semaphore.
+ */
+ mutex->owner = 0;
+ pthread_mutex_unlock(&mutex->id);
+ }
+ } else {
+ SDL_SetError("mutex not owned by this thread");
+ retval = -1;
+ }
+
+#else
+ if ( pthread_mutex_unlock(&mutex->id) < 0 ) {
+ SDL_SetError("pthread_mutex_unlock() failed");
+ retval = -1;
+ }
+#endif /* FAKE_RECURSIVE_MUTEX */
+
+ return retval;
+}
diff --git a/distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex_c.h b/distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex_c.h
new file mode 100644
index 0000000..5258890
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/thread/pthread/SDL_sysmutex_c.h
@@ -0,0 +1,31 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_mutex_c_h
+#define _SDL_mutex_c_h
+
+struct SDL_mutex {
+ pthread_mutex_t id;
+};
+
+#endif /* _SDL_mutex_c_h */
diff --git a/distrib/sdl-1.2.15/src/thread/pthread/SDL_syssem.c b/distrib/sdl-1.2.15/src/thread/pthread/SDL_syssem.c
new file mode 100644
index 0000000..a03870f
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/thread/pthread/SDL_syssem.c
@@ -0,0 +1,190 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include <pthread.h>
+#include <semaphore.h>
+#include <errno.h>
+#include <sys/time.h>
+
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+
+/* Wrapper around POSIX 1003.1b semaphores */
+
+#ifdef __MACOSX__
+/* Mac OS X doesn't support sem_getvalue() as of version 10.4 */
+#include "../generic/SDL_syssem.c"
+#else
+
+struct SDL_semaphore {
+ sem_t sem;
+};
+
+/* Create a semaphore, initialized with value */
+SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
+{
+ SDL_sem *sem = (SDL_sem *) SDL_malloc(sizeof(SDL_sem));
+ if ( sem ) {
+ if ( sem_init(&sem->sem, 0, initial_value) < 0 ) {
+ SDL_SetError("sem_init() failed");
+ SDL_free(sem);
+ sem = NULL;
+ }
+ } else {
+ SDL_OutOfMemory();
+ }
+ return sem;
+}
+
+void SDL_DestroySemaphore(SDL_sem *sem)
+{
+ if ( sem ) {
+ sem_destroy(&sem->sem);
+ SDL_free(sem);
+ }
+}
+
+int SDL_SemTryWait(SDL_sem *sem)
+{
+ int retval;
+
+ if ( ! sem ) {
+ SDL_SetError("Passed a NULL semaphore");
+ return -1;
+ }
+ retval = SDL_MUTEX_TIMEDOUT;
+ if ( sem_trywait(&sem->sem) == 0 ) {
+ retval = 0;
+ }
+ return retval;
+}
+
+int SDL_SemWait(SDL_sem *sem)
+{
+ int retval;
+
+ if ( ! sem ) {
+ SDL_SetError("Passed a NULL semaphore");
+ return -1;
+ }
+
+ while ( ((retval = sem_wait(&sem->sem)) == -1) && (errno == EINTR) ) {}
+ if ( retval < 0 ) {
+ SDL_SetError("sem_wait() failed");
+ }
+ return retval;
+}
+
+int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
+{
+ int retval;
+#ifdef HAVE_SEM_TIMEDWAIT
+ struct timeval now;
+ struct timespec ts_timeout;
+#else
+ Uint32 end;
+#endif
+
+ if ( ! sem ) {
+ SDL_SetError("Passed a NULL semaphore");
+ return -1;
+ }
+
+ /* Try the easy cases first */
+ if ( timeout == 0 ) {
+ return SDL_SemTryWait(sem);
+ }
+ if ( timeout == SDL_MUTEX_MAXWAIT ) {
+ return SDL_SemWait(sem);
+ }
+
+#ifdef HAVE_SEM_TIMEDWAIT
+ /* Setup the timeout. sem_timedwait doesn't wait for
+ * a lapse of time, but until we reach a certain time.
+ * This time is now plus the timeout.
+ */
+ gettimeofday(&now, NULL);
+
+ /* Add our timeout to current time */
+ now.tv_usec += (timeout % 1000) * 1000;
+ now.tv_sec += timeout / 1000;
+
+ /* Wrap the second if needed */
+ if ( now.tv_usec >= 1000000 ) {
+ now.tv_usec -= 1000000;
+ now.tv_sec ++;
+ }
+
+ /* Convert to timespec */
+ ts_timeout.tv_sec = now.tv_sec;
+ ts_timeout.tv_nsec = now.tv_usec * 1000;
+
+ /* Wait. */
+ do
+ retval = sem_timedwait(&sem->sem, &ts_timeout);
+ while (retval == -1 && errno == EINTR);
+
+ if (retval == -1)
+ SDL_SetError(strerror(errno));
+#else
+ end = SDL_GetTicks() + timeout;
+ while ((retval = SDL_SemTryWait(sem)) == SDL_MUTEX_TIMEDOUT) {
+ if ((SDL_GetTicks() - end) >= 0) {
+ break;
+ }
+ SDL_Delay(0);
+ }
+#endif /* HAVE_SEM_TIMEDWAIT */
+
+ return retval;
+}
+
+Uint32 SDL_SemValue(SDL_sem *sem)
+{
+ int ret = 0;
+ if ( sem ) {
+ sem_getvalue(&sem->sem, &ret);
+ if ( ret < 0 ) {
+ ret = 0;
+ }
+ }
+ return (Uint32)ret;
+}
+
+int SDL_SemPost(SDL_sem *sem)
+{
+ int retval;
+
+ if ( ! sem ) {
+ SDL_SetError("Passed a NULL semaphore");
+ return -1;
+ }
+
+ retval = sem_post(&sem->sem);
+ if ( retval < 0 ) {
+ SDL_SetError("sem_post() failed");
+ }
+ return retval;
+}
+
+#endif /* __MACOSX__ */
diff --git a/distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread.c b/distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread.c
new file mode 100644
index 0000000..40cc3b7
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread.c
@@ -0,0 +1,120 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include <pthread.h>
+#include <signal.h>
+
+#include "SDL_thread.h"
+#include "../SDL_thread_c.h"
+#include "../SDL_systhread.h"
+
+/* List of signals to mask in the subthreads */
+static int sig_list[] = {
+ SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGWINCH,
+ SIGVTALRM, SIGPROF, 0
+};
+
+#ifdef __RISCOS__
+/* RISC OS needs to know the main thread for
+ * it's timer and event processing. */
+int riscos_using_threads = 0;
+Uint32 riscos_main_thread = 0; /* Thread running events */
+#endif
+
+
+static void *RunThread(void *data)
+{
+ SDL_RunThread(data);
+ pthread_exit((void*)0);
+ return((void *)0); /* Prevent compiler warning */
+}
+
+int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
+{
+ pthread_attr_t type;
+
+ /* Set the thread attributes */
+ if ( pthread_attr_init(&type) != 0 ) {
+ SDL_SetError("Couldn't initialize pthread attributes");
+ return(-1);
+ }
+ pthread_attr_setdetachstate(&type, PTHREAD_CREATE_JOINABLE);
+
+ /* Create the thread and go! */
+ if ( pthread_create(&thread->handle, &type, RunThread, args) != 0 ) {
+ SDL_SetError("Not enough resources to create thread");
+ return(-1);
+ }
+
+#ifdef __RISCOS__
+ if (riscos_using_threads == 0) {
+ riscos_using_threads = 1;
+ riscos_main_thread = SDL_ThreadID();
+ }
+#endif
+
+ return(0);
+}
+
+void SDL_SYS_SetupThread(void)
+{
+ int i;
+ sigset_t mask;
+
+ /* Mask asynchronous signals for this thread */
+ sigemptyset(&mask);
+ for ( i=0; sig_list[i]; ++i ) {
+ sigaddset(&mask, sig_list[i]);
+ }
+ pthread_sigmask(SIG_BLOCK, &mask, 0);
+
+#ifdef PTHREAD_CANCEL_ASYNCHRONOUS
+ /* Allow ourselves to be asynchronously cancelled */
+ { int oldstate;
+ pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
+ }
+#endif
+}
+
+/* WARNING: This may not work for systems with 64-bit pid_t */
+Uint32 SDL_ThreadID(void)
+{
+ return((Uint32)((size_t)pthread_self()));
+}
+
+void SDL_SYS_WaitThread(SDL_Thread *thread)
+{
+ pthread_join(thread->handle, 0);
+}
+
+void SDL_SYS_KillThread(SDL_Thread *thread)
+{
+#ifdef PTHREAD_CANCEL_ASYNCHRONOUS
+ pthread_cancel(thread->handle);
+#else
+#ifdef __FREEBSD__
+#warning For some reason, this doesnt actually kill a thread - FreeBSD 3.2
+#endif
+ pthread_kill(thread->handle, SIGKILL);
+#endif
+}
diff --git a/distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread_c.h b/distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread_c.h
new file mode 100644
index 0000000..33ed750
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/thread/pthread/SDL_systhread_c.h
@@ -0,0 +1,26 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 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@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include <pthread.h>
+
+typedef pthread_t SYS_ThreadHandle;
generated by cgit v1.1 at 2024-12-22 16:45:00 +0000