[project @ 2004-08-13 13:04:50 by simonmar]

[ghc-hetmet.git] / ghc / rts / Schedule.h

diff --git a/ghc/rts/Schedule.h b/ghc/rts/Schedule.h
index cf49a78..588ddc5 100644 (file)
--- a/ghc/rts/Schedule.h
+++ b/ghc/rts/Schedule.h
@@ -1,5 +1,4 @@
 /* -----------------------------------------------------------------------------
- * $Id: Schedule.h,v 1.37 2003/01/25 15:54:50 wolfgang Exp $
  *
  * (c) The GHC Team 1998-1999
  *
@@ -33,10 +32,8 @@ void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
 #elif defined(PAR)
 void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
 #else
-void awakenBlockedQueue(StgTSO *tso);
-#if defined(RTS_SUPPORTS_THREADS)
-void awakenBlockedQueueNoLock(StgTSO *tso);
-#endif
+void awakenBlockedQueue (StgTSO *tso);
+void awakenBlockedQueueNoLock (StgTSO *tso);
 #endif
 
 /* unblockOne()
@@ -63,6 +60,9 @@ StgTSO *unblockOne(StgTSO *tso);
 void raiseAsync(StgTSO *tso, StgClosure *exception);
 void raiseAsyncWithLock(StgTSO *tso, StgClosure *exception);
 
+/* raiseExceptionHelper */
+StgWord raiseExceptionHelper (StgTSO *tso, StgClosure *exception);
+
 /* awaitEvent(rtsBool wait)
  *
  * Checks for blocked threads that need to be woken.
@@ -90,6 +90,14 @@ rtsBool wakeUpSleepingThreads(nat);  /* In Select.c */
  */
 void wakeBlockedWorkerThread(void); /* In Select.c */
 
+/* resetWorkerWakeupPipeAfterFork()
+ *
+ * Notify Select.c that a fork() has occured
+ *
+ * Called from STG :  NO
+ * Locks assumed   :  don't care, but must be called right after fork()
+ */
+void resetWorkerWakeupPipeAfterFork(void); /* In Select.c */
 
 /* GetRoots(evac_fn f)
  *
@@ -119,11 +127,11 @@ void    initThread(StgTSO *tso, nat stack_size);
 /* Context switch flag.
  * Locks required  : sched_mutex
  */
-extern nat context_switch;
-extern rtsBool interrupted;
+extern nat RTS_VAR(context_switch);
+extern rtsBool RTS_VAR(interrupted);
 
 /* In Select.c */
-extern nat timestamp;
+extern nat RTS_VAR(timestamp);
 
 /* Thread queues.
  * Locks required  : sched_mutex
@@ -133,25 +141,26 @@ extern nat timestamp;
 #if defined(GRAN)
 // run_queue_hds defined in GranSim.h
 #else
-extern  StgTSO *run_queue_hd, *run_queue_tl;
-extern  StgTSO *blocked_queue_hd, *blocked_queue_tl;
-extern  StgTSO *sleeping_queue;
+extern  StgTSO *RTS_VAR(run_queue_hd), *RTS_VAR(run_queue_tl);
+extern  StgTSO *RTS_VAR(blocked_queue_hd), *RTS_VAR(blocked_queue_tl);
+extern  StgTSO *RTS_VAR(sleeping_queue);
 #endif
 /* Linked list of all threads. */
-extern  StgTSO *all_threads;
+extern  StgTSO *RTS_VAR(all_threads);
 
 #if defined(RTS_SUPPORTS_THREADS)
 /* Schedule.c has detailed info on what these do */
-extern Mutex       sched_mutex;
-extern Condition   thread_ready_cond;
-extern Condition   returning_worker_cond;
-extern nat         rts_n_waiting_workers;
-extern nat         rts_n_waiting_tasks;
+extern Mutex       RTS_VAR(sched_mutex);
+extern Condition   RTS_VAR(returning_worker_cond);
+extern nat         RTS_VAR(rts_n_waiting_workers);
+extern nat         RTS_VAR(rts_n_waiting_tasks);
 #endif
 
-StgInt forkProcess(StgTSO *tso);
+StgBool rtsSupportsBoundThreads(void);
+StgBool isThreadBound(StgTSO *tso);
+StgInt forkProcess(HsStablePtr *entry);
 
-extern SchedulerStatus rts_mainEvalIO(HaskellObj p, /*out*/HaskellObj *ret);
+extern SchedulerStatus rts_mainLazyIO(HaskellObj p, /*out*/HaskellObj *ret);
 
 
 /* Called by shutdown_handler(). */
@@ -166,11 +175,13 @@ void resurrectThreads( StgTSO * );
  *
  * These are the threads which clients have requested that we run.  
  *
- * In a 'threaded' build, we might have several concurrent clients all
- * waiting for results, and each one will wait on a condition variable
- * until the result is available.
+ * In a 'threaded' build, each of these corresponds to one bound thread.
+ * The pointer to the StgMainThread is passed as a parameter to schedule;
+ * this invocation of schedule will always pass this main thread's
+ * bound_thread_cond to waitForkWorkCapability; OS-thread-switching
+ * takes place using passCapability.
  *
- * In non-SMP, clients are strictly nested: the first client calls
+ * In non-threaded builds, clients are strictly nested: the first client calls
  * into the RTS, which might call out again to C with a _ccall_GC, and
  * eventually re-enter the RTS.
  *
@@ -186,12 +197,13 @@ typedef struct StgMainThread_ {
   SchedulerStatus  stat;
   StgClosure **    ret;
 #if defined(RTS_SUPPORTS_THREADS)
-  Condition        wakeup;
 #if defined(THREADED_RTS)
-  rtsBool          thread_bound;
   Condition        bound_thread_cond;
+#else
+  Condition        wakeup;
 #endif
 #endif
+  struct StgMainThread_ *prev;
   struct StgMainThread_ *link;
 } StgMainThread;
 
@@ -246,17 +258,17 @@ void labelThread(StgPtr tso, char *label);
 
 /* Pop the first thread off the runnable queue.
  */
-#define POP_RUN_QUEUE()                                \
-  ({ StgTSO *t = run_queue_hd;                 \
-    if (t != END_TSO_QUEUE) {                  \
-      run_queue_hd = t->link;                  \
-      t->link = END_TSO_QUEUE;                 \
+#define POP_RUN_QUEUE(pt)                      \
+  do { StgTSO *__tmp_t = run_queue_hd;         \
+    if (__tmp_t != END_TSO_QUEUE) {            \
+      run_queue_hd = __tmp_t->link;            \
+      __tmp_t->link = END_TSO_QUEUE;           \
       if (run_queue_hd == END_TSO_QUEUE) {     \
         run_queue_tl = END_TSO_QUEUE;          \
       }                                                \
     }                                          \
-    t;                                         \
-  })
+    pt = __tmp_t;                              \
+  } while(0)
 
 /* Add a thread to the end of the blocked queue.
  */
@@ -294,12 +306,16 @@ void labelThread(StgPtr tso, char *label);
 
 #if defined(RTS_SUPPORTS_THREADS)
 /* If no task is waiting for a capability,
+ * and if there is work to be done
+ * or if we need to wait for IO or delay requests,
  * spawn a new worker thread.
- *
- * (Used by the RtsAPI)
  */
 void
-startSchedulerTask(void);
+startSchedulerTaskIfNecessary(void);
+#endif
+
+#ifdef DEBUG
+extern void sched_belch(char *s, ...);
 #endif
 
 #endif /* __SCHEDULE_H__ */