home *** CD-ROM | disk | FTP | other *** search
/ Point Programming 1 / PPROG1.ISO / c / mtl100je / threads.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-05  |  5.1 KB  |  135 lines
  1. //--------------------------------------------------------------------------
  2. //
  3. //      THREADS.H: header file for DOS multithreading library.
  4. //      Copyright (c) J.English 1993.
  5. //      Author's address: je@unix.brighton.ac.uk
  6. //
  7. //      Permission is granted to use copy and distribute the
  8. //      information contained in this file provided that this
  9. //      copyright notice is retained intact and that any software
  10. //      or other document incorporating this file or parts thereof
  11. //      makes the source code for the library of which this file
  12. //      is a part freely available.
  13. //
  14. //--------------------------------------------------------------------------
  15. //
  16. //      Note: this library is highly DOS specific and hence non-portable.
  17. //      It also involves the use of assembly language and interrupt
  18. //      functions, so it is also very compiler-specific and will need
  19. //      modification for use with compilers other than Borland C++ 3.0
  20. //      or later.
  21. //
  22. //      Revision history:
  23. //      1.0     March 1993      Initial coding
  24. //
  25. //--------------------------------------------------------------------------
  26.  
  27. #ifndef __THREADS_H
  28. #define __THREADS_H
  29.  
  30. #include <stdlib.h>
  31. #include <stdio.h>
  32.  
  33. //--------------------------------------------------------------------------
  34. //
  35. //      Class DOSThread: abstract DOS multithreading base class.
  36. //
  37. //      Note that you must derive a concrete class from this base class
  38. //      by supplying a main function containing the body of the thread.
  39. //
  40. class DOSThread
  41. {
  42.     friend class DOSThreadManager;
  43.     
  44.   public:
  45.     enum State                            // status codes for threads
  46.         { CREATED, READY, DELAYED, WAITING, SUSPENDED, TERMINATED };
  47.     enum Error                            // result codes for critical errors
  48.         { IGNORE = 0, RETRY = 1, FAIL = 3 };
  49.  
  50.     DOSThread (unsigned stacksize = 2048);  // constructor
  51.     virtual ~DOSThread ();                  // destructor
  52.  
  53.     int  status ()                        { return state; }
  54.  
  55.     int  run ();                          // start thread running
  56.     void terminate ();                    // terminate thread
  57.  
  58.     static void pause ();                 // schedule another thread
  59.     static void delay (int n);            // delay for "n" clock ticks
  60.     static void timeslice (unsigned n);   // set timeslice to "n" ticks
  61.     static int  userbreak ();             // test if control-break pressed
  62.     static int  cancelbreak ();           // test and reset control-break flag
  63.  
  64.   protected:
  65.     virtual void  main () = 0;            // main body of thread
  66.     virtual Error DOSerror (int)          { return FAIL; }
  67.  
  68.     void wait ();                         // wait for thread to terminate
  69.  
  70.   private:
  71.     DOSThreadManager* const entry;
  72.     char* const             stack;
  73.     volatile State          state;
  74. };
  75.  
  76. //--------------------------------------------------------------------------
  77. //
  78. //      Class DOSMonitorQueue: event queue for use by monitor classes.
  79. //
  80. //      Note that there are no member functions for this class.  The
  81. //      functions "suspend" and "resume" in class DOSMonitor (below)
  82. //      are the only operations allowed on a monitor queue.
  83. //
  84. class DOSMonitorQueue
  85. {
  86.     friend class DOSMonitor;
  87.  
  88.   public:
  89.     DOSMonitorQueue ();                   // constructor
  90.     ~DOSMonitorQueue ();                  // destructor
  91.  
  92.   private:
  93.     DOSThreadManager* const queue;
  94. };
  95.  
  96.  
  97. //--------------------------------------------------------------------------
  98. //
  99. //      Class DOSMonitor: thread synchronisation management class
  100. //
  101. //      Note that there are no public members for this class.  You must
  102. //      derive classes from it which use the locking primitives below
  103. //      to protect against re-entry.  You should overload the error
  104. //      handling function "error" to report any errors as necessary;
  105. //      the default action is to exit with the error code as the exit
  106. //      status.
  107. //
  108. class DOSMonitor
  109. {
  110.   protected:
  111.     DOSMonitor ();                        // constructor
  112.     virtual ~DOSMonitor ();               // destructor
  113.  
  114.     enum ErrorCode {                      // internal error codes:
  115.         NEW_FAIL     = -1,                // ...out of memory
  116.         NO_THREAD    = -2,                // ...no threads running
  117.         LOCK_FAIL    = -3,                // ...thread already holds lock
  118.         UNLOCK_FAIL  = -4,                // ...unlock attempted without lock
  119.         SUSPEND_FAIL = -5,                // ...suspend attempted without lock
  120.         RESUME_FAIL  = -6                 // ...resume attempted without lock
  121.     };
  122.     virtual void error (ErrorCode e)      { exit (e); }
  123.  
  124.     void lock ();                         // lock monitor against re-entry
  125.     void unlock ();                       // unlock monitor
  126.     void suspend (DOSMonitorQueue& q);    // suspend & await event
  127.     void resume (DOSMonitorQueue& q);     // resume thread waiting for event
  128.  
  129.   private:
  130.     DOSThreadManager* const lockq;
  131.     volatile DOSThreadManager* lockholder;
  132. };
  133.  
  134. #endif
  135.