mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
input: park the pointer worker until pointer or gesture work exists (#172)
* input: park the pointer worker until pointer or gesture work exists A fixed 4 ms tick kept ~250 wakeups/s (clock_gettime storms, worker steal spins, pow-heavy flush math) burning ~3% CPU on an idle host with no viewer connected. The worker now parks on a Notify permit until a pointer/scroll/button event or a live touch gesture needs the 4 ms cadence; notify_one permit semantics make the park check race-free. Sub-notch scroll residue cannot inject alone, so it parks too. * fix(input): preserve pointer wake ordering and motion cadence Hold the serial lock before notifying button transitions so a parked worker cannot miss a newly pending gesture. Keep the 4 ms coalescing cadence until an empty tick and reset the interval after each parked phase. Add regression coverage for button wake ordering, 1 ms motion streams, and idle cadence reset using Tokio test-only clock control. --------- Co-authored-by: ferstar <[email protected]>
This commit is contained in:
1 parent
7b8980771d
commit
b9586f226d
2 files changed
+124
-4
No files matched your search
@@ -63,6 +63,7 @@ ab_glyph = { version = "0.2", optional = true }
|
||||
png = { version = "0.18", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { version = "1", features = ["test-util"] }
|
||||
# Synthetic loopback WSS certificates only; both crates already occur in Cargo.lock.
|
||||
rcgen = "0.11.3"
|
||||
tokio-rustls = { version = "0.26.6", default-features = false, features = ["ring", "tls12"] }
|
||||
|
||||
+123
-4
@@ -99,7 +99,7 @@ impl Controller {
|
||||
#[derive(Default)]
|
||||
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
|
||||
|
||||
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, uinput_pointer: bool, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput>, touch: std::sync::Mutex<TouchDrag> }
|
||||
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, uinput_pointer: bool, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput>, touch: std::sync::Mutex<TouchDrag>, pointer_wake: tokio::sync::Notify }
|
||||
|
||||
fn active_output_count(json: &[u8]) -> Option<usize> {
|
||||
let data: serde_json::Value = serde_json::from_slice(json).ok()?;
|
||||
@@ -135,7 +135,7 @@ impl InputInjector {
|
||||
|| (backend == crate::desktop_backend::DesktopBackend::Portal && single_portal_output()));
|
||||
if uinput_pointer { log::info!("Input pointer backend: uinput (motion, buttons and wheel)"); }
|
||||
else if backend == crate::desktop_backend::DesktopBackend::Portal { log::info!("Input pointer backend: portal (monitor-local coordinates)"); }
|
||||
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, uinput_pointer, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()) }
|
||||
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, uinput_pointer, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
|
||||
}
|
||||
|
||||
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
|
||||
@@ -153,6 +153,7 @@ impl InputInjector {
|
||||
let mut pending = self.pending.lock().unwrap();
|
||||
pending.absolute = Some(position);
|
||||
pending.relative = (0,0);
|
||||
self.pointer_wake.notify_one();
|
||||
}
|
||||
}
|
||||
pub fn mouse_relative(&self, dx: i32, dy: i32) {
|
||||
@@ -160,6 +161,7 @@ impl InputInjector {
|
||||
let mut pending = self.pending.lock().unwrap();
|
||||
pending.relative.0 = (pending.relative.0 + i64::from(dx)).clamp(-65535,65535);
|
||||
pending.relative.1 = (pending.relative.1 + i64::from(dy)).clamp(-65535,65535);
|
||||
self.pointer_wake.notify_one();
|
||||
}
|
||||
}
|
||||
pub fn mouse_scroll(&self, dx: i32, dy: i32) {
|
||||
@@ -167,15 +169,38 @@ impl InputInjector {
|
||||
let mut pending = self.pending.lock().unwrap();
|
||||
pending.scroll.0 = (pending.scroll.0 + i64::from(dx)).clamp(-12000,12000);
|
||||
pending.scroll.1 = (pending.scroll.1 + i64::from(dy)).clamp(-12000,12000);
|
||||
self.pointer_wake.notify_one();
|
||||
}
|
||||
pub fn start_pointer_worker(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> {
|
||||
let input = self.clone();
|
||||
tokio::spawn(async move {
|
||||
// Parked until pointer work exists: a fixed 4 ms tick burned ~250 wakeups/s
|
||||
// (≈3% CPU with pow-heavy flush math) even with no viewer connected.
|
||||
// notify_one() stores a permit, so an event racing the park check cannot be lost.
|
||||
let mut tick = tokio::time::interval(std::time::Duration::from_millis(4));
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
loop { tick.tick().await; input.flush_pointer(); }
|
||||
loop {
|
||||
input.pointer_wake.notified().await;
|
||||
// The first event is immediate; later events coalesce until the next tick.
|
||||
tick.reset();
|
||||
loop {
|
||||
input.flush_pointer();
|
||||
tick.tick().await;
|
||||
if input.pointer_idle() { break; }
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
/// Whether the worker may park: nothing accumulated, no full scroll notch waiting and no
|
||||
/// touch gesture in flight (`Pending` needs ticks until its hold resolves, `Scroll`/`Select`
|
||||
/// and `down` until release). Sub-notch scroll residue cannot inject alone, so it parks.
|
||||
fn pointer_idle(&self) -> bool {
|
||||
let pending = self.pending.lock().unwrap();
|
||||
let touch = self.touch.lock().unwrap();
|
||||
pending.absolute.is_none() && pending.relative == (0,0)
|
||||
&& pending.scroll.0 / 120 == 0 && pending.scroll.1 / 120 == 0
|
||||
&& !touch.down && touch.finger == Finger::Up
|
||||
}
|
||||
pub fn discard_pointer(&self) { *self.pending.lock().unwrap() = PendingPointer::default(); }
|
||||
pub fn flush_pointer(&self) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
@@ -229,6 +254,8 @@ impl InputInjector {
|
||||
}
|
||||
pub fn mouse_button(&self, button: i32, is_press: bool) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
// The worker cannot consume the wake and flush until this transition is published.
|
||||
self.pointer_wake.notify_one();
|
||||
self.flush_pointer_locked();
|
||||
if button == 1 && self.touch_button(is_press) { return; }
|
||||
let result = self.inject_button(button,is_press);
|
||||
@@ -841,6 +868,98 @@ mod motion_tests {
|
||||
input.mouse_relative(1,2); input.discard_pointer();
|
||||
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
|
||||
}
|
||||
#[test]
|
||||
fn parks_when_pointer_state_is_idle() {
|
||||
let input = InputInjector::new();
|
||||
assert!(input.pointer_idle());
|
||||
input.mouse_relative(5,5);
|
||||
assert!(!input.pointer_idle());
|
||||
input.flush_pointer();
|
||||
assert!(input.pointer_idle());
|
||||
input.mouse_scroll(0,125); input.flush_pointer();
|
||||
assert!(input.pointer_idle(), "sub-notch scroll residue cannot inject alone");
|
||||
}
|
||||
#[test]
|
||||
fn live_touch_gesture_stays_busy_until_it_resolves() {
|
||||
let input = InputInjector::new();
|
||||
input.touch.lock().unwrap().finger = Finger::Pending { start: (5,5), at: std::time::Instant::now() };
|
||||
assert!(!input.pointer_idle());
|
||||
input.touch.lock().unwrap().finger = Finger::Scroll { last: (9,9) };
|
||||
assert!(!input.pointer_idle());
|
||||
*input.touch.lock().unwrap() = TouchDrag::default();
|
||||
assert!(input.pointer_idle());
|
||||
}
|
||||
#[test]
|
||||
fn button_wake_waits_for_the_serialized_transition() {
|
||||
use futures_util::FutureExt;
|
||||
let input = std::sync::Arc::new(InputInjector::without_desktop());
|
||||
let serial = input.serial.lock().unwrap();
|
||||
let ready = std::sync::Arc::new(std::sync::Barrier::new(2));
|
||||
let pressing = input.clone();
|
||||
let started = ready.clone();
|
||||
let button = std::thread::spawn(move || { started.wait(); pressing.mouse_button(1,true); });
|
||||
ready.wait();
|
||||
let runtime = tokio::runtime::Builder::new_current_thread().enable_time().build().unwrap();
|
||||
let premature = runtime.block_on(async {
|
||||
tokio::time::timeout(std::time::Duration::from_millis(50), input.pointer_wake.notified()).await.is_ok()
|
||||
});
|
||||
drop(serial);
|
||||
button.join().unwrap();
|
||||
assert!(!premature, "a parked worker must not wake before the button owns the serial lock");
|
||||
assert!(input.pointer_wake.notified().now_or_never().is_some());
|
||||
}
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn worker_coalesces_one_ms_motion_on_four_ms_ticks() {
|
||||
let input = std::sync::Arc::new(InputInjector::without_desktop());
|
||||
let worker = input.start_pointer_worker();
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1, "first motion is immediate");
|
||||
for ms in 1..=12 {
|
||||
tokio::time::advance(std::time::Duration::from_millis(1)).await;
|
||||
tokio::task::yield_now().await;
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1+ms/4, "motion at {ms} ms bypassed the cadence");
|
||||
}
|
||||
tokio::time::advance(std::time::Duration::from_millis(4)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],5);
|
||||
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
|
||||
worker.abort();
|
||||
assert!(worker.await.unwrap_err().is_cancelled());
|
||||
}
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn worker_parks_and_resets_the_tick_after_a_quiet_period() {
|
||||
let input = std::sync::Arc::new(InputInjector::without_desktop());
|
||||
let worker = input.start_pointer_worker();
|
||||
tokio::task::yield_now().await;
|
||||
// Without a notification, raw queued state must remain untouched while parked.
|
||||
input.pending.lock().unwrap().relative = (1,0);
|
||||
tokio::time::advance(std::time::Duration::from_secs(1)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],0);
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1);
|
||||
tokio::time::advance(std::time::Duration::from_millis(4)).await;
|
||||
tokio::task::yield_now().await;
|
||||
input.pending.lock().unwrap().relative = (1,0);
|
||||
tokio::time::advance(std::time::Duration::from_millis(997)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1, "idle ticks must stop after activity");
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],2);
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],2, "a stale interval must not flush a second time immediately");
|
||||
tokio::time::advance(std::time::Duration::from_millis(4)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],3);
|
||||
worker.abort();
|
||||
assert!(worker.await.unwrap_err().is_cancelled());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(test, target_os = "linux"))]
|
||||
@@ -1088,7 +1207,7 @@ impl InputInjector {
|
||||
portal_outcomes:std::array::from_fn(|_|std::sync::atomic::AtomicUsize::new(0)),
|
||||
portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::DesktopBackend::Portal,
|
||||
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()),
|
||||
touch:std::sync::Mutex::new(TouchDrag::default()) }
|
||||
touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user