X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FSchedule.h;h=59bdb9e999045b40abb0a416002539c7e59426c8;hb=27de38efce6d73d2a0209f803cfa98c82773e773;hp=edbe246ed326be74915798735dfcd7d924c613a2;hpb=90d88088ee8b3697ce68f7b1e07506bc4f33687d;p=ghc-hetmet.git

diff --git a/rts/Schedule.h b/rts/Schedule.h
index edbe246..59bdb9e 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,15 +64,6 @@ 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.
@@ -152,11 +133,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
@@ -170,8 +146,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(). */
@@ -180,6 +154,7 @@ void interruptStgRts (void);
 nat  run_queue_len (void);
 
 void resurrectThreads (StgTSO *);
+void performPendingThrowTos (StgTSO *);
 
 void printAllThreads(void);
 
@@ -192,8 +167,6 @@ void print_bq (StgClosure *node);
 void print_bqe (StgBlockingQueueElement *bqe);
 #endif
 
-void labelThread(StgPtr tso, char *label);
-
 /* -----------------------------------------------------------------------------
  * Some convenient macros/inline functions...
  */
@@ -206,14 +179,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;
 }
@@ -222,10 +195,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;
@@ -234,13 +207,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;
     }
@@ -250,28 +223,28 @@ 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
+INLINE_HEADER void
 appendToWakeupQueue (Capability *cap, StgTSO *tso)
 {
-    ASSERT(tso->link == END_TSO_QUEUE);
+    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;
+	setTSOLink(cap, cap->wakeup_queue_tl, tso);
     }
     cap->wakeup_queue_tl = tso;
 }
@@ -279,20 +252,20 @@ appendToWakeupQueue (Capability *cap, StgTSO *tso)
 
 /* 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);
@@ -304,7 +277,7 @@ emptyWakeupQueue(Capability *cap)
 #define EMPTY_SLEEPING_QUEUE() (emptyQueue(sleeping_queue))
 #endif
 
-STATIC_INLINE rtsBool
+INLINE_HEADER rtsBool
 emptyThreadQueues(Capability *cap)
 {
     return emptyRunQueue(cap)
@@ -314,18 +287,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 */