Source code upload

eoe/cmd/bps/Thread.H

@@ -0,0 +1,196 @@
+/****************************************************************
+*    NAME:                                                     
+*    ACCT: kostadis                                            
+*    FILE: Thread.H                                            
+*    ASGN:                                                     
+*    DATE: Sun Jul 16 18:16:07 1995                            
+     Special thanks to twd@cs.brown.edu.
+****************************************************************/
+
+
+#ifndef THREAD_HEADER
+#define THREAD_HEADER
+#include <pthread.h>
+#include <ulocks.h>
+#include <assert.h>
+#include <stdlib.h>
+
+/****************************************************************
+ * CLASS NAME : Semaphore
+   Wrapper around the 'c semaphore' found in libC. Handles the 
+   initialization. Uses lock and unlock rather than P and V, because
+   frankly P and V are too cryptic.
+   Note that a Semaphore can not be initialized until *AFTER* main.
+   So it can not be a member of any static objects.
+****************************************************************/
+
+
+class Semaphore {
+private:
+   int max_in_;
+   static void S_init();
+   static pthread_once_t S_once_;
+   usema_t *semaphore_;
+   static usptr_t* S_mem_area_;
+   friend class Thread;
+   Semaphore(char){;} // need this because of
+                       // initialization problems
+public:
+   void lock();
+   Semaphore(int max_in=1);
+   ~Semaphore();
+   void unlock();
+};
+
+/****************************************************************
+ * CLASS NAME : Thread                             
+   Wrapper around the 'basic detacheable thread'. Note that the
+   current pthread library does not support the detacheable thread
+   so this thread acts as joinable threads without a join member 
+   function.                   
+  NOTE: Why a Thread class? Well a thread object has the advantage that thread
+        specific data is member data and access is very cheap.
+****************************************************************/
+
+
+class Thread {
+   Semaphore semaphore_;
+   static void realStartup(void* thisp);
+   Thread& operator=(Thread&);
+   Thread(Thread&);
+protected:
+   pthread_attr_t* attr_;
+   enum ThreadType{detachable, joinable};
+   pthread_t thr_;
+   virtual void startup() = 0;
+   Thread(int):semaphore_('a'){;}
+   Thread(ThreadType t);
+public:
+   ~Thread();
+   void exit();
+   void makeRunnable(); // need this because all constructors + vtbl
+                               // needs to be constructed
+};
+
+/****************************************************************
+ * CLASS NAME :JoinableThread
+    C++ wrapper on top of the pthread joinable thread.
+****************************************************************/
+
+
+class JoinableThread : public Thread{
+public:
+   JoinableThread();
+   ~JoinableThread();
+   int join();
+};
+
+
+ /****************************************************************
+ * CLASS NAME :  FirstThread
+   This class guarantees that the pthreads library init structure
+   is created before main. This should be removed once the pthread
+   library is fixed.
+****************************************************************/
+
+
+template <class T>
+class FirstThread {
+   static int do_once_;
+public:
+   FirstThread<T>()
+      {
+         if(do_once_ == 0){
+            first_thread_ = new T;
+            FirstThread<T>::real_thread_ = first_thread_;
+         }
+         else
+            {
+               assert(FirstThread<T>::real_thread_ != 0);
+               first_thread_ = (T*) FirstThread<T>::real_thread_;
+            }
+         FirstThread<T>::do_once_ ++;
+      }
+   static Thread* real_thread_;
+   T* operator->(){return first_thread_;}
+protected:
+   T* first_thread_;
+};
+
+template<class T>
+int FirstThread<T>::do_once_ = 0;
+
+template<class T>
+Thread* FirstThread<T>::real_thread_ = 0;
+
+class FirstThreadInstance 
+: public Thread {
+   struct pthread_init init_area;
+   sproc_t sid;
+public:
+   FirstThreadInstance();
+   void startup(){};
+};
+static FirstThread<FirstThreadInstance> FT;
+
+   
+class Mutex {
+   pthread_mutex_t mutex_;
+   Mutex(Mutex& mutex);
+   Mutex& operator=(Mutex& mutex);
+public:
+   Mutex();
+   ~Mutex();
+   int lock();
+   int unlock();
+};
+
+
+/****************************************************************
+ * CLASS NAME : RWLock_reader
+   Readers writers lock that has a 'reader' preference
+****************************************************************/
+
+
+class RWLock_reader {
+   pthread_mutex_t mutex_;
+   pthread_cond_t readers_q_;
+   pthread_cond_t writers_q_;
+   int writers_;
+   int readers_;
+
+public:
+   RWLock_reader();
+   ~RWLock_reader();
+   void rlock();
+   void wlock();
+   void unlock();
+
+};
+/****************************************************************
+ * CLASS NAME :  RWLock_writer                                  
+   Readers-writers lock that has a 'writer' preference
+****************************************************************/
+
+
+
+class RWLock_writer {
+   pthread_mutex_t mutex_;
+   pthread_cond_t readers_q_;
+   pthread_cond_t writers_q_;
+   int writers_;
+   int readers_;
+   int waiting_writers_;
+public:
+   RWLock_writer();
+   ~RWLock_writer();
+   void rlock();
+   void wlock();
+   void unlock();
+};
+
+
+
+#endif
+
+