subc-daemon 0.49.2

Embeddable subc daemon: bootstrap, module supervision, and opaque-byte splice routing.
Documentation
use super::*;

fn member(pid: u32, parent: Option<u32>, own_ms: u64, reaped_ms: u64) -> Member {
    Member {
        new_since_baseline: true,
        identity: (pid, 1),
        parent: parent.map(|pid| (pid, 1)),
        own_ms,
        reaped_ms,
    }
}

fn observe(ledger: &mut Ledger, revision: u64, members: &[Member], alive: &[u32]) {
    ledger.observe(
        revision,
        members.iter().copied(),
        &alive.iter().map(|pid| (*pid, 1)).collect(),
    );
}

#[test]
fn leaving_ninety_ms_never_masks_the_next_five_ms() {
    let mut scope = Ledger::new(false);
    let mut command = Ledger::new(true);
    let mut allocation = Allocation::default();
    let mut minute_rows = Vec::new();
    for (revision, members, alive) in [
        (
            1,
            vec![member(1, None, 10, 0), member(2, Some(1), 0, 0)],
            vec![1, 2],
        ),
        (
            2,
            vec![member(1, None, 10, 0), member(2, Some(1), 90, 0)],
            vec![1, 2],
        ),
        (3, vec![member(1, None, 10, 0)], vec![1, 2]),
        (4, vec![member(1, None, 15, 0)], vec![1, 2]),
    ] {
        let alive: BTreeSet<_> = alive.into_iter().map(|pid| (pid, 1)).collect();
        scope.observe(revision, members.iter().copied(), &alive);
        let own = if revision == 1 { 0 } else { 90 };
        let increments = command.observe(revision, [member(2, Some(1), own, 0)], &alive);
        allocation.observe(scope.total(), increments.values().sum(), 0);
        minute_rows.push(allocation.rows());
    }
    assert_eq!(minute_rows[1], (10, 90, 100));
    assert_eq!(minute_rows[2], (10, 90, 100));
    assert_eq!(minute_rows[3], (15, 90, 105));
}

#[test]
fn late_declaration_starts_at_a_baseline_and_creates_no_hourly_cpu() {
    let mut scope = Ledger::new(false);
    let mut command = Ledger::new(true);
    let mut allocation = Allocation::default();
    let mut module_hour = crate::resource_history::History::default();
    let mut agents_hour = crate::resource_history::History::default();
    let mut total_hour = crate::resource_history::History::default();
    for revision in 1..=3 {
        let alive = BTreeSet::from([(1, 1), (2, 1)]);
        scope.observe(
            revision,
            [member(1, None, 10, 0), member(2, Some(1), 90, 0)],
            &alive,
        );
        let inside = if revision == 3 {
            command
                .observe(revision, [member(2, Some(1), 90, 0)], &alive)
                .values()
                .sum()
        } else {
            0
        };
        allocation.observe(scope.total(), inside, 0);
        let (module, agents, total) = allocation.rows();
        module_hour.record(revision * 60_000, 0, module);
        agents_hour.record(revision * 60_000, 0, agents);
        total_hour.record(revision * 60_000, 0, total);
    }
    assert_eq!(allocation.rows(), (100, 0, 100));
    let module = module_hour.last_hour_at(180_000).unwrap();
    let agents = agents_hour.last_hour_at(180_000).unwrap();
    let total = total_hour.last_hour_at(180_000).unwrap();
    assert_eq!(module.cpu_ms + agents.cpu_ms, total.cpu_ms);
    assert_eq!(total.cpu_ms, 0);
}

#[test]
fn init_reap_and_unseen_child_histories_share_a_provable_floor() {
    for true_cpu in [135, 225] {
        let mut ledger = Ledger::new(false);
        observe(
            &mut ledger,
            1,
            &[
                member(1, None, 10, 0),
                member(2, Some(1), 20, 0),
                member(3, Some(2), 90, 0),
            ],
            &[1, 2, 3],
        );
        observe(&mut ledger, 2, &[member(1, None, 15, 120)], &[1]);
        assert_eq!(ledger.total(), 135);
        assert!(ledger.total() <= true_cpu);
        assert_eq!(ledger.members.len(), 1);
        observe(&mut ledger, 3, &[member(1, None, 20, 120)], &[1]);
        assert_eq!(ledger.total(), 140);
        assert!(ledger.total() <= true_cpu + 5);
    }
}

#[test]
fn child_exit_after_parent_read_recovers_reaped_cpu_exactly_once() {
    for child_previously_measured in [false, true] {
        let mut ledger = Ledger::new(false);
        let mut first = vec![member(1, None, 10, 0)];
        if child_previously_measured {
            first.push(member(2, Some(1), 100, 0));
        }
        observe(&mut ledger, 1, &first, &[1, 2]);
        observe(&mut ledger, 2, &[member(1, None, 10, 0)], &[1]);
        assert_eq!(
            ledger.total(),
            if child_previously_measured { 110 } else { 10 }
        );
        observe(&mut ledger, 3, &[member(1, None, 10, 100)], &[1]);
        assert_eq!(ledger.total(), 110);
        observe(&mut ledger, 4, &[member(1, None, 15, 100)], &[1]);
        assert_eq!(
            ledger.total(),
            115,
            "the parent's later reaped counter cannot credit the child's sample twice"
        );
    }
}

#[test]
fn confirmed_live_orphans_cannot_be_absorbed_as_reaped_cpu() {
    let mut ledger = Ledger::new(false);
    observe(
        &mut ledger,
        1,
        &[
            member(1, None, 10, 0),
            member(2, Some(1), 20, 0),
            member(3, Some(2), 90, 0),
        ],
        &[1, 2, 3],
    );
    observe(&mut ledger, 2, &[member(1, None, 15, 120)], &[1, 3]);
    assert_eq!(ledger.total(), 225);
    assert_eq!(ledger.outside.len(), 1);
    observe(&mut ledger, 3, &[member(1, None, 20, 120)], &[1]);
    assert_eq!(ledger.total(), 230);
    assert!(ledger.outside.is_empty());
}

#[test]
fn inside_debit_skew_retains_the_pending_increment() {
    let mut allocation = Allocation::default();
    allocation.observe(0, 0, 0);
    allocation.observe(100, 150, 0);
    assert_eq!(allocation.rows(), (0, 100, 100));
    assert_eq!(allocation.pending, 50);
    allocation.observe(150, 0, 0);
    assert_eq!(allocation.rows(), (0, 150, 150));
    assert_eq!(allocation.pending, 0);
}

#[path = "property.rs"]
pub(crate) mod property;

#[test]
fn overlapping_walks_cannot_lower_an_identity_baseline_and_count_its_recovery_twice() {
    let mut ledger = Ledger::new(false);
    let alive = BTreeSet::from([(1, 1)]);
    ledger.observe(1, [member(1, None, 10, 20)], &alive);
    ledger.observe(2, [member(1, None, 9, 18)], &alive);
    assert_eq!(ledger.total(), 30);
    ledger.observe(3, [member(1, None, 11, 21)], &alive);
    assert_eq!(
        ledger.total(),
        32,
        "only one new own and one new reaped millisecond were observed"
    );
}