rloop 0.1.4__tar.gz → 0.1.6__tar.gz

{rloop-0.1.4 → rloop-0.1.6}/Cargo.lock

@@ -4,9 +4,9 @@ version = 4
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
 
 [[package]]
 name = "autocfg"
@@ -16,9 +16,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "cc"
-version = "1.2.29"
+version = "1.2.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c1599538de2394445747c8cf7935946e3cc27e9625f889d979bfb2aaf569362"
+checksum = "3ee0f8803222ba5a7e2777dd72ca451868909b1ac410621b676adf07280e9b5f"
 dependencies = [
  "shlex",
 ]
@@ -43,9 +43,9 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.175"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
 
 [[package]]
 name = "log"
@@ -98,9 +98,9 @@ checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
 dependencies = [
  "unicode-ident",
 ]
@@ -189,7 +189,7 @@ dependencies = [
 
 [[package]]
 name = "rloop"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "anyhow",
  "libc",
@@ -228,9 +228,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.104"
+version = "2.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
 dependencies = [
  "proc-macro2",
  "quote",

{rloop-0.1.4 → rloop-0.1.6}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rloop"
-version = "0.1.4"
+version = "0.1.6"
 description = "An asyncio event loop implemented in Rust"
 authors = ["Giovanni Barillari <g@baro.dev>"]
 license = "BSD-3-Clause"

{rloop-0.1.4 → rloop-0.1.6}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: rloop
-Version: 0.1.4
+Version: 0.1.6
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -20,7 +21,6 @@ License-File: LICENSE
 Summary: An asyncio event loop implemented in Rust
 Keywords: asyncio
 Home-Page: https://github.com/gi0baro/rloop
-Author: Giovanni Barillari <g@baro.dev>
 Author-email: Giovanni Barillari <g@baro.dev>
 License: BSD-3-Clause
 Requires-Python: >=3.9

{rloop-0.1.4 → rloop-0.1.6}/pyproject.toml

@@ -9,6 +9,7 @@ classifiers = [
     'License :: OSI Approved :: BSD License',
     'Operating System :: MacOS',
     'Operating System :: POSIX :: Linux',
+    'Programming Language :: Python :: Free Threading :: 2 - Beta',
     'Programming Language :: Python :: 3',
     'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',

{rloop-0.1.4 → rloop-0.1.6}/rloop/loop.py

@@ -816,22 +816,22 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
         try:
             n = sock.send(data)
         except (BlockingIOError, InterruptedError):
-            pass
-        else:
-            if n == len(data):
-                return
-            data = memoryview(data)
-            data = data[n:]
+            n = 0
+
+        if n == len(data):
+            return
 
         fd = sock.fileno()
         self._ensure_fd_no_transport(fd)
         future = _SyncSockWriterFuture(sock, self)
-        self.add_writer(fd, self._sock_sendall, future, sock, data)
+        self.add_writer(fd, self._sock_sendall, future, sock, memoryview(data), [n])
         return await future
 
-    def _sock_sendall(self, fut, sock, data):
+    def _sock_sendall(self, fut, sock, data, pos):
+        start = pos[0]
+
         try:
-            n = sock.send(data)
+            n = sock.send(data[start:])
         except (BlockingIOError, InterruptedError):
             return
         except (SystemExit, KeyboardInterrupt):
@@ -841,12 +841,13 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
             self.remove_writer(sock.fileno())
             return
 
-        self.remove_writer(sock.fileno())
-        if n == len(data):
+        start += n
+
+        if start == len(data):
             fut.set_result(None)
+            self.remove_writer(sock.fileno())
         else:
-            data = data[n:]
-            self.add_writer(sock.fileno(), self._sock_sendall, fut, sock, data)
+            pos[0] = start
 
     # async def sock_sendto(self, sock, data, address):
     #     raise NotImplementedError

{rloop-0.1.4 → rloop-0.1.6}/src/event_loop.rs

@@ -3,12 +3,12 @@ use std::{
     io::Read,
     mem,
     os::fd::{AsRawFd, FromRawFd},
-    sync::{Mutex, RwLock, atomic},
+    sync::{Arc, Mutex, RwLock, atomic},
     time::{Duration, Instant},
 };
 
 use anyhow::Result;
-use mio::{Interest, Poll, Token, event, net::TcpListener};
+use mio::{Interest, Poll, Token, Waker, event, net::TcpListener};
 use pyo3::prelude::*;
 
 use crate::{
@@ -19,13 +19,9 @@ use crate::{
     server::Server,
     tcp::{TCPReadHandle, TCPServer, TCPServerRef, TCPTransport, TCPWriteHandle},
     time::Timer,
-    utils::syscall,
 };
 
-const WAKEB: &[u8; 1] = b"\0";
-
 enum IOHandle {
-    Internal,
     Py(PyHandleData),
     Signals,
     TCPListener(TCPListenerHandleData),
@@ -47,7 +43,6 @@ pub struct EventLoopRunState {
     buf: Box<[u8]>,
     events: event::Events,
     pub read_buf: Box<[u8]>,
-    sock: socket2::Socket,
     tick_last: u128,
 }
 
@@ -55,14 +50,13 @@ pub struct EventLoopRunState {
 pub struct EventLoop {
     idle: atomic::AtomicBool,
     io: Mutex<Poll>,
+    waker: Arc<Waker>,
     handles_io: papaya::HashMap<Token, IOHandle>,
     handles_ready: Mutex<VecDeque<BoxedHandle>>,
     handles_sched: Mutex<BinaryHeap<Timer>>,
     epoch: Instant,
     counter_ready: atomic::AtomicUsize,
     ssock: RwLock<Option<(socket2::Socket, socket2::Socket)>>,
-    wsock: Mutex<Option<socket2::Socket>>,
-    wsock_fd: atomic::AtomicI32,
     closed: atomic::AtomicBool,
     exc_handler: RwLock<PyObject>,
     exception_handler: RwLock<PyObject>,
@@ -88,46 +82,6 @@ pub struct EventLoop {
 }
 
 impl EventLoop {
-    fn run_pre(&self) -> Result<EventLoopRunState> {
-        // wake sockets
-        let (sock_r, sock_w) = socket2::Socket::pair(socket2::Domain::UNIX, socket2::Type::STREAM, None)?;
-        sock_r.set_nonblocking(true)?;
-        sock_w.set_nonblocking(true)?;
-        let token = Token(sock_r.as_raw_fd() as usize);
-        let mut source = Source::FD(sock_r.as_raw_fd());
-        {
-            let guard = self.io.lock().unwrap();
-            guard.registry().register(&mut source, token, Interest::READABLE)?;
-        }
-        self.handles_io.pin().insert(token, IOHandle::Internal);
-        {
-            let mut guard = self.wsock.lock().unwrap();
-            self.wsock_fd.store(sock_w.as_raw_fd(), atomic::Ordering::Relaxed);
-            *guard = Some(sock_w);
-        }
-
-        Ok(EventLoopRunState {
-            buf: vec![0; 4096].into_boxed_slice(),
-            events: event::Events::with_capacity(128),
-            read_buf: vec![0; 262_144].into_boxed_slice(),
-            tick_last: 0,
-            sock: sock_r,
-        })
-    }
-
-    fn run_post(&self, state: &mut EventLoopRunState) {
-        // cleanup wake sockets
-        self.wsock.lock().unwrap().take();
-        self.wsock_fd.store(-1, atomic::Ordering::Relaxed);
-        let token = Token(state.sock.as_raw_fd() as usize);
-        let mut source = Source::FD(state.sock.as_raw_fd());
-        {
-            let guard = self.io.lock().unwrap();
-            _ = guard.registry().deregister(&mut source);
-        }
-        self.handles_io.pin().remove(&token);
-    }
-
     #[inline]
     fn step(&self, py: Python, state: &mut EventLoopRunState) -> std::result::Result<(), std::io::Error> {
         let mut sched_time: Option<u64> = None;
@@ -154,33 +108,29 @@ impl EventLoop {
         }
 
         // I/O
-        let poll_result = match skip_poll {
-            true => {
-                state.events.clear();
-                Ok(())
+        let poll_result = if skip_poll {
+            Ok(())
+        } else {
+            let idle_swap = !matches!(sched_time, Some(0));
+            if idle_swap {
+                self.idle.store(true, atomic::Ordering::Release);
             }
-            false => {
-                let idle_swap = !matches!(sched_time, Some(0));
+            let res = py.allow_threads(|| {
+                let mut io = self.io.lock().unwrap();
+                let res = io.poll(&mut state.events, sched_time.map(Duration::from_micros));
                 if idle_swap {
-                    self.idle.store(true, atomic::Ordering::Release);
+                    self.idle.store(false, atomic::Ordering::Release);
+                }
+                if let Err(ref err) = res
+                    && err.kind() == std::io::ErrorKind::Interrupted
+                {
+                    // if we got an interrupt, we retry ready events (as we might need to process signals)
+                    let _ = io.poll(&mut state.events, Some(Duration::from_millis(0)));
                 }
-                let res = py.allow_threads(|| {
-                    let mut io = self.io.lock().unwrap();
-                    let res = io.poll(&mut state.events, sched_time.map(Duration::from_micros));
-                    if idle_swap {
-                        self.idle.store(false, atomic::Ordering::Release);
-                    }
-                    if let Err(ref err) = res {
-                        if err.kind() == std::io::ErrorKind::Interrupted {
-                            // if we got an interrupt, we retry ready events (as we might need to process signals)
-                            let _ = io.poll(&mut state.events, Some(Duration::from_millis(0)));
-                        }
-                    }
-                    res
-                });
-                state.tick_last = Instant::now().duration_since(self.epoch).as_micros();
                 res
-            }
+            });
+            state.tick_last = Instant::now().duration_since(self.epoch).as_micros();
+            res
         };
 
         let mut cb_handles = {
@@ -190,7 +140,7 @@ impl EventLoop {
         self.counter_ready
             .fetch_sub(cb_handles.len(), atomic::Ordering::Release);
 
-        {
+        if !skip_poll {
             let io_handles = self.handles_io.pin();
             for event in &state.events {
                 // NOTE: cancellation is not necessary as we have custom futures
@@ -199,7 +149,6 @@ impl EventLoop {
                         IOHandle::Py(handle) => self.handle_io_py(py, event, handle, &mut cb_handles),
                         IOHandle::TCPListener(handle) => self.handle_io_tcpl(py, handle, &io_handles, &mut cb_handles),
                         IOHandle::TCPStream(_) => self.handle_io_tcps(event, &mut cb_handles),
-                        IOHandle::Internal => self.handle_io_internal(&mut state.sock, &mut state.buf),
                         IOHandle::Signals => self.handle_io_signals(py, &mut state.buf, &mut cb_handles),
                     }
                 }
@@ -245,11 +194,6 @@ impl EventLoop {
         len
     }
 
-    #[inline]
-    fn handle_io_internal(&self, socket: &mut socket2::Socket, buf: &mut [u8]) {
-        self.read_from_sock(socket, buf);
-    }
-
     #[inline]
     fn handle_io_py(
         &self,
@@ -258,15 +202,15 @@ impl EventLoop {
         handle: &PyHandleData,
         handles: &mut VecDeque<BoxedHandle>,
     ) {
-        if let Some(cbr) = &handle.cbr {
-            if event.is_readable() {
-                handles.push_back(Box::new(cbr.clone_ref(py)));
-            }
+        if let Some(cbr) = &handle.cbr
+            && event.is_readable()
+        {
+            handles.push_back(Box::new(cbr.clone_ref(py)));
         }
-        if let Some(cbw) = &handle.cbw {
-            if event.is_writable() {
-                handles.push_back(Box::new(cbw.clone_ref(py)));
-            }
+        if let Some(cbw) = &handle.cbw
+            && event.is_writable()
+        {
+            handles.push_back(Box::new(cbw.clone_ref(py)));
         }
     }
 
@@ -338,8 +282,9 @@ impl EventLoop {
 
     #[inline(always)]
     fn wake(&self) {
-        let fd = self.wsock_fd.load(atomic::Ordering::Relaxed);
-        _ = syscall!(write(fd, WAKEB.as_ptr().cast(), 1));
+        if self.idle.load(atomic::Ordering::Acquire) {
+            _ = self.waker.wake();
+        }
     }
 
     pub(crate) fn tcp_listener_add(&self, listener: TcpListener, server: TCPServerRef) {
@@ -437,11 +382,10 @@ impl EventLoop {
 
     #[inline(always)]
     pub(crate) fn tcp_stream_close(&self, py: Python, fd: usize) {
-        if let Some(transport) = self.tcp_transports.pin().remove(&fd) {
-            if let Some(lfd) = transport.borrow(py).lfd {
-                self.tcp_lstreams.pin().get(&lfd).map(|v| v.pin().remove(&fd));
-            }
-            // transport.drop_ref(py);
+        if let Some(transport) = self.tcp_transports.pin().remove(&fd)
+            && let Some(lfd) = transport.borrow(py).lfd
+        {
+            self.tcp_lstreams.pin().get(&lfd).map(|v| v.pin().remove(&fd));
         }
     }
 
@@ -486,9 +430,7 @@ impl EventLoop {
             guard.push_back(Box::new(handle));
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -509,9 +451,7 @@ impl EventLoop {
             guard.push_back(Box::new(handle));
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -532,9 +472,7 @@ impl EventLoop {
             guard.push_back(Box::new(handle));
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -559,9 +497,7 @@ impl EventLoop {
                 .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
             guard.push(timer);
         }
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -592,9 +528,7 @@ impl EventLoop {
                 .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
             guard.push(timer);
         }
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -625,9 +559,7 @@ impl EventLoop {
                 .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
             guard.push(timer);
         }
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -660,9 +592,7 @@ impl EventLoop {
                 self.counter_ready.fetch_add(1, atomic::Ordering::Release);
             }
         }
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -672,17 +602,19 @@ impl EventLoop {
 impl EventLoop {
     #[new]
     fn new(py: Python) -> PyResult<Self> {
+        let poll = Poll::new()?;
+        let waker = Waker::new(poll.registry(), Token(0))?;
+
         Ok(Self {
             idle: atomic::AtomicBool::new(false),
-            io: Mutex::new(Poll::new()?),
+            io: Mutex::new(poll),
+            waker: Arc::new(waker),
             handles_io: papaya::HashMap::with_capacity(128),
             handles_ready: Mutex::new(VecDeque::with_capacity(128)),
             handles_sched: Mutex::new(BinaryHeap::with_capacity(32)),
             epoch: Instant::now(),
             counter_ready: atomic::AtomicUsize::new(0),
             ssock: RwLock::new(None),
-            wsock: Mutex::new(None),
-            wsock_fd: atomic::AtomicI32::new(-1),
             closed: atomic::AtomicBool::new(false),
             exc_handler: RwLock::new(py.None()),
             exception_handler: RwLock::new(py.None()),
@@ -935,10 +867,7 @@ impl EventLoop {
             guard.push_back(bhandle);
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        // wake when necessary
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         handle
     }
@@ -1195,7 +1124,12 @@ impl EventLoop {
     }
 
     fn _run(&self, py: Python) -> PyResult<()> {
-        let mut state = self.run_pre()?;
+        let mut state = EventLoopRunState {
+            buf: vec![0; 4096].into_boxed_slice(),
+            events: event::Events::with_capacity(128),
+            read_buf: vec![0; 262_144].into_boxed_slice(),
+            tick_last: 0,
+        };
 
         loop {
             if self.stopping.load(atomic::Ordering::Acquire) {
@@ -1208,12 +1142,10 @@ impl EventLoop {
                     }
                     break;
                 }
-                self.run_post(&mut state);
                 return Err(err.into());
             }
         }
 
-        self.run_post(&mut state);
         Ok(())
     }
 }

{rloop-0.1.4 → rloop-0.1.6}/src/tcp.rs

@@ -605,10 +605,10 @@ impl TCPReadHandle {
     #[inline]
     fn recv_eof(&self, py: Python, event_loop: &EventLoop, transport: &TCPTransport) -> bool {
         event_loop.tcp_stream_rem(self.fd, Interest::READABLE);
-        if let Ok(pyr) = transport.proto.call_method0(py, pyo3::intern!(py, "eof_received")) {
-            if let Ok(true) = pyr.is_truthy(py) {
-                return false;
-            }
+        if let Ok(pyr) = transport.proto.call_method0(py, pyo3::intern!(py, "eof_received"))
+            && let Ok(true) = pyr.is_truthy(py)
+        {
+            return false;
         }
         transport.close_from_read_handle(py, event_loop)
     }

{rloop-0.1.4 → rloop-0.1.6}/tests/test_handles.py

@@ -1,3 +1,6 @@
+import threading
+
+
 def run_loop(loop):
     async def run():
         loop.stop()
@@ -57,3 +60,39 @@ def test_call_at(loop):
     dt = loop.time() - t0
 
     assert dt >= delay
+
+
+def test_call_soon_threadsafe(loop):
+    calls = []
+
+    def cb(arg):
+        calls.append(arg)
+
+    def wake(cond):
+        with cond:
+            cond.notify_all()
+
+    def stop():
+        loop.stop()
+
+    def trun(cond1, cond2, loop, cb):
+        with cond1:
+            cond1.wait()
+        loop.call_soon_threadsafe(cb, 2)
+        with cond2:
+            cond2.wait()
+        loop.call_soon_threadsafe(cb, 4)
+
+    cond1 = threading.Condition()
+    cond2 = threading.Condition()
+    t = threading.Thread(target=trun, args=(cond1, cond2, loop, cb))
+    t.start()
+
+    loop.call_soon(cb, 1)
+    loop.call_soon(wake, cond1)
+    loop.call_later(0.5, cb, 3)
+    loop.call_later(0.6, wake, cond2)
+    loop.call_later(1.0, stop)
+    loop.run_forever()
+
+    assert calls == [1, 2, 3, 4]