diff options
Diffstat (limited to 'src/swarm')
| -rw-r--r-- | src/swarm/tree.rs | 25 |
1 files changed, 20 insertions, 5 deletions
diff --git a/src/swarm/tree.rs b/src/swarm/tree.rs index f04e442..29186d8 100644 --- a/src/swarm/tree.rs +++ b/src/swarm/tree.rs @@ -327,7 +327,9 @@ fn shape( /// How long our writes take to reach the members along our own tree, by link latency /// alone (the bench's, which knows each link's): the mean over the members it reaches -/// (and the others do), against two other trees of ours. In one, each member's parent is +/// (and the others do), against two other trees of ours. Our tree as the members chose +/// their parents (`parents`, from `own_parent` on each): of members beyond our +/// neighbours, we don't know the round trips their choice goes by. In one, each member's parent is /// chosen as now, but among those as close to us and as well placed (`rank`) by the /// exact latency, not the round-trip bucket it said; in the other, every member takes the fastest path over the links members /// reach (no tree computed alike everywhere gets below it). In milliseconds, one way. @@ -340,11 +342,23 @@ pub(crate) struct Latencies { pub(crate) fastest: f64, } +/// Our parent in `writer`'s tree, as we choose it (`parent`, by what we and our +/// neighbours said); None if we have none, or no tree is known. +#[cfg(test)] +pub(crate) async fn own_parent(state: &AppState, writer: &str) -> Option<String> { + let (graph, distance) = distances(state, topology::pair_key(writer))?; + let known = known_reaches(state, &graph).await; + let reached = |by: &str, member: &str| known.reached(by, member); + let round_trip = |by: &str, member: &str| known.round_trip(by, member); + parent(&graph, &distance, &reached, &round_trip, state.local_id()).map(str::to_owned) +} + /// `Latencies` of our own tree, by `latency(from, to)` in milliseconds; None while the /// member list isn't known, or we aren't in it, or the tree reaches nobody. #[cfg(test)] pub(crate) async fn own_latencies( state: &AppState, + parents: &HashMap<String, Option<String>>, latency: &(dyn Fn(&str, &str) -> f64 + Sync), ) -> Option<Latencies> { let me = state.local_id(); @@ -360,10 +374,11 @@ pub(crate) async fn own_latencies( let now: HashMap<&str, Option<&str>> = members .iter() .map(|member| { - ( - *member, - parent(&graph, &distance, &reached, &round_trip, member), - ) + let chosen = match parents.get(*member) { + Some(chosen) => chosen.as_deref(), + None => parent(&graph, &distance, &reached, &round_trip, member), + }; + (*member, chosen) }) .collect(); let faster: HashMap<&str, Option<&str>> = members |