aRts audio server
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

398 lines
8.3 KiB

/*
Copyright (C) 2001 Stefan Westerfeld
stefan@space.twc.de
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; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/* only compile this if we have libpthread available */
#ifdef HAVE_LIBPTHREAD
#include <gsl/gslconfig.h>
#include <gsl/gslcommon.h>
#include <sys/types.h>
#include <stddef.h>
#include <stdarg.h>
#include <pthread.h>
#include <semaphore.h>
#include <debug.h>
#include <string.h>
#include "thread.h"
/*
* define this if you want to protect mutexes against being locked twice by
* the same thread
*/
#undef PTHREAD_DEBUG
namespace Arts {
extern void *gslGlobalMutexTable;
namespace PosixThreads {
class ThreadCondition_impl;
class Mutex_impl : public Arts::Mutex_impl {
protected:
friend class ThreadCondition_impl;
pthread_mutex_t mutex;
#ifdef PTHREAD_DEBUG
pthread_t owner;
#endif
public:
Mutex_impl()
{
pthread_mutex_init(&mutex, 0);
#ifdef PTHREAD_DEBUG
owner = 0;
#endif
}
void lock()
{
#ifdef PTHREAD_DEBUG
pthread_t self = pthread_self();
arts_assert(owner != self);
#endif
pthread_mutex_lock(&mutex);
#ifdef PTHREAD_DEBUG
arts_assert(!owner);
owner = self;
#endif
}
bool tryLock()
{
#ifdef PTHREAD_DEBUG
pthread_t self = pthread_self();
arts_assert(owner != self);
#endif
int result = pthread_mutex_trylock(&mutex);
#ifdef PTHREAD_DEBUG
if(result == 0)
{
arts_assert(!owner);
owner = self;
}
#endif
return(result == 0);
}
void unlock()
{
#ifdef PTHREAD_DEBUG
arts_assert(owner == pthread_self());
owner = 0;
#endif
pthread_mutex_unlock(&mutex);
}
};
class RecMutex_impl : public Arts::Mutex_impl {
protected:
friend class ThreadCondition_impl;
pthread_mutex_t mutex;
pthread_t owner;
int count;
public:
RecMutex_impl()
{
pthread_mutex_init(&mutex, 0);
owner = 0;
count = 0;
}
void lock()
{
pthread_t self = pthread_self();
if(owner != self)
{
pthread_mutex_lock(&mutex);
#ifdef PTHREAD_DEBUG
arts_assert(count == 0);
arts_assert(!owner);
#endif
owner = self;
}
count++;
}
bool tryLock()
{
pthread_t self = pthread_self();
if(owner != self)
{
int result = pthread_mutex_trylock(&mutex);
if(result != 0)
return false;
#ifdef PTHREAD_DEBUG
arts_assert(count == 0);
arts_assert(!owner);
#endif
owner = self;
}
count++;
return true;
}
void unlock()
{
#ifdef PTHREAD_DEBUG
arts_assert(owner == pthread_self());
arts_assert(count > 0);
#endif
count--;
if(count == 0)
{
owner = 0;
pthread_mutex_unlock(&mutex);
}
}
};
class Thread_impl : public Arts::Thread_impl {
protected:
friend class PosixThreads;
pthread_t pthread;
Thread *thread;
public:
Thread_impl(Thread *thread) : thread(thread) {
}
void setPriority(int priority) {
struct sched_param sp;
sp.sched_priority = priority;
if (pthread_setschedparam(pthread, SCHED_FIFO, &sp))
arts_debug("Thread::setPriority: sched_setscheduler failed");
}
static pthread_key_t privateDataKey;
static void *threadStartInternal(void *impl)
{
pthread_setspecific(privateDataKey, impl);
((Thread_impl *)impl)->thread->run();
return 0;
}
void start() {
pthread_create(&pthread,0,threadStartInternal,this);
}
void waitDone() {
void *foo;
pthread_join(pthread,&foo);
}
};
pthread_key_t Thread_impl::privateDataKey;
class ThreadCondition_impl : public Arts::ThreadCondition_impl {
protected:
pthread_cond_t cond;
public:
ThreadCondition_impl() {
pthread_cond_init(&cond, 0);
}
~ThreadCondition_impl() {
pthread_cond_destroy(&cond);
}
void wakeOne() {
pthread_cond_signal(&cond);
}
void wakeAll() {
pthread_cond_broadcast(&cond);
}
void wait(Arts::Mutex_impl *mutex) {
#ifdef PTHREAD_DEBUG
pthread_t self = pthread_self();
arts_assert(((Mutex_impl *)mutex)->owner == self);
((Mutex_impl *)mutex)->owner = 0;
#endif
pthread_cond_wait(&cond, &((Mutex_impl*)mutex)->mutex);
#ifdef PTHREAD_DEBUG
arts_assert(((Mutex_impl *)mutex)->owner == 0);
((Mutex_impl *)mutex)->owner = self;
#endif
}
};
class Semaphore_impl : public Arts::Semaphore_impl
{
private:
sem_t semaphore;
public:
Semaphore_impl(int shared, int count) {
sem_init(&semaphore, shared, count);
}
~Semaphore_impl() {
sem_destroy(&semaphore);
}
void wait() {
sem_wait(&semaphore);
}
int tryWait() {
return sem_trywait(&semaphore);
}
void post() {
sem_post(&semaphore);
}
int getValue() {
int retval;
sem_getvalue(&semaphore, &retval);
return retval;
}
};
class PosixThreads : public SystemThreads {
private:
pthread_t mainThread;
public:
PosixThreads() {
mainThread = pthread_self();
}
bool isMainThread() {
return pthread_equal(pthread_self(), mainThread);
}
Arts::Mutex_impl *createMutex_impl() {
return new Mutex_impl();
}
Arts::Mutex_impl *createRecMutex_impl() {
return new RecMutex_impl();
}
Arts::Thread_impl *createThread_impl(Arts::Thread *thread) {
return new Thread_impl(thread);
}
Arts::ThreadCondition_impl *createThreadCondition_impl() {
return new ThreadCondition_impl();
}
Thread *getCurrentThread() {
void *data = pthread_getspecific(Thread_impl::privateDataKey);
if(data)
return ((Thread_impl *)data)->thread;
else
return 0; /* main thread */
}
Arts::Semaphore_impl *createSemaphore_impl(int shared, int count) {
return new Semaphore_impl(shared, count);
}
};
// set posix threads on startup
static class SetSystemThreads {
private:
PosixThreads posixThreads;
public:
SetSystemThreads() {
if(pthread_key_create(&Thread_impl::privateDataKey, 0))
arts_debug("SystemThreads init: pthread_key_create failed");
SystemThreads::init(&posixThreads);
}
~SetSystemThreads() {
SystemThreads::init(0);
if(pthread_key_delete(Thread_impl::privateDataKey))
arts_debug("SystemThreads init: pthread_key_delete failed");
}
} initOnStartup;
/* -fast- locking for gsl on platforms with unix98 support */
#if (GSL_HAVE_MUTEXATTR_SETTYPE > 0)
static void pth_mutex_init (GslMutex *mutex)
{
/* need NULL attribute here, which is the fast mutex on glibc
* and cannot be chosen through the pthread_mutexattr_settype()
*/
pthread_mutex_init ((pthread_mutex_t*) mutex, NULL);
}
static void pth_rec_mutex_init (GslRecMutex *mutex)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init (&attr);
pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init ((pthread_mutex_t*) mutex, &attr);
pthread_mutexattr_destroy (&attr);
}
static void pth_rec_cond_init (GslCond *cond)
{
pthread_cond_init ((pthread_cond_t*) cond, NULL);
}
static void pth_rec_cond_wait_timed (GslCond *cond, GslMutex *mutex,
gulong abs_secs, gulong abs_usecs)
{
struct ::timespec abstime;
abstime.tv_sec = abs_secs;
abstime.tv_nsec = abs_usecs * 1000;
pthread_cond_timedwait ((pthread_cond_t*) cond, (pthread_mutex_t*) mutex, &abstime);
}
static GslMutexTable pth_mutex_table = {
pth_mutex_init,
(void (*) (GslMutex*)) pthread_mutex_lock,
(int (*) (GslMutex*)) pthread_mutex_trylock,
(void (*) (GslMutex*)) pthread_mutex_unlock,
(void (*) (GslMutex*)) pthread_mutex_destroy,
pth_rec_mutex_init,
(void (*) (GslRecMutex*)) pthread_mutex_lock,
(int (*) (GslRecMutex*)) pthread_mutex_trylock,
(void (*) (GslRecMutex*)) pthread_mutex_unlock,
(void (*) (GslRecMutex*)) pthread_mutex_destroy,
pth_rec_cond_init,
(void (*) (GslCond*)) pthread_cond_signal,
(void (*) (GslCond*)) pthread_cond_broadcast,
(void (*) (GslCond*, GslMutex*)) pthread_cond_wait,
pth_rec_cond_wait_timed,
(void (*) (GslCond*)) pthread_cond_destroy,
};
static class SetGslMutexTable {
public:
SetGslMutexTable()
{
gslGlobalMutexTable = &pth_mutex_table;
}
} initGslMutexTable;
#endif
}
}
#endif