1 /* -----------------------------------------------------------------------------
2 * $Id: Schedule.h,v 1.29 2002/02/15 07:50:37 sof Exp $
4 * (c) The GHC Team 1998-1999
6 * Prototypes for functions in Schedule.c
7 * (RTS internal scheduler interface)
9 * -------------------------------------------------------------------------*/
10 #ifndef __SCHEDULE_H__
11 #define __SCHEDULE_H__
12 #include "OSThreads.h"
15 //* Scheduler Functions::
16 //* Scheduler Vars and Data Types::
17 //* Some convenient macros::
21 //@node Scheduler Functions, Scheduler Vars and Data Types
22 //@subsection Scheduler Functions
24 //@cindex initScheduler
25 //@cindex exitScheduler
26 /* initScheduler(), exitScheduler(), startTasks()
28 * Called from STG : no
29 * Locks assumed : none
31 extern void initScheduler ( void );
32 extern void exitScheduler ( void );
34 //@cindex awakenBlockedQueue
35 /* awakenBlockedQueue()
37 * Takes a pointer to the beginning of a blocked TSO queue, and
38 * wakes up the entire queue.
40 * Called from STG : yes
41 * Locks assumed : none
44 void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
46 void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
48 void awakenBlockedQueue(StgTSO *tso);
54 * Takes a pointer to the beginning of a blocked TSO queue, and
55 * removes the first thread, placing it on the runnable queue.
57 * Called from STG : yes
58 * Locks assumed : none
60 #if defined(GRAN) || defined(PAR)
61 StgBlockingQueueElement *unblockOne(StgBlockingQueueElement *bqe, StgClosure *node);
63 StgTSO *unblockOne(StgTSO *tso);
69 * Raises an exception asynchronously in the specified thread.
71 * Called from STG : yes
72 * Locks assumed : none
74 void raiseAsync(StgTSO *tso, StgClosure *exception);
79 * Raises an exception asynchronously in the specified thread.
81 * Called from STG : NO
82 * Locks assumed : sched_mutex
84 void awaitEvent(rtsBool wait); /* In Select.c */
86 /* wakeUpSleepingThreads(nat ticks)
88 * Wakes up any sleeping threads whose timers have expired.
90 * Called from STG : NO
91 * Locks assumed : sched_mutex
93 rtsBool wakeUpSleepingThreads(nat); /* In Select.c */
95 /* GetRoots(evac_fn f)
97 * Call f() for each root known to the scheduler.
99 * Called from STG : NO
100 * Locks assumed : ????
102 void GetRoots(evac_fn);
104 // ToDo: check whether all fcts below are used in the SMP version, too
105 //@cindex awaken_blocked_queue
107 void awaken_blocked_queue(StgBlockingQueueElement *q, StgClosure *node);
108 void unlink_from_bq(StgTSO* tso, StgClosure* node);
109 void initThread(StgTSO *tso, nat stack_size, StgInt pri);
111 nat run_queue_len(void);
112 void awaken_blocked_queue(StgBlockingQueueElement *q, StgClosure *node);
113 void initThread(StgTSO *tso, nat stack_size);
115 char *info_type(StgClosure *closure); // dummy
116 char *info_type_by_ip(StgInfoTable *ip); // dummy
117 void awaken_blocked_queue(StgTSO *q);
118 void initThread(StgTSO *tso, nat stack_size);
121 //@node Scheduler Vars and Data Types, Some convenient macros, Scheduler Functions
122 //@subsection Scheduler Vars and Data Types
124 //@cindex context_switch
125 /* Context switch flag.
126 * Locks required : sched_mutex
128 extern nat context_switch;
129 extern rtsBool interrupted;
132 extern nat timestamp;
135 * Locks required : sched_mutex
137 * In GranSim we have one run/blocked_queue per PE.
140 // run_queue_hds defined in GranSim.h
142 extern StgTSO *run_queue_hd, *run_queue_tl;
143 extern StgTSO *blocked_queue_hd, *blocked_queue_tl;
144 extern StgTSO *sleeping_queue;
146 /* Linked list of all threads. */
147 extern StgTSO *all_threads;
149 #if defined(RTS_SUPPORTS_THREADS)
150 /* Schedule.c has detailed info on what these do */
151 extern Mutex sched_mutex;
152 extern Condition thread_ready_cond;
153 extern Condition returning_worker_cond;
154 extern nat rts_n_waiting_workers;
155 extern nat rts_n_waiting_tasks;
159 /* Sigh, RTS-internal versions of waitThread(), scheduleThread(), and
160 rts_evalIO() for the use by main() only. ToDo: better. */
161 extern SchedulerStatus waitThread_(StgTSO *tso,
162 /*out*/StgClosure **ret
163 #if defined(THREADED_RTS)
164 , rtsBool blockWaiting
167 extern SchedulerStatus rts_mainEvalIO(HaskellObj p, /*out*/HaskellObj *ret);
170 /* Called by shutdown_handler(). */
171 void interruptStgRts ( void );
173 void raiseAsync(StgTSO *tso, StgClosure *exception);
174 nat run_queue_len(void);
176 void resurrectThreads( StgTSO * );
178 //@node Some convenient macros, Index, Scheduler Vars and Data Types
179 //@subsection Some convenient macros
184 void printThreadBlockage(StgTSO *tso);
185 void printThreadStatus(StgTSO *tso);
186 void printAllThreads(void);
188 void print_bq (StgClosure *node);
190 void print_bqe (StgBlockingQueueElement *bqe);
193 /* -----------------------------------------------------------------------------
194 * Some convenient macros...
197 /* END_TSO_QUEUE and friends now defined in includes/StgMiscClosures.h */
199 //@cindex APPEND_TO_RUN_QUEUE
200 /* Add a thread to the end of the run queue.
201 * NOTE: tso->link should be END_TSO_QUEUE before calling this macro.
203 #define APPEND_TO_RUN_QUEUE(tso) \
204 ASSERT(tso->link == END_TSO_QUEUE); \
205 if (run_queue_hd == END_TSO_QUEUE) { \
206 run_queue_hd = tso; \
208 run_queue_tl->link = tso; \
212 //@cindex PUSH_ON_RUN_QUEUE
213 /* Push a thread on the beginning of the run queue. Used for
214 * newly awakened threads, so they get run as soon as possible.
216 #define PUSH_ON_RUN_QUEUE(tso) \
217 tso->link = run_queue_hd; \
218 run_queue_hd = tso; \
219 if (run_queue_tl == END_TSO_QUEUE) { \
220 run_queue_tl = tso; \
223 //@cindex POP_RUN_QUEUE
224 /* Pop the first thread off the runnable queue.
226 #define POP_RUN_QUEUE() \
227 ({ StgTSO *t = run_queue_hd; \
228 if (t != END_TSO_QUEUE) { \
229 run_queue_hd = t->link; \
230 t->link = END_TSO_QUEUE; \
231 if (run_queue_hd == END_TSO_QUEUE) { \
232 run_queue_tl = END_TSO_QUEUE; \
238 //@cindex APPEND_TO_BLOCKED_QUEUE
239 /* Add a thread to the end of the blocked queue.
241 #define APPEND_TO_BLOCKED_QUEUE(tso) \
242 ASSERT(tso->link == END_TSO_QUEUE); \
243 if (blocked_queue_hd == END_TSO_QUEUE) { \
244 blocked_queue_hd = tso; \
246 blocked_queue_tl->link = tso; \
248 blocked_queue_tl = tso;
250 //@cindex THREAD_RUNNABLE
251 /* Signal that a runnable thread has become available, in
252 * case there are any waiting tasks to execute it.
254 #if defined(RTS_SUPPORTS_THREADS)
255 #define THREAD_RUNNABLE() \
256 if ( !noCapabilities() ) { \
257 signalCondition(&thread_ready_cond); \
261 #define THREAD_RUNNABLE() /* nothing */
264 //@cindex EMPTY_RUN_QUEUE
265 /* Check whether the run queue is empty i.e. the PE is idle
267 #define EMPTY_RUN_QUEUE() (run_queue_hd == END_TSO_QUEUE)
268 #define EMPTY_QUEUE(q) (q == END_TSO_QUEUE)
270 #endif /* __SCHEDULE_H__ */
272 //@node Index, , Some convenient macros
276 //* APPEND_TO_BLOCKED_QUEUE:: @cindex\s-+APPEND_TO_BLOCKED_QUEUE
277 //* APPEND_TO_RUN_QUEUE:: @cindex\s-+APPEND_TO_RUN_QUEUE
278 //* POP_RUN_QUEUE :: @cindex\s-+POP_RUN_QUEUE
279 //* PUSH_ON_RUN_QUEUE:: @cindex\s-+PUSH_ON_RUN_QUEUE
280 //* awaitEvent:: @cindex\s-+awaitEvent
281 //* awakenBlockedQueue:: @cindex\s-+awakenBlockedQueue
282 //* awaken_blocked_queue:: @cindex\s-+awaken_blocked_queue
283 //* context_switch:: @cindex\s-+context_switch
284 //* exitScheduler:: @cindex\s-+exitScheduler
285 //* gc_pending_cond:: @cindex\s-+gc_pending_cond
286 //* initScheduler:: @cindex\s-+initScheduler
287 //* raiseAsync:: @cindex\s-+raiseAsync
288 //* startTasks:: @cindex\s-+startTasks
289 //* unblockOne:: @cindex\s-+unblockOne