X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=rts%2FSchedule.h;h=549f555a1178667f4b01add9ce5943b0eb9d49c6;hp=e30e911e68e013c4063ad09c726febc0e8a2b8ef;hb=1fb38442d3a55ac92795aa6c5ed4df82011df724;hpb=7434fb5be86c7cc59c520dc07dc96b27b4fb1406 diff --git a/rts/Schedule.h b/rts/Schedule.h index e30e911..549f555 100644 --- a/rts/Schedule.h +++ b/rts/Schedule.h @@ -10,15 +10,20 @@ #ifndef SCHEDULE_H #define SCHEDULE_H -#include "OSThreads.h" +#include "rts/OSThreads.h" #include "Capability.h" +#include "Trace.h" + +#include "BeginPrivate.h" /* initScheduler(), exitScheduler() * Called from STG : no * Locks assumed : none */ void initScheduler (void); -void exitScheduler (void); +void exitScheduler (rtsBool wait_foreign); +void freeScheduler (void); +void markScheduler (evac_fn evac, void *user); // Place a new thread on the run queue of the current Capability void scheduleThread (Capability *cap, StgTSO *tso); @@ -28,94 +33,22 @@ void scheduleThread (Capability *cap, StgTSO *tso); // 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 - /* wakeUpRts() * * Causes an OS thread to wake up and run the scheduler, if necessary. */ +#if defined(THREADED_RTS) void wakeUpRts(void); - -/* 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); +#endif /* raiseExceptionHelper */ StgWord raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *exception); /* findRetryFrameHelper */ -StgWord findRetryFrameHelper (StgTSO *tso); +StgWord findRetryFrameHelper (Capability *cap, 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); +/* Entry point for a new worker */ +void scheduleWorker (Capability *cap, Task *task); /* The state of the scheduler. This is used to control the sequence * of events during shutdown, and when the runtime is interrupted @@ -125,7 +58,7 @@ extern int RTS_VAR(context_switch); #define SCHED_INTERRUPTING 1 /* ^C detected, before threads are deleted */ #define SCHED_SHUTTING_DOWN 2 /* final shutdown */ -extern rtsBool RTS_VAR(sched_state); +extern volatile StgWord sched_state; /* * flag that tracks whether we have done any execution in this time slice. @@ -141,65 +74,30 @@ extern rtsBool RTS_VAR(sched_state); * INACTIVE to DONE_GC happens under sched_mutex. No lock required * to set it to ACTIVITY_YES. */ -extern nat recent_activity; +extern volatile StgWord 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); +extern StgTSO *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 +extern StgTSO *blocked_queue_hd, *blocked_queue_tl; +extern StgTSO *sleeping_queue; #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; +extern rtsBool heap_overflow; #if defined(THREADED_RTS) -extern Mutex RTS_VAR(sched_mutex); +extern Mutex 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... */ @@ -212,26 +110,38 @@ void labelThread(StgPtr tso, char *label); * NOTE: tso->link should be END_TSO_QUEUE before calling this macro. * ASSUMES: cap->running_task is the current task. */ -STATIC_INLINE void +EXTERN_INLINE void +appendToRunQueue (Capability *cap, StgTSO *tso); + +EXTERN_INLINE void appendToRunQueue (Capability *cap, StgTSO *tso) { - ASSERT(tso->link == END_TSO_QUEUE); + ASSERT(tso->_link == END_TSO_QUEUE); if (cap->run_queue_hd == END_TSO_QUEUE) { cap->run_queue_hd = tso; + tso->block_info.prev = END_TSO_QUEUE; } else { - cap->run_queue_tl->link = tso; + setTSOLink(cap, cap->run_queue_tl, tso); + setTSOPrev(cap, tso, cap->run_queue_tl); } cap->run_queue_tl = tso; + traceEventThreadRunnable (cap, tso); } -/* Push a thread on the beginning of the run queue. Used for - * newly awakened threads, so they get run as soon as possible. +/* Push a thread on the beginning of the run queue. * ASSUMES: cap->running_task is the current task. */ -STATIC_INLINE void +EXTERN_INLINE void +pushOnRunQueue (Capability *cap, StgTSO *tso); + +EXTERN_INLINE void pushOnRunQueue (Capability *cap, StgTSO *tso) { - tso->link = cap->run_queue_hd; + setTSOLink(cap, tso, cap->run_queue_hd); + tso->block_info.prev = END_TSO_QUEUE; + if (cap->run_queue_hd != END_TSO_QUEUE) { + setTSOPrev(cap, cap->run_queue_hd, tso); + } cap->run_queue_hd = tso; if (cap->run_queue_tl == END_TSO_QUEUE) { cap->run_queue_tl = tso; @@ -240,77 +150,60 @@ pushOnRunQueue (Capability *cap, StgTSO *tso) /* Pop the first thread off the runnable queue. */ -STATIC_INLINE StgTSO * +INLINE_HEADER 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; + cap->run_queue_hd = t->_link; + if (t->_link != END_TSO_QUEUE) { + t->_link->block_info.prev = END_TSO_QUEUE; + } + t->_link = END_TSO_QUEUE; // no write barrier req'd if (cap->run_queue_hd == END_TSO_QUEUE) { cap->run_queue_tl = END_TSO_QUEUE; } return t; } +extern void removeFromRunQueue (Capability *cap, StgTSO *tso); + /* Add a thread to the end of the blocked queue. */ #if !defined(THREADED_RTS) -STATIC_INLINE void +INLINE_HEADER void appendToBlockedQueue(StgTSO *tso) { - ASSERT(tso->link == END_TSO_QUEUE); + ASSERT(tso->_link == END_TSO_QUEUE); if (blocked_queue_hd == END_TSO_QUEUE) { blocked_queue_hd = tso; } else { - blocked_queue_tl->link = tso; + setTSOLink(&MainCapability, blocked_queue_tl, 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 +INLINE_HEADER rtsBool emptyQueue (StgTSO *q) { return (q == END_TSO_QUEUE); } -STATIC_INLINE rtsBool +INLINE_HEADER 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 +INLINE_HEADER rtsBool emptyThreadQueues(Capability *cap) { return emptyRunQueue(cap) @@ -322,11 +215,7 @@ emptyThreadQueues(Capability *cap) #endif /* !IN_STG_CODE */ -STATIC_INLINE void -dirtyTSO (StgTSO *tso) -{ - tso->flags |= TSO_DIRTY; -} +#include "EndPrivate.h" #endif /* SCHEDULE_H */