![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to task.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / cfront / libC / task|
Return to task.h CVS log | Up to [Research Unix] / researchv8dc / cmd / cfront / libC / task |
1.1 root 1: /* HEADER FILE FOR THE TASK SYSTEM */
2:
3: printf(char* ...);
4: void exit(int);
5:
6: #define SIZE 750
7: #define MODE DEDICATED
8:
9: class object;
10: class sched; /* : public object */
11: class task; /* : public sched */
12: class qhead; /* : public object */
13: class qtail; /* : public object */
14: class team;
15:
16: extern sched* run_chain; /* list of ready-to-run scheds (ordered by s_time) */
17: extern task* task_chain; /* list of tasks */
18:
19: extern int task_error(int, object*);
20: extern void print_error(int);
21:
22: /* object.o_type */
23: #define TIMER 1
24: #define TASK 2
25: #define QHEAD 4
26: #define QTAIL 5
27:
28: /* sched.s_state */
29: #define IDLE 1
30: #define RUNNING 2
31: #define TERMINATED 4
32:
33: /* type of stack */
34: #define DEDICATED 1
35: #define SHARED 2
36: /* loc on stack */
37: #define UNTOUCHED 052525
38:
39: extern task* clock_task;
40: extern task* thistask;
41: extern long clock;
42: void setclock(long);
43:
44: /* error codes */
45: #define E_OLINK 1
46: #define E_ONEXT 2
47: #define E_GETEMPTY 3
48: #define E_PUTOBJ 4
49: #define E_PUTFULL 5
50: #define E_BACKOBJ 6
51: #define E_BACKFULL 7
52: #define E_SETCLOCK 8
53: #define E_CLOCKIDLE 9
54: #define E_RESTERM 10
55: #define E_RESRUN 11
56: #define E_NEGTIME 12
57: #define E_RESOBJ 13
58: #define E_HISTO 14
59: #define E_STACK 15
60: #define E_STORE 16
61: #define E_TASKMODE 17
62: #define E_TASKDEL 18
63: #define E_TASKPRE 19
64: #define E_TIMERDEL 20
65: #define E_SCHTIME 21
66: #define E_SCHOBJ 22
67: #define E_QDEL 23
68: #define E_RESULT 24
69: #define E_WAIT 25
70: #define MAXERR E_WAIT
71:
72: typedef int (*PFIO)(int,object*);
73: typedef void (*PFV)();
74:
75: extern PFIO error_fct;
76: extern PFV exit_fct;
77:
78: /* print flags */
79: #define CHAIN 1
80: #define VERBOSE 2
81: #define STACK 4
82:
83:
84: /* DATA STRUCTURES */
85: /*
86: object --> olink --> olink ...
87: | | |
88: ... V V
89: | task task
90: V
91: object --> ...
92: */
93:
94: class olink
95: /* the building block for chains of task pointers */
96: {
97: friend object;
98: olink* l_next;
99: task* l_task;
100: olink(task* t, olink* l) { l_task=t; l_next=l; };
101: };
102:
103: class object
104: {
105: olink* o_link;
106: public:
107: object* o_next;
108: int o_type; /* TASK,TIMER,QHEAD/QTAIL */
109:
110: object(int t = 0) { o_type=t; o_link=0; o_next=0; }
111: ~object();
112:
113: void remember(task* t) { o_link = new olink(t,o_link); }
114: void forget(task*); /* remove all occurrences of task from chain */
115: void alert(); /* prepare IDLE tasks for scheduling */
116:
117: void print(int);
118: };
119:
120: class sched : public object
121: {
122: friend timer;
123: friend task;
124: friend object;
125: void schedule(); /* sched clock_task or front of run_chain */
126: void insert(int,object*); /* sched for d time units, ?t_alert=obj */
127: void remove(); /* remove from run_chain & make IDLE */
128:
129: long s_time; /* time to sched; result after cancel() */
130: int s_state; /* IDLE, RUNNING, TERMINATED */
131: public:
132: void print(int);
133:
134: long rdtime() { return s_time; };
135: int rdstate() { return s_state; };
136:
137: void cancel(int);
138: int result();
139: };
140:
141: struct timer : public sched
142: {
143: timer(int);
144: ~timer();
145: void reset(int);
146: void print(int);
147: };
148:
149: extern _hwm;
150: class task : public sched
151: {
152: friend sched;
153: task(char* =0, int =0, int =0);
154: ~task();
155:
156: void save();
157: void restore(); /* swap in new task */
158: int curr_hwm(); /* "high water mark" */
159: /* (how high stack has risen) */
160: int* t_framep; /* WARNING: t_framep
161: is manipulated as an offset
162: by restore()
163: */
164: void* th; /* fudge return from swap */
165: int* t_basep;
166: int t_size; /* holds hwm after cancel() */
167: int* t_savearea; /* for saving stack */
168: int t_trap;
169: team* t_team; /* stack and info for sharing */
170:
171: int t_mode; /* DEDICATED/SHARED stack */
172: int t_stacksize;
173:
174: object* t_alert; /* object that inserted you */
175: public:
176: task* t_next; /* insertion in "task_chain" */
177: char* t_name;
178:
179: int waitvec(object**);
180: int waitlist(object* ...);
181: void wait(object* ob) { (void) waitlist(ob,0); };
182:
183: void delay(int);
184: int preempt();
185: void sleep();
186: void resultis(int);
187: void cancel(int);
188: void swap_stack(int*,int*,int*,int*,int*); /* set fram and restore */
189:
190: void print(int);
191: };
192:
193:
194: /* QUEUE MANIPULATION (see queue.c) */
195: /*
196: qhead <--> oqueue <--> qtail (qhead, qtail independent)
197: oqueue ->> circular queue of objects
198: */
199:
200: /* qh_modes */
201: #define EMODE 1
202: #define WMODE 2
203: #define ZMODE 3
204:
205: class oqueue
206: {
207: friend qhead;
208: friend qtail;
209: int q_max;
210: int q_count;
211: object* q_ptr;
212: qhead* q_head;
213: qtail* q_tail;
214:
215: oqueue(int m) { q_max=m; q_count=0; q_head=0; q_tail=0; };
216: ~oqueue() { (q_count)?task_error(E_QDEL,0):0; };
217: void print(int);
218: };
219:
220: class qhead : public object
221: {
222: friend qtail;
223: qhead(int = WMODE, int = 10000);
224: ~qhead();
225:
226: int qh_mode; /* EMODE,WMODE,ZMODE */
227: oqueue* qh_queue;
228: public:
229: object* get();
230: int putback(object*);
231:
232: int rdcount() { return qh_queue->q_count; }
233: int rdmax() { return qh_queue->q_max; }
234: int rdmode() { return qh_mode; }
235: qtail* tail();
236:
237: qhead* cut();
238: void splice(qtail*);
239:
240: void setmode(int m) { qh_mode = m; };
241: void setmax(int m) { qh_queue->q_max = m; };
242:
243: void print(int);
244: };
245:
246: class qtail : public object
247: {
248: friend qhead;
249: qtail(int = WMODE, int = 10000);
250: ~qtail();
251:
252: int qt_mode;
253: oqueue* qt_queue;
254: public:
255: int put(object*);
256:
257: int rdspace() { return qt_queue->q_max - qt_queue->q_count; };
258: int rdmax() { return qt_queue->q_max; };
259: int rdmode() { return qt_mode; };
260:
261: qtail* cut();
262: void splice(qhead*);
263:
264: qhead* head();
265:
266: void setmode(int m) { qt_mode = m; };
267: void setmax(int m) { qt_queue->q_max = m; };
268:
269: void print(int);
270: };
271:
272:
273: struct histogram
274: /*
275: "nbin" bins covering the range [l:r[ uniformly
276: nbin*binsize == r-l
277: */
278: {
279: int l, r;
280: int binsize;
281: int nbin;
282: int* h;
283: long sum;
284: long sqsum;
285: histogram(int=16, int=0, int=16);
286:
287: void add(int);
288: void print();
289: };
290:
291: /* the result of randint() is always >= 0 */
292:
293: #define DRAW (randx = randx*1103515245 + 12345)
294: #define ABS(x) (x&0x7fffffff)
295:
296: #ifdef pdp11
297: #define MASK(x) ((x>>16)&077777)
298: #define MAX 32768.0
299: #endif
300:
301: #ifdef vax
302: #define MASK(x) ABS(x)
303: #define MAX 2147483648.0
304: #endif
305:
306: class randint
307: /* uniform distribution in the interval [0,MAX] */
308: {
309: long randx;
310: public:
311: randint(long s = 0) { randx=s; }
312: void seed(long s) { randx=s; }
313: int draw() { return MASK(DRAW); }
314: float fdraw() { return ABS(DRAW)/MAX; };
315: };
316:
317: class urand : public randint
318: /* uniform distribution in the interval [low,high] */
319: {
320: public:
321: int low, high;
322: urand(int l, int h) { low=l; high=h; }
323: int draw() { return int(low + (high-low) * (0+randint::draw()/MAX)); }
324: };
325:
326: extern double log(double);
327:
328: class erand : public randint
329: /* exponential distribution random number generator */
330: {
331: public:
332: int mean;
333: erand(int m) { mean=m; };
334: int draw() { return (int)(-mean * log( (double)(MAX-randint::draw())
335: / MAX) + .5); };
336: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.