rloop 0.1.1__tar.gz → 0.1.3__tar.gz

{rloop-0.1.1 → rloop-0.1.3}/Cargo.lock

@@ -14,52 +14,20 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
-[[package]]
-name = "bitflags"
-version = "2.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
-
 [[package]]
 name = "cc"
-version = "1.2.19"
+version = "1.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e3a13707ac958681c13b39b458c073d0d9bc8a22cb1b2f4c8e55eb72c13f362"
+checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
 dependencies = [
  "shlex",
 ]
 
 [[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.21"
+name = "equivalent"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
-
-[[package]]
-name = "dashmap"
-version = "6.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
- "hashbrown",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.14.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "heck"
@@ -79,16 +47,6 @@ version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
-[[package]]
-name = "lock_api"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
 [[package]]
 name = "log"
 version = "0.4.27"
@@ -106,14 +64,14 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
 dependencies = [
  "libc",
  "log",
  "wasi",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -123,16 +81,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
-name = "parking_lot_core"
-version = "0.9.10"
+name = "papaya"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "6827e3fc394523c21d4464d02c0bb1c19966ea4a58a9844ad6d746214179d2bc"
 dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-targets",
+ "equivalent",
+ "seize",
 ]
 
 [[package]]
@@ -152,12 +107,11 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.24.1"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17da310086b068fbdcefbba30aeb3721d5bb9af8db4987d6735b2183ca567229"
+checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
 dependencies = [
  "anyhow",
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -171,9 +125,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.24.1"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e27165889bd793000a098bb966adc4300c312497ea25cf7a690a9f0ac5aa5fc1"
+checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -182,9 +136,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.24.1"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05280526e1dbf6b420062f3ef228b78c0c54ba94e157f5cb724a609d0f2faabc"
+checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -192,9 +146,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.24.1"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c3ce5686aa4d3f63359a5100c62a127c9f15e8398e5fdeb5deef1fed5cd5f44"
+checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -204,9 +158,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.24.1"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4cf6faa0cbfb0ed08e89beb8103ae9724eb4750e3a78084ba4017cbe94f3855"
+checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -217,9 +171,9 @@ dependencies = [
 
 [[package]]
 name = "python3-dll-a"
-version = "0.2.13"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49fe4227a288cf9493942ad0220ea3f185f4d1f2a14f197f7344d6d02f4ed4ed"
+checksum = "d381ef313ae70b4da5f95f8a4de773c6aa5cd28f73adec4b4a31df70b66780d8"
 dependencies = [
  "cc",
 ]
@@ -233,33 +187,28 @@ dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "redox_syscall"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3"
-dependencies = [
- "bitflags",
-]
-
 [[package]]
 name = "rloop"
-version = "0.1.1"
+version = "0.1.3"
 dependencies = [
  "anyhow",
- "dashmap",
  "libc",
  "mio",
+ "papaya",
  "pyo3",
  "pyo3-build-config",
  "socket2",
 ]
 
 [[package]]
-name = "scopeguard"
-version = "1.2.0"
+name = "seize"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+checksum = "e4b8d813387d566f627f3ea1b914c068aac94c40ae27ec43f5f33bde65abefe7"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
 
 [[package]]
 name = "shlex"
@@ -267,27 +216,21 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
-[[package]]
-name = "smallvec"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
-
 [[package]]
 name = "socket2"
-version = "0.5.8"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "syn"
-version = "2.0.100"
+version = "2.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -327,6 +270,15 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"

{rloop-0.1.1 → rloop-0.1.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rloop"
-version = "0.1.1"
+version = "0.1.3"
 description = "An asyncio event loop implemented in Rust"
 authors = ["Giovanni Barillari <g@baro.dev>"]
 license = "BSD-3-Clause"
@@ -31,16 +31,16 @@ crate-type = ["cdylib"]
 
 [dependencies]
 anyhow = "=1.0"
-dashmap = { version = "=6.1", features = ["inline"] }
 mio = { version = "=1.0", features = ["net", "os-ext", "os-poll"] }
-pyo3 = { version = "=0.24", features = ["anyhow", "extension-module", "generate-import-lib"] }
+papaya = "=0.2"
+pyo3 = { version = "=0.25", features = ["anyhow", "extension-module", "generate-import-lib"] }
 socket2 = { version = "=0.5", features = ["all"] }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.159"
 
 [build-dependencies]
-pyo3-build-config = "=0.24"
+pyo3-build-config = "=0.25"
 
 [profile.release]
 codegen-units = 1

{rloop-0.1.1 → rloop-0.1.3}/PKG-INFO

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

{rloop-0.1.1 → rloop-0.1.3}/rloop/server.py

@@ -27,7 +27,7 @@ class Server:
         #     raise RuntimeError(f'server {self!r} is closed')
 
         self._inner._start_serving()
-        self._sff = self._loop.create_future()
+        self._sff = self._inner._loop.create_future()
 
         try:
             await self._sff

{rloop-0.1.1 → rloop-0.1.3}/src/event_loop.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::{BinaryHeap, HashSet, VecDeque},
+    collections::{BinaryHeap, VecDeque},
     io::Read,
     mem,
     os::fd::{AsRawFd, FromRawFd},
@@ -8,7 +8,6 @@ use std::{
 };
 
 use anyhow::Result;
-use dashmap::DashMap;
 use mio::{event, net::TcpListener, Interest, Poll, Token};
 use pyo3::prelude::*;
 
@@ -28,13 +27,12 @@ const WAKEB: &[u8; 1] = b"\0";
 enum IOHandle {
     Internal,
     Py(PyHandleData),
-    Signals(Source),
+    Signals,
     TCPListener(TCPListenerHandleData),
-    TCPStream(TCPStreamHandleData),
+    TCPStream(Interest),
 }
 
 struct PyHandleData {
-    source: Source,
     interest: Interest,
     cbr: Option<Py<CBHandle>>,
     cbw: Option<Py<CBHandle>>,
@@ -45,11 +43,6 @@ struct TCPListenerHandleData {
     server: TCPServerRef,
 }
 
-struct TCPStreamHandleData {
-    source: Source,
-    interest: Interest,
-}
-
 pub(crate) struct EventLoopRunState {
     buf: Box<[u8]>,
     events: event::Events,
@@ -62,7 +55,7 @@ pub(crate) struct EventLoopRunState {
 pub struct EventLoop {
     idle: atomic::AtomicBool,
     io: Mutex<Poll>,
-    handles_io: DashMap<Token, IOHandle>,
+    handles_io: papaya::HashMap<Token, IOHandle>,
     handles_ready: Mutex<VecDeque<BoxedHandle>>,
     handles_sched: Mutex<BinaryHeap<Timer>>,
     epoch: Instant,
@@ -74,7 +67,7 @@ pub struct EventLoop {
     exc_handler: RwLock<PyObject>,
     exception_handler: RwLock<PyObject>,
     executor: RwLock<PyObject>,
-    sig_handlers: DashMap<u8, Py<CBHandle>>,
+    sig_handlers: papaya::HashMap<u8, Py<CBHandle>>,
     sig_listening: atomic::AtomicBool,
     sig_loop_handled: atomic::AtomicBool,
     sig_wfd: RwLock<PyObject>,
@@ -84,8 +77,8 @@ pub struct EventLoop {
     ssock_r: RwLock<PyObject>,
     ssock_w: RwLock<PyObject>,
     task_factory: RwLock<PyObject>,
-    tcp_lstreams: DashMap<usize, HashSet<usize>>,
-    tcp_transports: DashMap<usize, Py<TCPTransport>>,
+    tcp_lstreams: papaya::HashMap<usize, papaya::HashSet<usize>>,
+    tcp_transports: papaya::HashMap<usize, Py<TCPTransport>>,
     thread_id: atomic::AtomicI64,
     watcher_child: RwLock<PyObject>,
     #[pyo3(get)]
@@ -106,7 +99,7 @@ impl EventLoop {
             let guard = self.io.lock().unwrap();
             guard.registry().register(&mut source, token, Interest::READABLE)?;
         }
-        self.handles_io.insert(token, IOHandle::Internal);
+        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);
@@ -132,7 +125,7 @@ impl EventLoop {
             let guard = self.io.lock().unwrap();
             _ = guard.registry().deregister(&mut source);
         }
-        self.handles_io.remove(&token);
+        self.handles_io.pin().remove(&token);
     }
 
     #[inline]
@@ -197,15 +190,18 @@ impl EventLoop {
         self.counter_ready
             .fetch_sub(cb_handles.len(), atomic::Ordering::Release);
 
-        for event in &state.events {
-            // NOTE: cancellation is not necessary as we have custom futures
-            if let Some(io_handle) = self.handles_io.get(&event.token()) {
-                match io_handle.value() {
-                    IOHandle::Py(handle) => self.handle_io_py(py, event, handle, &mut cb_handles),
-                    IOHandle::TCPListener(handle) => self.handle_io_tcpl(py, handle, &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),
+        {
+            let io_handles = self.handles_io.pin();
+            for event in &state.events {
+                // NOTE: cancellation is not necessary as we have custom futures
+                if let Some(io_handle) = io_handles.get(&event.token()) {
+                    match io_handle {
+                        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),
+                    }
                 }
             }
         }
@@ -275,23 +271,33 @@ impl EventLoop {
     }
 
     #[inline]
-    fn handle_io_tcpl(&self, py: Python, handle: &TCPListenerHandleData, handles: &mut VecDeque<BoxedHandle>) {
-        match &handle.source {
-            Source::TCPListener(listener) => {
-                while let Ok((stream, _)) = listener.accept() {
-                    let fd = stream.as_raw_fd() as usize;
-                    let (pytransport, stream_handle) = handle.server.new_stream(py, stream);
-                    self.tcp_transports.insert(fd, pytransport);
-                    self.tcp_lstreams.alter(&handle.server.fd, |_, mut v| {
-                        v.insert(fd);
-                        v
-                    });
-                    self.tcp_stream_add(fd, Interest::READABLE);
-                    handles.push_back(stream_handle);
-                }
+    fn handle_io_tcpl(
+        &self,
+        py: Python,
+        handle: &TCPListenerHandleData,
+        io_handles: &papaya::HashMapRef<'_, Token, IOHandle, std::hash::RandomState, papaya::LocalGuard<'_>>,
+        handles: &mut VecDeque<BoxedHandle>,
+    ) {
+        if let Source::TCPListener(listener) = &handle.source {
+            let guard_poll = self.io.lock().unwrap();
+            let transports = self.tcp_transports.pin();
+            let streams = self.tcp_lstreams.pin();
+            let lstreams = streams.get(&handle.server.fd).unwrap().pin();
+            while let Ok((stream, _)) = listener.accept() {
+                let fd = stream.as_raw_fd() as usize;
+                let token = Token(fd);
+                #[allow(clippy::cast_possible_wrap)]
+                let mut source = Source::TCPStream(fd as i32);
+                let (pytransport, stream_handle) = handle.server.new_stream(py, stream);
+                transports.insert(fd, pytransport);
+                lstreams.insert(fd);
+                _ = guard_poll.registry().register(&mut source, token, Interest::READABLE);
+                io_handles.insert(Token(fd), IOHandle::TCPStream(Interest::READABLE));
+                handles.push_back(stream_handle);
             }
-            _ => unreachable!(),
+            return;
         }
+        unreachable!()
     }
 
     #[inline]
@@ -319,9 +325,8 @@ impl EventLoop {
 
     #[inline]
     fn sig_handle(&self, py: Python, sig: u8, handles_ready: &mut VecDeque<BoxedHandle>) {
-        if let Some(handle) = self.sig_handlers.get(&sig) {
+        if let Some(handle) = self.sig_handlers.pin().get(&sig) {
             self.sig_loop_handled.store(true, atomic::Ordering::Relaxed);
-            let handle = handle.value();
 
             if handle.cancelled() {
                 self._sig_rem(sig);
@@ -343,112 +348,114 @@ impl EventLoop {
         let mut source = Source::TCPListener(listener);
         let guard_poll = self.io.lock().unwrap();
         let _ = guard_poll.registry().register(&mut source, token, Interest::READABLE);
-        self.tcp_lstreams.insert(fd, HashSet::new());
+        self.tcp_lstreams.pin().insert(fd, papaya::HashSet::new());
         self.handles_io
+            .pin()
             .insert(token, IOHandle::TCPListener(TCPListenerHandleData { source, server }));
     }
 
     pub(crate) fn tcp_listener_rem(&self, fd: usize) -> Result<bool> {
         let token = Token(fd);
-        if let Some((_, handle)) = self.handles_io.remove(&token) {
-            match handle {
-                IOHandle::TCPListener(mut item) => {
-                    self.tcp_lstreams.remove(&fd);
-                    let guard_poll = self.io.lock().unwrap();
-                    guard_poll.registry().deregister(&mut item.source)?;
-                    return Ok(true);
-                }
-                _ => unreachable!(),
+        if let Some(handle) = self.handles_io.pin().remove(&token) {
+            if let IOHandle::TCPListener(_) = handle {
+                self.tcp_lstreams.pin().remove(&fd);
+                #[allow(clippy::cast_possible_wrap)]
+                let mut source = Source::FD(fd as i32);
+                let guard_poll = self.io.lock().unwrap();
+                guard_poll.registry().deregister(&mut source)?;
+                return Ok(true);
             }
+            unreachable!()
         }
         Ok(false)
     }
 
     pub(crate) fn tcp_stream_add(&self, fd: usize, interest: Interest) {
         let token = Token(fd);
-        self.handles_io
-            .entry(token)
-            .and_modify(|io_handle| match io_handle {
-                IOHandle::TCPStream(data) => {
-                    if data.interest == interest {
-                        return;
+        self.handles_io.pin().update_or_insert_with(
+            token,
+            |io_handle| {
+                if let IOHandle::TCPStream(interest_prev) = io_handle {
+                    if *interest_prev == interest {
+                        return IOHandle::TCPStream(interest);
                     }
 
-                    let interests = data.interest | interest;
+                    let interests = *interest_prev | interest;
                     {
+                        #[allow(clippy::cast_possible_wrap)]
+                        let mut source = Source::FD(fd as i32);
                         let guard_poll = self.io.lock().unwrap();
-                        _ = guard_poll.registry().reregister(&mut data.source, token, interests);
+                        _ = guard_poll.registry().reregister(&mut source, token, interests);
                     }
-                    data.interest = interests;
+                    return IOHandle::TCPStream(interests);
                 }
-                _ => unreachable!(),
-            })
-            .or_insert_with(|| {
+                unreachable!()
+            },
+            || {
                 #[allow(clippy::cast_possible_wrap)]
                 let mut source = Source::TCPStream(fd as i32);
                 {
                     let guard_poll = self.io.lock().unwrap();
                     _ = guard_poll.registry().register(&mut source, token, interest);
                 }
-                IOHandle::TCPStream(TCPStreamHandleData { source, interest })
-            });
+                IOHandle::TCPStream(interest)
+            },
+        );
     }
 
     pub(crate) fn tcp_stream_rem(&self, fd: usize, interest: Interest) {
         let token = Token(fd);
 
-        if let Some((_, io_handle)) = self.handles_io.remove_if(&token, |_, io_handle| {
-            if let IOHandle::TCPStream(handle) = io_handle {
-                return handle.interest == interest;
+        match self.handles_io.pin().remove_if(&token, |_, io_handle| {
+            if let IOHandle::TCPStream(interest_ex) = io_handle {
+                return *interest_ex == interest;
             }
             false
         }) {
-            match io_handle {
-                IOHandle::TCPStream(mut handle) => {
-                    let guard_poll = self.io.lock().unwrap();
-                    _ = guard_poll.registry().deregister(&mut handle.source);
-                }
-                _ => unreachable!(),
-            }
-            return;
-        }
-
-        self.handles_io.alter(&token, |_, mut io_handle| {
-            if let IOHandle::TCPStream(handle) = &mut io_handle {
-                handle.interest = handle.interest.remove(interest).unwrap();
+            Ok(None) => {}
+            Ok(_) => {
+                #[allow(clippy::cast_possible_wrap)]
+                let mut source = Source::FD(fd as i32);
                 let guard_poll = self.io.lock().unwrap();
-                _ = guard_poll
-                    .registry()
-                    .reregister(&mut handle.source, token, handle.interest);
+                _ = guard_poll.registry().deregister(&mut source);
+            }
+            _ => {
+                self.handles_io.pin().update(token, |io_handle| {
+                    if let IOHandle::TCPStream(interest_ex) = io_handle {
+                        let interest_new = interest_ex.remove(interest).unwrap();
+                        #[allow(clippy::cast_possible_wrap)]
+                        let mut source = Source::FD(fd as i32);
+                        let guard_poll = self.io.lock().unwrap();
+                        _ = guard_poll.registry().reregister(&mut source, token, interest_new);
+                        return IOHandle::TCPStream(interest_new);
+                    }
+                    unreachable!()
+                });
             }
-            io_handle
-        });
+        }
     }
 
     #[inline(always)]
     pub(crate) fn tcp_stream_close(&self, py: Python, fd: usize) {
-        if let Some((_, transport)) = self.tcp_transports.remove(&fd) {
+        if let Some(transport) = self.tcp_transports.pin().remove(&fd) {
             if let Some(lfd) = transport.borrow(py).lfd {
-                self.tcp_lstreams.alter(&lfd, |_, mut v| {
-                    v.remove(&fd);
-                    v
-                });
+                self.tcp_lstreams.pin().get(&lfd).map(|v| v.pin().remove(&fd));
             }
-            transport.drop_ref(py);
+            // transport.drop_ref(py);
         }
     }
 
     #[inline(always)]
     pub(crate) fn get_tcp_transport(&self, fd: usize, py: Python) -> Py<TCPTransport> {
-        self.tcp_transports.get(&fd).unwrap().clone_ref(py)
+        self.tcp_transports.pin().get(&fd).unwrap().clone_ref(py)
     }
 
     pub(crate) fn with_tcp_listener_streams<T>(&self, fd: usize, func: T)
     where
-        T: FnOnce(&HashSet<usize>),
+        T: FnOnce(&papaya::HashSet<usize>),
     {
-        if let Some(streams_ref) = self.tcp_lstreams.get(&fd) {
-            func(streams_ref.value());
+        if let Some(streams_ref) = self.tcp_lstreams.pin().get(&fd) {
+            func(streams_ref);
         }
     }
 
@@ -633,7 +640,7 @@ impl EventLoop {
         Ok(Self {
             idle: atomic::AtomicBool::new(false),
             io: Mutex::new(Poll::new()?),
-            handles_io: DashMap::with_capacity(128),
+            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(),
@@ -645,7 +652,7 @@ impl EventLoop {
             exc_handler: RwLock::new(py.None()),
             exception_handler: RwLock::new(py.None()),
             executor: RwLock::new(py.None()),
-            sig_handlers: DashMap::with_capacity(32),
+            sig_handlers: papaya::HashMap::with_capacity(32),
             sig_listening: atomic::AtomicBool::new(false),
             sig_loop_handled: atomic::AtomicBool::new(false),
             sig_wfd: RwLock::new(py.None()),
@@ -655,8 +662,8 @@ impl EventLoop {
             ssock_r: RwLock::new(py.None()),
             ssock_w: RwLock::new(py.None()),
             task_factory: RwLock::new(py.None()),
-            tcp_lstreams: DashMap::with_capacity(32),
-            tcp_transports: DashMap::with_capacity(1024),
+            tcp_lstreams: papaya::HashMap::with_capacity(32),
+            tcp_transports: papaya::HashMap::with_capacity(1024),
             thread_id: atomic::AtomicI64::new(0),
             watcher_child: RwLock::new(py.None()),
             _asyncgens: weakset(py)?.unbind(),
@@ -838,14 +845,16 @@ impl EventLoop {
             let guard_poll = self.io.lock().unwrap();
             guard_poll.registry().register(&mut source, token, interest)?;
         }
-        self.handles_io.insert(token, IOHandle::Signals(source));
+        self.handles_io.pin().insert(token, IOHandle::Signals);
 
         Ok(())
     }
 
     fn _ssock_del(&self, fd_r: usize) -> PyResult<()> {
         let token = Token(fd_r);
-        if let Some((_, IOHandle::Signals(mut source))) = self.handles_io.remove(&token) {
+        if let Some(IOHandle::Signals) = self.handles_io.pin().remove(&token) {
+            #[allow(clippy::cast_possible_wrap)]
+            let mut source = Source::FD(fd_r as i32);
             let guard_poll = self.io.lock().unwrap();
             guard_poll.registry().deregister(&mut source)?;
         }
@@ -937,18 +946,24 @@ impl EventLoop {
         )
         .unwrap();
 
-        self.handles_io
-            .entry(token)
-            .and_modify(|io_handle| match io_handle {
-                IOHandle::Py(data) => {
-                    data.interest |= Interest::READABLE;
-                    data.cbr = Some(handle.clone_ref(py));
+        self.handles_io.pin().update_or_insert_with(
+            token,
+            |io_handle| {
+                if let IOHandle::Py(data) = io_handle {
+                    let interest = data.interest | Interest::READABLE;
+                    #[allow(clippy::cast_possible_wrap)]
+                    let mut source = Source::FD(fd as i32);
                     let guard_poll = self.io.lock().unwrap();
-                    _ = guard_poll.registry().reregister(&mut data.source, token, data.interest);
+                    _ = guard_poll.registry().reregister(&mut source, token, data.interest);
+                    return IOHandle::Py(PyHandleData {
+                        interest,
+                        cbr: Some(handle.clone_ref(py)),
+                        cbw: Some(data.cbw.as_ref().unwrap().clone_ref(py)),
+                    });
                 }
-                _ => unreachable!(),
-            })
-            .or_insert_with(|| {
+                unreachable!()
+            },
+            || {
                 #[allow(clippy::cast_possible_wrap)]
                 let mut source = Source::FD(fd as i32);
                 let interest = Interest::READABLE;
@@ -957,50 +972,52 @@ impl EventLoop {
                     _ = guard_poll.registry().register(&mut source, token, interest);
                 }
                 IOHandle::Py(PyHandleData {
-                    source,
                     interest,
                     cbr: Some(handle.clone_ref(py)),
                     cbw: None,
                 })
-            });
+            },
+        );
 
         handle
     }
 
-    fn remove_reader(&self, fd: usize) -> bool {
+    fn remove_reader(&self, py: Python, fd: usize) -> bool {
         let token = Token(fd);
 
-        if let Some((_, io_handle)) = self.handles_io.remove_if(&token, |_, io_handle| {
-            if let IOHandle::Py(handle) = io_handle {
-                return handle.interest == Interest::READABLE;
+        match self.handles_io.pin().remove_if(&token, |_, io_handle| {
+            if let IOHandle::Py(data) = io_handle {
+                return data.interest == Interest::READABLE;
             }
             false
         }) {
-            match io_handle {
-                IOHandle::Py(mut handle) => {
-                    let guard_poll = self.io.lock().unwrap();
-                    _ = guard_poll.registry().deregister(&mut handle.source);
-                }
-                _ => unreachable!(),
-            }
-            return true;
-        }
-
-        let mut altered = false;
-        self.handles_io.alter(&token, |_, mut io_handle| {
-            if let IOHandle::Py(handle) = &mut io_handle {
-                handle.interest = Interest::WRITABLE;
-                handle.cbr = None;
+            Ok(None) => false,
+            Ok(_) => {
+                #[allow(clippy::cast_possible_wrap)]
+                let mut source = Source::FD(fd as i32);
                 let guard_poll = self.io.lock().unwrap();
-                _ = guard_poll
-                    .registry()
-                    .reregister(&mut handle.source, token, handle.interest);
-                altered = true;
+                _ = guard_poll.registry().deregister(&mut source);
+                true
             }
-            io_handle
-        });
-
-        altered
+            _ => {
+                self.handles_io.pin().update(token, |io_handle| {
+                    if let IOHandle::Py(data) = io_handle {
+                        let interest = Interest::WRITABLE;
+                        #[allow(clippy::cast_possible_wrap)]
+                        let mut source = Source::FD(fd as i32);
+                        let guard_poll = self.io.lock().unwrap();
+                        _ = guard_poll.registry().reregister(&mut source, token, interest);
+                        return IOHandle::Py(PyHandleData {
+                            interest,
+                            cbr: None,
+                            cbw: Some(data.cbw.as_ref().unwrap().clone_ref(py)),
+                        });
+                    }
+                    unreachable!()
+                });
+                true
+            }
+        }
     }
 
     #[pyo3(signature = (fd, callback, *args, context=None))]
@@ -1019,18 +1036,24 @@ impl EventLoop {
         )
         .unwrap();
 
-        self.handles_io
-            .entry(token)
-            .and_modify(|io_handle| match io_handle {
-                IOHandle::Py(data) => {
-                    data.interest |= Interest::WRITABLE;
-                    data.cbw = Some(handle.clone_ref(py));
+        self.handles_io.pin().update_or_insert_with(
+            token,
+            |io_handle| {
+                if let IOHandle::Py(data) = io_handle {
+                    let interest = data.interest | Interest::WRITABLE;
+                    #[allow(clippy::cast_possible_wrap)]
+                    let mut source = Source::FD(fd as i32);
                     let guard_poll = self.io.lock().unwrap();
-                    _ = guard_poll.registry().reregister(&mut data.source, token, data.interest);
+                    _ = guard_poll.registry().reregister(&mut source, token, data.interest);
+                    return IOHandle::Py(PyHandleData {
+                        interest,
+                        cbr: Some(data.cbr.as_ref().unwrap().clone_ref(py)),
+                        cbw: Some(handle.clone_ref(py)),
+                    });
                 }
-                _ => unreachable!(),
-            })
-            .or_insert_with(|| {
+                unreachable!()
+            },
+            || {
                 #[allow(clippy::cast_possible_wrap)]
                 let mut source = Source::FD(fd as i32);
                 let interest = Interest::WRITABLE;
@@ -1039,50 +1062,52 @@ impl EventLoop {
                     _ = guard_poll.registry().register(&mut source, token, interest);
                 }
                 IOHandle::Py(PyHandleData {
-                    source,
                     interest,
                     cbr: None,
                     cbw: Some(handle.clone_ref(py)),
                 })
-            });
+            },
+        );
 
         handle
     }
 
-    fn remove_writer(&self, fd: usize) -> bool {
+    fn remove_writer(&self, py: Python, fd: usize) -> bool {
         let token = Token(fd);
 
-        if let Some((_, io_handle)) = self.handles_io.remove_if(&token, |_, io_handle| {
-            if let IOHandle::Py(handle) = io_handle {
-                return handle.interest == Interest::WRITABLE;
+        match self.handles_io.pin().remove_if(&token, |_, io_handle| {
+            if let IOHandle::Py(data) = io_handle {
+                return data.interest == Interest::WRITABLE;
             }
             false
         }) {
-            match io_handle {
-                IOHandle::Py(mut handle) => {
-                    let guard_poll = self.io.lock().unwrap();
-                    _ = guard_poll.registry().deregister(&mut handle.source);
-                }
-                _ => unreachable!(),
-            }
-            return true;
-        }
-
-        let mut altered = false;
-        self.handles_io.alter(&token, |_, mut io_handle| {
-            if let IOHandle::Py(handle) = &mut io_handle {
-                handle.interest = Interest::READABLE;
-                handle.cbw = None;
+            Ok(None) => false,
+            Ok(_) => {
+                #[allow(clippy::cast_possible_wrap)]
+                let mut source = Source::FD(fd as i32);
                 let guard_poll = self.io.lock().unwrap();
-                _ = guard_poll
-                    .registry()
-                    .reregister(&mut handle.source, token, handle.interest);
-                altered = true;
+                _ = guard_poll.registry().deregister(&mut source);
+                true
             }
-            io_handle
-        });
-
-        altered
+            _ => {
+                self.handles_io.pin().update(token, |io_handle| {
+                    if let IOHandle::Py(data) = io_handle {
+                        let interest = Interest::READABLE;
+                        #[allow(clippy::cast_possible_wrap)]
+                        let mut source = Source::FD(fd as i32);
+                        let guard_poll = self.io.lock().unwrap();
+                        _ = guard_poll.registry().reregister(&mut source, token, interest);
+                        return IOHandle::Py(PyHandleData {
+                            interest,
+                            cbr: Some(data.cbr.as_ref().unwrap().clone_ref(py)),
+                            cbw: None,
+                        });
+                    }
+                    unreachable!()
+                });
+                true
+            }
+        }
     }
 
     fn _tcp_conn(
@@ -1096,7 +1121,7 @@ impl EventLoop {
         let fd = transport.fd;
         let pytransport = Py::new(py, transport)?;
         let proto = TCPTransport::attach(&pytransport, py)?;
-        rself.tcp_transports.insert(fd, pytransport.clone_ref(py));
+        rself.tcp_transports.pin().insert(fd, pytransport.clone_ref(py));
         rself.tcp_stream_add(fd, Interest::READABLE);
         Ok((pytransport, proto))
     }
@@ -1118,20 +1143,20 @@ impl EventLoop {
     }
 
     fn _tcp_stream_bound(&self, fd: usize) -> bool {
-        self.tcp_transports.contains_key(&fd)
+        self.tcp_transports.pin().contains_key(&fd)
     }
 
     fn _sig_add(&self, py: Python, sig: u8, callback: PyObject, args: PyObject, context: PyObject) {
         let handle = Py::new(py, CBHandle::new(callback, args, context)).unwrap();
-        self.sig_handlers.insert(sig, handle);
+        self.sig_handlers.pin().insert(sig, handle);
     }
 
     fn _sig_rem(&self, sig: u8) -> bool {
-        self.sig_handlers.remove(&sig).is_some()
+        self.sig_handlers.pin().remove(&sig).is_some()
     }
 
     fn _sig_clear(&self) {
-        self.sig_handlers.clear();
+        self.sig_handlers.pin().clear();
     }
 
     fn _run(&self, py: Python) -> PyResult<()> {

{rloop-0.1.1 → rloop-0.1.3}/src/tcp.rs

@@ -68,7 +68,7 @@ impl TCPServer {
     pub(crate) fn streams_close(&self, py: Python, event_loop: &EventLoop) {
         let mut transports = Vec::new();
         event_loop.with_tcp_listener_streams(self.fd as usize, |streams| {
-            for stream_fd in streams {
+            for stream_fd in &streams.pin() {
                 transports.push(event_loop.get_tcp_transport(*stream_fd, py));
             }
         });
@@ -80,7 +80,7 @@ impl TCPServer {
     pub(crate) fn streams_abort(&self, py: Python, event_loop: &EventLoop) {
         let mut transports = Vec::new();
         event_loop.with_tcp_listener_streams(self.fd as usize, |streams| {
-            for stream_fd in streams {
+            for stream_fd in &streams.pin() {
                 transports.push(event_loop.get_tcp_transport(*stream_fd, py));
             }
         });
@@ -264,6 +264,7 @@ impl TCPTransport {
         if self.closing.load(atomic::Ordering::Relaxed) {
             _ = self.protom_conn_lost.call1(
                 py,
+                #[allow(clippy::obfuscated_if_else)]
                 (errored
                     .then(|| {
                         pyo3::exceptions::PyRuntimeError::new_err("socket transport failed")