use super::arena::{Arena, Kept, PENDING};
use super::counts::{Counts, Split};
use super::memo::{Key, Shared, Table};
use super::schedule::{Plan, closed, merged};
use super::split::Join;
use super::zone::Zone;
use super::{Alternative, Cuts, Found, Problem, Run, SetUp, Step, Unrestricted};
use crate::Error;
use crate::limits::Limits;
use crate::linear::proofs::{Node, NodeId};
use crate::linear::search::memory::{Account, bytes_of};
use crate::linear::search::parallel::{Flags, Lent, RaiseOnPanic, Runtime, record};
use crate::linear::search::{Finished, Options, Reason, Statistics, Stop, Task, Work};
use crate::linear::search::{lock, taken};
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
const LEVELS: u32 = 2;
const MAX_FIXED: usize = 6;
pub(super) fn search_goal<Z: Zone>(
task: &Task<'_>,
options: &Options,
limits: &Limits,
account: &Account,
work: &Work,
stop: &mut dyn FnMut(u64) -> bool,
) -> Result<Finished, Error> {
let Some((classes, first, second)) = super::prepare(task, options, stop) else {
return Ok(Finished::gave_up(Reason::Stopped));
};
let set_up = SetUp {
task,
classes: &classes,
options,
limits,
};
let stack = limits.stack_bytes();
let search = |plan: Plan, runtime: &Runtime, account: &Account, flags: Flags<'_>| {
account.charge(classes.bytes());
plan.search_on::<Z>(set_up, account, runtime, flags)
};
let Some(second) = second else {
let runtime = Lent::take(options.pool.as_ref(), options.threads(), stack)?;
let finished = runtime.drive(stop, work, |flags| search(first, &runtime, account, flags));
return Ok(Finished {
result: finished.result.map_err(|r| r.as_set(options, limits)),
..finished
});
};
let threads = options.threads() / 2;
let runtimes = (
Lent::take(options.pool.as_ref(), threads, stack)?,
Lent::take(options.pool.as_ref(), options.threads() - threads, stack)?,
);
let accounts = (account.share(2), account.share(2));
let (forward, backward) = crate::linear::search::parallel::race(
(&runtimes.0, &runtimes.1),
stop,
work,
(
|flags: Flags<'_>| search(first, &runtimes.0, &accounts.0, flags),
|flags: Flags<'_>| search(second, &runtimes.1, &accounts.1, flags),
),
|finished: &Finished| finished.result.is_ok(),
);
Ok(merged(forward, backward, options, limits))
}
impl Plan {
fn search_on<Z: Zone>(
self,
set_up: SetUp<'_>,
account: &Account,
runtime: &Runtime,
flags: Flags<'_>,
) -> Finished {
let forest = set_up.task.forest;
let mode = set_up.task.mode;
let counts =
match Counts::new_until(forest, self.bias, mode, account, &mut |_| flags.raised()) {
Ok(counts) => counts,
Err(reason) => return Finished::gave_up(reason),
};
let entries = set_up.options.memo_entries();
let memo = Shared::new(entries, if Z::FIRST_ORDER { 0 } else { entries });
let shared = (!Z::FIRST_ORDER).then(|| Mutex::new(Vec::new()));
let kept = shared.as_ref().map_or(Kept::Own(Vec::new()), Kept::Shared);
let mut zone = Z::new(forest, set_up.options);
zone.share();
let mut engine = Run::new(
Problem::new(set_up, &counts, self.copies, account),
Stop::flags(flags),
Table::Shared(&memo),
Arena::new(kept, account),
zone,
);
engine.runtime = (runtime.threads() > 1).then_some(runtime);
let mut result = engine.run_kept(set_up.task.goal);
let statistics = engine.statistics();
let (nodes, instances) = match engine.nodes.kept {
Kept::Own(mut nodes) => {
let instances = closed(&engine.zone, forest, &mut result, &mut nodes);
(nodes, instances)
}
Kept::Shared(_) => {
drop(engine);
(taken(shared.expect("a shared arena")), None)
}
};
Finished {
result,
nodes,
statistics,
instances,
}
}
}
struct Spawn<'s, Z: Zone> {
problem: Problem<'s>,
zone: &'s Z,
memo: &'s Shared,
arena: Option<&'s Mutex<Vec<Node>>>,
runtime: &'s Runtime,
flags: Flags<'s>,
branch: Vec<(&'s [Key], &'s [u64])>,
depth: u32,
or_depth: u32,
}
impl<'s, Z: Zone> Spawn<'s, Z> {
fn worker<'w>(&'w self, cancel: &'w AtomicBool) -> Run<'w, Z> {
let kept = self.arena.map_or(Kept::Own(Vec::new()), Kept::Shared);
let mut worker = Run::new(
self.problem,
Stop::flags(self.flags.child(cancel)),
Table::Shared(self.memo),
Arena::new(kept, self.problem.account),
self.zone.fork(),
);
worker.runtime = Some(self.runtime);
worker.depth = self.depth.max(self.runtime.depth_here());
worker.or_depth = self.or_depth;
worker.ancestors = self.branch.clone();
worker
}
}
struct Collected<Z: Zone> {
proof: Option<NodeId>,
won: Option<(Z, Vec<Node>)>,
cut: Option<Reason>,
error: Option<Reason>,
cuts: Cuts,
statistics: Statistics,
}
impl<Z: Zone> Collected<Z> {
fn new() -> Self {
Self {
proof: None,
won: None,
cut: None,
error: None,
cuts: Cuts::NONE,
statistics: Statistics::default(),
}
}
fn take(&mut self, result: Step, worker: Run<'_, Z>, cancel: &AtomicBool) {
self.statistics.add_run(&worker.report());
if self.cut.is_none() {
self.cut = worker.zone.cut();
}
let won = matches!(result, Ok(Found::Proved(_))) && self.proof.is_none();
let Run {
zone,
nodes,
problem,
..
} = worker;
if let Kept::Own(kept) = nodes.kept {
if won {
self.won = Some((zone, kept));
} else {
problem.account.resize(bytes_of(&kept), 0);
}
}
match result {
Ok(Found::Proved(node)) => {
self.proof.get_or_insert(node);
cancel.store(true, Ordering::Relaxed);
}
Ok(Found::Failed(failed)) => self.cuts = self.cuts.and(failed),
Err(Reason::Stopped) if cancel.load(Ordering::Relaxed) => {}
Err(reason) => {
record(&mut self.error, reason);
cancel.store(true, Ordering::Relaxed);
}
}
}
fn skip(&mut self, cancel: &AtomicBool) {
if cancel.load(Ordering::Relaxed) {
return;
}
if self.error.is_none() {
self.error = Some(Reason::Stopped);
}
cancel.store(true, Ordering::Relaxed);
}
}
struct Premise {
result: Step,
statistics: Statistics,
}
impl Premise {
fn of<Z: Zone>(worker: &Run<'_, Z>, result: Step) -> Self {
Self {
result,
statistics: worker.statistics,
}
}
}
impl<'a, Z: Zone> Run<'a, Z> {
pub(super) fn cubes(&self) -> bool {
self.runtime.is_some() && self.or_depth < LEVELS && self.zone.divides()
}
fn spawn<'s>(&'s self, or_depth: u32) -> Spawn<'s, Z>
where
'a: 's,
{
let (Table::Shared(memo), Stop::Flags(flags, _), Some(runtime)) =
(&self.memo, &self.stop, self.runtime)
else {
unreachable!("a parallel choice is met on a worker of the pool")
};
let arena = match &self.nodes.kept {
Kept::Shared(arena) => Some(*arena),
Kept::Own(_) => None,
};
Spawn {
problem: self.problem,
zone: &self.zone,
memo,
arena,
runtime,
flags: *flags,
branch: self
.ancestors
.iter()
.copied()
.chain([(
&self.stack[..self.stack_len],
&self.hashes[..self.stack_len],
)])
.collect(),
depth: self.depth,
or_depth,
}
}
fn exported(&mut self, result: Step) -> Step {
match result? {
Found::Proved(node) => Ok(Found::proved(self.nodes.keep(0, node)?)),
failed => Ok(failed),
}
}
fn run_alternative(
&mut self,
theta: &Unrestricted<Z>,
gamma: &Z::Linear,
alternative: Alternative<'_, Z>,
budget: u32,
) -> Step {
let mut rest = None;
let result = self.alternative(theta, gamma, alternative, &mut rest, budget);
if let Some(rest) = rest {
self.give_context(rest);
}
self.exported(result)
}
pub(super) fn choose_parallel(
&mut self,
theta: &Unrestricted<Z>,
gamma: &Z::Linear,
alternatives: &[Alternative<'_, Z>],
budget: u32,
) -> Step {
self.divided = true;
let cancel = AtomicBool::new(false);
let spawn = self.spawn(self.or_depth + 1);
let collected = Mutex::new(Collected::new());
let (&first, rest) = alternatives
.split_first()
.expect("a choice has an alternative");
let waiting = spawn.runtime.waiting(self.depth);
spawn.runtime.pool.in_place_scope(|scope| {
for &alternative in rest {
let (spawn, cancel, collected) = (&spawn, &cancel, &collected);
scope.spawn(move |_| {
if spawn.flags.child(cancel).raised() {
lock(collected).skip(cancel);
return;
}
let _cancel = RaiseOnPanic(cancel);
let mut worker = spawn.worker(cancel);
let result = worker.run_alternative(theta, gamma, alternative, budget);
lock(collected).take(result, worker, cancel);
});
}
let _cancel = RaiseOnPanic(&cancel);
let mut worker = spawn.worker(&cancel);
let result = worker.run_alternative(theta, gamma, first, budget);
lock(&collected).take(result, worker, &cancel);
});
drop(waiting);
let collected = taken(collected);
self.statistics.add_run(&collected.statistics);
if let Some(reason) = collected.cut {
self.zone.cut_by(reason);
}
match (collected.proof, collected.error) {
(Some(node), _) => match collected.won {
Some((zone, kept)) => self.adopted(zone, kept, node),
None => Ok(Found::proved(node)),
},
(None, Some(reason)) => Err(reason),
(None, None) => Ok(Found::failed(collected.cuts)),
}
}
fn adopted(&mut self, zone: Z, kept: Vec<Node>, node: NodeId) -> Step {
self.zone.adopt(zone);
let base = self.nodes.mark();
if base + kept.len() > PENDING as usize {
return Err(Reason::IndexLimit);
}
let renamed = |id: NodeId| NodeId::new(PENDING | (base + id.index()) as u32);
for n in &kept {
self.nodes.push(n.map_premises(renamed));
}
self.problem.account.resize(bytes_of(&kept), 0);
Ok(Found::proved(renamed(node)))
}
pub(super) fn split_parallel(
&mut self,
theta: &Unrestricted<Z>,
members: &[Z::Member],
sides: (&Z::Linear, &Z::Linear),
split: &Split,
join: Join<Z::Member>,
budget: u32,
) -> Step {
let threads = self.runtime.map_or(1, Runtime::threads);
let bits = (2 * threads).next_power_of_two().trailing_zeros() as usize;
let fixed = bits.clamp(1, MAX_FIXED).min(members.len());
let canonical = |pattern: u64| {
(1..fixed).all(|i| {
pattern >> (i - 1) & 1 == 0
|| pattern >> i & 1 == 1
|| !self
.zone
.same(self.problem.classes, members[i - 1], members[i])
})
};
let alternatives: Vec<Alternative<'_, Z>> = (0..1u64 << fixed)
.filter(|&pattern| canonical(pattern))
.map(|pattern| Alternative::Splits {
join,
members,
fixed,
pattern,
sides,
split,
})
.collect();
self.choose_parallel(theta, sides.1, &alternatives, budget)
}
pub(super) fn with_parallel(
&mut self,
theta: &Unrestricted<Z>,
gamma: &Z::Linear,
list: &[Z::Member],
o: Z::Member,
budget: u32,
) -> Step {
if self.stop.fired(0) {
return Err(Reason::Stopped);
}
let cancel = AtomicBool::new(false);
let spawn = self.spawn(self.or_depth + 1);
let premise: Mutex<Option<Premise>> = Mutex::new(None);
let (left_sub, right_sub) = (self.left(o), self.right(o));
let search = |worker: &mut Run<'_, Z>, sub: Z::Member, left: bool| {
let _cancel = RaiseOnPanic(&cancel);
let result = worker.premise(theta, gamma, list, sub, budget);
let result = worker.exported(result);
if matches!(result, Ok(Found::Failed(_))) || (left && result.is_err()) {
cancel.store(true, Ordering::Relaxed);
}
result
};
let waiting = spawn.runtime.waiting(self.depth);
let left = spawn.runtime.pool.in_place_scope(|scope| {
let (spawn, cancel, premise, search) = (&spawn, &cancel, &premise, &search);
scope.spawn(move |_| {
let mut worker = spawn.worker(cancel);
let result = search(&mut worker, right_sub, false);
*lock(premise) = Some(Premise::of(&worker, result));
});
let mut worker = spawn.worker(cancel);
let result = search(&mut worker, left_sub, true);
Premise::of(&worker, result)
});
drop(waiting);
let right = taken(premise).expect("the worker reports before the scope ends");
self.statistics.add_run(&left.statistics);
self.statistics.add_run(&right.statistics);
match (left.result, right.result) {
(Ok(Found::Proved(l)), Ok(right @ Found::Proved(_))) => {
Ok(self.both(o, l, right, self.nodes.mark()))
}
(Ok(failed @ Found::Failed(_)), _) | (_, Ok(failed @ Found::Failed(_))) => Ok(failed),
(Err(Reason::Stopped), Err(reason)) | (Err(reason), _) | (Ok(_), Err(reason)) => {
Err(reason)
}
}
}
}
#[cfg(all(test, feature = "parse"))]
mod tests {
use crate::linear::fragment::Mode;
use crate::linear::search::generate::{self, IllRules, Rng, Rules};
use crate::linear::search::{Engine, Options, Reason, Verdict, prove, prove_within};
use crate::linear::sequents::Sequent;
fn decided(input: &str, mode: Mode, options: &Options) -> Option<bool> {
let sequent: Sequent = input.parse().unwrap();
let outcome = prove(&sequent, mode, options).unwrap();
match outcome.verdict {
Verdict::Proved(proof) => {
assert_eq!(proof.check(mode), Ok(()), "{input:?} with {options:?}");
Some(true)
}
Verdict::Unprovable(_) => Some(false),
Verdict::Unknown(Reason::CopyBound { .. }) => None,
Verdict::Unknown(reason) => panic!("{input:?}: {reason}"),
}
}
fn agree(text: &str, mode: Mode, options: &Options) {
let sequential = decided(text, mode, options);
for jobs in [2, 4] {
let options = options.clone().with_jobs(jobs);
let parallel = decided(text, mode, &options);
assert!(
sequential.is_none() || parallel.is_none() || sequential == parallel,
"{text:?} in {mode} mode: {sequential:?} on one thread, {parallel:?} with {options:?}"
);
}
}
#[test]
fn classical_verdicts_agree() {
for (i, rules) in Rules::ALL.into_iter().enumerate() {
let mode = if rules.mix {
Mode::CLASSICAL.with_mix()
} else {
Mode::CLASSICAL
};
let mut rng = Rng::new(100 + i as u64);
for _ in 0..10 {
let budget = 2 + rng.below(9);
let generate::Provable {
mut formulas,
copies,
} = generate::provable(&mut rng, rules, 3, budget);
let texts = [
generate::sequent(&formulas),
generate::sequent(if generate::mutate(&mut rng, &mut formulas, 3) {
&formulas
} else {
&[]
}),
];
for text in texts.iter().filter(|t| !t.is_empty()) {
for engine in [None, Some(Engine::Focus)] {
let options = Options::default()
.with_copies(Some(copies))
.with_engine(engine);
agree(text, mode, &options);
}
}
}
}
}
#[test]
fn intuitionistic_verdicts_agree() {
for (i, rules) in IllRules::ALL.into_iter().enumerate() {
let mut rng = Rng::new(200 + i as u64);
for _ in 0..8 {
let budget = 2 + rng.below(9);
let generate::Ill {
mut hypotheses,
mut goal,
copies,
..
} = generate::ill(&mut rng, rules, 3, budget);
let mut texts = vec![generate::two_sided(&hypotheses, &goal)];
if generate::mutate_two_sided(&mut rng, &mut hypotheses, &mut goal, 3) {
texts.push(generate::two_sided(&hypotheses, &goal));
}
for text in &texts {
let options = Options::default().with_copies(Some(copies));
agree(text, Mode::INTUITIONISTIC, &options);
agree(text, Mode::INTUITIONISTIC.with_affine(), &options);
}
}
}
}
fn first_order(sequent: &Sequent, mode: Mode, options: &Options, jobs: usize) -> Option<bool> {
let options = options.clone().with_jobs(jobs);
let limits = crate::Limits::default().with_work(Some(1 << 22));
let outcome = prove_within(sequent, mode, &options, &limits, |_| false).unwrap();
match outcome.verdict {
Verdict::Proved(proof) => {
assert_eq!(proof.check(mode), Ok(()), "{sequent} on {jobs} threads");
Some(true)
}
Verdict::Unprovable(_) => Some(false),
Verdict::Unknown(
Reason::CopyBound { .. }
| Reason::WitnessDepth { .. }
| Reason::Instances { .. }
| Reason::WorkLimit { .. },
) => None,
Verdict::Unknown(reason) => panic!("{sequent} on {jobs} threads: {reason}"),
}
}
#[test]
fn first_order_verdicts_agree() {
use crate::linear::families::FAMILIES;
use crate::linear::search::reference_fo::tests::{random_ill_text, random_sequent};
for (name, sizes, indices) in [
("witness-fo", [4, 6], 4),
("lambek-fo", [8, 16], 5),
("chain-fo", [8, 16], 2),
] {
let family = FAMILIES.iter().find(|f| f.name == name).unwrap();
for (size, index) in sizes
.into_iter()
.flat_map(|s| (0..indices).map(move |i| (s, i)))
{
let instance = family.instance(size, index).unwrap();
let mut options = Options::default().with_copies(instance.copies);
if let Some(depth) = instance.witness_depth {
options = options.with_witness_depth(depth);
}
let one = first_order(&instance.sequent, instance.mode, &options, 1);
for jobs in [2, 4] {
let pool = first_order(&instance.sequent, instance.mode, &options, jobs);
assert_eq!(pool, one, "{} on {jobs} threads", instance.name);
}
}
}
let modes = [
Mode::CLASSICAL,
Mode::CLASSICAL.with_mix(),
Mode::CLASSICAL.with_affine(),
];
let options = Options::default().with_copies(Some(1));
let mut rng = Rng::new(4700);
for i in 0..240 {
let rules = [i % 2 == 1, i % 4 >= 2, i % 8 >= 4];
let text = random_sequent(&mut rng, rules);
let sequent: Sequent = text.parse().unwrap();
let mode = modes[i % 3];
let one = first_order(&sequent, mode, &options, 1);
for jobs in [2, 4] {
let pool = first_order(&sequent, mode, &options, jobs);
assert!(
one.is_none() || pool.is_none() || one == pool,
"{text:?} in {mode} mode: {one:?} on one thread, {pool:?} on {jobs}"
);
}
}
let modes = [Mode::INTUITIONISTIC, Mode::INTUITIONISTIC.with_affine()];
for i in 0..160 {
let text = random_ill_text(&mut rng, [i % 2 == 1, i % 4 >= 2]);
let sequent: Sequent = text.parse().unwrap();
let mode = modes[i % 2];
let one = first_order(&sequent, mode, &options, 1);
for jobs in [2, 4] {
let pool = first_order(&sequent, mode, &options, jobs);
assert!(
one.is_none() || pool.is_none() || one == pool,
"{text:?} in {mode} mode: {one:?} on one thread, {pool:?} on {jobs}"
);
}
}
}
#[test]
fn stops() {
let sequent = crate::linear::families::mix(11);
let options = Options::default().with_jobs(4);
let mut polls = 0;
let outcome = prove_within(
&sequent,
Mode::CLASSICAL.with_mix(),
&options,
&crate::Limits::default(),
|_| {
polls += 1;
polls > 20
},
)
.unwrap();
assert!(
matches!(outcome.verdict, Verdict::Unknown(Reason::Stopped)),
"{:?}",
outcome.verdict
);
assert!(outcome.statistics.nodes > 0);
let input = format!(
"|- p * q, 0 * (~p par ~p), 0 * (~q par ~q), {}",
crate::linear::search::focus::tests::wide_context()
);
let sequent: Sequent = input.parse().unwrap();
let mut polls = 0;
let outcome = prove_within(
&sequent,
Mode::CLASSICAL.with_affine(),
&options,
&crate::Limits::default(),
|_| {
polls += 1;
polls > 20
},
)
.unwrap();
assert!(
matches!(outcome.verdict, Verdict::Unknown(Reason::Stopped)),
"{:?}",
outcome.verdict
);
}
#[test]
fn a_premise_that_gives_up_cancels_no_other() {
let chain = format!("{}0{}", "(0 + ".repeat(40), ")".repeat(40));
let pairs: Vec<String> = (0..6)
.map(|i| format!("(a{i} * b{i}) + 0, (~a{i} * ~b{i}) + 0"))
.collect();
let sequent: Sequent = format!("|- bot & {chain}, {}", pairs.join(", "))
.parse()
.unwrap();
for jobs in [1, 2, 4] {
let options = Options::default().with_jobs(jobs);
let limits = crate::Limits::default().with_recursion_depth(24);
let mode = Mode::CLASSICAL.with_mix();
let outcome = prove_within(&sequent, mode, &options, &limits, |_| false).unwrap();
assert!(
matches!(outcome.verdict, Verdict::Unprovable(_)),
"{:?} on {jobs} threads",
outcome.verdict
);
}
}
#[test]
fn nested_premises_that_give_up_search_no_tree() {
let chain = format!("{}0{}", "(0 + ".repeat(40), ")".repeat(40));
let withs = vec!["bot & bot"; 16].join(", ");
let sequent: Sequent = format!("|- {withs}, {chain}").parse().unwrap();
for jobs in [2, 4] {
let options = Options::default().with_jobs(jobs).with_classical_work(0);
let limits = crate::Limits::default().with_recursion_depth(36);
let outcome =
prove_within(&sequent, Mode::CLASSICAL, &options, &limits, |_| false).unwrap();
assert!(
matches!(
outcome.verdict,
Verdict::Unknown(Reason::RecursionLimit { .. })
),
"{:?} on {jobs} threads",
outcome.verdict
);
assert!(
outcome.statistics.nodes < 1_000,
"{} stable sequents on {jobs} threads",
outcome.statistics.nodes
);
}
}
#[test]
fn a_cancelled_premise_starts_no_other() {
let roots: Vec<String> = (0..40).map(|i| format!("a{i} & b{i}")).collect();
let sequent: Sequent = format!("|- {}", roots.join(", ")).parse().unwrap();
for jobs in [2, 4] {
let options = Options::default().with_jobs(jobs);
let outcome = prove(&sequent, Mode::CLASSICAL, &options).unwrap();
assert!(matches!(outcome.verdict, Verdict::Unprovable(_)));
assert!(
outcome.statistics.nodes < 100_000,
"{} stable sequents on {jobs} threads",
outcome.statistics.nodes
);
}
}
#[test]
fn a_raised_limit_holds_on_the_pool() {
let n = 2_900;
let tower = |i: usize| format!("{}c{i}{}", "b & (".repeat(n), ")".repeat(n));
let sequent: Sequent = format!("|- ?({}), ?({}), ~b", tower(0), tower(1))
.parse()
.unwrap();
let limits = crate::Limits::default().with_recursion_depth(3_000);
let options = Options::default().with_jobs(2).with_classical_work(0);
let outcome = prove_within(
&sequent,
Mode::CLASSICAL.with_affine(),
&options,
&limits,
|_| false,
)
.unwrap();
assert!(
matches!(
outcome.verdict,
Verdict::Unknown(Reason::RecursionLimit { .. } | Reason::CopyBound { .. })
),
"{:?}",
outcome.verdict
);
}
#[test]
fn a_panicking_stop_ends_every_worker() {
let (sender, ended) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let sequent = crate::linear::families::mix(11);
let options = Options::default().with_jobs(2);
let mut polls = 0;
let panicked = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
prove_within(
&sequent,
Mode::CLASSICAL.with_mix(),
&options,
&crate::Limits::default(),
|_| {
polls += 1;
assert!(polls < 20, "the stop condition panics");
false
},
)
}));
sender.send(panicked.is_err()).unwrap();
});
let panicked = ended.recv_timeout(std::time::Duration::from_secs(20));
assert_eq!(panicked, Ok(true));
}
#[test]
fn a_skipped_alternative_is_no_failure() {
use std::sync::atomic::{AtomicBool, Ordering};
let cancel = AtomicBool::new(false);
let mut collected = super::Collected::<super::super::zone::Ground>::new();
collected.skip(&cancel);
assert_eq!(collected.error, Some(Reason::Stopped));
assert!(cancel.load(Ordering::Relaxed));
}
}