[DRAFT] pythongh-135358 follow-up: Use PyErr_CheckSignalsDetached in the stdlib.

This patch demonstrates how `PyErr_CheckSignalsDetached` (python#135358; see
also python#133465 and capi-workgroup/decisions#68) might be used for some
(small) efficiency improvements in the stdlib.  Almost all existing
uses of `PyErr_CheckSignals` in the stdlib appear in loops with this
general structure:

```c
int res = 0;
int async_err = 0;
do {
    Py_BEGIN_ALLOW_THREADS
    res = system_call(arg1, arg2);
    Py_END_ALLOW_THREADS
} while (res < 0 && errno == EINTR
         && !(async_err = PyErr_CheckSignals()));
if (res < 0) {
    return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
}
Py_RETURN_NONE;
```

With the addition of `PyErr_CheckSignalsDetached`, this can become

```c
int res = 0;
int async_err = 0;
PyThreadState *tstate = PyEval_SaveThread();
do {
    res = system_call(arg1, arg2);
} while (res < 0 && errno == EINTR
         && !(async_err = PyErr_CheckSignalsDetached(tstate)));
PyEval_RestoreThread(tstate);
if (res < 0) {
    return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
}
Py_RETURN_NONE;
```

There were also a small number of places where

```
Py_BLOCK_THREADS
sig = PyErr_CheckSignals();
Py_UNBLOCK_THREADS
```

could become just

```
sig = PyErr_CheckSignalsDetached(tstate);
```

I chose to use explicit `PyErr_{Save,Restore}Thread` throughout this
patch, in order to give the thread-state parameter to
`PyErr_CheckSignalsDetached` a visible name in the calling code.

This is possibly an argument for adding a wrapper macro
(`PyErr_CHECK_SIGNALS_DETACHED()`, perhaps) that is part of the
`Py_BEGIN_ALLOW_THREADS` family, and is therefore entitled to use the
hidden `_state` variable.  Or it could be an argument for adding a new
construct like

```
Py_WITH_DETACHED_THREAD_STATE (tstate) {
    do {
        res = system_call(arg1, arg2);
    } while (res < 0 && errno == EINTR
             && !(async_err = PyErr_CheckSignalsDetached(tstate)));
}
```

(This could be implemented in plain C by off-label use of a for loop.
I’m not sure if that’s a good idea or not.  In particular, `break`
and `continue` at the top level of a `Py_WITH_DETACHED_THREAD_STATE`
block would have surprising effects.)

The patch only tackles the most straightforward conversions.  Places
in the stdlib that could probably benefit from a conversion, but that
I did not touch, are:

* `signal.sigtimedwait`, `select.select`, `select.poll`, `select.devpoll`,
  `select.epoll`, `select.kevent`, `time.sleep`, `_multiprocessing.semaphore`,
  and the ssl and socket modules.  All of these places need to do arithmetic
  on some combination of `struct timespec`, `struct timeval`, and `Py_time_t`
  in their loops, and the APIs for doing so are not currently safe to use
  without an attached thread state (in particular, they may set the error
  indicator).

* The ssl and socket modules also do a bunch of other work in the
  same loops that detach the thread state and I’m not familiar enough
  with those APIs to know if it’s safe to expand the regions with
  detached thread state.  This is unfortunate as I think these are the
  loops with the biggest chance of _substantial_ efficiency gains from
  enlarging those regions.

* `time.sleep` is also a horrible maze of `#ifdef`s and I think I see
  a race bug in the Windows-specific code (filed separately as python#135407).

* The tkinter module goes back and forth between holding a Python
  thread state and holding a _Tcl_ thread state and I didn’t want to
  mess with that.

There are also many places where no conversion is necessary:

* `signal.pause`, `signal.raise`, `signal.signal`,
  `signal.pthread_sigmask`, `signal.pthread_kill`, `os.kill`,
  `os._getdiskusage`, `PyObject_Print`, `PyObject_Repr`,
  `PyObject_Str`, `PyErr_SetFromErrnoWithFilenameObjects`,
  `builtin_input_impl`:
  These do not contain a loop, so there’s no reason to mess with them.

* The `_sre` module, `longobject.c`, `faulthandler.c`, `traceback.c`:
  These don’t detach the thread state at all, so again there’s no
  reason to mess with them.

As a final note, it would probably be a good idea to make it a
documented guarantee that `PyEval_{Save,Restore}Thread` and
`PyErr_CheckSignals{,Detached}` preserve the value of `errno`
and all the Windows-specific errno analogues.  A lot of this code
is already assuming that this is the case, and the code that isn’t
making that assumption is substantially clunkier for it.

Author: zackw

Modules/_io/fileio.c

@@ -403,16 +403,16 @@ _io_FileIO___init___impl(fileio *self, PyObject *nameobj, const char *mode,
 
         errno = 0;
         if (opener == Py_None) {
+            PyThreadState *tstate = PyEval_SaveThread();
             do {
-                Py_BEGIN_ALLOW_THREADS
 #ifdef MS_WINDOWS
                 self->fd = _wopen(widename, flags, 0666);
 #else
                 self->fd = open(name, flags, 0666);
 #endif
-                Py_END_ALLOW_THREADS
             } while (self->fd < 0 && errno == EINTR &&
-                     !(async_err = PyErr_CheckSignals()));
+                     !(async_err = PyErr_CheckSignalsDetached(tstate)));
+            PyEval_RestoreThread(tstate);
 
             if (async_err)
                 goto error;

Modules/_io/winconsoleio.c

@@ -623,7 +623,7 @@ read_console_w(HANDLE handle, DWORD maxlen, DWORD *readlen) {
     *readlen = 0;
 
     //DebugBreak();
-    Py_BEGIN_ALLOW_THREADS
+    PyThreadState *tstate = PyEval_SaveThread();
     DWORD off = 0;
     while (off < maxlen) {
         DWORD n = (DWORD)-1;
@@ -647,9 +647,7 @@ read_console_w(HANDLE handle, DWORD maxlen, DWORD *readlen) {
             if (WaitForSingleObjectEx(hInterruptEvent, 100, FALSE)
                     == WAIT_OBJECT_0) {
                 ResetEvent(hInterruptEvent);
-                Py_BLOCK_THREADS
-                sig = PyErr_CheckSignals();
-                Py_UNBLOCK_THREADS
+                sig = PyErr_CheckSignalsDetached(tstate);
                 if (sig < 0)
                     break;
             }
@@ -687,8 +685,7 @@ read_console_w(HANDLE handle, DWORD maxlen, DWORD *readlen) {
 
         off += BUFSIZ;
     }
-
-    Py_END_ALLOW_THREADS
+    PyEval_RestoreThread(tstate);
 
     if (sig)
         goto error;

Modules/_multiprocessing/posixshmem.c

@@ -57,11 +57,12 @@ _posixshmem_shm_open_impl(PyObject *module, PyObject *path, int flags,
         PyErr_SetString(PyExc_ValueError, "embedded null character");
         return -1;
     }
+    PyThreadState *tstate = PyEval_SaveThread();
     do {
-        Py_BEGIN_ALLOW_THREADS
         fd = shm_open(name, flags, mode);
-        Py_END_ALLOW_THREADS
-    } while (fd < 0 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+    } while (fd < 0 && errno == EINTR
+             && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+    PyEval_RestoreThread(tstate);
 
     if (fd < 0) {
         if (!async_err)
@@ -102,11 +103,12 @@ _posixshmem_shm_unlink_impl(PyObject *module, PyObject *path)
         PyErr_SetString(PyExc_ValueError, "embedded null character");
         return NULL;
     }
+    PyThreadState *tstate = PyEval_SaveThread();
     do {
-        Py_BEGIN_ALLOW_THREADS
         rv = shm_unlink(name);
-        Py_END_ALLOW_THREADS
-    } while (rv < 0 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+    } while (rv < 0 && errno == EINTR
+             && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+    PyEval_RestoreThread(tstate);
 
     if (rv < 0) {
         if (!async_err)

Modules/fcntlmodule.c

@@ -73,11 +73,12 @@ fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)
             }
         }
 
+        PyThreadState *tstate = PyEval_SaveThread();
         do {
-            Py_BEGIN_ALLOW_THREADS
             ret = fcntl(fd, code, (int)int_arg);
-            Py_END_ALLOW_THREADS
-        } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+        } while (ret == -1 && errno == EINTR
+                 && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+        PyEval_RestoreThread(tstate);
         if (ret < 0) {
             return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
         }
@@ -86,23 +87,24 @@ fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)
     if (PyUnicode_Check(arg) || PyObject_CheckBuffer(arg)) {
         Py_buffer view;
 #define FCNTL_BUFSZ 1024
-        /* argument plus NUL byte plus guard to detect a buffer overflow */
-        char buf[FCNTL_BUFSZ+GUARDSZ];
 
         if (!PyArg_Parse(arg, "s*", &view)) {
             return NULL;
         }
         Py_ssize_t len = view.len;
         if (len <= FCNTL_BUFSZ) {
+            /* argument plus NUL byte plus guard to detect a buffer overflow */
+            char buf[FCNTL_BUFSZ+GUARDSZ];
             memcpy(buf, view.buf, len);
             memcpy(buf + len, guard, GUARDSZ);
             PyBuffer_Release(&view);
 
+            PyThreadState *tstate = PyEval_SaveThread();
             do {
-                Py_BEGIN_ALLOW_THREADS
                 ret = fcntl(fd, code, buf);
-                Py_END_ALLOW_THREADS
-            } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+            } while (ret == -1 && errno == EINTR
+                     && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+            PyEval_RestoreThread(tstate);
             if (ret < 0) {
                 return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
             }
@@ -122,11 +124,12 @@ fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)
             memcpy(ptr, view.buf, len);
             PyBuffer_Release(&view);
 
+            PyThreadState *tstate = PyEval_SaveThread();
             do {
-                Py_BEGIN_ALLOW_THREADS
                 ret = fcntl(fd, code, ptr);
-                Py_END_ALLOW_THREADS
-            } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+            } while (ret == -1 && errno == EINTR
+                     && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+            PyEval_RestoreThread(tstate);
             if (ret < 0) {
                 if (!async_err) {
                     PyErr_SetFromErrno(PyExc_OSError);
@@ -220,11 +223,12 @@ fcntl_ioctl_impl(PyObject *module, int fd, unsigned long code, PyObject *arg,
             }
         }
 
+        PyThreadState *tstate = PyEval_SaveThread();
         do {
-            Py_BEGIN_ALLOW_THREADS
             ret = ioctl(fd, code, int_arg);
-            Py_END_ALLOW_THREADS
-        } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+        } while (ret == -1 && errno == EINTR
+                 && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+        PyEval_RestoreThread(tstate);
         if (ret < 0) {
             return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
         }
@@ -244,11 +248,12 @@ fcntl_ioctl_impl(PyObject *module, int fd, unsigned long code, PyObject *arg,
                     memcpy(buf + len, guard, GUARDSZ);
                     ptr = buf;
                 }
+                PyThreadState *tstate = PyEval_SaveThread();
                 do {
-                    Py_BEGIN_ALLOW_THREADS
                     ret = ioctl(fd, code, ptr);
-                    Py_END_ALLOW_THREADS
-                } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+                } while (ret == -1 && errno == EINTR
+                         && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+                PyEval_RestoreThread(tstate);
                 if (ret < 0) {
                     if (!async_err) {
                         PyErr_SetFromErrno(PyExc_OSError);
@@ -281,11 +286,12 @@ fcntl_ioctl_impl(PyObject *module, int fd, unsigned long code, PyObject *arg,
             memcpy(buf + len, guard, GUARDSZ);
             PyBuffer_Release(&view);
 
+            PyThreadState *tstate = PyEval_SaveThread();
             do {
-                Py_BEGIN_ALLOW_THREADS
                 ret = ioctl(fd, code, buf);
-                Py_END_ALLOW_THREADS
-            } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+            } while (ret == -1 && errno == EINTR
+                     && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+            PyEval_RestoreThread(tstate);
             if (ret < 0) {
                 return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
             }
@@ -305,11 +311,12 @@ fcntl_ioctl_impl(PyObject *module, int fd, unsigned long code, PyObject *arg,
             memcpy(ptr, view.buf, len);
             PyBuffer_Release(&view);
 
+            PyThreadState *tstate = PyEval_SaveThread();
             do {
-                Py_BEGIN_ALLOW_THREADS
                 ret = ioctl(fd, code, ptr);
-                Py_END_ALLOW_THREADS
-            } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+            } while (ret == -1 && errno == EINTR
+                     && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+            PyEval_RestoreThread(tstate);
             if (ret < 0) {
                 if (!async_err) {
                     PyErr_SetFromErrno(PyExc_OSError);
@@ -352,17 +359,18 @@ fcntl_flock_impl(PyObject *module, int fd, int code)
 {
     int ret;
     int async_err = 0;
+    PyThreadState *tstate;
 
     if (PySys_Audit("fcntl.flock", "ii", fd, code) < 0) {
         return NULL;
     }
 
+    tstate = PyEval_SaveThread();
 #ifdef HAVE_FLOCK
     do {
-        Py_BEGIN_ALLOW_THREADS
         ret = flock(fd, code);
-        Py_END_ALLOW_THREADS
-    } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+    } while (ret == -1 && errno == EINTR
+             && !(async_err = PyErr_CheckSignalsDetached(tstate)));
 #else
 
 #ifndef LOCK_SH
@@ -386,12 +394,12 @@ fcntl_flock_impl(PyObject *module, int fd, int code)
         }
         l.l_whence = l.l_start = l.l_len = 0;
         do {
-            Py_BEGIN_ALLOW_THREADS
             ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
-            Py_END_ALLOW_THREADS
-        } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+        } while (ret == -1 && errno == EINTR
+                 && !(async_err = PyErr_CheckSignalsDetached(tstate)));
     }
 #endif /* HAVE_FLOCK */
+    PyEval_RestoreThread(tstate);
     if (ret < 0) {
         return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
     }
@@ -489,11 +497,12 @@ fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
                 return NULL;
         }
         l.l_whence = whence;
+        PyThreadState *tstate = PyEval_SaveThread();
         do {
-            Py_BEGIN_ALLOW_THREADS
             ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
-            Py_END_ALLOW_THREADS
-        } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+        } while (ret == -1 && errno == EINTR
+                 && !(async_err = PyErr_CheckSignalsDetached(tstate)));
+        PyEval_RestoreThread(tstate);
     }
     if (ret < 0) {
         return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;