rloop 0.1.0a2__tar.gz → 0.1.0a3__tar.gz

{rloop-0.1.0a2 → rloop-0.1.0a3}/Cargo.lock

@@ -1,12 +1,12 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "anyhow"
-version = "1.0.93"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
+checksum = "c1fd03a028ef38ba2276dce7e33fcd6369c158a1bca17946c4b1b701891c1ff7"
 
 [[package]]
 name = "autocfg"
@@ -22,9 +22,9 @@ checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "cc"
-version = "1.1.37"
+version = "1.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40545c26d092346d8a8dab71ee48e7685a7a9cba76e634790c215b41a4a7b4cf"
+checksum = "c31a0499c1dc64f458ad13872de75c0eb7e3fdb0e67964610c914b034fc5956e"
 dependencies = [
  "shlex",
 ]
@@ -37,9 +37,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "dashmap"
@@ -67,12 +67,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hermit-abi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
-
 [[package]]
 name = "indoc"
 version = "2.0.5"
@@ -81,19 +75,9 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "libc"
-version = "0.2.162"
+version = "0.2.169"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18d287de67fe55fd7e1581fe933d965a5a9477b38e949cfa9f8574ef01506398"
-
-[[package]]
-name = "libmimalloc-sys"
-version = "0.1.39"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23aa6811d3bd4deb8a84dde645f943476d13b248d818edcf8ce0b2f37f036b44"
-dependencies = [
- "cc",
- "libc",
-]
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
 
 [[package]]
 name = "lock_api"
@@ -120,22 +104,12 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "mimalloc"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68914350ae34959d83f732418d51e2427a794055d0b9529f48259ac07af65633"
-dependencies = [
- "libmimalloc-sys",
-]
-
 [[package]]
 name = "mio"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
 dependencies = [
- "hermit-abi",
  "libc",
  "log",
  "wasi",
@@ -163,24 +137,24 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
+checksum = "280dc24453071f1b63954171985a0b0d30058d287960968b9b2aca264c8d4ee6"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "pyo3"
-version = "0.23.1"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebb0c0cc0de9678e53be9ccf8a2ab53045e6e3a8be03393ceccc5e7396ccb40"
+checksum = "e484fd2c8b4cb67ab05a318f1fd6fa8f199fcc30819f08f07d200809dba26c15"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -197,9 +171,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.1"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80e3ce69c4ec34476534b490e412b871ba03a82e35604c3dfb95fcb6bfb60c09"
+checksum = "dc0e0469a84f208e20044b98965e1561028180219e35352a2afaf2b942beff3b"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -208,9 +182,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.1"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b09f311c76b36dfd6dd6f7fa6f9f18e7e46a1c937110d283e80b12ba2468a75"
+checksum = "eb1547a7f9966f6f1a0f0227564a9945fe36b90da5a93b3933fc3dc03fae372d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -218,9 +192,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.1"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd4f74086536d1e1deaff99ec0387481fb3325c82e4e48be0e75ab3d3fcb487a"
+checksum = "fdb6da8ec6fa5cedd1626c886fc8749bdcbb09424a86461eb8cdf096b7c33257"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -230,9 +204,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.1"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e77dfeb76b32bbf069144a5ea0a36176ab59c8db9ce28732d0f06f096bbfbc8"
+checksum = "38a385202ff5a92791168b1136afae5059d3ac118457bb7bc304c197c2d33e7d"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -243,9 +217,9 @@ dependencies = [
 
 [[package]]
 name = "python3-dll-a"
-version = "0.2.10"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd0b78171a90d808b319acfad166c4790d9e9759bbc14ac8273fe133673dd41b"
+checksum = "9b66f9171950e674e64bad3456e11bb3cca108e5c34844383cfe277f45c8a7a8"
 dependencies = [
  "cc",
 ]
@@ -261,24 +235,22 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.7"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
+checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "rloop"
-version = "0.1.0-alpha2"
+version = "0.1.0-alpha3"
 dependencies = [
  "anyhow",
  "dashmap",
- "mimalloc",
  "mio",
  "pyo3",
  "socket2",
- "tikv-jemallocator",
 ]
 
 [[package]]
@@ -301,9 +273,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "socket2"
-version = "0.5.7"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
+checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
 dependencies = [
  "libc",
  "windows-sys",
@@ -311,9 +283,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.87"
+version = "2.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
+checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -326,31 +298,11 @@ version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
-[[package]]
-name = "tikv-jemalloc-sys"
-version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "tikv-jemallocator"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cec5ff18518d81584f477e9bfdf957f5bb0979b0bac3af4ca30b5b3ae2d2865"
-dependencies = [
- "libc",
- "tikv-jemalloc-sys",
-]
-
 [[package]]
 name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
 
 [[package]]
 name = "unindent"

{rloop-0.1.0a2 → rloop-0.1.0a3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rloop"
-version = "0.1.0-alpha2"
+version = "0.1.0-alpha3"
 description = "An asyncio event loop implemented in Rust"
 authors = ["Giovanni Barillari <g@baro.dev>"]
 license = "BSD-3-Clause"
@@ -36,12 +36,6 @@ mio = { version = "=1.0", features = ["net", "os-ext", "os-poll"] }
 pyo3 = { version = "=0.23", features = ["anyhow", "extension-module", "generate-import-lib"] }
 socket2 = "=0.5"
 
-[target.'cfg(any(target_os = "freebsd", target_os = "windows"))'.dependencies]
-mimalloc = { version = "0.1.43", default-features = false, features = ["local_dynamic_tls"] }
-
-[target.'cfg(not(any(target_os = "freebsd", target_os = "windows")))'.dependencies]
-tikv-jemallocator = { version = "0.6.0", default-features = false, features = ["disable_initial_exec_tls"] }
-
 [profile.release]
 codegen-units = 1
 debug = false

{rloop-0.1.0a2 → rloop-0.1.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: rloop
-Version: 0.1.0a2
+Version: 0.1.0a3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{rloop-0.1.0a2 → rloop-0.1.0a3}/pyproject.toml

@@ -95,3 +95,6 @@ known-first-party = ['rloop', 'tests']
 
 [tool.pytest.ini_options]
 asyncio_mode = 'auto'
+
+[tool.uv]
+package = false

{rloop-0.1.0a2 → rloop-0.1.0a3}/rloop/_rloop.pyi

@@ -35,8 +35,6 @@ class EventLoop:
     _watcher_child: Any
 
     def _run(self): ...
-    def _wake(self): ...
-    def _call_soon(self, callback, args, context) -> CBHandle: ...
     def _call_later(self, delay, callback, args, context) -> TimerHandle: ...
     def _reader_add(self, fd, callback, args, context) -> CBHandle: ...
     def _reader_rem(self, fd) -> bool: ...
@@ -45,7 +43,7 @@ class EventLoop:
     def _sig_add(self, sig, callback, context): ...
     def _sig_rem(self, sig) -> bool: ...
     def _sig_clear(self): ...
-    def _sig_handle(self, sig) -> bool: ...
-    def _sig_ceval(self, noop: Any): ...
     def _ssock_set(self, fd): ...
     def _ssock_del(self, fd): ...
+    def call_soon(self, callback, *args, context=None) -> CBHandle: ...
+    def call_soon_threadsafe(self, callback, *args, context=None) -> CBHandle: ...

{rloop-0.1.0a2 → rloop-0.1.0a3}/rloop/loop.py

@@ -210,19 +210,16 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
     # def _timer_handle_cancelled(self, handle):
     #     raise NotImplementedError
 
-    def call_soon(self, callback, *args, context=None) -> CBHandle:
-        return self._call_soon(callback, args, context or _copy_context())
-
     def call_later(self, delay, callback, *args, context=None) -> Union[CBHandle, TimerHandle]:
         if delay <= 0:
-            return self._call_soon(callback, args, context or _copy_context())
+            return self.call_soon(callback, *args, context=context or _copy_context())
         delay = round(delay * 1_000_000)
         return self._call_later(delay, callback, args, context or _copy_context())
 
     def call_at(self, when, callback, *args, context=None) -> Union[CBHandle, TimerHandle]:
         delay = round((when - self.time()) * 1_000_000)
         if delay <= 0:
-            return self._call_soon(callback, args, context or _copy_context())
+            return self.call_soon(callback, *args, context=context or _copy_context())
         return self._call_later(delay, callback, args, context or _copy_context())
 
     def time(self) -> float:
@@ -269,11 +266,6 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
             return task
 
     #: threads methods
-    def call_soon_threadsafe(self, callback, *args, context=None) -> CBHandle:
-        rv = self._call_soon(callback, args, context or self._base_ctx)
-        self._wake()
-        return rv
-
     def run_in_executor(self, executor, fn, *args):
         if _iscoroutine(fn) or _iscoroutinefunction(fn):
             raise TypeError('Coroutines cannot be used with executors')
@@ -675,41 +667,21 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
         try:
             self._ssock_r.setblocking(False)
             self._ssock_w.setblocking(False)
-            self._ssock_set(self._ssock_w.fileno())
+            self._ssock_set(self._ssock_r.fileno(), self._ssock_w.fileno())
         except Exception:
-            self._ssock_del()
-            self._ssock_r.close()
+            self._ssock_del(self._ssock_r.fileno())
             self._ssock_w = None
             self._ssock_r = None
             raise
 
-        self._reader_add(self._ssock_r.fileno(), self._ssock_reader, (), _copy_context())
-
     def _ssock_stop(self):
         if not self._ssock_w:
             raise RuntimeError('self-socket has not been setup')
 
-        self._reader_rem(self._ssock_r.fileno())
-        self._ssock_del()
-        self._ssock_r.close()
+        self._ssock_del(self._ssock_r.fileno())
         self._ssock_w = None
         self._ssock_r = None
 
-    def _ssock_reader(self):
-        sigdata = b''
-        while True:
-            try:
-                data = self._ssock_r.recv(65536)
-                if not data:
-                    break
-                sigdata += data
-            except InterruptedError:
-                continue
-            except BlockingIOError:
-                break
-        if sigdata and self._sig_listening:
-            self._signals_invoke(sigdata)
-
     def add_signal_handler(self, sig, callback, *args):
         if not self.__is_main_thread():
             raise ValueError('Signals can only be handled from the main thread')
@@ -718,10 +690,11 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
             raise TypeError('Coroutines cannot be used as signals handlers')
 
         self._check_closed()
-        self._sig_add(sig, callback, _copy_context())
+        self._check_signal(sig)
+        self._sig_add(sig, callback, args, _copy_context())
         try:
             # register a dummy signal handler so Python will write the signal no in the wakeup fd
-            signal.signal(sig, self.__sighandler)
+            signal.signal(sig, _noop)
             # set SA_RESTART to limit EINTR occurrences
             signal.siginterrupt(sig, False)
         except OSError as exc:
@@ -734,13 +707,32 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
         if not self._is_main_thread():
             raise ValueError('Signals can only be handled from the main thread')
 
-        return self._sig_rem(sig)
+        if not self._sig_rem(sig):
+            return False
+
+        if sig == signal.SIGINT:
+            handler = signal.default_int_handler
+        else:
+            handler = signal.SIG_DFL
+
+        try:
+            signal.signal(sig, handler)
+        except OSError as exc:
+            if exc.errno == errno.EINVAL:
+                raise RuntimeError(f'signum {sig} cannot be caught')
+            raise
+
+        return True
 
     def __is_main_thread(self):
         return threading.main_thread().ident == threading.current_thread().ident
 
-    def __sighandler(self, signum, frame):
-        self._signals.add(signum)
+    def _check_signal(self, sig):
+        if not isinstance(sig, int):
+            raise TypeError(f'sig must be an int, not {sig!r}')
+
+        if sig not in signal.valid_signals():
+            raise ValueError(f'invalid signal number {sig}')
 
     def __set_sig_wfd(self, fd):
         if fd >= 0:
@@ -786,25 +778,6 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
 
         self._sig_clear()
 
-    def _signals_invoke(self, data):
-        self._sig_ceval(_noop)
-        self._sig_loop_handled = True
-
-        sigs = self._signals.copy()
-        self._signals.clear()
-        for signum in data:
-            if not signum:
-                continue
-            sigs.discard(signum)
-            self._signal_handle(signum)
-
-        for signum in sigs:
-            self._signal_handle(signum)
-
-    def _signal_handle(self, signum):
-        if not self._sig_handle(signum):
-            self._sig_ceval(_noop)
-
     #: task factory
     def set_task_factory(self, factory):
         self._task_factory = factory

{rloop-0.1.0a2 → rloop-0.1.0a3}/rloop/utils.py

@@ -75,5 +75,5 @@ def _ipaddr_info(host, port, family, type, proto, flowinfo=0, scopeid=0):
     return None
 
 
-def _noop():
+def _noop(*args, **kwargs):
     return

{rloop-0.1.0a2 → rloop-0.1.0a3}/src/event_loop.rs

@@ -1,7 +1,7 @@
 use std::{
     cmp::Ordering,
     collections::{BinaryHeap, VecDeque},
-    io::Write,
+    io::{Read, Write},
     mem,
     os::fd::FromRawFd,
     sync::{atomic, Arc, Mutex, RwLock},
@@ -11,13 +11,10 @@ use std::{
 use anyhow::Result;
 use dashmap::DashMap;
 use mio::{Events, Interest, Poll, Token};
-use pyo3::{
-    prelude::*,
-    types::{PyDict, PySet, PyTuple},
-};
+use pyo3::{prelude::*, types::PyDict};
 
 use crate::handles::{CBHandle, TimerHandle};
-use crate::io::Source;
+use crate::io::{InternalIO, Source};
 use crate::py::{copy_context, weakset};
 
 struct Timer {
@@ -51,7 +48,19 @@ impl Ord for Timer {
     }
 }
 
+enum IOHandle {
+    Internal(IOHandleData),
+    Py(PyIOHandleData),
+}
+
 struct IOHandleData {
+    source: Source,
+    #[allow(dead_code)]
+    interest: Interest,
+    handle: InternalIO,
+}
+
+struct PyIOHandleData {
     source: Source,
     interest: Interest,
     cbr: Option<Py<CBHandle>>,
@@ -60,20 +69,21 @@ struct IOHandleData {
 
 #[pyclass(frozen, subclass)]
 struct EventLoop {
+    idle: atomic::AtomicBool,
     io: Arc<Mutex<Poll>>,
-    handles_io: Arc<DashMap<Token, IOHandleData>>,
+    handles_io: Arc<DashMap<Token, IOHandle>>,
     handles_ready: Arc<Mutex<VecDeque<Py<CBHandle>>>>,
     handles_sched: Arc<Mutex<BinaryHeap<Timer>>>,
     epoch: Instant,
     counter_ready: atomic::AtomicUsize,
     counter_io: atomic::AtomicU16,
-    ssock: Arc<RwLock<Option<socket2::Socket>>>,
+    ssock: Arc<RwLock<Option<(socket2::Socket, socket2::Socket)>>>,
     tick_last_poll: atomic::AtomicU64,
     closed: atomic::AtomicBool,
     exc_handler: Arc<RwLock<PyObject>>,
     exception_handler: Arc<RwLock<PyObject>>,
     executor: Arc<RwLock<PyObject>>,
-    sig_handlers: Arc<DashMap<u16, Py<CBHandle>>>,
+    sig_handlers: Arc<DashMap<u8, Py<CBHandle>>>,
     sig_listening: atomic::AtomicBool,
     sig_loop_handled: atomic::AtomicBool,
     sig_wfd: Arc<RwLock<PyObject>>,
@@ -89,8 +99,6 @@ struct EventLoop {
     _asyncgens: PyObject,
     #[pyo3(get)]
     _base_ctx: PyObject,
-    #[pyo3(get)]
-    _signals: Py<PySet>,
 }
 
 impl EventLoop {
@@ -104,16 +112,9 @@ impl EventLoop {
         if self.counter_ready.load(atomic::Ordering::Relaxed) > 0 {
             sched_time = Some(0);
             // we want to skip polling when unnecessary:
-            //   if we have I/O handles, we need to check the time since last poll
-            //   otherwise we don't need to poll at all
-            // NOTE: >1 as we always have signal socket reader
-            if self.counter_io.load(atomic::Ordering::Relaxed) > 1 {
-                // we max out at 250μs poll intervals
-                let tick = Instant::now().duration_since(self.epoch).as_micros() as u64;
-                if (tick - self.tick_last_poll.load(atomic::Ordering::Relaxed)) < 250 {
-                    skip_poll = true;
-                }
-            } else {
+            // if work is ready we check the time since last poll and skip for max 250μs
+            let tick = Instant::now().duration_since(self.epoch).as_micros() as u64;
+            if (tick - self.tick_last_poll.load(atomic::Ordering::Relaxed)) < 250 {
                 skip_poll = true;
             }
         } else {
@@ -133,6 +134,9 @@ impl EventLoop {
             true => Ok(()),
             false => py.allow_threads(|| {
                 let mut io = self.io.lock().unwrap();
+                if sched_time.is_none() {
+                    self.idle.store(true, atomic::Ordering::Relaxed);
+                }
                 let res = io.poll(&mut io_events, sched_time.map(Duration::from_millis));
                 if let Err(ref err) = res {
                     if err.kind() == std::io::ErrorKind::Interrupted {
@@ -140,6 +144,7 @@ impl EventLoop {
                         let _ = io.poll(&mut io_events, Some(Duration::from_millis(0)));
                     }
                 }
+                self.idle.store(false, atomic::Ordering::Relaxed);
                 self.tick_last_poll.store(
                     Instant::now().duration_since(self.epoch).as_micros() as u64,
                     atomic::Ordering::Relaxed,
@@ -148,20 +153,28 @@ impl EventLoop {
             }),
         };
         let mut guard_cb = self.handles_ready.lock().unwrap();
-        self.counter_ready.fetch_sub(guard_cb.len(), atomic::Ordering::Relaxed);
+        let mut cb_handles = mem::replace(&mut *guard_cb, VecDeque::with_capacity(128));
+        self.counter_ready
+            .fetch_sub(cb_handles.len(), atomic::Ordering::Relaxed);
+        drop(guard_cb);
 
         for event in &io_events {
             // NOTE: cancellation is not necessary as we have custom futures
-            if let Some(handle) = self.handles_io.get(&event.token()) {
-                if let Some(cbr) = &handle.cbr {
-                    if event.is_readable() {
-                        guard_cb.push_back(cbr.clone_ref(py));
-                    }
-                }
-                if let Some(cbw) = &handle.cbw {
-                    if event.is_writable() {
-                        guard_cb.push_back(cbw.clone_ref(py));
+            if let Some(io_handle) = self.handles_io.get(&event.token()) {
+                match io_handle.value() {
+                    IOHandle::Py(handle) => {
+                        if let Some(cbr) = &handle.cbr {
+                            if event.is_readable() {
+                                cb_handles.push_back(cbr.clone_ref(py));
+                            }
+                        }
+                        if let Some(cbw) = &handle.cbw {
+                            if event.is_writable() {
+                                cb_handles.push_back(cbw.clone_ref(py));
+                            }
+                        }
                     }
+                    IOHandle::Internal(handle) => self.handle_internal_io(handle, py, &mut cb_handles),
                 }
             }
         }
@@ -175,15 +188,13 @@ impl EventLoop {
                     if timer.when > tick {
                         break;
                     }
-                    guard_cb.push_back(guard_sched.pop().unwrap().handle);
+                    cb_handles.push_back(guard_sched.pop().unwrap().handle);
                 }
             }
         }
         drop(guard_sched);
 
         // callbacks
-        let mut cb_handles = mem::replace(&mut *guard_cb, VecDeque::with_capacity(128));
-        drop(guard_cb);
         while let Some(cb_handle) = cb_handles.pop_front() {
             // let handle = match cb_handle {
             //     Handle::Callback(ref v) => v.get(),
@@ -207,9 +218,71 @@ impl EventLoop {
         poll_result
     }
 
+    #[inline]
+    fn handle_internal_io(&self, handle_data: &IOHandleData, py: Python, handles_ready: &mut VecDeque<Py<CBHandle>>) {
+        match handle_data.handle {
+            InternalIO::Signals => {
+                let sigs = py.allow_threads(|| self.read_from_self());
+                for sig in sigs {
+                    self.sig_handle(py, sig, handles_ready);
+                }
+            }
+        }
+    }
+
+    #[inline]
+    fn sig_handle(&self, py: Python, sig: u8, handles_ready: &mut VecDeque<Py<CBHandle>>) {
+        if let Some(pyhandle) = self.sig_handlers.get(&sig) {
+            self.sig_loop_handled.store(true, atomic::Ordering::Relaxed);
+
+            if pyhandle.get().cancelled.load(atomic::Ordering::Relaxed) {
+                self._sig_rem(sig);
+            } else {
+                handles_ready.push_back(pyhandle.clone_ref(py));
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn wake(&self) {
+        let mut guard = self.ssock.write().unwrap();
+        if let Some((_, sockw)) = guard.as_mut() {
+            let _ = sockw.write(b"\0");
+        }
+    }
+
+    fn read_from_self(&self) -> Vec<u8> {
+        let mut guard = self.ssock.write().unwrap();
+        if let Some((sockr, _)) = guard.as_mut() {
+            let mut buf = [0; 4096];
+            let mut len = 0;
+            loop {
+                match sockr.read(&mut buf[len..]) {
+                    Ok(0) => break,
+                    Ok(readn) => {
+                        len += readn;
+                    }
+                    Err(err) if err.kind() == std::io::ErrorKind::Interrupted => continue,
+                    Err(_) => break,
+                }
+            }
+            if self.sig_listening.load(atomic::Ordering::Relaxed) {
+                let mut sigs = Vec::with_capacity(len);
+                for sig in &buf[..len] {
+                    if *sig == 0 {
+                        continue;
+                    }
+                    sigs.push(*sig);
+                }
+                return sigs;
+            }
+        }
+        Vec::new()
+    }
+
     #[inline]
     fn reader_rem(&self, token: Token) -> Result<bool> {
-        if let Some((_, mut item)) = self.handles_io.remove(&token) {
+        if let Some((_, IOHandle::Py(mut item))) = self.handles_io.remove(&token) {
             let guard_poll = self.io.lock().unwrap();
             match item.interest {
                 Interest::READABLE => {
@@ -221,12 +294,12 @@ impl EventLoop {
                     guard_poll.registry().reregister(&mut item.source, token, interest)?;
                     self.handles_io.insert(
                         token,
-                        IOHandleData {
+                        IOHandle::Py(PyIOHandleData {
                             source: item.source,
                             interest,
                             cbr: None,
                             cbw: item.cbw,
-                        },
+                        }),
                     );
                 }
             }
@@ -237,7 +310,7 @@ impl EventLoop {
 
     #[inline]
     fn writer_rem(&self, token: Token) -> Result<bool> {
-        if let Some((_, mut item)) = self.handles_io.remove(&token) {
+        if let Some((_, IOHandle::Py(mut item))) = self.handles_io.remove(&token) {
             let guard_poll = self.io.lock().unwrap();
             match item.interest {
                 Interest::WRITABLE => {
@@ -249,12 +322,12 @@ impl EventLoop {
                     guard_poll.registry().reregister(&mut item.source, token, interest)?;
                     self.handles_io.insert(
                         token,
-                        IOHandleData {
+                        IOHandle::Py(PyIOHandleData {
                             source: item.source,
                             interest,
                             cbr: item.cbr,
                             cbw: None,
-                        },
+                        }),
                     );
                 }
             }
@@ -263,14 +336,6 @@ impl EventLoop {
         Ok(false)
     }
 
-    #[inline]
-    fn wake(&self) {
-        let mut guard = self.ssock.write().unwrap();
-        if let Some(sock) = guard.as_mut() {
-            let _ = sock.write(b"\0");
-        }
-    }
-
     fn log_exception(&self, py: Python, ctx: Bound<PyDict>) -> PyResult<PyObject> {
         let handler = self.exc_handler.read().unwrap();
         handler.call1(py, (ctx, self.exception_handler.read().unwrap().clone_ref(py)))
@@ -282,6 +347,7 @@ impl EventLoop {
     #[new]
     fn new(py: Python) -> PyResult<Self> {
         Ok(Self {
+            idle: atomic::AtomicBool::new(false),
             io: Arc::new(Mutex::new(Poll::new()?)),
             handles_io: Arc::new(DashMap::with_capacity(128)),
             handles_ready: Arc::new(Mutex::new(VecDeque::with_capacity(128))),
@@ -309,7 +375,6 @@ impl EventLoop {
             watcher_child: Arc::new(RwLock::new(py.None())),
             _asyncgens: weakset(py)?.unbind(),
             _base_ctx: copy_context(py)?.unbind(),
-            _signals: PySet::empty(py)?.into_pyobject(py)?.unbind(),
         })
     }
 
@@ -411,16 +476,6 @@ impl EventLoop {
         self.sig_listening.store(val, atomic::Ordering::Relaxed);
     }
 
-    #[getter(_sig_loop_handled)]
-    fn _get_sig_loop_handled(&self) -> bool {
-        self.sig_loop_handled.load(atomic::Ordering::Relaxed)
-    }
-
-    #[setter(_sig_loop_handled)]
-    fn _set_sig_loop_handled(&self, val: bool) {
-        self.sig_loop_handled.store(val, atomic::Ordering::Relaxed);
-    }
-
     #[getter(_sig_wfd)]
     fn _get_sig_wfd(&self, py: Python) -> PyObject {
         self.sig_wfd.read().unwrap().clone_ref(py)
@@ -476,21 +531,84 @@ impl EventLoop {
         *guard = factory;
     }
 
-    fn _ssock_set(&self, fd: i32) {
+    fn _ssock_set(&self, fd_r: usize, fd_w: usize) -> PyResult<()> {
         let mut guard = self.ssock.write().unwrap();
-        *guard = Some(unsafe { socket2::Socket::from_raw_fd(fd) });
+        *guard = Some(unsafe {
+            (
+                #[allow(clippy::cast_possible_wrap)]
+                socket2::Socket::from_raw_fd(fd_r as i32),
+                #[allow(clippy::cast_possible_wrap)]
+                socket2::Socket::from_raw_fd(fd_w as i32),
+            )
+        });
+
+        let token = Token(fd_r);
+        let mut source = Source::FD(fd_r.try_into()?);
+        let interest = Interest::READABLE;
+        let guard_poll = self.io.lock().unwrap();
+        guard_poll.registry().register(&mut source, token, interest)?;
+        drop(guard_poll);
+        self.handles_io.insert(
+            token,
+            IOHandle::Internal(IOHandleData {
+                source,
+                interest,
+                handle: InternalIO::Signals,
+            }),
+        );
+
+        Ok(())
     }
 
-    fn _ssock_del(&self) {
+    fn _ssock_del(&self, fd_r: usize) -> PyResult<()> {
+        let token = Token(fd_r);
+        if let Some((_, IOHandle::Internal(mut item))) = self.handles_io.remove(&token) {
+            let guard_poll = self.io.lock().unwrap();
+            guard_poll.registry().deregister(&mut item.source)?;
+        }
         self.ssock.write().unwrap().take();
+        Ok(())
     }
 
-    fn _call_soon(&self, py: Python, callback: PyObject, args: PyObject, context: PyObject) -> PyResult<Py<CBHandle>> {
-        let handle = Py::new(py, CBHandle::new(callback, args, context))?;
+    #[pyo3(signature = (callback, *args, context=None))]
+    fn call_soon(
+        &self,
+        py: Python,
+        callback: PyObject,
+        args: PyObject,
+        context: Option<PyObject>,
+    ) -> PyResult<Py<CBHandle>> {
+        let handle = Py::new(
+            py,
+            CBHandle::new(callback, args, context.unwrap_or_else(|| self._base_ctx.clone_ref(py))),
+        )?;
+        let mut guard = self.handles_ready.lock().unwrap();
+        guard.push_back(handle.clone_ref(py));
+        self.counter_ready.fetch_add(1, atomic::Ordering::Relaxed);
+        drop(guard);
+        Ok(handle)
+    }
+
+    #[pyo3(signature = (callback, *args, context=None))]
+    fn call_soon_threadsafe(
+        &self,
+        py: Python,
+        callback: PyObject,
+        args: PyObject,
+        context: Option<PyObject>,
+    ) -> PyResult<Py<CBHandle>> {
+        let handle = Py::new(
+            py,
+            CBHandle::new(callback, args, context.unwrap_or_else(|| self._base_ctx.clone_ref(py))),
+        )?;
         let mut guard = self.handles_ready.lock().unwrap();
         guard.push_back(handle.clone_ref(py));
         self.counter_ready.fetch_add(1, atomic::Ordering::Relaxed);
         drop(guard);
+        // wake when necessary
+        if self.idle.load(atomic::Ordering::Relaxed) {
+            py.allow_threads(|| self.wake());
+        }
         Ok(handle)
     }
 
@@ -521,33 +639,34 @@ impl EventLoop {
     ) -> PyResult<Py<CBHandle>> {
         let token = Token(fd);
         let handle = Py::new(py, CBHandle::new(callback, args, context))?;
-        match self.handles_io.get_mut(&token) {
-            Some(mut item) => {
-                let interest = item.interest | Interest::READABLE;
+        if let Some(mut item) = self.handles_io.get_mut(&token) {
+            if let IOHandle::Py(data) = item.value_mut() {
+                let interest = data.interest | Interest::READABLE;
                 let guard_poll = self.io.lock().unwrap();
-                guard_poll.registry().reregister(&mut item.source, token, interest)?;
+                guard_poll.registry().reregister(&mut data.source, token, interest)?;
                 drop(guard_poll);
-                item.interest = interest;
-                item.cbr = Some(handle.clone_ref(py));
-            }
-            _ => {
-                let mut source = Source::FD(fd.try_into()?);
-                let interest = Interest::READABLE;
-                let guard_poll = self.io.lock().unwrap();
-                guard_poll.registry().register(&mut source, token, interest)?;
-                drop(guard_poll);
-                self.handles_io.insert(
-                    token,
-                    IOHandleData {
-                        source,
-                        interest,
-                        cbr: Some(handle.clone_ref(py)),
-                        cbw: None,
-                    },
-                );
-                self.counter_io.fetch_add(1, atomic::Ordering::Relaxed);
+                data.interest = interest;
+                data.cbr = Some(handle.clone_ref(py));
+                return Ok(handle);
             }
         }
+
+        let mut source = Source::FD(fd.try_into()?);
+        let interest = Interest::READABLE;
+        let guard_poll = self.io.lock().unwrap();
+        guard_poll.registry().register(&mut source, token, interest)?;
+        drop(guard_poll);
+        self.handles_io.insert(
+            token,
+            IOHandle::Py(PyIOHandleData {
+                source,
+                interest,
+                cbr: Some(handle.clone_ref(py)),
+                cbw: None,
+            }),
+        );
+        self.counter_io.fetch_add(1, atomic::Ordering::Relaxed);
+
         Ok(handle)
     }
 
@@ -566,33 +685,35 @@ impl EventLoop {
     ) -> PyResult<Py<CBHandle>> {
         let token = Token(fd);
         let handle = Py::new(py, CBHandle::new(callback, args, context))?;
-        match self.handles_io.get_mut(&token) {
-            Some(mut item) => {
-                let interest = item.interest | Interest::WRITABLE;
-                let guard_poll = self.io.lock().unwrap();
-                guard_poll.registry().reregister(&mut item.source, token, interest)?;
-                drop(guard_poll);
-                item.interest = interest;
-                item.cbw = Some(handle.clone_ref(py));
-            }
-            _ => {
-                let mut source = Source::FD(fd.try_into()?);
-                let interest = Interest::WRITABLE;
+
+        if let Some(mut item) = self.handles_io.get_mut(&token) {
+            if let IOHandle::Py(data) = item.value_mut() {
+                let interest = data.interest | Interest::WRITABLE;
                 let guard_poll = self.io.lock().unwrap();
-                guard_poll.registry().register(&mut source, token, interest)?;
+                guard_poll.registry().reregister(&mut data.source, token, interest)?;
                 drop(guard_poll);
-                self.handles_io.insert(
-                    token,
-                    IOHandleData {
-                        source,
-                        interest,
-                        cbr: None,
-                        cbw: Some(handle.clone_ref(py)),
-                    },
-                );
-                self.counter_io.fetch_add(1, atomic::Ordering::Relaxed);
+                data.interest = interest;
+                data.cbw = Some(handle.clone_ref(py));
+                return Ok(handle);
             }
         }
+
+        let mut source = Source::FD(fd.try_into()?);
+        let interest = Interest::WRITABLE;
+        let guard_poll = self.io.lock().unwrap();
+        guard_poll.registry().register(&mut source, token, interest)?;
+        drop(guard_poll);
+        self.handles_io.insert(
+            token,
+            IOHandle::Py(PyIOHandleData {
+                source,
+                interest,
+                cbr: None,
+                cbw: Some(handle.clone_ref(py)),
+            }),
+        );
+        self.counter_io.fetch_add(1, atomic::Ordering::Relaxed);
+
         Ok(handle)
     }
 
@@ -601,14 +722,13 @@ impl EventLoop {
         self.writer_rem(token)
     }
 
-    fn _sig_add(&self, py: Python, sig: u16, callback: PyObject, context: PyObject) -> Result<()> {
-        let args = PyTuple::empty(py).into_pyobject(py)?.into_any().unbind();
+    fn _sig_add(&self, py: Python, sig: u8, callback: PyObject, args: PyObject, context: PyObject) -> Result<()> {
         let handle = Py::new(py, CBHandle::new(callback, args, context))?;
         self.sig_handlers.insert(sig, handle);
         Ok(())
     }
 
-    fn _sig_rem(&self, sig: u16) -> bool {
+    fn _sig_rem(&self, sig: u8) -> bool {
         self.sig_handlers.remove(&sig).is_some()
     }
 
@@ -616,26 +736,6 @@ impl EventLoop {
         self.sig_handlers.clear();
     }
 
-    fn _sig_handle(&self, py: Python, sig: u16) -> bool {
-        if let Some(handle) = self.sig_handlers.get(&sig) {
-            handle.get().run(py);
-            return true;
-        }
-        false
-    }
-
-    fn _sig_ceval(&self, noop: PyObject) {
-        let noop_ptr = noop.as_ptr();
-        unsafe {
-            pyo3::ffi::PyErr_CheckSignals();
-            pyo3::ffi::compat::PyObject_CallNoArgs(noop_ptr);
-        }
-    }
-
-    fn _wake(&self) {
-        self.wake();
-    }
-
     fn _run(&self, py: Python) -> PyResult<()> {
         loop {
             if self.stopping.load(atomic::Ordering::Relaxed) {

{rloop-0.1.0a2 → rloop-0.1.0a3}/src/handles.rs

@@ -3,8 +3,9 @@ use std::sync::atomic;
 
 // pub(crate) enum Handle {
 //     Callback(Py<CBHandle>),
+//     Signal,
 //     // Timer(Py<TimerHandle>),
-//     IO(Arc<CBHandle>),
+//     // IO(Arc<CBHandle>),
 // }
 
 #[pyclass(frozen)]

{rloop-0.1.0a2 → rloop-0.1.0a3}/src/io.rs

@@ -21,6 +21,10 @@ pub(crate) enum Source {
     FD(RawSocket),
 }
 
+pub(crate) enum InternalIO {
+    Signals,
+}
+
 #[cfg(windows)]
 #[derive(Debug)]
 pub struct SourceRawSocket<'a>(pub &'a RawSocket);

{rloop-0.1.0a2 → rloop-0.1.0a3}/src/lib.rs

@@ -1,11 +1,3 @@
-#[cfg(not(any(target_os = "freebsd", target_os = "windows")))]
-#[global_allocator]
-static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
-
-#[cfg(any(target_os = "freebsd", target_os = "windows"))]
-#[global_allocator]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
 use pyo3::prelude::*;
 use std::sync::OnceLock;