home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 2 / AUCD2.iso / program / vista.arc / !Vista / h / thread < prev    next >
Text File  |  1996-01-25  |  9KB  |  254 lines
  1. // **************************************************************************
  2. //                     Copyright 1996 David Allison
  3. //
  4. //             VV    VV    IIIIII     SSSSS     TTTTTT       AA
  5. //             VV    VV      II      SS           TT       AA  AA
  6. //             VV    VV      II        SSSS       TT      AA    AA
  7. //              VV  VV       II           SS      TT      AAAAAAAA
  8. //                VV       IIIIII     SSSS        TT      AA    AA
  9. //
  10. //                    MULTI-THREADED C++ WIMP CLASS LIBRARY
  11. //                                for RISC OS
  12. // **************************************************************************
  13. //
  14. //             P U B L I C    D O M A I N    L I C E N C E
  15. //             -------------------------------------------
  16. //
  17. //     This library is copyright. You may not sell the library for
  18. //     profit, but you may sell products which use it providing
  19. //     those products are presented as executable code and are not
  20. //     libraries themselves.  The library is supplied without any
  21. //     warranty and the copyright owner cannot be held responsible for
  22. //     damage resulting from failure of any part of this library.
  23. //
  24. //          See the User Manual for details of the licence.
  25. //
  26. // *************************************************************************
  27.  
  28. //
  29. // threads
  30. //
  31.  
  32. #ifndef __thread_h
  33. #define __thread_h
  34.  
  35. #include "Vista:defs.h"
  36.  
  37. #include "Vista:tasm.h"
  38. #ifdef __EASY_C
  39. #include <throw.h>          // exception stuff
  40. #endif
  41.  
  42. #ifndef __delete_h
  43. #include "Vista:delete.h"
  44. #endif
  45.  
  46. #include <kernel.h>
  47.  
  48. #ifndef __EXCEPTION_STATE_SIZE
  49. #define __EXCEPTION_STATE_SIZE 16
  50. #endif
  51.  
  52.  
  53. class ThreadManager ;
  54.  
  55. extern void dprintf (char*...) ;
  56.  
  57. //
  58. // general thread resource class
  59. //
  60.  
  61. class ThreadResource
  62.    {
  63.    public:
  64.       ThreadResource() ;
  65.       int available ;
  66.    } ;
  67.  
  68. //
  69. // thread timer resource
  70. //
  71.  
  72. class ThreadTimer : public ThreadResource
  73.    {
  74.    public:
  75.       ThreadTimer (ThreadManager *m, int delay) ;
  76.       ~ThreadTimer() ;
  77.       void check_time (int time) ;
  78.       ThreadTimer *next, *prev ;
  79.       ThreadManager *manager ;
  80.    private:
  81.       int time_set ;
  82.  
  83.    } ;
  84.  
  85. //
  86. // thread pipe resource for comms
  87. //
  88.  
  89.  
  90. class ThreadPipe : public ThreadResource
  91.    {
  92.    public:
  93.       ThreadPipe () ;
  94.       ~ThreadPipe() ;
  95.       void write (char *buffer, int nbytes) ;
  96.       void read (char *buffer, int max, int &nbytes) ;
  97.    private:
  98.       char *data ;         // data buffer
  99.       int size ;           // size of data in buffer
  100.       int max ;            // max size of buffer
  101.    } ;
  102.  
  103.  
  104. class ThreadSemaphore : public ThreadResource
  105.    {
  106.    public:
  107.       void set() { available = 1 ;}
  108.       void clear() { available = 0 ; }
  109.       int check() { return available ; }
  110.    } ;
  111.  
  112.  
  113. const int THREAD_BASE_PRIORITY = 60 ;
  114. const int THREAD_STARTUP_PRIORITY = 60 ;
  115.  
  116. // The base priority is the starting priority for a thread.  The neutral value
  117. // is 60.  Any priority lower than this is consider higher priority and
  118. // will get more cpu cycles than lower priority threads.  A higher priority
  119. // value will get less cpu cycles.  This is equivalent to the UNIX 'nice'
  120. // value.
  121.  
  122. class Thread : public ThreadResource, virtual public DeferredDelete
  123.    {
  124.    public:
  125.       enum State
  126.          {
  127.          IDLE,         // not on any queues
  128.          READY,        // on the run queue and ready
  129.          RUNNING,      // running
  130.          SLEEPING,     // on the sleep queue
  131.          STOPPED,      // not on any queue, but can be restarted
  132.          DEAD          // not on any queue and is dead
  133.          } ;
  134.  
  135.    public:
  136.       Thread(char *name, int priority = THREAD_BASE_PRIORITY, int newstack = 1) ;
  137.       virtual ~Thread() ;
  138.       void start() ;                   // start the thread running asynchronously
  139.       void start2() ;                  // internal start routine - DO NOT CALL
  140.       virtual void run() = 0 ;         // pure virtual user supplied run function
  141.       virtual void stop() ;                    // stop the thread until resumed
  142.       virtual void resume() ;                  // resume a stopped thread running
  143.       virtual void kill() ;                    // kill a thread off - cannot be rerun
  144.       virtual void sleep (int time) ;          // sleep for a number of centiseconds
  145.       virtual void sleep (ThreadResource *, int pri = THREAD_BASE_PRIORITY) ;    // sleep waiting for a resource
  146.       virtual void wakeup () ;                                                   // wake up the thread
  147.       virtual void write (ThreadPipe *pipe, char *buffer, int nbytes) ;          // write to a pipe
  148.       virtual void read (ThreadPipe *pipe, char *buffer, int max, int &nbytes) ; // read from a pipe
  149.       void setpriority (int pri) ;                                       // set the base priority
  150.       virtual int resource_available() ;  // is the resource availble while sleeping
  151.       virtual void exit (int status = 0) ;
  152.       virtual void yield() ;              // yield control to another thread
  153.    public:
  154.       Thread *next, *prev ;          // links to main thread list
  155.       Thread *nextq, *prevq ;        // queue pointers
  156.       char save_area[16 * 4 + 12 * 8 + 4] ;           // register save area
  157. #ifdef __EASY_C
  158.       char exception_state [__EXCEPTION_STATE_SIZE] ; // exception handler state
  159. #endif
  160.       _kernel_stack_chunk *stack ;   // private stack
  161.       ThreadManager *manager ;       // my manager
  162.       State state ;                  // current state
  163.       ThreadResource *resource ;     // resource I am waiting for
  164.       int priority ;                 // current priority
  165.       int base_priority ;            // base priority
  166.       int cputime ;                  // current CPU usage in centiseconds
  167.       int accumulated_cputime ;      // accumulated CPU centiseconds
  168.       char *name ;                   // thread name
  169.       int exit_status ;              // exit status
  170.       int time ;                     // time thread gained CPU
  171.    } ;
  172.  
  173. //
  174. // This is the main thread.  It is the overall controller thread.  When it returns all threads
  175. // are suspended
  176. //
  177.  
  178.  
  179. class MainThread : public Thread
  180.    {
  181.    public:
  182.       MainThread() ;
  183.       ~MainThread() ;
  184.       void run() ;
  185.       void set_limit (int quanta) ;
  186.    private:
  187.       int quantum_limit ;
  188.    } ;
  189.  
  190. //
  191. // This thread is responsible for the management of timers and resources
  192. //
  193.  
  194. class ResourceThread : public Thread
  195.    {
  196.    public:
  197.       ResourceThread() ;
  198.       void run() ;
  199.    } ;
  200.  
  201. //
  202. // The thread manager.  This manages a set of running threads.
  203. //
  204.  
  205. const int THREAD_STACK_BLOCK = 5 ;
  206. const int THREAD_STACK_SIZE = 4096 ;
  207.  
  208. class ThreadManager
  209.    {
  210.    friend class MainThread ;
  211.    friend class Thread ;
  212.    friend class ResourceThread ;
  213.    public:
  214.       ThreadManager() ;
  215.       ~ThreadManager() ;
  216.       void run (int quanta) ;              // run for a specified number of quanta
  217.       void context_switch() ;              // switch to next thread
  218.       void run_thread (Thread *) ;         // place a thread on the run queue
  219.       void stop_thread (Thread *) ;        // remove a thread from the run queue
  220.       void sleep_thread (Thread *) ;       // place a thread on the sleep queue
  221.       void wakeup_thread (Thread *) ;      // remove a thread from the sleep queue
  222.       void insert_thread (Thread *) ;      // insert a new thread
  223.       void delete_thread (Thread *) ;      // delete a thread
  224.       void next_thread() ;                 // start the highest priority thread running
  225.       void insert_timer(ThreadTimer *) ;   // start a new timer
  226.       void delete_timer (ThreadTimer*) ;   // remove a timer
  227.       _kernel_stack_chunk *new_stack() ;   // allocate a new stack
  228.       void delete_stack(_kernel_stack_chunk *stack) ;
  229.       void exit() ;                         // exit the thread manager
  230.       void sleep (int time) ;
  231.       void sleep (ThreadResource *, int pri = THREAD_BASE_PRIORITY) ;
  232.       void yield() ;
  233.       void show_threads() ;
  234.       void stop_threads() ;
  235.       void resume_threads() ;
  236.       int num_running_threads ;             // number of threads currenly running
  237.       int num_threads ;                    // number of threads including system ones
  238.    private:
  239.       Thread *threads, *last_thread ;      // list of current threads
  240.       Thread *runqueue, *end_runqueue ;    // the run queue - threads ready to run
  241.       Thread *sleepqueue, *end_sleepqueue ;// the sleep queue - threads waiting for a resource
  242.       ThreadTimer *timers, *last_timer ;   // list of current timers
  243.       Thread *running ;                    // thread currently running
  244.       MainThread *main_thread ;            // main thread
  245.       ResourceThread *resource_thread ;    // resource thread
  246.    public:
  247.       static ThreadManager *current_manager ;  // me
  248.    private:
  249.       int quantum_count ;                      // number of quanta counter
  250.       _kernel_stack_chunk *stack_pool ;     // pool of stacks
  251.    } ;
  252.  
  253. #endif
  254.