From d308710d4f820e14eea68f95926bf1795a7bc843 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Mon, 16 Jan 2023 23:47:11 +0000 Subject: [PATCH] Use flexible timer types in background processor's regular jobs `background-processor` does a number of jobs on various timers. Currently, those are all done by checking the timers every 100ms by interrogating `std::time::Instant`. This is fine for the threaded version, but we'd like more flexibility in the `futures`- based `background-processor`. Here we swap the `std::time::Instant` interrogation for a lambda which we will switch out to the user-provided sleeper in the next commit. --- lightning-background-processor/src/lib.rs | 39 ++++++++++++----------- 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index ea24ef85e..e93139bf0 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -207,15 +207,15 @@ macro_rules! define_run_body { ($persister: ident, $chain_monitor: ident, $process_chain_monitor_events: expr, $channel_manager: ident, $process_channel_manager_events: expr, $gossip_sync: ident, $peer_manager: ident, $logger: ident, $scorer: ident, - $loop_exit_check: expr, $await: expr) + $loop_exit_check: expr, $await: expr, $get_timer: expr, $timer_elapsed: expr) => { { log_trace!($logger, "Calling ChannelManager's timer_tick_occurred on startup"); $channel_manager.timer_tick_occurred(); - let mut last_freshness_call = Instant::now(); - let mut last_ping_call = Instant::now(); - let mut last_prune_call = Instant::now(); - let mut last_scorer_persist_call = Instant::now(); + let mut last_freshness_call = $get_timer(FRESHNESS_TIMER); + let mut last_ping_call = $get_timer(PING_TIMER); + let mut last_prune_call = $get_timer(FIRST_NETWORK_PRUNE_TIMER); + let mut last_scorer_persist_call = $get_timer(SCORER_PERSIST_TIMER); let mut have_pruned = false; loop { @@ -237,9 +237,9 @@ macro_rules! define_run_body { // We wait up to 100ms, but track how long it takes to detect being put to sleep, // see `await_start`'s use below. - let await_start = Instant::now(); + let mut await_start = $get_timer(1); let updates_available = $await; - let await_time = await_start.elapsed(); + let await_slow = $timer_elapsed(&mut await_start, 1); if updates_available { log_trace!($logger, "Persisting ChannelManager..."); @@ -251,12 +251,12 @@ macro_rules! define_run_body { log_trace!($logger, "Terminating background processor."); break; } - if last_freshness_call.elapsed().as_secs() > FRESHNESS_TIMER { + if $timer_elapsed(&mut last_freshness_call, FRESHNESS_TIMER) { log_trace!($logger, "Calling ChannelManager's timer_tick_occurred"); $channel_manager.timer_tick_occurred(); - last_freshness_call = Instant::now(); + last_freshness_call = $get_timer(FRESHNESS_TIMER); } - if await_time > Duration::from_secs(1) { + if await_slow { // On various platforms, we may be starved of CPU cycles for several reasons. // E.g. on iOS, if we've been in the background, we will be entirely paused. // Similarly, if we're on a desktop platform and the device has been asleep, we @@ -271,18 +271,18 @@ macro_rules! define_run_body { // peers. log_trace!($logger, "100ms sleep took more than a second, disconnecting peers."); $peer_manager.disconnect_all_peers(); - last_ping_call = Instant::now(); - } else if last_ping_call.elapsed().as_secs() > PING_TIMER { + last_ping_call = $get_timer(PING_TIMER); + } else if $timer_elapsed(&mut last_ping_call, PING_TIMER) { log_trace!($logger, "Calling PeerManager's timer_tick_occurred"); $peer_manager.timer_tick_occurred(); - last_ping_call = Instant::now(); + last_ping_call = $get_timer(PING_TIMER); } // Note that we want to run a graph prune once not long after startup before // falling back to our usual hourly prunes. This avoids short-lived clients never // pruning their network graph. We run once 60 seconds after startup before // continuing our normal cadence. - if last_prune_call.elapsed().as_secs() > if have_pruned { NETWORK_PRUNE_TIMER } else { FIRST_NETWORK_PRUNE_TIMER } { + if $timer_elapsed(&mut last_prune_call, if have_pruned { NETWORK_PRUNE_TIMER } else { FIRST_NETWORK_PRUNE_TIMER }) { // The network graph must not be pruned while rapid sync completion is pending if let Some(network_graph) = $gossip_sync.prunable_network_graph() { log_trace!($logger, "Pruning and persisting network graph."); @@ -292,19 +292,19 @@ macro_rules! define_run_body { log_error!($logger, "Error: Failed to persist network graph, check your disk and permissions {}", e) } - last_prune_call = Instant::now(); + last_prune_call = $get_timer(NETWORK_PRUNE_TIMER); have_pruned = true; } } - if last_scorer_persist_call.elapsed().as_secs() > SCORER_PERSIST_TIMER { + if $timer_elapsed(&mut last_scorer_persist_call, SCORER_PERSIST_TIMER) { if let Some(ref scorer) = $scorer { log_trace!($logger, "Persisting scorer"); if let Err(e) = $persister.persist_scorer(&scorer) { log_error!($logger, "Error: Failed to persist scorer, check your disk and permissions {}", e) } } - last_scorer_persist_call = Instant::now(); + last_scorer_persist_call = $get_timer(SCORER_PERSIST_TIMER); } } @@ -411,7 +411,7 @@ where false } } - }) + }, |_| Instant::now(), |time: &Instant, dur| time.elapsed().as_secs() > dur) } impl BackgroundProcessor { @@ -522,7 +522,8 @@ impl BackgroundProcessor { define_run_body!(persister, chain_monitor, chain_monitor.process_pending_events(&event_handler), channel_manager, channel_manager.process_pending_events(&event_handler), gossip_sync, peer_manager, logger, scorer, stop_thread.load(Ordering::Acquire), - channel_manager.await_persistable_update_timeout(Duration::from_millis(100))) + channel_manager.await_persistable_update_timeout(Duration::from_millis(100)), + |_| Instant::now(), |time: &Instant, dur| time.elapsed().as_secs() > dur) }); Self { stop_thread: stop_thread_clone, thread_handle: Some(handle) } } -- 2.39.5