threads/thread.h

   1 /*
   2  * thread.h
   3  * Thread support.
   4  *
   5  * Copyright (c) 1996 T. J. Wilkinson & Associates, London, UK.
   6  *
   7  * See the file "license.terms" for information on usage and redistribution
   8  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
   9  *
  10  * Written by Tim Wilkinson <tim@tjwassoc.demon.co.uk>, 1996.
  11  */
  12
  13 #ifndef __thread_h
  14 #define __thread_h
  15
  16 #ifdef USE_THREADS
  17
  18 #include "../global.h"
  19
  20 #define MAXTHREADS              256          /* schani */
  21
  22 #define THREADCLASS             "java/lang/Thread"
  23 #define THREADGROUPCLASS        "java/lang/ThreadGroup"
  24 #define THREADDEATHCLASS        "java/lang/ThreadDeath"
  25
  26 #define MIN_THREAD_PRIO         1
  27 #define NORM_THREAD_PRIO        5
  28 #define MAX_THREAD_PRIO         10
  29
  30 #define THREAD_SUSPENDED        0
  31 #define THREAD_RUNNING          1
  32 #define THREAD_DEAD             2
  33 #define THREAD_KILL             3
  34
  35 #define THREAD_FLAGS_GENERAL            0
  36 #define THREAD_FLAGS_NOSTACKALLOC       1
  37 #define THREAD_FLAGS_USER_SUSPEND       2  /* Flag explicit suspend() call */
  38 #define THREAD_FLAGS_KILLED             4
  39
  40 struct _thread;
  41
  42 typedef struct _ctx
  43 {
  44     bool               free;           /* schani */
  45     u1                 status;
  46     u1                 priority;
  47     u1*                restorePoint;
  48     u1*                stackMem;           /* includes guard page */
  49     u1*                stackBase;
  50     u1*                stackEnd;
  51     u1*                usedStackTop;
  52     s8                 time;
  53     java_objectheader *exceptionptr;
  54     struct _thread    *nextlive;
  55     u1                 flags;
  56 } ctx;
  57
  58 /*
  59 struct _stringClass;
  60 struct _object;
  61 */
  62
  63 /* This structure mirrors java.lang.ThreadGroup.h */
  64
  65 typedef struct _threadGroup
  66 {
  67     java_objectheader    header;
  68     struct _threadGroup* parent;
  69     java_objectheader*   name;
  70     s4                   maxPrio;
  71     s4                   destroyed;
  72     s4                   daemon;
  73     s4                   nthreads;
  74     java_objectheader*   threads;
  75     s4                   ngroups;
  76     java_objectheader*   groups;
  77 } threadGroup;
  78
  79 /* This structure mirrors java.lang.Thread.h */
  80 typedef struct _thread
  81 {
  82     java_objectheader        header;
  83     java_objectheader*       name;
  84     s4                       priority;
  85     struct _thread*          next;
  86     s8                       PrivateInfo;
  87     struct java_lang_Object* eetop;           /* ??? */
  88     s4                       single_step;
  89     s4                       daemon;
  90     s4                       stillborn;
  91     java_objectheader*       target;
  92     s4                       interruptRequested;
  93     threadGroup*             group;
  94 } thread;
  95
  96 void initThreads(u1 *stackbottom);
  97 void startThread(thread*);
  98 void resumeThread(thread*);
  99 void iresumeThread(thread*);
 100 void suspendThread(thread*);
 101 void suspendOnQThread(thread*, thread**);
 102 void yieldThread(void);
 103 void killThread(thread*);
 104 void setPriorityThread(thread*, int);
 105
 106 void sleepThread(s8);
 107 bool aliveThread(thread*);
 108 long framesThread(thread*);
 109
 110 void reschedule(void);
 111
 112 void checkEvents(bool block);
 113
 114 extern int blockInts;
 115 extern bool needReschedule;
 116 extern thread *currentThread;
 117 extern ctx contexts[];
 118 extern int threadStackSize;
 119
 120 extern thread *liveThreads;
 121
 122 extern thread *threadQhead[MAX_THREAD_PRIO + 1];
 123
 124 #define CONTEXT(_t)                                                     \
 125         (contexts[(_t)->PrivateInfo - 1])
 126
 127 #if 1
 128 #define intsDisable()   blockInts++
 129 #define intsRestore()   if (blockInts == 1 && needReschedule) {         \
 130                             reschedule();                               \
 131                         }                                               \
 132                         blockInts--
 133 #else
 134 #define intsDisable()   do { blockInts++; fprintf(stderr, "++: %d (%s:%d)\n", blockInts, __FILE__, __LINE__); } while (0)
 135 #define intsRestore()   do { \
 136                             if (blockInts == 1 && needReschedule) {     \
 137                                 reschedule();                           \
 138                             }                                           \
 139                             blockInts--;                                \
 140                             fprintf(stderr, "--: %d (%s:%d)\n", blockInts, __FILE__, __LINE__);     \
 141                         } while (0)
 142 #endif
 143
 144 #else
 145
 146 #define intsDisable()
 147 #define intsRestore()
 148
 149 #endif
 150
 151 #endif