[project @ 2003-10-01 10:49:07 by wolfgang]

[ghc-hetmet.git] / ghc / rts / Select.c

diff --git a/ghc/rts/Select.c b/ghc/rts/Select.c
index 5f43ec0..d7e6ffc 100644 (file)
--- a/ghc/rts/Select.c
+++ b/ghc/rts/Select.c
@@ -1,5 +1,5 @@
 /* -----------------------------------------------------------------------------
- * $Id: Select.c,v 1.24 2003/02/21 05:34:16 sof Exp $
+ * $Id: Select.c,v 1.30 2003/10/01 10:49:09 wolfgang Exp $
  *
  * (c) The GHC Team 1995-2002
  *
@@ -7,6 +7,7 @@
  *
  * ---------------------------------------------------------------------------*/
 
+
 /* we're outside the realms of POSIX here... */
 /* #include "PosixSource.h" */
 
@@ -14,6 +15,7 @@
 #include "Schedule.h"
 #include "RtsUtils.h"
 #include "RtsFlags.h"
+#include "Timer.h"
 #include "Itimer.h"
 #include "Signals.h"
 #include "Capability.h"
@@ -26,25 +28,22 @@
 #  include <sys/time.h>
 # endif
 
-# ifdef mingw32_TARGET_OS
-#  include <windows.h>
-#  include "win32/AsyncIO.h"
-# endif
-
 #include <errno.h>
 #include <string.h>
 
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
 /* last timestamp */
 nat timestamp = 0;
 
 #ifdef RTS_SUPPORTS_THREADS
 static rtsBool isWorkerBlockedInAwaitEvent = rtsFalse;
 static rtsBool workerWakeupPending = rtsFalse;
-#ifndef mingw32_TARGET_OS
 static int workerWakeupPipe[2];
 static rtsBool workerWakeupInited = rtsFalse;
 #endif
-#endif
 
 /* There's a clever trick here to avoid problems when the time wraps
  * around.  Since our maximum delay is smaller than 31 bits of ticks
@@ -95,10 +94,8 @@ awaitEvent(rtsBool wait)
     StgTSO *tso, *prev, *next;
     rtsBool ready;
     fd_set rfd,wfd;
-#ifndef mingw32_TARGET_OS
     int numFound;
     int maxfd = -1;
-#endif
     rtsBool select_succeeded = rtsTrue;
     rtsBool unblock_all = rtsFalse;
     struct timeval tv;
@@ -136,7 +133,6 @@ awaitEvent(rtsBool wait)
          min = 0x7ffffff;
       }
 
-#ifndef mingw32_TARGET_OS
       /* 
        * Collect all of the fd's that we're interested in
        */
@@ -230,27 +226,17 @@ awaitEvent(rtsBool wait)
              barf("select failed");
            }
          }
-#else /* on mingwin */
-#ifdef RTS_SUPPORTS_THREADS
-      isWorkerBlockedInAwaitEvent = rtsTrue;
-#endif
-      RELEASE_LOCK(&sched_mutex);
-      while (1) {
-         if (!awaitRequests(wait)) {
-           Sleep(0); /* don't busy wait */
-         }
-#endif /* mingw32_TARGET_OS */
          ACQUIRE_LOCK(&sched_mutex);
 #ifdef RTS_SUPPORTS_THREADS
           isWorkerBlockedInAwaitEvent = rtsFalse;
 #endif
 
-#ifndef mingw32_TARGET_OS
          /* We got a signal; could be one of ours.  If so, we need
           * to start up the signal handler straight away, otherwise
           * we could block for a long time before the signal is
           * serviced.
           */
+#if defined(RTS_USER_SIGNALS)
          if (signals_pending()) {
              RELEASE_LOCK(&sched_mutex); /* ToDo: kill */
              startSignalHandlers();
@@ -334,7 +320,7 @@ awaitEvent(rtsBool wait)
          }
       }
       
-#if defined(RTS_SUPPORTS_THREADS) && !defined(mingw32_TARGET_OS)
+#if defined(RTS_SUPPORTS_THREADS)
        // if we were woken up by wakeBlockedWorkerThread,
        // read the dummy byte from the pipe
       if(select_succeeded && FD_ISSET(workerWakeupPipe[0], &rfd)) {
@@ -354,11 +340,9 @@ awaitEvent(rtsBool wait)
  * wake it.
  * Must be called with sched_mutex held.
  */
-
 void
 wakeBlockedWorkerThread()
 {
-#ifndef mingw32_TARGET_OS
     if(isWorkerBlockedInAwaitEvent && !workerWakeupPending) {
        unsigned char dummy = 42;       // Any value will do here
        
@@ -366,10 +350,21 @@ wakeBlockedWorkerThread()
        write(workerWakeupPipe[1],&dummy,1);
        workerWakeupPending = rtsTrue;
     }
-#else
-       // The Win32 implementation currently uses a polling loop,
-       // so there is no need to explicitly wake it
-#endif
 }
 
+/* resetWorkerWakeupPipeAfterFork
+ *
+ * To be called right after a fork().
+ * After the fork(), the worker wakeup pipe will be shared
+ * with the parent process, and that's something we don't want.
+ */
+void
+resetWorkerWakeupPipeAfterFork()
+{
+    if(workerWakeupInited) {
+       close(workerWakeupPipe[0]);
+       close(workerWakeupPipe[1]);
+    }
+    workerWakeupInited = rtsFalse;
+}
 #endif