/* -----------------------------------------------------------------------------
- * $Id: Select.c,v 1.17 2001/08/14 13:40:09 sewardj Exp $
+ * $Id: Select.c,v 1.29 2003/06/26 12:22:59 stolz Exp $
*
- * (c) The GHC Team 1995-1999
+ * (c) The GHC Team 1995-2002
*
* Support for concurrent non-blocking I/O and thread waiting.
*
* ---------------------------------------------------------------------------*/
+
/* we're outside the realms of POSIX here... */
/* #include "PosixSource.h" */
#include "Schedule.h"
#include "RtsUtils.h"
#include "RtsFlags.h"
+#include "Timer.h"
#include "Itimer.h"
#include "Signals.h"
+#include "Capability.h"
# ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
# include <sys/time.h>
# endif
-# ifdef mingw32_TARGET_OS
-# include <windows.h>
-# endif
+#include <errno.h>
+#include <string.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
/* last timestamp */
nat timestamp = 0;
-/* keep track of the number of ticks since we last called
- * gettimeofday(), to avoid having to call it every time we need
- * a timestamp.
- */
-nat ticks_since_timestamp = 0;
+#ifdef RTS_SUPPORTS_THREADS
+static rtsBool isWorkerBlockedInAwaitEvent = rtsFalse;
+static rtsBool workerWakeupPending = rtsFalse;
+static int workerWakeupPipe[2];
+static rtsBool workerWakeupInited = rtsFalse;
+#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
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;
lnat min, ticks;
tv.tv_sec = 0;
tv.tv_usec = 0;
-
+
IF_DEBUG(scheduler,
belch("scheduler: checking for threads blocked on I/O");
if (wait) {
do {
ticks = timestamp = getourtimeofday();
- ticks_since_timestamp = 0;
if (wakeUpSleepingThreads(ticks)) {
return;
}
min = 0x7ffffff;
}
-#ifndef mingw32_TARGET_OS
/*
* Collect all of the fd's that we're interested in
*/
}
}
+#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:
*
* 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 */
while ((numFound = select(maxfd+1, &rfd, &wfd, NULL, &tv)) < 0) {
if (errno != EINTR) {
-
- printf("%d\n", errno);
- fflush(stdout);
- perror("select");
+ /* Handle bad file descriptors by unblocking all the
+ waiting threads. Why? Because a thread might have been
+ a bit naughty and closed a file descriptor while another
+ was blocked waiting. This is less-than-good programming
+ practice, but having the RTS as a result fall over isn't
+ acceptable, so we simply unblock all the waiting threads
+ should we see a bad file descriptor & give the threads
+ a chance to clean up their act.
+
+ Note: assume here that threads becoming unblocked
+ will try to read/write the file descriptor before trying
+ to issue a threadWaitRead/threadWaitWrite again (==> an
+ IOError will result for the thread that's got the bad
+ file descriptor.) Hence, there's no danger of a bad
+ file descriptor being repeatedly select()'ed on, so
+ the RTS won't loop.
+ */
+ if ( errno == EBADF ) {
+ unblock_all = rtsTrue;
+ break;
+ } else {
+ fprintf(stderr,"%d\n", errno);
+ fflush(stderr);
+ perror("select");
barf("select failed");
+ }
}
-#else /* on mingwin */
- while (1) {
- 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 */
- start_signal_handlers();
+ startSignalHandlers();
ACQUIRE_LOCK(&sched_mutex);
return; /* still hold the lock */
}
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);
}
*/
prev = NULL;
- if (select_succeeded) {
+ if (select_succeeded || unblock_all) {
for(tso = blocked_queue_hd; tso != END_TSO_QUEUE; tso = next) {
next = tso->link;
switch (tso->why_blocked) {
case BlockedOnRead:
- ready = FD_ISSET(tso->block_info.fd, &rfd);
+ ready = unblock_all || FD_ISSET(tso->block_info.fd, &rfd);
break;
case BlockedOnWrite:
- ready = FD_ISSET(tso->block_info.fd, &wfd);
+ ready = unblock_all || FD_ISSET(tso->block_info.fd, &wfd);
break;
default:
barf("awaitEvent");
blocked_queue_tl = prev;
}
}
-
+
+#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
projects / ghc-hetmet.git / blobdiff