home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / quartz / quartz10.lha / src / presto / threadq.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-02  |  4.8 KB  |  269 lines
  1.  
  2. //
  3. // Thread Q stuff
  4. //
  5.  
  6.  
  7. //
  8. // ThreadQUnlocked should be used when the threadq is already 
  9. // associated with a locked data structuire (such as a synchronization
  10. // object).  We save having to test for locking.
  11. //
  12.  
  13. class ThreadQUnlocked    : public Oqueue    {
  14.     int    tq_neededstate;
  15.         int     tq_length;
  16. public:
  17.         inline ThreadQUnlocked(int neededstate, Thread *t = 0);
  18.         inline ~ThreadQUnlocked();
  19.     inline Thread* get();
  20.     inline Thread*     lookat();
  21.     inline void        append(Thread* t);
  22.     inline void    prepend(Thread* t);
  23.     inline void     remove(Thread* t);
  24.         inline int      length()
  25.                                 { return tq_length; }
  26.     virtual void print(ostream& = cout);    // in threads.c
  27. };
  28.  
  29. class ThreadQ    : public Oqueue    {
  30.     int        tq_neededstate;        // sanity check
  31.     int        tq_length;
  32.     Spinlock     *tq_lock;
  33.     inline        void lock();
  34.     inline        void unlock();
  35. public:
  36.         inline ThreadQ(int neededstate, Thread *t = 0);
  37.         inline ~ThreadQ();
  38.     inline Thread*    get();
  39.     inline Thread*     lookat();
  40.     inline void        append(Thread* t);
  41.     inline void    prepend(Thread* t);
  42.     inline void     remove(Thread* t);
  43.     inline int    length()
  44.                 { return tq_length; }
  45.     virtual void print(ostream& = cout);    // in threads.c
  46. };
  47.  
  48.  
  49.  
  50. //
  51. //  Unlocked thread queues.
  52. //
  53.  
  54. inline
  55. ThreadQUnlocked::ThreadQUnlocked(int neededstate, Thread *t = 0)        :(t)
  56. {
  57.         tq_neededstate = neededstate;
  58.         tq_length = 0;
  59. }
  60.  
  61.  
  62. inline
  63. ThreadQUnlocked::~ThreadQUnlocked()
  64. {
  65.         Thread *t;
  66.         while (t = get())       {
  67.                 t->setstate(TS_DELETE);
  68.                 delete (Thread*)t;
  69.         }
  70. }
  71.  
  72.  
  73. inline
  74. Thread*
  75. ThreadQUnlocked::get()
  76. {  
  77.     Thread* t = (Thread*)(Oqueue::get());
  78.         if (t) tq_length--;
  79.     if (t==0 || t->t_state&tq_neededstate) 
  80.         return t;
  81.     else
  82.                 t->error("bad state - threadqunlocked get");
  83. }
  84.  
  85. inline
  86. Thread*
  87. ThreadQUnlocked::lookat()
  88. {
  89.     Thread* t = (Thread*)(Oqueue::lookat());
  90.     if (t==0 || t->t_state&tq_neededstate)
  91.            return t;
  92.     else
  93.                 t->error("bad state - threadqunlocked lookat");
  94. }
  95.  
  96.  
  97. inline
  98. void
  99. ThreadQUnlocked::append(Thread* t)
  100. {
  101.     if (t && t->t_state&tq_neededstate)    {
  102.         Oqueue::append(t); 
  103.         tq_length++;
  104.  
  105. //    if (t==0 || t->t_state&tq_neededstate)    {
  106. //        Oqueue::append(t); 
  107. //                if (t) tq_length++;
  108.  
  109.     } else
  110.                 t->error("Bad state - threadqunlocked append");
  111. }
  112.  
  113.  
  114.  
  115. inline
  116. void
  117. ThreadQUnlocked::prepend(Thread* t)
  118. {
  119.     if (t && t->t_state&tq_neededstate)    {
  120.         Oqueue::prepend(t);
  121.         tq_length++; 
  122.  
  123. //    if (t==0 || t->t_state&tq_neededstate)    {
  124. //        Oqueue::prepend(t); 
  125. //              tq_length++;
  126.  
  127.     }  else
  128.                 t->error("Bad state - threadqunlocked prepend");
  129. }
  130.  
  131.  
  132. inline
  133. void
  134. ThreadQUnlocked::remove(Thread *t)
  135. { 
  136.     if (t && t->t_state&tq_neededstate)    {
  137.         Oqueue::remove(t); 
  138.         tq_length--;
  139.  
  140. //    if (t==0 || t->t_state&tq_neededstate)    {
  141. //        Oqueue::remove(t); 
  142. //              tq_length--;
  143.  
  144.     } else
  145.                 t->error("Bad state - threadqunlocked remove");
  146. }
  147.  
  148.  
  149. //
  150. // Locked threadq's
  151. //
  152.  
  153. inline ThreadQ::ThreadQ(int neededstate, Thread *t = 0) : (t)
  154. {
  155.         tq_lock = new Spinlock;
  156.         tq_neededstate = neededstate;
  157.         tq_length = 0;
  158. }
  159.  
  160.  
  161. //
  162. // Delete a threadQ and all of the threads sitting on it.
  163. // We do not bother to return the threads to the reclaimq.
  164. // (in fact, we don't even bother to invoke the threads potentially
  165. // virtual constructor becuase the derived thread class may have
  166. // already seen this thread destroyed.  Memory management needs to be
  167. // separated from object cleanup.
  168. //
  169. inline ThreadQ::~ThreadQ()
  170. {
  171.         Thread *t;
  172.         while (t = get())       {
  173.                 t->setstate(TS_DELETE);
  174.                 delete (Thread*)t;
  175.         }
  176. }
  177.  
  178. inline
  179. void ThreadQ::lock()
  180. {
  181.     register Spinlock *sp = tq_lock; 
  182.     sp->lock(); 
  183. }
  184.  
  185. inline
  186. void ThreadQ::unlock()
  187. {
  188.     register Spinlock *sp = tq_lock; 
  189.     sp->unlock(); 
  190. }
  191.  
  192.  
  193.  
  194. inline
  195. Thread*
  196. ThreadQ::get()
  197. {  
  198.     lock();
  199.     Thread* t = (Thread*)(Oqueue::get());
  200.     if (t)
  201.         tq_length--;
  202.     unlock();
  203.     
  204.     if (t==0 || t->t_state&tq_neededstate) 
  205.         return t;
  206.     else
  207.                 t->error("bad state - threadq get");
  208. }
  209.             
  210. inline
  211. Thread*
  212. ThreadQ::lookat()
  213. {
  214.     Thread* t = (Thread*)(Oqueue::lookat());
  215.     if (t==0 || t->t_state&tq_neededstate)
  216.            return t;
  217.     else
  218.                 t->error("bad state - threadq lookat");
  219. }
  220.     
  221.  
  222. inline
  223. void
  224. ThreadQ::append(Thread* t)
  225. {
  226.     if (t && t->t_state&tq_neededstate)    {
  227.         lock();
  228.         Oqueue::append(t); 
  229.         tq_length++;
  230.         unlock();
  231.     } else
  232.                 t->error("Bad state - threadq append");
  233. }
  234.  
  235.  
  236.  
  237. inline
  238. void
  239. ThreadQ::prepend(Thread* t)
  240. {
  241.     if (t && t->t_state&tq_neededstate)    {
  242.         lock();
  243.         Oqueue::prepend(t);
  244.         tq_length++; 
  245.         unlock();
  246.     }  else
  247.                 t->error("Bad state - threadq prepend");
  248. }
  249.  
  250. inline
  251. void
  252. ThreadQ::remove(Thread *t)
  253. { 
  254.     if (t && t->t_state&tq_neededstate)    {
  255.         lock();
  256.         Oqueue::remove(t); 
  257.         tq_length--;
  258.         unlock();
  259.     } else
  260.                 t->error("Bad state - threadq remove");
  261. }
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.