Expose poll() to wait on single fds

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/socket/SocketBuiltins.java

@@ -67,6 +67,7 @@
 import com.oracle.graal.python.builtins.CoreFunctions;
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.PythonBuiltins;
+import com.oracle.graal.python.builtins.PythonOS;
 import com.oracle.graal.python.builtins.modules.SysModuleBuiltins;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.buffer.PythonBufferAccessLibrary;
@@ -137,7 +138,9 @@ private static void checkSelectable(Node inliningTarget, PRaiseNode raiseNode, P
     }
 
     private static boolean isSelectable(PSocket socket) {
-        return socket.getTimeoutNs() <= 0 || socket.getFd() < PosixConstants.FD_SETSIZE.value;
+        // See posix.c - on Unix systems we use poll() instead of select() which does not have the
+        // limitation of select()
+        return PythonOS.getPythonOS() != PythonOS.PLATFORM_WIN32 || socket.getTimeoutNs() <= 0 || socket.getFd() < PosixConstants.FD_SETSIZE.value;
     }
 
     // socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/socket/SocketUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -44,14 +44,12 @@
 import static com.oracle.graal.python.builtins.objects.exception.OSErrorEnum.EINTR;
 import static com.oracle.graal.python.builtins.objects.exception.OSErrorEnum.EWOULDBLOCK;
 import static com.oracle.graal.python.builtins.objects.socket.PSocket.INVALID_FD;
-import static com.oracle.graal.python.util.PythonUtils.EMPTY_INT_ARRAY;
 
 import com.oracle.graal.python.nodes.ErrorMessages;
 import com.oracle.graal.python.nodes.PConstructAndRaiseNode;
 import com.oracle.graal.python.runtime.GilNode;
 import com.oracle.graal.python.runtime.PosixSupportLibrary;
 import com.oracle.graal.python.runtime.PosixSupportLibrary.PosixException;
-import com.oracle.graal.python.runtime.PosixSupportLibrary.SelectResult;
 import com.oracle.graal.python.runtime.PosixSupportLibrary.Timeval;
 import com.oracle.graal.python.runtime.PythonContext;
 import com.oracle.graal.python.util.TimeUtils;
@@ -101,12 +99,9 @@ public static <T> T callSocketFunctionWithRetry(Frame frame, Node inliningTarget
                 try {
                     gil.release(true);
                     try {
-                        int[] fds = new int[]{socket.getFd()};
-                        int[] readfds = writing ? EMPTY_INT_ARRAY : fds;
-                        int[] writefds = writing ? fds : EMPTY_INT_ARRAY;
-                        SelectResult selectResult = posixLib.select(posixSupport, readfds, writefds, EMPTY_INT_ARRAY, selectTimeout);
-                        boolean[] resultFds = writing ? selectResult.getWriteFds() : selectResult.getReadFds();
-                        if (resultFds.length == 0 || !resultFds[0]) {
+                        // CPython uses poll for a single fd when available here, so even higher fd
+                        // socket connections can be established
+                        if (!posixLib.poll(posixSupport, socket.getFd(), writing, selectTimeout)) {
                             throw constructAndRaiseNode.get(inliningTarget).raiseTimeoutError(frame, ErrorMessages.TIMED_OUT);
                         }
                     } finally {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/EmulatedPosixSupport.java

@@ -127,6 +127,7 @@
 import static com.oracle.graal.python.runtime.PosixConstants.TCP_NODELAY;
 import static com.oracle.graal.python.runtime.PosixConstants.W_OK;
 import static com.oracle.graal.python.runtime.PosixConstants.X_OK;
+import static com.oracle.graal.python.util.PythonUtils.EMPTY_INT_ARRAY;
 import static com.oracle.graal.python.util.PythonUtils.TS_ENCODING;
 import static com.oracle.graal.python.util.PythonUtils.toTruffleStringUncached;
 import static com.oracle.graal.python.util.PythonUtils.tsLiteral;
@@ -726,6 +727,17 @@ private SelectableChannel[] getSelectableChannels(int[] fds) throws PosixExcepti
         return channels;
     }
 
+    @ExportMessage
+    public boolean poll(int fd, boolean forWriting, Timeval timeout) throws PosixException {
+        SelectResult r = select(forWriting ? EMPTY_INT_ARRAY : new int[]{fd},
+                        forWriting ? new int[]{fd} : EMPTY_INT_ARRAY, EMPTY_INT_ARRAY, timeout);
+        if (forWriting) {
+            return r.getWriteFds().length > 0 && r.getWriteFds()[0];
+        } else {
+            return r.getReadFds().length > 0 && r.getReadFds()[0];
+        }
+    }
+
     @ExportMessage
     public long lseek(int fd, long offset, int how,
                     @Bind("$node") Node inliningTarget,

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/LoggingPosixSupport.java

@@ -262,6 +262,17 @@ public SelectResult select(int[] readfds, int[] writefds, int[] errorfds, Timeva
         }
     }
 
+    @ExportMessage
+    public boolean poll(int fd, boolean forWriting, Timeval timeout,
+                    @CachedLibrary("this.delegate") PosixSupportLibrary lib) throws PosixException {
+        logEnter("poll", "%s %s %s", fd, forWriting, timeout);
+        try {
+            return logExit("poll", "%s", lib.poll(delegate, fd, forWriting, timeout));
+        } catch (PosixException e) {
+            throw logException("poll", e);
+        }
+    }
+
     @ExportMessage
     final long lseek(int fd, long offset, int how,
                     @CachedLibrary("this.delegate") PosixSupportLibrary lib) throws PosixException {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/NFIPosixSupport.java

@@ -185,6 +185,7 @@ private enum PosixNativeFunction {
         call_dup2("(sint32, sint32, sint32):sint32"),
         call_pipe2("([sint32]):sint32"),
         call_select("(sint32, [sint32], sint32, [sint32], sint32, [sint32], sint32, sint64, sint64, [sint8]):sint32"),
+        call_poll("(sint32, sint32, sint64, sint64):sint32"),
         call_lseek("(sint32, sint64, sint32):sint64"),
         call_ftruncate("(sint32, sint64):sint32"),
         call_truncate("([sint8], sint64):sint32"),
@@ -669,6 +670,26 @@ private static int findMax(int[] items, int currentMax) {
         return max;
     }
 
+    @ExportMessage
+    public boolean poll(int fd, boolean forWriting, Timeval timeout,
+                    @Shared("invoke") @Cached InvokeNativeFunction invokeNode) throws PosixException {
+        long secs = -1, usecs = -1;
+        if (timeout != null) {
+            secs = timeout.getSeconds();
+            usecs = timeout.getMicroseconds();
+        }
+        int result = invokeNode.callInt(this, PosixNativeFunction.call_poll, fd,
+                        forWriting ? 1 : 0, secs, usecs);
+        if (result < 0) {
+            throw getErrnoAndThrowPosixException(invokeNode);
+        }
+        if (result == 0) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
     @ExportMessage
     public long lseek(int fd, long offset, int how,
                     @Shared("invoke") @Cached InvokeNativeFunction invokeNode) throws PosixException {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PosixSupportLibrary.java

@@ -107,6 +107,8 @@ public abstract class PosixSupportLibrary extends Library {
 
     public abstract SelectResult select(Object receiver, int[] readfds, int[] writefds, int[] errorfds, Timeval timeout) throws PosixException;
 
+    public abstract boolean poll(Object receiver, int fd, boolean forWriting, Timeval timeout) throws PosixException;
+
     public abstract long lseek(Object receiver, int fd, long offset, int how) throws PosixException;
 
     public abstract void ftruncate(Object receiver, int fd, long length) throws PosixException;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PreInitPosixSupport.java

@@ -254,6 +254,13 @@ final SelectResult select(int[] readfds, int[] writefds, int[] errorfds, Timeval
         return nativeLib.select(nativePosixSupport, readfds, writefds, errorfds, timeout);
     }
 
+    @ExportMessage
+    final boolean poll(int fd, boolean forWriting, Timeval timeout,
+                    @CachedLibrary("this.nativePosixSupport") PosixSupportLibrary nativeLib) throws PosixException {
+        checkNotInPreInitialization();
+        return nativeLib.poll(nativePosixSupport, fd, forWriting, timeout);
+    }
+
     @ExportMessage
     final long lseek(int fd, long offset, int how,
                     @CachedLibrary("this.nativePosixSupport") PosixSupportLibrary nativeLib) throws PosixException {

graalpython/python-libposix/src/posix.c

@@ -84,6 +84,9 @@
 #endif
 
 #ifndef _WIN32
+#include <time.h>
+#include <poll.h>
+#include <limits.h>
 #include <sys/resource.h>
 #endif
 
@@ -198,7 +201,6 @@ static void fill_fd_set(fd_set *set, int32_t* fds, int32_t len) {
 int32_t call_select(int32_t nfds, int32_t* readfds, int32_t readfdsLen,
     int32_t* writefds, int32_t writefdsLen, int32_t* errfds, int32_t errfdsLen,
     int64_t timeoutSec, int64_t timeoutUsec, int8_t* selected) {
-
     fd_set readfdsSet, writefdsSet, errfdsSet;
     fill_fd_set(&readfdsSet, readfds, readfdsLen);
     fill_fd_set(&writefdsSet, writefds, writefdsLen);
@@ -215,6 +217,38 @@ int32_t call_select(int32_t nfds, int32_t* readfds, int32_t readfdsLen,
     return (int32_t) result;
 }
 
+int32_t call_poll(int32_t fd, int32_t writing, int64_t timeoutSec, int64_t timeoutUsec) {
+#ifdef _WIN32
+    // for windows, use select() as a worse fallback
+    int selected[2] = {0, 0};
+    return call_select(1,
+                       writing ? NULL : &fd, writing ? 0 : 1,
+                       writing ? &fd : NULL, writing ? 1 : 0,
+                       NULL, 0,
+                       timeoutSec, timeoutUsec, &selected);
+#else
+    struct pollfd pollfd;
+    pollfd.fd = fd;
+    pollfd.events = writing ? POLLOUT : POLLIN;
+
+    int timeout_ms;
+    if (timeoutSec < 0) {
+        timeout_ms = -1;
+    } else if (timeoutSec > INT_MAX / 1000) {
+        errno = EINVAL;
+        return -1;
+    } else {
+        int64_t timeout_ms_64 = timeoutSec * 1000 + timeoutUsec / 1000;
+        if (timeout_ms_64 > INT_MAX) {
+            errno = EINVAL;
+            return -1;
+        }
+        timeout_ms = (int)timeout_ms_64;
+    }
+    return poll(&pollfd, 1, timeout_ms);
+#endif
+}
+
 int64_t call_lseek(int32_t fd, int64_t offset, int32_t whence) {
     return lseek(fd, offset, whence);
 }