use thread_select on macos only

- thread_select on linux performances very badly (input lagging)
- async_fd works very well on linux, but there are too many
  "EXC_BAD_ACCESS (code=1, address=0x0)" on macOS. Also no input
   lagging like linux

Author: declantsien

src/wr/src/event_loop.rs

@@ -1,4 +1,4 @@
-use std::{cell::RefCell, os::unix::prelude::AsRawFd, ptr, sync::Mutex, time::Instant};
+use std::{cell::RefCell, ptr, sync::Mutex, time::Instant};
 
 #[cfg(target_os = "macos")]
 use copypasta::osx_clipboard::OSXClipboardContext;
@@ -11,10 +11,9 @@ use copypasta::{
     x11_clipboard::{Clipboard, X11ClipboardContext},
 };
 
-use futures::future::FutureExt;
 use libc::{c_void, fd_set, pselect, sigset_t, timespec};
 use once_cell::sync::Lazy;
-use tokio::{io::unix::AsyncFd, io::Interest, runtime::Runtime, time::Duration};
+use tokio::{runtime::Runtime, time::Duration};
 #[cfg(all(feature = "wayland", not(any(target_os = "macos", windows))))]
 use winit::platform::unix::EventLoopWindowTargetExtUnix;
 use winit::{
@@ -26,14 +25,14 @@ use winit::{
     window::WindowId,
 };
 
-use crate::future::batch_select;
-
 use surfman::Connection;
 use surfman::SurfaceType;
 use webrender_surfman::WebrenderSurfman;
 
 use lisp_types::bindings::{inhibit_window_system, thread_select};
 
+use crate::select::tokio_select_fds;
+
 pub type GUIEvent = Event<'static, i32>;
 
 #[allow(dead_code)]
@@ -177,7 +176,7 @@ pub static TOKIO_RUNTIME: Lazy<Mutex<Runtime>> =
 
 pub static EVENT_BUFFER: Lazy<Mutex<Vec<GUIEvent>>> = Lazy::new(|| Mutex::new(Vec::new()));
 
-struct FdSet(*mut fd_set);
+pub struct FdSet(pub *mut fd_set);
 
 unsafe impl Send for FdSet {}
 unsafe impl Sync for FdSet {}
@@ -190,7 +189,7 @@ impl FdSet {
     }
 }
 
-struct Timespec(*mut timespec);
+pub struct Timespec(pub *mut timespec);
 
 unsafe impl Send for Timespec {}
 unsafe impl Sync for Timespec {}
@@ -293,87 +292,9 @@ pub extern "C" fn wr_select(
         };
     });
 
-    return nfds_result.into_inner();
-}
-
-fn fd_set_to_async_fds(nfds: i32, fds: &FdSet, interest: Interest) -> Vec<AsyncFd<i32>> {
-    if fds.0 == ptr::null_mut() {
-        return Vec::new();
-    }
-
-    let mut async_fds = Vec::new();
-
-    for fd in 0..nfds {
-        unsafe {
-            if libc::FD_ISSET(fd, fds.0) {
-                let async_fd_result = AsyncFd::with_interest(fd, interest);
-                if async_fd_result.is_err() {
-                    println!("AsyncFd err: {:?}", async_fd_result.unwrap_err());
-                    continue;
-                }
-
-                async_fds.push(async_fd_result.unwrap())
-            }
-        }
-    }
-
-    async_fds
-}
-
-fn async_fds_to_fd_set(fds: Vec<i32>, fd_set: &FdSet) {
-    if fd_set.0 == ptr::null_mut() {
-        return;
-    }
-
-    unsafe { libc::FD_ZERO(fd_set.0) }
-
-    for f in fds {
-        unsafe { libc::FD_SET(f, fd_set.0) }
-    }
-}
-
-async fn tokio_select_fds(
-    nfds: i32,
-    readfds: &FdSet,
-    writefds: &FdSet,
-    _timeout: &Timespec,
-) -> i32 {
-    let read_fds = fd_set_to_async_fds(nfds, readfds, Interest::READABLE);
-    let write_fds = fd_set_to_async_fds(nfds, writefds, Interest::WRITABLE);
-
-    let mut fd_futures = Vec::new();
-
-    for f in read_fds.iter() {
-        fd_futures.push(f.readable().boxed())
-    }
-
-    for f in write_fds.iter() {
-        fd_futures.push(f.writable().boxed())
-    }
-
-    let read_fds_count = read_fds.len();
-
-    let readliness = batch_select(fd_futures).await;
-
-    let mut readable_result = Vec::new();
-    let mut writable_result = Vec::new();
-
-    for (result, index) in readliness {
-        if result.is_err() {
-            continue;
-        }
-
-        if index < read_fds_count {
-            readable_result.push(read_fds[index].as_raw_fd())
-        } else {
-            writable_result.push(write_fds[index - read_fds_count].as_raw_fd())
-        }
-    }
-
-    let nfds = readable_result.len() + writable_result.len();
-
-    async_fds_to_fd_set(readable_result, readfds);
-    async_fds_to_fd_set(writable_result, writefds);
+    // stop tokio select
+    #[cfg(target_os = "macos")]
+    let _ = select_stop_sender.send(());
 
-    nfds as i32
+    return nfds_result.into_inner();
 }

src/wr/src/future.rs

@@ -22,12 +22,23 @@ mod event;
 mod event_loop;
 mod font_db;
 mod fringe;
-mod future;
 mod image;
 mod texture;
 mod util;
 mod wrterm;
 
+pub mod select {
+    #[cfg(not(target_os = "macos"))]
+    pub use crate::select::future::tokio_select_fds;
+    #[cfg(target_os = "macos")]
+    pub use crate::select::thread::tokio_select_fds;
+
+    #[cfg(not(target_os = "macos"))]
+    pub mod future;
+    #[cfg(target_os = "macos")]
+    pub mod thread;
+}
+
 mod platform {
     #[cfg(target_os = "macos")]
     pub mod macos {

src/wr/src/lib.rs

@@ -0,0 +1,4 @@
+- thread_select on linux performances very badly (input lagging)
+- async_fd works very well on linux, but there are too many
+  "EXC_BAD_ACCESS (code=1, address=0x0)" on macOS. Also no input
+   lagging like linux

src/wr/src/select/README

@@ -0,0 +1,133 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use std::{os::unix::prelude::AsRawFd, ptr};
+
+use futures::FutureExt;
+use tokio::io::{unix::AsyncFd, Interest};
+
+use crate::event_loop::{FdSet, Timespec};
+
+pub struct SelectBatch<Fut> {
+    inner: Vec<Fut>,
+}
+
+impl<Fut: Unpin> Unpin for SelectBatch<Fut> {}
+
+fn batch_select<I>(iter: I) -> SelectBatch<I::Item>
+where
+    I: IntoIterator,
+    I::Item: Future + Unpin,
+{
+    let ret = SelectBatch {
+        inner: iter.into_iter().collect(),
+    };
+    ret
+}
+
+impl<Fut: Future + Unpin> Future for SelectBatch<Fut> {
+    type Output = Vec<(Fut::Output, usize)>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let items = self
+            .inner
+            .iter_mut()
+            .enumerate()
+            .filter_map(|(i, f)| match f.poll_unpin(cx) {
+                Poll::Pending => None,
+                Poll::Ready(e) => Some((e, i)),
+            })
+            .collect::<Vec<_>>();
+
+        if items.is_empty() {
+            return Poll::Pending;
+        }
+
+        Poll::Ready(items)
+    }
+}
+
+fn fd_set_to_async_fds(nfds: i32, fds: &FdSet, interest: Interest) -> Vec<AsyncFd<i32>> {
+    if fds.0 == ptr::null_mut() {
+        return Vec::new();
+    }
+
+    let mut async_fds = Vec::new();
+
+    for fd in 0..nfds {
+        unsafe {
+            if libc::FD_ISSET(fd, fds.0) {
+                let async_fd_result = AsyncFd::with_interest(fd, interest);
+                if async_fd_result.is_err() {
+                    println!("AsyncFd err: {:?}", async_fd_result.unwrap_err());
+                    continue;
+                }
+
+                async_fds.push(async_fd_result.unwrap())
+            }
+        }
+    }
+
+    async_fds
+}
+
+fn async_fds_to_fd_set(fds: Vec<i32>, fd_set: &FdSet) {
+    if fd_set.0 == ptr::null_mut() {
+        return;
+    }
+
+    unsafe { libc::FD_ZERO(fd_set.0) }
+
+    for f in fds {
+        unsafe { libc::FD_SET(f, fd_set.0) }
+    }
+}
+
+pub async fn tokio_select_fds(
+    nfds: i32,
+    readfds: &FdSet,
+    writefds: &FdSet,
+    _timeout: &Timespec,
+) -> i32 {
+    let read_fds = fd_set_to_async_fds(nfds, readfds, Interest::READABLE);
+    let write_fds = fd_set_to_async_fds(nfds, writefds, Interest::WRITABLE);
+
+    let mut fd_futures = Vec::new();
+
+    for f in read_fds.iter() {
+        fd_futures.push(f.readable().boxed())
+    }
+
+    for f in write_fds.iter() {
+        fd_futures.push(f.writable().boxed())
+    }
+
+    let read_fds_count = read_fds.len();
+
+    let readliness = batch_select(fd_futures).await;
+
+    let mut readable_result = Vec::new();
+    let mut writable_result = Vec::new();
+
+    for (result, index) in readliness {
+        if result.is_err() {
+            continue;
+        }
+
+        if index < read_fds_count {
+            readable_result.push(read_fds[index].as_raw_fd())
+        } else {
+            writable_result.push(write_fds[index - read_fds_count].as_raw_fd())
+        }
+    }
+
+    let nfds = readable_result.len() + writable_result.len();
+
+    async_fds_to_fd_set(readable_result, readfds);
+    async_fds_to_fd_set(writable_result, writefds);
+
+    nfds as i32
+}

src/wr/src/select/future.rs

@@ -0,0 +1,38 @@
+use std::ptr;
+
+use futures::Future;
+use libc::pselect;
+use lisp_types::bindings::thread_select;
+
+use crate::event_loop::{FdSet, Timespec};
+
+async fn async_thread_select(
+    nfds: i32,
+    readfds: &FdSet,
+    writefds: &FdSet,
+    timeout: &Timespec,
+) -> i32 {
+    unsafe {
+        thread_select(
+            Some(pselect),
+            nfds,
+            readfds.0,
+            writefds.0,
+            ptr::null_mut(),
+            timeout.0,
+            ptr::null_mut(),
+        )
+    }
+}
+
+pub fn tokio_select_fds<'a>(
+    nfds: i32,
+    readfds: &'a FdSet,
+    writefds: &'a FdSet,
+    timeout: &'a Timespec,
+) -> impl Future<Output = i32> + 'a {
+    async move {
+        let nfds: i32 = async_thread_select(nfds, readfds, writefds, timeout).await;
+        nfds
+    }
+}