[project @ 2000-05-26 10:14:33 by sewardj]

[ghc-hetmet.git] / ghc / includes / TSO.h

diff --git a/ghc/includes/TSO.h b/ghc/includes/TSO.h
index ce46e00..6572a7e 100644 (file)
--- a/ghc/includes/TSO.h
+++ b/ghc/includes/TSO.h
@@ -1,5 +1,5 @@
 /* -----------------------------------------------------------------------------
- * $Id: TSO.h,v 1.10 2000/01/13 14:34:01 hwloidl Exp $
+ * $Id: TSO.h,v 1.16 2000/05/26 10:14:33 sewardj Exp $
  *
  * (c) The GHC Team, 1998-1999
  *
@@ -11,8 +11,11 @@
 #define TSO_H
 
 #if defined(GRAN) || defined(PAR)
+
+#if DEBUG // && PARANOIA_LEVEL>999
 // magic marker for TSOs; debugging only
 #define TSO_MAGIC 4321
+#endif
 
 typedef struct {
   StgInt   pri;
@@ -71,12 +74,16 @@ typedef enum {
     tso_state_stopped
 } StgTSOState;
 
+/*
+ * The what_next field of a TSO indicates how the thread is to be run. 
+ */
 typedef enum {
-  ThreadEnterGHC,
-  ThreadRunGHC,
-  ThreadEnterHugs,
-  ThreadKilled,
-  ThreadComplete
+  ThreadEnterGHC,              /* enter top thunk on stack */
+  ThreadRunGHC,                        /* return to address on top of stack */
+  ThreadEnterHugs,             /* enter top thunk on stack (w/ interpreter) */
+  ThreadKilled,                        /* thread has died, don't run it */
+  ThreadRelocated,             /* thread has moved, link points to new locn */
+  ThreadComplete               /* thread has finished */
 } StgTSOWhatNext;
 
 /*
@@ -118,7 +125,8 @@ typedef enum {
   BlockedOnWrite,
   BlockedOnDelay
 #if defined(PAR)
-  , BlockedOnGA    // blocked on a remote closure represented by a Global Address
+  , BlockedOnGA  // blocked on a remote closure represented by a Global Address
+  , BlockedOnGA_NoSend // same as above but without sending a Fetch message
 #endif
 } StgTSOBlockReason;
 
@@ -126,9 +134,10 @@ typedef union {
   StgClosure *closure;
   struct StgTSO_ *tso;
   int fd;
+#if defined(HAVE_SETITIMER) || defined(mingw32_TARGET_OS)
   unsigned int delay;
-#if defined(PAR)
-  globalAddr ga;
+#else
+  unsigned int target;
 #endif
 } StgTSOBlockInfo;
 
@@ -140,10 +149,12 @@ typedef union {
 
 typedef struct StgTSO_ {
   StgHeader          header;
-  struct StgTSO_*    link;
-  /* SDM and HWL agree that it would be cool to have a list of all TSOs */
-  StgMutClosure *    mut_link; /* TSO's are mutable of course! */
-  StgTSOWhatNext     whatNext;
+
+  struct StgTSO_*    link;          /* Links threads onto blocking queues */
+  StgMutClosure *    mut_link;      /* TSO's are mutable of course! */
+  struct StgTSO_*    global_link;    /* Links all threads together */
+  
+  StgTSOWhatNext     what_next;
   StgTSOBlockReason  why_blocked;
   StgTSOBlockInfo    block_info;
   struct StgTSO_*    blocked_exceptions;
@@ -179,7 +190,7 @@ typedef struct StgTSO_ {
         (a) smaller than a block, or
        (b) a multiple of BLOCK_SIZE
 
-       tso->block_reason      tso->block_info      location
+       tso->why_blocked       tso->block_info      location
         ----------------------------------------------------------------------
        NotBlocked             NULL                 runnable_queue, or running
        
@@ -192,17 +203,19 @@ typedef struct StgTSO_ {
         BlockedOnRead          NULL                 blocked_queue
         BlockedOnWrite         NULL                blocked_queue
         BlockedOnDelay         NULL                 blocked_queue
+       BlockedOnGA            closure TSO blocks on   BQ of that closure
+       BlockedOnGA_NoSend     closure TSO blocks on   BQ of that closure
 
       tso->link == END_TSO_QUEUE, if the thread is currently running.
 
    A zombie thread has the following properties:
       
-      tso->whatNext == ThreadComplete or ThreadKilled
+      tso->what_next == ThreadComplete or ThreadKilled
       tso->link     ==  (could be on some queue somewhere)
       tso->su       ==  tso->stack + tso->stack_size
       tso->sp       ==  tso->stack + tso->stack_size - 1 (i.e. top stack word)
-      tso->sp[0]    ==  return value of thread, if whatNext == ThreadComplete,
-                        exception             , if whatNext == ThreadKilled
+      tso->sp[0]    ==  return value of thread, if what_next == ThreadComplete,
+                        exception             , if what_next == ThreadKilled
 
       (tso->sp is left pointing at the top word on the stack so that
       the return value or exception will be retained by a GC).
@@ -217,6 +230,13 @@ typedef struct StgTSO_ {
       (StgTSO *)tso    if threads are currently awaiting delivery of
                        exceptions to this thread.
 
+   The 2 cases BlockedOnGA and BlockedOnGA_NoSend are needed in a GUM
+   setup only. They mark a TSO that has entered a FETCH_ME or
+   FETCH_ME_BQ closure, respectively; only the first TSO hitting the 
+   closure will send a Fetch message.
+   Currently we have no separate code for blocking on an RBH; we use the
+   BlockedOnBlackHole case for that.   -- HWL
+
  ---------------------------------------------------------------------------- */
 
 /* Workaround for a bug/quirk in gcc on certain architectures.