X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FSchedule.h;h=d76f42b3af89e7ee2b3d50f60b07fc98a7f46dfe;hb=66579ff945831c5fc9a17c58c722ff01f2268d76;hp=37b07941f47b1b359f28157c00b279340ba532f6;hpb=0065d5ab628975892cea1ec7303f968c3338cbe1;p=ghc-hetmet.git diff --git a/rts/Schedule.h b/rts/Schedule.h index 37b0794..d76f42b 100644 --- a/rts/Schedule.h +++ b/rts/Schedule.h @@ -18,7 +18,8 @@ * Locks assumed : none */ void initScheduler (void); -void exitScheduler (void); +void exitScheduler (rtsBool wait_foreign); +void freeScheduler (void); // Place a new thread on the run queue of the current Capability void scheduleThread (Capability *cap, StgTSO *tso); @@ -43,30 +44,19 @@ void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node); void awakenBlockedQueue (Capability *cap, StgTSO *tso); #endif +/* wakeUpRts() + * + * Causes an OS thread to wake up and run the scheduler, if necessary. + */ +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); +StgTSO * unblockOne (Capability *cap, StgTSO *tso); /* raiseExceptionHelper */ StgWord raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *exception); @@ -74,22 +64,15 @@ StgWord raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *excepti /* 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(THREADED_RTS) +void OSThreadProcAttr workerStart(Task *task); +#endif #if defined(GRAN) void awaken_blocked_queue(StgBlockingQueueElement *q, StgClosure *node); @@ -106,19 +89,13 @@ 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 */ +#define SCHED_SHUTTING_DOWN 2 /* final shutdown */ extern rtsBool RTS_VAR(sched_state); @@ -153,11 +130,6 @@ 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 @@ -171,8 +143,6 @@ extern rtsBool blackholes_need_checking; extern Mutex RTS_VAR(sched_mutex); #endif -StgBool isThreadBound(StgTSO *tso); - SchedulerStatus rts_mainLazyIO(HaskellObj p, /*out*/HaskellObj *ret); /* Called by shutdown_handler(). */ @@ -181,6 +151,7 @@ void interruptStgRts (void); nat run_queue_len (void); void resurrectThreads (StgTSO *); +void performPendingThrowTos (StgTSO *); void printAllThreads(void); @@ -193,8 +164,6 @@ void print_bq (StgClosure *node); void print_bqe (StgBlockingQueueElement *bqe); #endif -void labelThread(StgPtr tso, char *label); - /* ----------------------------------------------------------------------------- * Some convenient macros/inline functions... */ @@ -207,14 +176,14 @@ 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 +INLINE_HEADER 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; } else { - cap->run_queue_tl->link = tso; + setTSOLink(cap, cap->run_queue_tl, tso); } cap->run_queue_tl = tso; } @@ -223,10 +192,10 @@ appendToRunQueue (Capability *cap, StgTSO *tso) * newly awakened threads, so they get run as soon as possible. * ASSUMES: cap->running_task is the current task. */ -STATIC_INLINE void +INLINE_HEADER void pushOnRunQueue (Capability *cap, StgTSO *tso) { - tso->link = cap->run_queue_hd; + setTSOLink(cap, tso, cap->run_queue_hd); cap->run_queue_hd = tso; if (cap->run_queue_tl == END_TSO_QUEUE) { cap->run_queue_tl = tso; @@ -235,13 +204,13 @@ 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; + 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; } @@ -251,49 +220,54 @@ popRunQueue (Capability *cap) /* 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) +// Assumes: my_cap is owned by the current Task. We hold +// other_cap->lock, but we do not necessarily own other_cap; another +// Task may be running on it. +INLINE_HEADER void +appendToWakeupQueue (Capability *my_cap, Capability *other_cap, StgTSO *tso) { - ASSERT(tso->link == END_TSO_QUEUE); - if (cap->wakeup_queue_hd == END_TSO_QUEUE) { - cap->wakeup_queue_hd = tso; + ASSERT(tso->_link == END_TSO_QUEUE); + if (other_cap->wakeup_queue_hd == END_TSO_QUEUE) { + other_cap->wakeup_queue_hd = tso; } else { - cap->wakeup_queue_tl->link = tso; + // my_cap is passed to setTSOLink() because it may need to + // write to the mutable list. + setTSOLink(my_cap, other_cap->wakeup_queue_tl, tso); } - cap->wakeup_queue_tl = tso; + other_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 +INLINE_HEADER rtsBool emptyWakeupQueue(Capability *cap) { return emptyQueue(cap->wakeup_queue_hd); @@ -305,7 +279,7 @@ emptyWakeupQueue(Capability *cap) #define EMPTY_SLEEPING_QUEUE() (emptyQueue(sleeping_queue)) #endif -STATIC_INLINE rtsBool +INLINE_HEADER rtsBool emptyThreadQueues(Capability *cap) { return emptyRunQueue(cap) @@ -315,18 +289,7 @@ emptyThreadQueues(Capability *cap) ; } -#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 */