Reimplement max_idle without a separate thread

[empserver] / src / lib / lwp / sel.c

diff --git a/src/lib/lwp/sel.c b/src/lib/lwp/sel.c
index 62bca68d263b8274568d3171a1ff931f7bbb4a82..aa1e66a411d086a51e0e7c18917feab68feb4302 100644 (file)
--- a/src/lib/lwp/sel.c
+++ b/src/lib/lwp/sel.c
@@ -1,6 +1,6 @@
 /*
  *  Empire - A multi-player, client/server Internet based war game.
- *  Copyright (C) 1994-2006, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ *  Copyright (C) 1994-2008, Dave Pare, Jeff Bailey, Thomas Ruschak,
  *                           Ken Stevens, Steve McClure
  *  Copyright (C) 1991-3 Stephen Crane
  *
@@ -27,16 +27,15 @@
  *  ---
  *
  *  sel.c: arrange to block on read/write file descriptors using lwp
- * 
+ *
  *  Known contributors to this file:
  *     Dave Pare, 1994
+ *     Markus Armbruster, 2007
  */
 
 #include <config.h>
 
 #include <errno.h>
-#include <sys/uio.h>
-#include <sys/file.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
@@ -56,11 +55,14 @@ static fd_set LwpReadfds, LwpWritefds;
 /* Map file descriptor to thread sleeping in lwpSleepFd() */
 static struct lwpProc **LwpFdwait;
 
-/* Threads sleeping in lwpSleepUntil(), in no particular order */
+/*
+ * Threads sleeping until a wakeup time, in lwpSleepUntil() or
+ * lwpSleepFd(), in no particular order
+ */
 static struct lwpQueue LwpDelayq;
 
 /* The thread executing lwpSelect() */
-static struct lwpProc *LwpSelProc;     
+static struct lwpProc *LwpSelProc;
 
 void
 lwpInitSelect(struct lwpProc *proc)
@@ -75,23 +77,25 @@ lwpInitSelect(struct lwpProc *proc)
     LwpSelProc = proc;
 }
 
-void
-lwpSleepFd(int fd, int mask)
+int
+lwpSleepFd(int fd, int mask, struct timeval *timeout)
 {
     lwpStatus(LwpCurrent, "sleeping on fd %d for %d", fd, mask);
 
-    if (CANT_HAPPEN(fd > FD_SETSIZE))
-       return;
+    if (CANT_HAPPEN(fd > FD_SETSIZE)) {
+       errno = EBADF;
+       return -1;
+    }
     if (LwpFdwait[fd] != 0) {
        lwpStatus(LwpCurrent,
                  "multiple sleeps attempted on file descriptor %d", fd);
-       return;
+       errno = EBADF;
+       return -1;
     }
     if (mask & LWP_FD_READ)
        FD_SET(fd, &LwpReadfds);
     if (mask & LWP_FD_WRITE)
        FD_SET(fd, &LwpWritefds);
-
     LwpNfds++;
 
     if (LwpMaxfd == 0 && LwpDelayq.head == 0) {
@@ -100,20 +104,39 @@ lwpSleepFd(int fd, int mask)
        lwpReady(LwpSelProc);
     }
     lwpStatus(LwpCurrent, "going to wait on fd %d", fd);
+
+    if (timeout) {
+       LwpCurrent->runtime = time(NULL) + timeout->tv_sec +
+           (timeout->tv_usec > 0);
+       lwpAddTail(&LwpDelayq, LwpCurrent);
+    } else
+       LwpCurrent->runtime = (time_t)-1;
+
     if (fd > LwpMaxfd)
        LwpMaxfd = fd;
     LwpFdwait[fd] = LwpCurrent;
     LwpCurrent->fd = fd;
+    LwpCurrent->fd_ready = 0;
     lwpReschedule();
+    return LwpCurrent->fd_ready != 0;
 }
 
-void
+/*
+ * Wake up PROC if it is sleeping in lwpSleepFd().
+ * Must be followed by lwpWakeupSleep() before the next lwpReschedule().
+ */
+static void
 lwpWakeupFd(struct lwpProc *proc)
 {
-    if (proc->fd < 0)
+    if (CANT_HAPPEN(proc->fd < 0 || proc->fd > LwpMaxfd))
        return;
 
     lwpStatus(proc, "awakening; was sleeping on fd %d", proc->fd);
+    if (proc->runtime != (time_t)-1) {
+       /* is in LwpDelayq; leave the job to lwpWakeupSleep() */
+       proc->runtime = 0;
+       return;
+    }
     FD_CLR(proc->fd, &LwpReadfds);
     FD_CLR(proc->fd, &LwpWritefds);
     LwpNfds--;
@@ -122,10 +145,52 @@ lwpWakeupFd(struct lwpProc *proc)
     lwpReady(proc);
 }
 
+/*
+ * Wake up threads in LwpDelayq whose time has come.
+ */
+void
+lwpWakeupSleep(void)
+{
+    time_t now;
+    struct lwpQueue save;
+    struct lwpProc *proc;
+
+    if (LwpDelayq.head) {
+       now = time(NULL);
+       save.tail = save.head = 0;
+       while (NULL != (proc = lwpGetFirst(&LwpDelayq))) {
+           if (now >= proc->runtime) {
+               lwpStatus(proc, "sleep done");
+               proc->runtime = (time_t)-1;
+               if (proc->fd >= 0)
+                   lwpWakeupFd(proc);
+               else
+                   lwpReady(proc);
+           } else {
+               lwpAddTail(&save, proc);
+           }
+       }
+       LwpDelayq = save;
+    }
+}
+
 void
-lwpSleepUntil(long until)
+lwpWakeup(struct lwpProc *proc)
+{
+    if (proc->fd >= 0)
+       lwpWakeupFd(proc);
+    else if (proc->runtime != (time_t)-1)
+       proc->runtime = 0;
+    lwpWakeupSleep();
+}
+
+int
+lwpSleepUntil(time_t until)
 {
-    lwpStatus(LwpCurrent, "sleeping for %ld sec", until - time(0));
+    int res;
+
+    lwpStatus(LwpCurrent, "sleeping for %ld sec",
+             (long)(until - time(NULL)));
     LwpCurrent->runtime = until;
     if (LwpMaxfd == 0 && LwpDelayq.head == 0) {
        /* select process is sleeping until first waiter arrives */
@@ -133,6 +198,9 @@ lwpSleepUntil(long until)
     }
     lwpAddTail(&LwpDelayq, LwpCurrent);
     lwpReschedule();
+    res = LwpCurrent->runtime ? 0 : -1;
+    LwpCurrent->runtime = (time_t)-1;
+    return res;
 }
 
 /*ARGSUSED*/
@@ -148,7 +216,6 @@ lwpSelect(void *arg)
     time_t delta;
     struct lwpProc *proc;
     struct timeval tv;
-    struct lwpQueue save;
 
     lwpStatus(us, "starting select loop");
     FD_ZERO(&readmask);
@@ -193,20 +260,6 @@ lwpSelect(void *arg)
            continue;
        }
 
-       if (LwpDelayq.head) {
-           /* sleeping proecss activity */
-           time(&now);
-           save.tail = save.head = 0;
-           while (NULL != (proc = lwpGetFirst(&LwpDelayq))) {
-               if (now >= proc->runtime) {
-                   lwpStatus(proc, "sleep done");
-                   lwpReady(proc);
-               } else {
-                   lwpAddTail(&save, proc);
-               }
-           }
-           LwpDelayq = save;
-       }
        if (n > 0) {
            /* file descriptor activity */
            for (fd = 0; fd <= LwpMaxfd; fd++) {
@@ -214,16 +267,19 @@ lwpSelect(void *arg)
                    continue;
                if (FD_ISSET(fd, &readmask)) {
                    lwpStatus(LwpFdwait[fd], "input ready");
+                   LwpFdwait[fd]->fd_ready = 1;
                    lwpWakeupFd(LwpFdwait[fd]);
                    continue;
                }
                if (FD_ISSET(fd, &writemask)) {
                    lwpStatus(LwpFdwait[fd], "output ready");
+                   LwpFdwait[fd]->fd_ready = 1;
                    lwpWakeupFd(LwpFdwait[fd]);
                    continue;
                }
            }
        }
+       lwpWakeupSleep();
        lwpStatus(us, "fd dispatch completed");
        lwpReady(LwpCurrent);
        lwpReschedule();