diff --git a/native/aetherlight/src/golden_tests.rs b/native/aetherlight/src/golden_tests.rs index 382e728bc..98373b59d 100644 --- a/native/aetherlight/src/golden_tests.rs +++ b/native/aetherlight/src/golden_tests.rs @@ -1135,6 +1135,99 @@ fn operation_reads_are_equal_at_100_and_1600() { assert_eq!(worked[0], worked[1], "an operation's read work grew with the world"); } +/// The commit lane's checks read what the transaction wrote, not the world: +/// conservation sums the holders that were written, disjointness judges the +/// holders whose authority was written, and both cost the same rows at 100 and +/// 1600 persons. Each shape also has to be answered right: a holder already +/// written when the operations begin is measured from where it stood then, and +/// an overlap made by installing an incumbent, or by a grant, is refused with +/// every other holder untouched. +#[test] +fn apply_checks_read_the_log() { + use crate::patch::{AuthorityGrant, AuthorityTarget, ResolvedOp}; + use crate::tests::{LEVY_KIND, WARDEN_OFFICE, authority_kind, office}; + use crate::{Quantity, apply_operations}; + + let mut worked = Vec::new(); + for persons in [100usize, 1600] { + let (mut kernel, people, _) = clockwork_world(persons); + let place = |label: &str| { + *kernel.state.entities.iter().find(|(_, record)| record.label == label).expect("declared").0 + }; + let (zero, one, grain) = (place("Place 0"), place("Place 1"), place("Grain 0")); + let institution = subject_by_label(&kernel.state, "Institution 0"); + let level = AuthorityGrant { + kind: authority_kind(LEVY_KIND), + over: AuthorityTarget::PlaceSubtree(one), + }; + let revision = kernel.state.revision + 1; + let transfer = ResolvedOp::Transfer { from: people[0], to: people[1], resource: grain, qty: Quantity(1) }; + let mut counts = Vec::new(); + let state = &mut kernel.state; + + // A transfer between two of ten holders: nothing else is read. + state.begin(); + let before = crate::docs::rows_read(); + apply_operations(state, std::slice::from_ref(&transfer), &[], revision) + .expect("a conserving transfer applies"); + counts.push(crate::docs::rows_read() - before); + state.rollback(); + + // A holder written before the operations begin is measured from there. + state.begin(); + crate::set_held(state, people[0], grain, 5); + let before = crate::docs::rows_read(); + apply_operations(state, std::slice::from_ref(&transfer), &[], revision) + .expect("the entry value is the before, not the value the transaction began with"); + counts.push(crate::docs::rows_read() - before); + state.rollback(); + + // Place 1 inside place 0, committed, with person 5's own grant over place 1. + state.begin(); + state.entities.get_mut(&one).unwrap().container = Some(zero); + state.authority.insert(people[5], std::collections::BTreeSet::from([level.clone()])); + let folded = state.folded().unwrap(); + state.finish(folded); + crate::journal::verify_state_shape(state).expect("the world is still disjoint"); + + // A grant that overlaps the warden's lent ground is refused. + state.begin(); + let overlap = ResolvedOp::GrantAuthority { holder: people[0], grant: level.clone() }; + let before = crate::docs::rows_read(); + let refused = apply_operations(state, &[overlap], &[], revision).unwrap_err(); + counts.push(crate::docs::rows_read() - before); + assert!( + matches!(&refused, crate::KernelError::Invariant(m) if m.contains("overlapping")), + "{persons}: {refused:?}" + ); + state.rollback(); + + // Seating a holder of overlapping ground in the office is refused too. + state.begin(); + let install = ResolvedOp::InstallIncumbent { + institution, + office: office(WARDEN_OFFICE), + incumbent: people[5], + }; + let before = crate::docs::rows_read(); + let refused = apply_operations(state, &[install], &[], revision).unwrap_err(); + counts.push(crate::docs::rows_read() - before); + assert!( + matches!(&refused, crate::KernelError::Invariant(m) if m.contains("overlapping")), + "{persons}: {refused:?}" + ); + state.rollback(); + + // Custody is point reads, which are free; the disjointness judgments read + // the office index. A refusal stops at the first overlapping holder, and + // which holder that is depends on id order, so its reads are bounded + // rather than equal: a few rows, where a scan of the world reads thousands. + assert!(counts[2..].iter().all(|rows| (1..=8).contains(rows)), "{persons}: {counts:?}"); + worked.push(counts[..2].to_vec()); + } + assert_eq!(worked[0], worked[1], "a commit check's read work grew with the world"); +} + fn assert_indexes_derived(state: &crate::WorldState, label: &str) { for (schema, docs) in state.partitions() { assert!(docs.index_is_derived(), "{label}: the read index of {schema} left its documents"); diff --git a/native/aetherlight/src/lib.rs b/native/aetherlight/src/lib.rs index 9aa732548..c3837d8ad 100644 --- a/native/aetherlight/src/lib.rs +++ b/native/aetherlight/src/lib.rs @@ -1685,16 +1685,17 @@ fn admit_resolved( apply_operations(state, &resolved.operations, &resolved.evidence, resolves_to) } -/// The component writer for every lane: snapshot the before-totals for every -/// resource the operations name, apply each operation, accumulate the ledger -/// deltas, and prove conservation once. Declaration admission calls it after its -/// declaration loops; an exercised affordance's lowered effects call it -/// directly. One writer, one conservation statement. +/// The component writer for every lane: apply each operation, accumulate the +/// ledger deltas, and prove conservation once. Declaration admission calls it +/// after its declaration loops; an exercised affordance's lowered effects call +/// it directly. One writer, one conservation statement. /// /// A forged effect reaches this function without ever passing the resolver, so -/// conservation is re-derived over the committed partitions, against the same -/// equation, with `before` read from state rather than from anything the effect -/// asserts. +/// conservation and disjointness are re-derived here, from the transaction's own +/// log: only a holder the operations wrote can change either answer, because +/// every other holder appears on both sides of the equation and no other +/// jurisdiction moved. `before` is what each written holder held when this +/// function was entered, never anything the effect asserts. fn apply_operations( state: &mut WorldState, operations: &[ResolvedOp], @@ -1704,9 +1705,16 @@ fn apply_operations( let mut deltas: BTreeMap = BTreeMap::new(); for operation in operations { for resource in operation_resources(operation) { - deltas.entry(resource).or_default().before = resource_total(state, resource); + deltas.entry(resource).or_default(); } } + // Holders already written when the operations begin (the declarations + // above, normally none): what they hold now is their `before`. + let at_entry: BTreeMap>> = state + .holdings + .changes() + .map(|(holder, _, now)| (*holder, now.cloned())) + .collect(); for operation in operations { apply_operation(state, operation, evidence, resolves_to)?; match operation { @@ -1731,15 +1739,25 @@ fn apply_operations( _ => {} } } - for (resource, delta) in &mut deltas { - delta.after = resource_total(state, *resource); + let held_of = |held: Option<&BTreeMap>, resource: &EntityId| { + held.and_then(|held| held.get(resource)).map_or(0, |quantity| u128::from(quantity.0)) + }; + for (holder, logged, now) in state.holdings.changes() { + let before = match at_entry.get(holder) { + Some(recorded) => recorded.as_ref(), + None => logged, + }; + for (resource, delta) in &mut deltas { + delta.before += held_of(before, resource); + delta.after += held_of(now, resource); + } } if patch::check_ledger(&deltas).is_some() { return Err(KernelError::Invariant("custody does not conserve".into())); } - // Disjointness, re-derived over the committed partitions for the same - // reason conservation is: a forged effect reaches this function without - // passing the resolver. + // Disjointness, re-derived for the same reason conservation is: a forged + // effect reaches this function without passing the resolver. Only a holder + // the transaction touched can have gained an overlap. if operations.iter().any(|operation| { matches!( operation, @@ -1747,7 +1765,7 @@ fn apply_operations( | ResolvedOp::OpenOffice { .. } | ResolvedOp::InstallIncumbent { .. } ) - }) && overlapping_holder(state).is_some() + }) && touched_holders(state).into_iter().any(|holder| holder_overlaps(state, holder)) { return Err(KernelError::Invariant( "one subject holds two overlapping jurisdictions of one kind".into(), @@ -1756,6 +1774,37 @@ fn apply_operations( Ok(()) } +/// Every subject whose effective authority the open transaction may have +/// changed: whose own grants were written, whose offices were written (old +/// incumbent and new), and the incumbents of an institution whose grants were +/// written or whose retirement flipped, because an office lends what its +/// institution holds. +fn touched_holders(state: &WorldState) -> BTreeSet { + let mut touched = BTreeSet::new(); + let mut institutions = BTreeSet::new(); + for (holder, _, _) in state.authority.changes() { + touched.insert(*holder); + institutions.insert(*holder); + } + for (institution, old, new) in state.selection.changes() { + for offices in [old, new].into_iter().flatten() { + touched.extend(offices.values().filter_map(|office| office.incumbent)); + } + institutions.insert(*institution); + } + for (subject, old, new) in state.subjects.changes() { + if old.map(|record| record.retired) != new.map(|record| record.retired) { + institutions.insert(*subject); + } + } + for institution in institutions { + if let Some(offices) = state.selection.get(&institution) { + touched.extend(offices.values().filter_map(|office| office.incumbent)); + } + } + touched +} + /// Every resource an operation names, so `admit_resolved` can read its committed /// total before touching it. fn operation_resources(operation: &ResolvedOp) -> Vec { @@ -1773,7 +1822,10 @@ fn operation_resources(operation: &ResolvedOp) -> Vec { } } -fn resource_total(state: &WorldState, resource: EntityId) -> u128 { +/// What `apply_operations` sums before and after: every holder. Conservation +/// reads only the holders a transaction wrote, and this is the reference. +#[cfg(test)] +fn resource_total_by_scan(state: &WorldState, resource: EntityId) -> u128 { state .holdings .values() @@ -2944,14 +2996,17 @@ fn overlapping_holder(state: &WorldState) -> Option { .filter_map(|office| office.incumbent), ) .collect(); - holders.into_iter().find(|holder| { - let effective: Vec = - subject_authority(state, *holder).into_iter().collect(); - effective.iter().enumerate().any(|(index, one)| { - effective[index + 1..].iter().any(|other| { - one.kind == other.kind - && patch::targets_overlap(&state.entities, one.over, other.over) - }) + holders.into_iter().find(|holder| holder_overlaps(state, *holder)) +} + +/// Whether one subject's effective authority holds two grants of one kind over +/// overlapping ground. The pairwise check `overlapping_holder` runs over every +/// holder, and `apply_operations` over the holders a transaction touched. +fn holder_overlaps(state: &WorldState, holder: SubjectId) -> bool { + let effective: Vec = subject_authority(state, holder).into_iter().collect(); + effective.iter().enumerate().any(|(index, one)| { + effective[index + 1..].iter().any(|other| { + one.kind == other.kind && patch::targets_overlap(&state.entities, one.over, other.over) }) }) } @@ -6157,7 +6212,7 @@ mod custody_tests { assert_eq!(holding(&kernel, custody.holder, custody.tithe), 4); assert_eq!(holding(&kernel, custody.counterparty, custody.tithe), 3); - assert_eq!(resource_total(&kernel.state, custody.tithe), 7); + assert_eq!(resource_total_by_scan(&kernel.state, custody.tithe), 7); assert_eq!(kernel.state.entities, entities); assert_eq!(kernel.state.edges, edges); assert_eq!(kernel.state.positions, positions); @@ -6221,8 +6276,8 @@ mod custody_tests { assert_eq!(holding(&kernel, custody.holder, custody.tithe), 2); assert_eq!(holding(&kernel, custody.holder, custody.ingot), 5); - assert_eq!(resource_total(&kernel.state, custody.tithe), 2); - assert_eq!(resource_total(&kernel.state, custody.ingot), 5); + assert_eq!(resource_total_by_scan(&kernel.state, custody.tithe), 2); + assert_eq!(resource_total_by_scan(&kernel.state, custody.ingot), 5); } #[test] @@ -6494,13 +6549,13 @@ mod custody_tests { // The opening balance was created by `Admit` alone: before is zero, // admitted is the balance, and the total equals the sum of the two. assert_eq!( - resource_total(&kernel.state, custody.tithe), + resource_total_by_scan(&kernel.state, custody.tithe), u128::from(OPENING_BALANCE) ); - assert_eq!(resource_total(&kernel.state, custody.ingot), 0); + assert_eq!(resource_total_by_scan(&kernel.state, custody.ingot), 0); - let tithe_before = resource_total(&kernel.state, custody.tithe); - let ingot_before = resource_total(&kernel.state, custody.ingot); + let tithe_before = resource_total_by_scan(&kernel.state, custody.tithe); + let ingot_before = resource_total_by_scan(&kernel.state, custody.ingot); let receipt = submit_play( &mut kernel, @@ -6530,11 +6585,11 @@ mod custody_tests { // Transfer contributes to no term; transform contributes one spent and // one gained; consume contributes one consumed. Nothing was admitted. assert_eq!( - resource_total(&kernel.state, custody.tithe), + resource_total_by_scan(&kernel.state, custody.tithe), tithe_before - 1 - 2 ); assert_eq!( - resource_total(&kernel.state, custody.ingot), + resource_total_by_scan(&kernel.state, custody.ingot), ingot_before + 2 ); assert_eq!(holding(&kernel, custody.holder, custody.tithe), 2);