diff options
Diffstat (limited to 'ghc/rts/Schedule.h')
| -rw-r--r-- | ghc/rts/Schedule.h | 332 |
1 files changed, 0 insertions, 332 deletions
diff --git a/ghc/rts/Schedule.h b/ghc/rts/Schedule.h deleted file mode 100644 index 37b07941f4..0000000000 --- a/ghc/rts/Schedule.h +++ /dev/null @@ -1,332 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * (c) The GHC Team 1998-2005 - * - * Prototypes for functions in Schedule.c - * (RTS internal scheduler interface) - * - * -------------------------------------------------------------------------*/ - -#ifndef SCHEDULE_H -#define SCHEDULE_H - -#include "OSThreads.h" -#include "Capability.h" - -/* initScheduler(), exitScheduler() - * Called from STG : no - * Locks assumed : none - */ -void initScheduler (void); -void exitScheduler (void); - -// Place a new thread on the run queue of the current Capability -void scheduleThread (Capability *cap, StgTSO *tso); - -// Place a new thread on the run queue of a specified Capability -// (cap is the currently owned Capability, cpu is the number of -// the desired Capability). -void scheduleThreadOn(Capability *cap, StgWord cpu, StgTSO *tso); - -/* awakenBlockedQueue() - * - * Takes a pointer to the beginning of a blocked TSO queue, and - * wakes up the entire queue. - * Called from STG : yes - * Locks assumed : none - */ -#if defined(GRAN) -void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node); -#elif defined(PAR) -void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node); -#else -void awakenBlockedQueue (Capability *cap, StgTSO *tso); -#endif - -/* unblockOne() - * - * Put the specified thread on the run queue of the given Capability. - * Called from STG : yes - * Locks assumed : we own the Capability. - */ -StgTSO * unblockOne(Capability *cap, StgTSO *tso); - -/* raiseAsync() - * - * Raises an exception asynchronously in the specified thread. - * - * Called from STG : yes - * Locks assumed : none - */ -void raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception); - -/* suspendComputation() - * - * A variant of raiseAsync(), this strips the stack of the specified - * thread down to the stop_here point, leaving a current closure on - * top of the stack at [stop_here - 1]. - */ -void suspendComputation(Capability *cap, StgTSO *tso, StgPtr stop_here); - -/* raiseExceptionHelper */ -StgWord raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *exception); - -/* findRetryFrameHelper */ -StgWord findRetryFrameHelper (StgTSO *tso); - -/* GetRoots(evac_fn f) - * - * Call f() for each root known to the scheduler. - * - * Called from STG : NO - * Locks assumed : ???? - */ -void GetRoots(evac_fn); - -/* workerStart() - * - * Entry point for a new worker task. - * Called from STG : NO - * Locks assumed : none - */ -void workerStart(Task *task); - -#if defined(GRAN) -void awaken_blocked_queue(StgBlockingQueueElement *q, StgClosure *node); -void unlink_from_bq(StgTSO* tso, StgClosure* node); -void initThread(StgTSO *tso, nat stack_size, StgInt pri); -#elif defined(PAR) -nat run_queue_len(void); -void awaken_blocked_queue(StgBlockingQueueElement *q, StgClosure *node); -void initThread(StgTSO *tso, nat stack_size); -#else -char *info_type(StgClosure *closure); // dummy -char *info_type_by_ip(StgInfoTable *ip); // dummy -void awaken_blocked_queue(StgTSO *q); -void initThread(StgTSO *tso, nat stack_size); -#endif - -/* Context switch flag. - * Locks required : none (conflicts are harmless) - */ -extern int RTS_VAR(context_switch); - -/* The state of the scheduler. This is used to control the sequence - * of events during shutdown, and when the runtime is interrupted - * using ^C. - */ -#define SCHED_RUNNING 0 /* running as normal */ -#define SCHED_INTERRUPTING 1 /* ^C detected, before threads are deleted */ -#define SCHED_INTERRUPTED 2 /* ^C detected, after threads deleted */ -#define SCHED_SHUTTING_DOWN 3 /* final shutdown */ - -extern rtsBool RTS_VAR(sched_state); - -/* - * flag that tracks whether we have done any execution in this time slice. - */ -#define ACTIVITY_YES 0 /* there has been activity in the current slice */ -#define ACTIVITY_MAYBE_NO 1 /* no activity in the current slice */ -#define ACTIVITY_INACTIVE 2 /* a complete slice has passed with no activity */ -#define ACTIVITY_DONE_GC 3 /* like 2, but we've done a GC too */ - -/* Recent activity flag. - * Locks required : Transition from MAYBE_NO to INACTIVE - * happens in the timer signal, so it is atomic. Trnasition from - * INACTIVE to DONE_GC happens under sched_mutex. No lock required - * to set it to ACTIVITY_YES. - */ -extern nat recent_activity; - -/* Thread queues. - * Locks required : sched_mutex - * - * In GranSim we have one run/blocked_queue per PE. - */ -#if defined(GRAN) -// run_queue_hds defined in GranSim.h -#else -extern StgTSO *RTS_VAR(blackhole_queue); -#if !defined(THREADED_RTS) -extern StgTSO *RTS_VAR(blocked_queue_hd), *RTS_VAR(blocked_queue_tl); -extern StgTSO *RTS_VAR(sleeping_queue); -#endif -#endif - -/* Linked list of all threads. - * Locks required : sched_mutex - */ -extern StgTSO *RTS_VAR(all_threads); - -/* Set to rtsTrue if there are threads on the blackhole_queue, and - * it is possible that one or more of them may be available to run. - * This flag is set to rtsFalse after we've checked the queue, and - * set to rtsTrue just before we run some Haskell code. It is used - * to decide whether we should yield the Capability or not. - * Locks required : none (see scheduleCheckBlackHoles()). - */ -extern rtsBool blackholes_need_checking; - -#if defined(THREADED_RTS) -extern Mutex RTS_VAR(sched_mutex); -#endif - -StgBool isThreadBound(StgTSO *tso); - -SchedulerStatus rts_mainLazyIO(HaskellObj p, /*out*/HaskellObj *ret); - -/* Called by shutdown_handler(). */ -void interruptStgRts (void); - -nat run_queue_len (void); - -void resurrectThreads (StgTSO *); - -void printAllThreads(void); - -/* debugging only - */ -#ifdef DEBUG -void print_bq (StgClosure *node); -#endif -#if defined(PAR) -void print_bqe (StgBlockingQueueElement *bqe); -#endif - -void labelThread(StgPtr tso, char *label); - -/* ----------------------------------------------------------------------------- - * Some convenient macros/inline functions... - */ - -#if !IN_STG_CODE - -/* END_TSO_QUEUE and friends now defined in includes/StgMiscClosures.h */ - -/* Add a thread to the end of the run queue. - * NOTE: tso->link should be END_TSO_QUEUE before calling this macro. - * ASSUMES: cap->running_task is the current task. - */ -STATIC_INLINE void -appendToRunQueue (Capability *cap, StgTSO *tso) -{ - ASSERT(tso->link == END_TSO_QUEUE); - if (cap->run_queue_hd == END_TSO_QUEUE) { - cap->run_queue_hd = tso; - } else { - cap->run_queue_tl->link = tso; - } - cap->run_queue_tl = tso; -} - -/* Push a thread on the beginning of the run queue. Used for - * newly awakened threads, so they get run as soon as possible. - * ASSUMES: cap->running_task is the current task. - */ -STATIC_INLINE void -pushOnRunQueue (Capability *cap, StgTSO *tso) -{ - tso->link = cap->run_queue_hd; - cap->run_queue_hd = tso; - if (cap->run_queue_tl == END_TSO_QUEUE) { - cap->run_queue_tl = tso; - } -} - -/* Pop the first thread off the runnable queue. - */ -STATIC_INLINE StgTSO * -popRunQueue (Capability *cap) -{ - StgTSO *t = cap->run_queue_hd; - ASSERT(t != END_TSO_QUEUE); - cap->run_queue_hd = t->link; - t->link = END_TSO_QUEUE; - if (cap->run_queue_hd == END_TSO_QUEUE) { - cap->run_queue_tl = END_TSO_QUEUE; - } - return t; -} - -/* Add a thread to the end of the blocked queue. - */ -#if !defined(THREADED_RTS) -STATIC_INLINE void -appendToBlockedQueue(StgTSO *tso) -{ - ASSERT(tso->link == END_TSO_QUEUE); - if (blocked_queue_hd == END_TSO_QUEUE) { - blocked_queue_hd = tso; - } else { - blocked_queue_tl->link = tso; - } - blocked_queue_tl = tso; -} -#endif - -#if defined(THREADED_RTS) -STATIC_INLINE void -appendToWakeupQueue (Capability *cap, StgTSO *tso) -{ - ASSERT(tso->link == END_TSO_QUEUE); - if (cap->wakeup_queue_hd == END_TSO_QUEUE) { - cap->wakeup_queue_hd = tso; - } else { - cap->wakeup_queue_tl->link = tso; - } - cap->wakeup_queue_tl = tso; -} -#endif - -/* Check whether various thread queues are empty - */ -STATIC_INLINE rtsBool -emptyQueue (StgTSO *q) -{ - return (q == END_TSO_QUEUE); -} - -STATIC_INLINE rtsBool -emptyRunQueue(Capability *cap) -{ - return emptyQueue(cap->run_queue_hd); -} - -#if defined(THREADED_RTS) -STATIC_INLINE rtsBool -emptyWakeupQueue(Capability *cap) -{ - return emptyQueue(cap->wakeup_queue_hd); -} -#endif - -#if !defined(THREADED_RTS) -#define EMPTY_BLOCKED_QUEUE() (emptyQueue(blocked_queue_hd)) -#define EMPTY_SLEEPING_QUEUE() (emptyQueue(sleeping_queue)) -#endif - -STATIC_INLINE rtsBool -emptyThreadQueues(Capability *cap) -{ - return emptyRunQueue(cap) -#if !defined(THREADED_RTS) - && EMPTY_BLOCKED_QUEUE() && EMPTY_SLEEPING_QUEUE() -#endif - ; -} - -#ifdef DEBUG -void sched_belch(char *s, ...) - GNU_ATTRIBUTE(format (printf, 1, 2)); -#endif - -#endif /* !IN_STG_CODE */ - -STATIC_INLINE void -dirtyTSO (StgTSO *tso) -{ - tso->flags |= TSO_DIRTY; -} - -#endif /* SCHEDULE_H */ - |