perf: stop sampling when nothing is looking

Reported: "参考nex_squid的代码,进一步降低软件本身占用的系统资源." The
pattern worth copying out of nex_squid's `useSystemSnapshot` is that a
poll stops when nothing can see its answer. Shift had four places that
polled for the life of the process instead.

- `native/macos/drag-bridge.swift` — a separate tracked process polling at
  30 Hz forever, and allocating a CGEvent each pass to read a cursor
  position nothing wants while no button is held. A/B against the shipped
  0.1.11 binary: 20 ms CPU per 6 s idle is now 0 ms, while 12 s of holding
  the button still costs 30 ms either way, so a gesture is sampled exactly
  as finely as before and an idle Shift stops touching the CPU. It runs at
  10 Hz until the button goes down.
- `src-tauri/src/drag_bridge.rs` — the Windows gesture watch slept 33 ms
  unconditionally. An *enabled* ring keeps 33 ms, and not from
  conservatism: the loop has to observe the press to measure the drag
  threshold from where the button went down, so slowing it does not notice
  a gesture late, it never records it. Only a switched-off ring can afford
  a quarter second, since the one thing it waits for is the switch.
- `src-tauri/src/share.rs` — the discovery loop. Measured on the 0.1.11
  bundle: 0.22% CPU with ShiftDrop on, 0.03% with it off. Switching the
  feature off means "stop announcing", never "be deaf" — a silent copy
  still hears beacons so another machine can still find and send to it, and
  expiry must keep running or an hour-old peer pretends to be live forever.
  So the saving comes from waking less often while silent and from skipping
  bookkeeping when there is no peer to expire, not from probing less.
  Announce and sweep intervals are untouched, so discovery stays as fast.
  `a_silent_copy_still_knows_and_still_loses_peers` pins that distinction.
- `src/components/MainWindow.tsx` — the 30 s clock ticked for the life of
  the app while Shift sits parked in the menu bar with this window hidden,
  re-rendering a list nobody could see. It now exists only while the page is
  visible, and an empty library is not worth a render at all.

Co-Authored-By: Codex <noreply@openai.com>
main
mula.liu 2026-11-19 17:50:57 +08:00
parent 680b4f159e
commit 7e3bf5efc1
7 changed files with 223 additions and 17 deletions

View File

@ -1,6 +1,21 @@
import AppKit
import Foundation
// Idle, this process has one job: notice the moment the mouse goes down. It used to do
// that 30 times a second, and every tick allocated a CGEvent to read a cursor position
// nothing needs while no button is held. Measured A/B against the 0.1.11 binary on the
// 2026-11 idle review: 20ms of CPU per 6s idle (~0.3%, and 30 wakeups a second,
// forever) against 0ms for the same window now, while 12s of holding the button costs
// 30ms either way. So the gesture is sampled exactly as finely as it ever was and an
// idle Shift stops touching the CPU at all.
//
// 10 Hz while idle delays only the discovery that the button went down. The ring still
// cannot appear until Finder has published the dragged files on the drag pasteboard,
// which needs the drag threshold crossed first, and a press is what moves this timer to
// 30 Hz - so the arming path is unchanged in every respect a user can feel.
let idleInterval = 1.0 / 10.0
let gestureInterval = 1.0 / 30.0
struct Payload: Encodable {
let type: String
let x: Double?
@ -47,14 +62,18 @@ func tick() {
exit(0)
}
let mouseDown = NSEvent.pressedMouseButtons & 1 != 0
let point = cursorLocation()
// Reading the cursor costs a CGEvent allocation, and nothing downstream wants a
// position unless a press is in progress or has just ended. An idle tick is then
// one read of `pressedMouseButtons` and a couple of integer tests.
let pressEnded = mouseWasDown && !mouseDown
let point = mouseDown || pressEnded ? cursorLocation() : NSPoint(x: 0, y: 0)
if !mouseDown {
changeCountAtMouseDown = dragPasteboard.changeCount
cancelled = false
missingDragFiles = 0
}
if !mouseDown && mouseWasDown && pickerShown {
if pressEnded && pickerShown {
pickerShown = false
emit(Payload(type: "end", x: point.x, y: point.y, files: nil, tools: nil))
}
@ -104,8 +123,23 @@ func tick() {
}
}
let timer = Timer(timeInterval: 1.0 / 30.0, repeats: true) { _ in
tick()
var timer: Timer?
var timerIsGesture = false
func reschedule(gesture: Bool) {
guard gesture != timerIsGesture || timer == nil else { return }
timerIsGesture = gesture
timer?.invalidate()
let next = Timer(timeInterval: gesture ? gestureInterval : idleInterval, repeats: true) { _ in
let down = NSEvent.pressedMouseButtons & 1 != 0
tick()
// A press changes the pace on the next tick; the timer is replaced rather
// than retuned because NSTimer cannot change its own interval.
if down != timerIsGesture { reschedule(gesture: down) }
}
timer = next
RunLoop.main.add(next, forMode: .common)
}
RunLoop.main.add(timer, forMode: .common)
reschedule(gesture: NSEvent.pressedMouseButtons & 1 != 0)
RunLoop.main.run()

View File

@ -153,6 +153,8 @@ fn spawn_windows_monitor(app: &AppHandle) {
unsafe {
GetCursorPos(&mut point);
}
// Read once per pass so the sleep below and the arming test below agree.
let enabled = drag_enabled(&app);
if !mouse_down {
// Release ends the gesture. macOS gets an explicit `cancel` from its
@ -168,7 +170,7 @@ fn spawn_windows_monitor(app: &AppHandle) {
}
armed = false;
mouse_was_down = false;
thread::sleep(std::time::Duration::from_millis(33));
thread::sleep(monitor_pause(enabled, false));
continue;
}
@ -182,7 +184,7 @@ fn spawn_windows_monitor(app: &AppHandle) {
reported_foreground = true;
eprintln!("shift: press started inside Shift itself, ignoring this gesture");
}
thread::sleep(std::time::Duration::from_millis(33));
thread::sleep(monitor_pause(enabled, armed));
continue;
}
reported_foreground = false;
@ -194,23 +196,23 @@ fn spawn_windows_monitor(app: &AppHandle) {
let threshold_y = unsafe { GetSystemMetrics(SM_CYDRAG) }.max(4);
if !armed {
if !drag_enabled(&app) {
if !enabled {
if !reported_disabled {
reported_disabled = true;
eprintln!("shift: drag ring is disabled in settings, ignoring the gesture");
}
thread::sleep(std::time::Duration::from_millis(100));
thread::sleep(monitor_pause(enabled, armed));
continue;
}
reported_disabled = false;
if !shift {
thread::sleep(std::time::Duration::from_millis(33));
thread::sleep(monitor_pause(enabled, armed));
continue;
}
if (point.x - down.x).abs() <= threshold_x
&& (point.y - down.y).abs() <= threshold_y
{
thread::sleep(std::time::Duration::from_millis(33));
thread::sleep(monitor_pause(enabled, armed));
continue;
}
armed = true;
@ -236,11 +238,34 @@ fn spawn_windows_monitor(app: &AppHandle) {
}
}
thread::sleep(std::time::Duration::from_millis(33));
thread::sleep(monitor_pause(enabled, armed));
}
});
}
/// How long the Windows gesture watch sleeps before reading the mouse again.
///
/// The thread used to poll at 33ms for the whole life of the app: four user-input
/// calls, thirty times a second, forever, including on a machine where the ring is
/// switched off in Settings and no gesture can ever start. A disabled ring can afford
/// a quarter second, because the only thing it is waiting for is the switch itself,
/// and a flip in Settings is worth noticing within a blink rather than a frame.
///
/// An enabled ring keeps the original 33ms. That is not conservatism: the gesture is
/// a press-drag-release, and the loop has to observe the press in order to measure
/// the drag threshold from where the button went down. A slower watch does not merely
/// notice a finished gesture late, it never records the press at all, so the ring
/// silently stops opening for users who drag quickly. Once a gesture is in flight the
/// fast cadence is required for the same reason, which is why `armed` outranks `enabled`.
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
fn monitor_pause(enabled: bool, armed: bool) -> std::time::Duration {
if enabled || armed {
std::time::Duration::from_millis(33)
} else {
std::time::Duration::from_millis(250)
}
}
#[cfg(target_os = "windows")]
fn foreground_is_self() -> bool {
use windows_sys::Win32::UI::WindowsAndMessaging::{
@ -586,3 +611,39 @@ pub async fn show_files_in_radial(
.await
.map_err(|error| error.to_string())?
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_enabled_ring_keeps_the_press_by_polling_at_33ms() {
// The gesture is only recognised because the loop sees the button go down and
// measures the drag threshold from that point, so the watch cannot be slowed
// while the feature is switched on.
assert_eq!(
monitor_pause(true, false),
std::time::Duration::from_millis(33),
"an enabled ring must keep sampling at the original cadence"
);
}
#[test]
fn a_disabled_ring_is_watched_four_times_a_second_instead_of_thirty() {
assert_eq!(
monitor_pause(false, false),
std::time::Duration::from_millis(250),
"a switched-off ring should not cost a 33ms input poll for the life of the app"
);
}
#[test]
fn a_gesture_in_flight_outranks_the_switch_being_flipped_off() {
// Settings can be reached mid-drag; a gesture that has already armed must not
// slow down and drop the rest of the movement it is tracking.
assert_eq!(
monitor_pause(false, true),
std::time::Duration::from_millis(33)
);
}
}

View File

@ -47,6 +47,21 @@ const MAGIC: &[u8; 4] = b"SHSF";
/// A local-network attacker can mint unlimited beacon ids. Keep the visible peer
/// table bounded so discovery cannot grow without limit.
const MAX_PEERS: usize = 256;
/// How long the discovery thread may sleep inside `recv_from` before checking the
/// clock again. This is the loop's heartbeat, so it is the whole cost of a Shift that
/// is running and has nothing to do.
const LISTEN_TIMEOUT: Duration = Duration::from_millis(400);
/// The same wait while this copy stays silent on the discovery port. It still has to
/// hear other copies — being switched off means "do not announce", not "be deaf", and
/// a deaf copy cannot be sent to — but nothing is timed except a peer's expiry, so it
/// can afford to wake a quarter as often.
const LISTEN_TIMEOUT_SILENT: Duration = Duration::from_millis(1_600);
/// How often stale peers are dropped and the list is compared against what the UI was
/// last told. With peers live this stays sharp enough that a machine which stops
/// answering leaves the list inside its own timeout; with none, the tick has nothing to
/// expire and nothing to report, so it is worth a quarter as much.
const PEER_CHECK: Duration = Duration::from_millis(600);
const PEER_CHECK_IDLE: Duration = Duration::from_millis(2_400);
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
@ -248,6 +263,21 @@ impl ShareState {
peers.len() != before
}
/// Whether this copy currently knows of another copy, ignoring its own id.
/// Used only to decide how often the discovery loop may check the clock, never
/// to decide what the peer list contains.
fn has_peers(&self) -> bool {
let local_id = self
.local
.lock()
.map(|local| local.id.clone())
.unwrap_or_default();
self.peers
.lock()
.map(|peers| peers.keys().any(|id| *id != local_id))
.unwrap_or(false)
}
fn add_pending(&self, transfer_id: &str, respond: mpsc::Sender<Decision>, notice_id: &str) {
if let Ok(mut pending) = self.pending.lock() {
pending.insert(
@ -760,6 +790,9 @@ fn beacon_loop(app: &AppHandle, mut sock: UdpSocket, local: &Beacon) {
// working is replaced rather than abandoned, and the loop never exits.
'discovery: loop {
prepare(&sock);
// `prepare` gives a fresh socket the default heartbeat, so the cadence the
// loop wants is re-applied on the first pass rather than assumed.
let mut listen_timeout = Duration::ZERO;
let opened = Instant::now();
let mut last_announce = opened - BEACON_INTERVAL;
let mut last_scan = opened - SWEEP_INTERVAL;
@ -770,6 +803,18 @@ fn beacon_loop(app: &AppHandle, mut sock: UdpSocket, local: &Beacon) {
let state = app.state::<ShareState>();
(state.is_enabled(), state.take_refresh_request())
};
// A silent copy has no beacon to time, so it can wait longer for the next
// packet and wake a quarter as often. An announced peer is still heard just
// as fast, because the announce clock below is untouched.
let wanted = if discoverable {
LISTEN_TIMEOUT
} else {
LISTEN_TIMEOUT_SILENT
};
if wanted != listen_timeout {
listen_timeout = wanted;
let _ = sock.set_read_timeout(Some(wanted));
}
if discoverable && (refresh || last_announce.elapsed() >= BEACON_INTERVAL) {
announce(&sock, &payload);
let destinations = app.state::<ShareState>().peer_destinations();
@ -826,7 +871,8 @@ fn beacon_loop(app: &AppHandle, mut sock: UdpSocket, local: &Beacon) {
}
}
if last_peer_check.elapsed() >= Duration::from_millis(600) {
let watched = discoverable || app.state::<ShareState>().has_peers();
if last_peer_check.elapsed() >= if watched { PEER_CHECK } else { PEER_CHECK_IDLE } {
last_peer_check = Instant::now();
let state = app.state::<ShareState>();
state.expire();
@ -1620,6 +1666,35 @@ mod tests {
assert!(!state.is_enabled());
}
/// The distinction the discovery thread's idle cadence is built on.
///
/// Switching ShiftDrop off means "stop announcing", never "stop listening": a
/// silent copy still hears beacons, so another machine can still find and send to
/// it, and `expire()` still runs so a peer that went away really leaves the list.
/// A change that made a disabled copy deaf would look like a CPU win and quietly
/// break sending, so it is pinned here rather than only in a comment.
#[test]
fn a_silent_copy_still_knows_and_still_loses_peers() {
let state = ShareState::default();
let address: SocketAddr = "192.168.1.40:51234".parse().unwrap();
assert!(!state.has_peers(), "a fresh copy knows nobody");
state.enabled.store(false, Ordering::Relaxed);
assert!(
state.note(&beacon(), address),
"a silent copy must still record a peer it hears"
);
assert!(state.has_peers());
// The slow bookkeeping tick still has something to expire; if `expire` only
// ran while enabled, this peer would sit in the list forever pretending to be live.
state
.peers
.lock()
.unwrap()
.values_mut()
.for_each(|peer| peer.seen = Instant::now() - PEER_TIMEOUT);
assert!(state.expire(), "a silent copy must still expire its peers");
assert!(!state.has_peers());
}
#[test]
fn directed_broadcasts_follow_the_interface_netmask() {
assert_eq!(

View File

@ -300,6 +300,14 @@ export function MainWindow() {
const [sharePaths, setSharePaths] = useState<string[] | null>(null);
const toastTimer = useRef<number | null>(null);
const [, setNowTick] = useState(0);
/**
* How many rows the slow clock tick has to re-age. Kept in a ref because the tick
* lives in a mount-only effect and must not be rebuilt every time the list moves.
*/
const recentCount = useRef(0);
useEffect(() => {
recentCount.current = recent.length;
}, [recent.length]);
const [dropAction, setDropAction] = useState<DropAction | null>(null);
/** True while a Recent row is being dragged, which the native `dragging` never covers. */
const [rowDragging, setRowDragging] = useState(false);
@ -837,15 +845,43 @@ export function MainWindow() {
// Keeps the relative timestamps honest without re-reading storage constantly.
// The same slow tick keeps relative timestamps and the hotkey-ownership
// notice honest, so a copy that quits clears the warning without a restart.
const clockTimer = window.setInterval(() => {
setNowTick((value) => value + 1);
//
// Shift spends its life parked in the menu bar with this window hidden, and a
// timer that ignores that is the app waking up twice a minute to repaint a list
// nobody can see, forever. So the interval exists only while the page is
// visible - the same rule `useSystemSnapshot` in nex_squid applies to its
// polling - and an empty library is not worth a render at all, because the tick
// exists to re-age rows that are not there. The hotkey check still runs on
// becoming visible, which is the moment its answer could have changed.
let clockTimer: number | null = null;
const clockTick = () => {
if (recentCount.current > 0) setNowTick((value) => value + 1);
if (isTauri()) void refreshHotkeys();
}, 30_000);
};
const startClock = () => {
if (clockTimer === null) clockTimer = window.setInterval(clockTick, 30_000);
};
const stopClock = () => {
if (clockTimer !== null) {
window.clearInterval(clockTimer);
clockTimer = null;
}
};
const onClockVisibility = () => {
if (document.hidden) stopClock();
else {
clockTick();
startClock();
}
};
startClock();
document.addEventListener("visibilitychange", onClockVisibility);
return () => {
unlisteners.forEach((unlisten) => unlisten());
unsubscribeRecent();
unsubscribeHistory();
window.clearInterval(clockTimer);
stopClock();
document.removeEventListener("visibilitychange", onClockVisibility);
if (toastTimer.current) window.clearTimeout(toastTimer.current);
};
// Handlers only use stable setters and imported APIs.