From b321fc8ddd8e9257e9efaca620cb4b7b7733bd2a Mon Sep 17 00:00:00 2001 From: Willem Vanhulle Date: Wed, 21 Oct 2026 11:34:25 +0200 Subject: [PATCH] refactor: build the waiting graph once with petgraph --- Cargo.lock | 39 ++++++++++++++++++++-- Cargo.toml | 1 + src/boot_model.rs | 85 ++++++++++++++++++++++++----------------------- 3 files changed, 80 insertions(+), 45 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 39f41f8..5e3712f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -151,6 +151,7 @@ dependencies = [ "dbus", "heck", "jiff", + "petgraph", "ratatui", "rustix 1.1.5", "ser_nix", @@ -560,12 +561,24 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + [[package]] name = "fnv" version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + [[package]] name = "foldhash" version = "0.2.0" @@ -629,6 +642,15 @@ dependencies = [ "r-efi 6.0.0", ] +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + [[package]] name = "hashbrown" version = "0.16.1" @@ -637,7 +659,7 @@ checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" dependencies = [ "allocator-api2", "equivalent", - "foldhash", + "foldhash 0.2.0", ] [[package]] @@ -648,7 +670,7 @@ checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" dependencies = [ "allocator-api2", "equivalent", - "foldhash", + "foldhash 0.2.0", ] [[package]] @@ -1111,6 +1133,17 @@ dependencies = [ "pest", ] +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset 0.5.7", + "hashbrown 0.15.5", + "indexmap", +] + [[package]] name = "phf" version = "0.11.3" @@ -1721,7 +1754,7 @@ dependencies = [ "fancy-regex", "filedescriptor", "finl_unicode", - "fixedbitset", + "fixedbitset 0.4.2", "hex", "lazy_static", "libc", diff --git a/Cargo.toml b/Cargo.toml index f50a59a..acdd96c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,6 +23,7 @@ crossterm = "0.29.0" dbus = "0.9.12" heck = "0.5.0" jiff = { version = "0.2.38", default-features = false, features = ["serde", "std"] } +petgraph = { version = "0.8.3", default-features = false, features = ["std", "graphmap"] } ratatui = { version = "0.30.2", features = ["serde", "unstable-rendered-line-info"] } rustix = { version = "1.1.5", features = ["event", "fs", "process", "stdio", "system", "termios", "time"] } ser_nix = "0.2.4" diff --git a/src/boot_model.rs b/src/boot_model.rs index 2d11438..f7415bf 100644 --- a/src/boot_model.rs +++ b/src/boot_model.rs @@ -5,6 +5,16 @@ use std::{ vec::IntoIter, }; +use petgraph::{ + Direction::Incoming, + algo::{DfsSpace, has_path_connecting}, + graphmap::DiGraphMap, + visit::Visitable, +}; + +type WaitingGraph<'a> = DiGraphMap<&'a str, ()>; +type WaitingSearch<'a> = DfsSpace<&'a str, as Visitable>::Map>; + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Phase { Initrd, @@ -612,8 +622,8 @@ impl BootState { #[must_use] pub fn tree_rows(&self, finished_since: Duration) -> Vec { - let pending: HashSet<&str> = self - .units + let mut graph = WaitingGraph::new(); + self.units .iter() .filter(|(name, record)| match record.progress { Progress::Pending(_) | Progress::Finished(Outcome::Failed) => true, @@ -623,32 +633,40 @@ impl BootState { Progress::Finished(Outcome::Abandoned) => self.is_milestone(name), Progress::Untouched => false, }) - .map(|(name, _)| name.as_str()) + .for_each(|(name, _)| { + graph.add_node(name.as_str()); + }); + let edges: Vec<(&str, &str)> = graph + .nodes() + .flat_map(|waiter| { + self.waits_for(waiter, &graph) + .into_iter() + .map(move |dependency| (waiter, dependency)) + }) .collect(); - let root = self.root.unit().filter(|root| pending.contains(root)); + graph.extend(edges); + let root = self.root.unit().filter(|root| graph.contains_node(root)); let stages: Vec<&str> = self .milestone_targets .iter() .map(String::as_str) - .filter(|target| pending.contains(target)) + .filter(|target| graph.contains_node(target)) .chain(root.filter(|root| !self.is_milestone(root))) .collect(); - let blocked_by_pending: HashSet<&str> = pending - .iter() - .flat_map(|name| self.waits_for(name, &pending)) - .collect(); - let mut unblocked: Vec<&str> = pending - .iter() - .copied() - .filter(|name| !blocked_by_pending.contains(name) && !stages.contains(name)) + let mut unblocked: Vec<&str> = graph + .nodes() + .filter(|name| { + graph.neighbors_directed(name, Incoming).next().is_none() && !stages.contains(name) + }) .collect(); self.sort_siblings(&mut unblocked); - let mut leftovers: Vec<&str> = pending.iter().copied().collect(); + let mut leftovers: Vec<&str> = graph.nodes().collect(); self.sort_siblings(&mut leftovers); if self.phase == Phase::User { unblocked.clear(); leftovers.clear(); } + let mut space = DfsSpace::new(&graph); let mut visited = HashSet::new(); let mut rows = Vec::new(); stages @@ -660,7 +678,7 @@ impl BootState { if visited.contains(top) { return; } - let stage = self.grow(top, &pending, &mut visited); + let stage = self.grow(top, &graph, &mut space, &mut visited); if stage.row.status != RowStatus::Done || !stage.children.is_empty() { stage.flatten_into(0, &mut rows); } @@ -671,7 +689,8 @@ impl BootState { fn grow<'a>( &'a self, unit: &'a str, - pending: &HashSet<&'a str>, + graph: &WaitingGraph<'a>, + space: &mut WaitingSearch<'a>, visited: &mut HashSet<&'a str>, ) -> TreeNode { visited.insert(unit); @@ -684,24 +703,22 @@ impl BootState { status: record.row_status(), chain: Vec::new(), }; - let candidates: Vec<&str> = self - .waits_for(unit, pending) - .into_iter() + let candidates: Vec<&str> = graph + .neighbors(unit) .filter(|dependency| !visited.contains(dependency) && !self.is_milestone(dependency)) .collect(); + let mut waits_on = + |waiter, dependency| has_path_connecting(graph, waiter, dependency, Some(&mut *space)); let mut children: Vec<&str> = candidates .iter() .copied() .filter(|child| { !candidates.iter().any(|sibling| { - sibling != child - && self.waits_on(sibling, child, pending) - && !self.waits_on(child, sibling, pending) + sibling != child && waits_on(*sibling, *child) && !waits_on(*child, *sibling) }) }) .collect(); self.sort_siblings(&mut children); - children.dedup(); visited.extend(children.iter().copied()); TreeNode { row, @@ -709,7 +726,7 @@ impl BootState { .into_iter() .map(|child| { visited.remove(child); - self.grow(child, pending, visited) + self.grow(child, graph, space, visited) }) .collect(), } @@ -719,27 +736,11 @@ impl BootState { self.milestone_targets.iter().any(|target| target == unit) } - fn waits_on(&self, waiter: &str, dependency: &str, pending: &HashSet<&str>) -> bool { - let mut seen = HashSet::new(); - let mut frontier = vec![waiter]; - while let Some(unit) = frontier.pop() { - if !seen.insert(unit) { - continue; - } - let next = self.waits_for(unit, pending); - if next.contains(&dependency) { - return true; - } - frontier.extend(next); - } - false - } - - fn waits_for<'a>(&'a self, waiter: &str, pending: &HashSet<&str>) -> Vec<&'a str> { + fn waits_for<'a>(&'a self, waiter: &str, graph: &WaitingGraph) -> Vec<&'a str> { let Some(record) = self.units.get(waiter) else { return Vec::new(); }; - let pending_job = |dependency: &&'a str| pending.contains(dependency); + let pending_job = |dependency: &&'a str| graph.contains_node(dependency); let taking_down = |dependency: &&'a str| self.units[*dependency].takes_down(); let after = record.facts.after.iter().map(String::as_str); let before = record.facts.before.iter().map(String::as_str);