[project @ 2005-03-31 08:59:34 by simonmar]

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

diff --git a/ghc/rts/Select.c b/ghc/rts/Select.c
index 70e0a03..67ba589 100644 (file)
--- a/ghc/rts/Select.c
+++ b/ghc/rts/Select.c
@@ -1,5 +1,4 @@
 /* -----------------------------------------------------------------------------
- * $Id: Select.c,v 1.28 2003/04/01 15:05:22 sof Exp $
  *
  * (c) The GHC Team 1995-2002
  *
@@ -31,16 +30,13 @@
 #include <errno.h>
 #include <string.h>
 
-/* last timestamp */
-nat timestamp = 0;
-
-#ifdef RTS_SUPPORTS_THREADS
-static rtsBool isWorkerBlockedInAwaitEvent = rtsFalse;
-static rtsBool workerWakeupPending = rtsFalse;
-static int workerWakeupPipe[2];
-static rtsBool workerWakeupInited = rtsFalse;
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
 #endif
 
+/* last timestamp */
+lnat timestamp = 0;
+
 /* 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
  * (it's actually 31 bits of microseconds), we can safely check
@@ -53,7 +49,7 @@ static rtsBool workerWakeupInited = rtsFalse;
  * (idea due to Andy Gill).
  */
 rtsBool
-wakeUpSleepingThreads(nat ticks)
+wakeUpSleepingThreads(lnat ticks)
 {
     StgTSO *tso;
     rtsBool flag = rtsFalse;
@@ -64,7 +60,7 @@ wakeUpSleepingThreads(nat ticks)
        sleeping_queue = tso->link;
        tso->why_blocked = NotBlocked;
        tso->link = END_TSO_QUEUE;
-       IF_DEBUG(scheduler,belch("Waking up sleeping thread %d\n", tso->id));
+       IF_DEBUG(scheduler,debugBelch("Waking up sleeping thread %d\n", tso->id));
        PUSH_ON_RUN_QUEUE(tso);
        flag = rtsTrue;
     }
@@ -101,11 +97,11 @@ awaitEvent(rtsBool wait)
     tv.tv_usec = 0;
     
     IF_DEBUG(scheduler,
-            belch("scheduler: checking for threads blocked on I/O");
+            debugBelch("scheduler: checking for threads blocked on I/O");
             if (wait) {
-                belch(" (waiting)");
+                debugBelch(" (waiting)");
             }
-            belch("\n");
+            debugBelch("\n");
             );
 
     /* loop until we've woken up some threads.  This loop is needed
@@ -160,34 +156,6 @@ awaitEvent(rtsBool wait)
        }
       }
 
-#ifdef RTS_SUPPORTS_THREADS
-      if(!workerWakeupInited) {
-          pipe(workerWakeupPipe);
-          workerWakeupInited = rtsTrue;
-      }
-      FD_SET(workerWakeupPipe[0], &rfd);
-      maxfd = workerWakeupPipe[0] > maxfd ? workerWakeupPipe[0] : maxfd;
-#endif
-      
-      /* Release the scheduler lock while we do the poll.
-       * this means that someone might muck with the blocked_queue
-       * while we do this, but it shouldn't matter:
-       *
-       *   - another task might poll for I/O and remove one
-       *     or more threads from the blocked_queue.
-       *   - more I/O threads may be added to blocked_queue.
-       *   - more delayed threads may be added to blocked_queue. We'll
-       *     just subtract delta from their delays after the poll.
-       *
-       * I believe none of these cases lead to trouble --SDM.
-       */
-      
-#ifdef RTS_SUPPORTS_THREADS
-      isWorkerBlockedInAwaitEvent = rtsTrue;
-      workerWakeupPending = rtsFalse;
-#endif
-      RELEASE_LOCK(&sched_mutex);
-
       /* Check for any interesting events */
       
       tv.tv_sec  = min / 1000000;
@@ -216,16 +184,10 @@ awaitEvent(rtsBool wait)
              unblock_all = rtsTrue;
              break;
            } else {
-             fprintf(stderr,"%d\n", errno);
-             fflush(stderr);
              perror("select");
              barf("select failed");
            }
          }
-         ACQUIRE_LOCK(&sched_mutex);
-#ifdef RTS_SUPPORTS_THREADS
-          isWorkerBlockedInAwaitEvent = rtsFalse;
-#endif
 
          /* We got a signal; could be one of ours.  If so, we need
           * to start up the signal handler straight away, otherwise
@@ -234,9 +196,7 @@ awaitEvent(rtsBool wait)
           */
 #if defined(RTS_USER_SIGNALS)
          if (signals_pending()) {
-             RELEASE_LOCK(&sched_mutex); /* ToDo: kill */
              startSignalHandlers();
-             ACQUIRE_LOCK(&sched_mutex);
              return; /* still hold the lock */
          }
 #endif
@@ -257,24 +217,8 @@ awaitEvent(rtsBool wait)
          if (run_queue_hd != END_TSO_QUEUE) {
              return; /* still hold the lock */
          }
-         
-#ifdef RTS_SUPPORTS_THREADS
-         /* If another worker thread wants to take over,
-          * return to the scheduler
-          */
-         if (needToYieldToReturningWorker()) {
-             return; /* still hold the lock */
-         }
-#endif
-         
-#ifdef RTS_SUPPORTS_THREADS
-          isWorkerBlockedInAwaitEvent = rtsTrue;
-#endif
-         RELEASE_LOCK(&sched_mutex);
       }
 
-      ACQUIRE_LOCK(&sched_mutex);
-
       /* Step through the waiting queue, unblocking every thread that now has
        * a file descriptor in a ready state.
        */
@@ -295,7 +239,7 @@ awaitEvent(rtsBool wait)
              }
       
              if (ready) {
-                 IF_DEBUG(scheduler,belch("Waking up blocked thread %d\n", tso->id));
+                 IF_DEBUG(scheduler,debugBelch("Waking up blocked thread %d\n", tso->id));
                  tso->why_blocked = NotBlocked;
                  tso->link = END_TSO_QUEUE;
                  PUSH_ON_RUN_QUEUE(tso);
@@ -316,35 +260,5 @@ awaitEvent(rtsBool wait)
          }
       }
       
-#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)) {
-          unsigned char dummy;
-          wait = rtsFalse;
-          read(workerWakeupPipe[0],&dummy,1);
-      }
-#endif
     } while (wait && !interrupted && run_queue_hd == END_TSO_QUEUE);
 }
-
-
-#ifdef RTS_SUPPORTS_THREADS
-/* wakeBlockedWorkerThread
- *
- * If a worker thread is currently blocked within awaitEvent,
- * wake it.
- * Must be called with sched_mutex held.
- */
-void
-wakeBlockedWorkerThread()
-{
-    if(isWorkerBlockedInAwaitEvent && !workerWakeupPending) {
-       unsigned char dummy = 42;       // Any value will do here
-       
-                       // write something so that select() wakes up
-       write(workerWakeupPipe[1],&dummy,1);
-       workerWakeupPending = rtsTrue;
-    }
-}
-#endif