Skip to main content

qualia_core_db/net/peer/fabric/
select.rs

1//! Exclude prohibited paths, then rank remaining evidence. Never the reverse.
2
3use super::carrier::{prohibited, PathClass};
4use super::evidence::PathEvidence;
5use crate::net::peer::connectivity::policy::Disclosure;
6
7pub const MAX_RANKED: usize = 8;
8
9#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10pub struct RankedPath {
11    pub index: u8,
12    pub class: PathClass,
13    pub score: i32,
14}
15
16/// Lower RTT and larger validated payload score higher. Unvalidated rows are skipped.
17pub fn exclude_then_rank(
18    disclosure: Disclosure,
19    live_generation: u32,
20    rows: &[PathEvidence],
21    out: &mut [RankedPath],
22) -> usize {
23    let mut n = 0usize;
24    let mut i = 0usize;
25    while i < rows.len() {
26        let e = rows[i];
27        if prohibited(disclosure, e.class)
28            || !e.validated()
29            || e.stale_generation(live_generation)
30            || n >= out.len()
31            || n >= MAX_RANKED
32        {
33            i += 1;
34            continue;
35        }
36        let rtt = if e.rtt_ms > 60_000 { 60_000 } else { e.rtt_ms };
37        let score = (i32::from(e.max_payload) / 8) - (rtt as i32);
38        out[n] = RankedPath {
39            index: i as u8,
40            class: e.class,
41            score,
42        };
43        n += 1;
44        i += 1;
45    }
46    let mut a = 0usize;
47    while a + 1 < n {
48        let mut b = a + 1;
49        while b < n {
50            if out[b].score > out[a].score {
51                let t = out[a];
52                out[a] = out[b];
53                out[b] = t;
54            }
55            b += 1;
56        }
57        a += 1;
58    }
59    n
60}
61
62#[cfg(test)]
63mod tests {
64    use super::*;
65    use crate::net::peer::fabric::evidence::TransportWitness;
66
67    fn local(class: PathClass, rtt: u32) -> PathEvidence {
68        PathEvidence::from_witness(TransportWitness::from_local(class, 1, 1152, rtt, 10))
69    }
70
71    #[test]
72    fn faster_direct_cannot_beat_relay_only_policy() {
73        let rows = [local(PathClass::DirectV6, 1), local(PathClass::Relayed, 50)];
74        let mut out = [RankedPath {
75            index: 0,
76            class: PathClass::Offline,
77            score: 0,
78        }; MAX_RANKED];
79        let n = exclude_then_rank(Disclosure::ApprovedRelaysOnly, 1, &rows, &mut out);
80        assert_eq!(n, 1);
81        assert_eq!(out[0].class, PathClass::Relayed);
82    }
83
84    #[test]
85    fn ordinary_prefers_faster_validated_direct() {
86        let rows = [local(PathClass::Relayed, 50), local(PathClass::DirectV6, 1)];
87        let mut out = [RankedPath {
88            index: 0,
89            class: PathClass::Offline,
90            score: 0,
91        }; MAX_RANKED];
92        let n = exclude_then_rank(Disclosure::DirectPermitted, 1, &rows, &mut out);
93        assert_eq!(n, 2);
94        assert_eq!(out[0].class, PathClass::DirectV6);
95    }
96}