athread.hh

ac3的解码程序

/*
   File: athread.hh

   By: Alex Theo de Jong
   Created: March 1996
   Version: 0.1

   Description:
   Alex' Threads (athread) and synchronization objects, based on pthreads, 
   Solaris threads, and Irix sprocs. This library is a thin shell around the 
   previous MT solutions to use multi-processing with a shared memory space. 
   The interface is similar to the POSIX interface. Feel free to change the 
   interface names to anything you like :-)

   Compiler variable (select one):

     SOLARIS
     SOLARIS_PTHREAD
     IRIX
     IRIX_PTHREAD
     LINUX

   Synchronization Objects:

     class MutexLock {
       int lock();
       int unlock();
     }

     class Semaphore {
       int P();
       int V();
     }

     class Condition {
       int wait(MutexLock* lock);
       int timedwait(MutexLock* lock);
       int signal();
       int broadcast();
     }

   Threads:

     int athr_create();
     int athr_kill();
     int athr_yield();
     int athr_equal(athr_t t1, athr_t t2);
     int athr_join();
     int athr_


   Notes:
   - No considerable time has been spent on performance. This is something that
     should be done;
   - Pthreads are not able to work with X11 and the GNU C++ stream classes. This
     seems to be caused by the pthread library; 
*/


#ifndef __athread_hh
#define __athread_hh

class Errors {
  static int errcount;        // Number of classes using Error for debugging
 protected:
  int errnumber;              // Last error number
  char errstr[50];            // Last error string
  Errors(int e=0) : errnumber(e) { errstr[0]='\0'; errcount++; }
 public:
  int geterrno() const { return errnumber; }
  const char* geterrstr() const { return (char*) errstr; }
};


#if (defined( SOLARIS_PTHREAD) || defined(LINUX)) 

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include <pthread.h>

typedef pthread_t athr_t;

class MutexLock : public Errors {
  friend class Condition;
  pthread_mutex_t mlock;
 public:
  MutexLock(){ errnumber=pthread_mutex_init(&mlock, 0); }
  ~MutexLock(){ errnumber=pthread_mutex_destroy(&mlock); }
  int lock(){ return errnumber=pthread_mutex_lock(&mlock); }
//  int lock(){ return errnumber=pthread_mutex_unlock(&mlock); }  
  int unlock(){ return errnumber=pthread_mutex_unlock(&mlock); }
};

class Semaphore : public Errors {
  pthread_cond_t condition;
  pthread_mutex_t mlock;
  int count;
 public:
  Semaphore(int value=0) : count(value) {
    errnumber=pthread_cond_init(&condition, 0); 
    errnumber=pthread_mutex_init(&mlock, 0); 
  }
  ~Semaphore(){
    errnumber=pthread_cond_destroy(&condition); 
    errnumber=pthread_mutex_destroy(&mlock);
  }
  int P(){
    errnumber=pthread_mutex_unlock(&mlock);
    count--;
    while (count<0)
      errnumber=pthread_cond_wait(&condition, &mlock);
    errnumber=pthread_mutex_unlock(&mlock);
    return errnumber; 
  }
  int V(){ 
    errnumber=pthread_mutex_unlock(&mlock);
    count++;
    errnumber=pthread_cond_signal(&condition);
    errnumber=pthread_mutex_unlock(&mlock);
    return errnumber;
  }
};

class Condition : public Errors {
  pthread_cond_t condition;
 public:
  Condition(){ errnumber=pthread_cond_init(&condition, 0); }
  ~Condition(){ errnumber=pthread_cond_destroy(&condition); }
  int signal(){ return errnumber=pthread_cond_signal(&condition); }
  int broadcast(){ return errnumber=pthread_cond_broadcast(&condition); }
  int wait(MutexLock* l){ return errnumber=pthread_cond_wait(&condition, &l->mlock); }
  int timedwait(MutexLock* l, const timespec* time){ return errnumber=pthread_cond_timedwait(&condition, &l->mlock, time); }
};

inline int athr_create(void* (*function)(void*), void* arg, athr_t* id){
  return pthread_create(id, 0, function, arg);
}
inline int athr_join(athr_t id){ return pthread_join(id, 0); }
inline void athr_yield(){ sched_yield(); }
//inline void athr_yield(){ pthread_yield(); }
inline void athr_exit(void* code){ pthread_exit(code); }
inline int athr_suspend(athr_t& id){ return -1; }  // return pthread_suspend(id); }
inline int athr_continue(athr_t& id){ return -1; } // return pthread_continue(id); }
inline athr_t athr_self(){ return pthread_self(); }
inline int athr_kill(athr_t thread, int signal){ return pthread_kill(thread, signal); }
inline int athr_equal(athr_t thread1, athr_t thread2){ return pthread_equal(thread1, thread2); }
inline int athr_detach(athr_t thread){ return pthread_detach(thread); }
inline int athr_setschedparam(athr_t t, int p, sched_param* param){ return pthread_setschedparam(t, p, param); }
inline int athr_getschedparam(athr_t t, int* p, sched_param* param){ return pthread_getschedparam(t, p, param); }

#endif // SOLARIS_PTHREAD

#ifdef SOLARIS

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include <thread.h>

typedef thread_t athr_t;

struct sched_param {   // copied from pthread in order to stay compatible
  int prio;
  void* no_data;
  sched_param() : prio(0) { no_data=0; }
};

class MutexLock : public Errors {
  friend class Condition;
  mutex_t mlock;
 public:
  MutexLock(){ errnumber=mutex_init(&mlock, USYNC_THREAD, 0); }
  ~MutexLock(){ errnumber=mutex_destroy(&mlock); }
  int lock(){ return errnumber=mutex_unlock(&mlock); }
  int unlock(){ return errnumber=mutex_unlock(&mlock); }
};

class Semaphore : public Errors {
  sema_t sema;
 public:
  Semaphore(int value=0){ errnumber=sema_init(&sema, value, USYNC_THREAD, 0); }
  ~Semaphore(){ errnumber=sema_destroy(&sema); }
  int P(){ return errnumber=sema_wait(&sema); }
  int V(){ return errnumber=sema_post(&sema); }
};

class Condition : public Errors {
  cond_t condition;
 public:
  Condition(){ errnumber=cond_init(&condition, USYNC_THREAD, 0); }
  ~Condition(){ errnumber=cond_destroy(&condition); }
  int signal(){ return errnumber=cond_signal(&condition); }
  int broadcast(){ return errnumber=cond_broadcast(&condition); }
  int wait(MutexLock* l){ return errnumber=cond_wait(&condition, &l->mlock); }
  int timedwait(MutexLock* l, const timespec* time){ return errnumber=cond_timedwait(&condition, &l->mlock, (timespec*) time); }
};

inline int athr_create(void* (*function)(void*), void* arg, athr_t* id){
  return thr_create(0, 0, function, arg, 0, id);
}
inline int athr_join(athr_t id){ return thr_join(id, 0, 0); }
inline void athr_yield(){ thr_yield(); }
inline void athr_exit(void* code){ thr_exit(code); }
inline int athr_suspend(athr_t& id){ return thr_suspend(id); }
inline int athr_continue(athr_t& id){ return thr_continue(id); }
inline athr_t athr_self(){ return thr_self(); }
inline int athr_kill(athr_t thread, int signal){ return thr_kill(thread, signal); }
inline int athr_equal(athr_t thread1, athr_t thread2){ return (thread1==thread2); }
inline int athr_detach(athr_t){ return -1; } // thr_detach(thread); }
inline int athr_setschedparam(athr_t t, int policy, sched_param* arg){ 
  return (policy!=0) ? -1 : thr_setprio(t, arg->prio); }
inline int athr_getschedparam(athr_t t, int* policy, sched_param* arg){
  *policy=0; return thr_getprio(t, &arg->prio); }

#endif // SOLARIS


#ifdef IRIX_PTHREAD

#ifndef _SGI_MP_SOURCE
#define _SGI_MP_SOURCE
#endif

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include <pthread.h>

typedef pthread_t athr_t;

class MutexLock : public Errors {
  friend class Condition;
  pthread_mutex_t mlock;
 public:
  MutexLock(){ errnumber=pthread_mutex_init(&mlock, 0); }
  ~MutexLock(){ errnumber=pthread_mutex_destroy(&mlock); }
  int lock(){ return errnumber=pthread_mutex_lock(&mlock); }
  int unlock(){ return errnumber=pthread_mutex_unlock(&mlock); }
};

class Semaphore : public Errors {
  pthread_cond_t condition;
  pthread_mutex_t mlock;
  int count;
 public:
  Semaphore(int value=0) : count(value) { 
    errnumber=pthread_cond_init(&condition, 0); 
    errnumber=pthread_mutex_init(&mlock, 0);