use std::cell::RefCell;
use std::sync::{Arc, PoisonError};
#[cfg(loom)]
use loom::sync::{Condvar, Mutex, MutexGuard};
#[cfg(not(loom))]
use std::sync::{Condvar, Mutex, MutexGuard};
use crate::sync::{AtomicU64, Ordering};
use store_io_core::error::{Error, ErrorContext, FirstCause, NotWrittenCause};
use store_io_platform::{IoBuf, Platform};
use crate::completion::{Rejected, WriteMode};
use crate::domain::{Patience, PoisonWaker};
use crate::flusher::{Answer, Flushed};
use crate::io::not_written;
use crate::receipt::{DurableReceipt, RegionPos, WriteTicket};
use crate::region::{AppendRegion, PageRegion, sync_tail};
use crate::settle::in_range;
use crate::store::{LiveRegion, Store};
use crate::submitter::Submitter;
pub const MAX_SET_STORES: usize = 1 << 16;
const INDEX_BITS: u32 = 16;
const SEQ_MASK: u64 = (1 << (64 - INDEX_BITS)) - 1;
const SPARE_KEEP: usize = 1024;
static CALLS: core::sync::atomic::AtomicU64 = core::sync::atomic::AtomicU64::new(1);
pub struct StoreSet<P: Platform> {
stores: Vec<Store<P>>,
patience: Patience,
barriers: core::sync::atomic::AtomicU64,
stores_flushed: core::sync::atomic::AtomicU64,
sleeps: core::sync::atomic::AtomicU64,
fallbacks: core::sync::atomic::AtomicU64,
}
impl<P: Platform> core::fmt::Debug for StoreSet<P> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("StoreSet")
.field("stores", &self.stores.len())
.finish_non_exhaustive()
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct SetStats {
pub barriers: u64,
pub stores: u64,
pub sleeps: u64,
pub fallbacks: u64,
}
impl<P: Platform> StoreSet<P>
where
P::Queue: Send,
{
pub fn new<S: Into<Store<P>>>(stores: impl IntoIterator<Item = S>) -> Result<Self, Error> {
let stores: Vec<Store<P>> = stores.into_iter().map(Into::into).collect();
let refuse = |cause| not_written(cause, ErrorContext::default());
if stores.len() > MAX_SET_STORES {
return Err(refuse(NotWrittenCause::InvalidOptions));
}
for (i, s) in stores.iter().enumerate() {
if s.inner.read_only {
return Err(refuse(NotWrittenCause::ReadOnly));
}
let twice = stores[..i]
.iter()
.any(|t| Arc::ptr_eq(&t.inner, &s.inner) || t.inner.volume == s.inner.volume);
if twice {
return Err(refuse(NotWrittenCause::Overlap));
}
}
Ok(Self {
stores,
patience: Patience::default(),
barriers: core::sync::atomic::AtomicU64::new(0),
stores_flushed: core::sync::atomic::AtomicU64::new(0),
sleeps: core::sync::atomic::AtomicU64::new(0),
fallbacks: core::sync::atomic::AtomicU64::new(0),
})
}
#[must_use]
pub fn len(&self) -> usize {
self.stores.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.stores.is_empty()
}
pub fn iter(&self) -> core::slice::Iter<'_, Store<P>> {
self.stores.iter()
}
#[must_use]
pub fn distinct(&self, i: usize, j: usize) -> bool {
let identity = |s: &Store<P>| {
let inner = &s.inner;
inner.platform.device_identity(&inner._dir, &inner.file)
};
identity(&self.stores[i]).distinct(&identity(&self.stores[j]))
}
pub fn ditto(
&self,
regions: &[&AppendRegion<P>],
bytes: &[u8],
) -> Result<Vec<Result<WriteTicket, Error>>, Error> {
let at = self.ditto_checked(regions.iter().map(|r| r.store()))?;
Ok(in_set_order(&at, |k| regions[k].append(bytes)))
}
pub fn ditto_pages(
&self,
writes: &[(&PageRegion<P>, RegionPos)],
bytes: &[u8],
) -> Result<Vec<Result<WriteTicket, Error>>, Error> {
let at = self.ditto_checked(writes.iter().map(|(r, _)| r.store()))?;
for (r, pos) in writes {
let _end = r.check(pos, bytes.len())?;
}
Ok(in_set_order(&at, |k| writes[k].0.write(writes[k].1, bytes)))
}
fn ditto_checked<'s>(
&self,
stores: impl Iterator<Item = &'s Store<P>>,
) -> Result<Vec<usize>, Error>
where
P: 's,
{
let refuse = |cause| not_written(cause, ErrorContext::default());
let mut at = Vec::new();
for s in stores {
let i = self
.stores
.iter()
.position(|t| Arc::ptr_eq(&t.inner, &s.inner))
.ok_or_else(|| refuse(NotWrittenCause::ForeignPosition))?;
at.push(i);
}
let identities: Vec<_> = at
.iter()
.map(|&i| {
let inner = &self.stores[i].inner;
inner.platform.device_identity(&inner._dir, &inner.file)
})
.collect();
for (a, x) in identities.iter().enumerate() {
for y in &identities[a + 1..] {
if !x.distinct(y) {
return Err(refuse(NotWrittenCause::SameDevice));
}
}
}
Ok(at)
}
#[must_use]
pub fn stats(&self) -> SetStats {
use core::sync::atomic::Ordering::Relaxed;
SetStats {
barriers: self.barriers.load(Relaxed),
stores: self.stores_flushed.load(Relaxed),
sleeps: self.sleeps.load(Relaxed),
fallbacks: self.fallbacks.load(Relaxed),
}
}
pub fn barrier(&self, tickets: &[&WriteTicket]) -> Result<Vec<DurableReceipt>, Error> {
self.barrier_each(tickets)?.into_iter().collect()
}
pub fn barrier_each(
&self,
tickets: &[&WriteTicket],
) -> Result<Vec<Result<DurableReceipt, Error>>, Error> {
use core::sync::atomic::Ordering::Relaxed;
let mut call = Call::new(self, tickets)?;
let _ = self.barriers.fetch_add(1, Relaxed);
call.run();
let _ = self.stores_flushed.fetch_add(call.stores_waited(), Relaxed);
let _ = self.sleeps.fetch_add(call.sleeps, Relaxed);
let _ = self.fallbacks.fetch_add(call.fallbacks, Relaxed);
Ok(call.finish())
}
fn member(&self, store: &Store<P>) -> Result<(), Error> {
if self
.stores
.iter()
.any(|s| Arc::ptr_eq(&s.inner, &store.inner))
{
Ok(())
} else {
Err(not_written(
NotWrittenCause::ForeignPosition,
ErrorContext::default(),
))
}
}
pub fn append_after(
&self,
region: &AppendRegion<P>,
deps: &[DurableReceipt],
bytes: &[u8],
) -> Result<WriteTicket, Error> {
self.member(region.store())?;
region.append_after_in(deps, bytes, &self.stores)
}
pub fn write_after(
&self,
region: &PageRegion<P>,
deps: &[DurableReceipt],
pos: RegionPos,
bytes: &[u8],
) -> Result<WriteTicket, Error> {
self.member(region.store())?;
region.write_after_in(deps, pos, bytes, &self.stores)
}
}
impl<P: Platform> core::ops::Index<usize> for StoreSet<P> {
type Output = Store<P>;
fn index(&self, i: usize) -> &Store<P> {
&self.stores[i]
}
}
impl<'a, P: Platform> IntoIterator for &'a StoreSet<P> {
type Item = &'a Store<P>;
type IntoIter = core::slice::Iter<'a, Store<P>>;
fn into_iter(self) -> Self::IntoIter {
self.stores.iter()
}
}
impl<P: Platform> Submitter<P>
where
P::Queue: Send,
{
pub fn append_after_in(
&mut self,
set: &StoreSet<P>,
region: &AppendRegion<P>,
deps: &[DurableReceipt],
buf: IoBuf,
mode: WriteMode,
tag: u64,
) -> Result<RegionPos, Rejected> {
if let Err(error) = set.member(&self.store) {
return Err(Rejected {
error,
buf: Some(buf),
});
}
self.append_after_with(region, deps, buf, mode, tag, &set.stores)
}
#[allow(clippy::too_many_arguments)]
pub fn write_after_in(
&mut self,
set: &StoreSet<P>,
region: &PageRegion<P>,
deps: &[DurableReceipt],
pos: RegionPos,
buf: IoBuf,
mode: WriteMode,
tag: u64,
) -> Result<(), Rejected> {
if let Err(error) = set.member(&self.store) {
return Err(Rejected {
error,
buf: Some(buf),
});
}
self.write_after_with(region, deps, pos, buf, mode, tag, &set.stores)
}
}
fn in_set_order<T>(
at: &[usize],
mut write: impl FnMut(usize) -> Result<T, Error>,
) -> Vec<Result<T, Error>> {
let mut order: Vec<usize> = (0..at.len()).collect();
order.sort_by_key(|&k| at[k]);
let mut out: Vec<Option<Result<T, Error>>> = (0..at.len()).map(|_| None).collect();
for k in order {
out[k] = Some(write(k));
}
out.into_iter()
.map(|r| {
r.unwrap_or_else(|| {
Err(not_written(
NotWrittenCause::ForeignPosition,
ErrorContext::default(),
))
})
})
.collect()
}
pub(crate) struct Answers {
state: Mutex<AnswerState>,
ready: Condvar,
posted: AtomicU64,
poisons: AtomicU64,
}
struct AnswerState {
seq: u64,
slots: Vec<Option<Flushed>>,
}
struct Spare {
answers: Arc<Answers>,
states: Vec<Ticket>,
store_of: Vec<usize>,
parts: Vec<Part>,
}
thread_local! {
static SPARE: RefCell<Option<Spare>> = const { RefCell::new(None) };
}
fn lock_answers(a: &Answers) -> MutexGuard<'_, AnswerState> {
a.state.lock().unwrap_or_else(PoisonError::into_inner)
}
impl Spare {
fn take() -> Self {
let mut s = SPARE
.try_with(|s| s.try_borrow_mut().ok().and_then(|mut s| s.take()))
.ok()
.flatten()
.unwrap_or_else(|| Self {
answers: Arc::new(Answers {
state: Mutex::new(AnswerState {
seq: 0,
slots: Vec::new(),
}),
ready: Condvar::new(),
posted: AtomicU64::new(0),
poisons: AtomicU64::new(0),
}),
states: Vec::new(),
store_of: Vec::new(),
parts: Vec::new(),
});
s.states.clear();
s.store_of.clear();
s.parts.clear();
s
}
fn give_back(mut self) {
if self.parts.capacity() > SPARE_KEEP || self.states.capacity() > SPARE_KEEP {
return;
}
self.states.clear();
let _kept = SPARE.try_with(|s| {
if let Ok(mut slot) = s.try_borrow_mut() {
*slot = Some(self);
}
});
}
}
impl Answers {
fn reset(&self, seq: u64, stores: usize) {
let mut st = lock_answers(self);
st.seq = seq & SEQ_MASK;
st.slots.clear();
st.slots.resize_with(stores, || None);
self.posted.store(0, Ordering::SeqCst);
self.poisons.store(0, Ordering::SeqCst);
}
}
fn wait_settled(a: &Answers, settled: impl Fn(&AnswerState) -> bool) -> u64 {
let mut st = lock_answers(a);
let mut sleeps = 0;
while !settled(&st) {
sleeps += 1;
crate::test_hook::step(crate::test_hook::Step::AnswersWait);
st = a.ready.wait(st).unwrap_or_else(PoisonError::into_inner);
}
sleeps
}
impl Answer for Answers {
fn post(&self, tag: u64, outcome: Flushed) {
let (seq, i) = (tag >> INDEX_BITS, (tag & ((1 << INDEX_BITS) - 1)) as usize);
let mut st = lock_answers(self);
if st.seq != seq {
return;
}
if let Some(slot) = st.slots.get_mut(i) {
if slot.is_none() {
*slot = Some(outcome);
let _ = self.posted.fetch_add(1, Ordering::SeqCst);
}
}
}
fn signal(&self) {
crate::test_hook::step(crate::test_hook::Step::AnswerPosted);
self.ready.notify_one();
}
}
impl PoisonWaker for Answers {
fn poisoned(&self) {
let _ = self.poisons.fetch_add(1, Ordering::SeqCst);
let _sync = lock_answers(self);
self.ready.notify_one();
}
}
enum Ticket {
Done(Result<DurableReceipt, Error>),
Append {
region: Arc<LiveRegion>,
synced: bool,
snapshot: Option<u64>,
},
Page { synced: bool },
}
#[derive(Default)]
struct Part {
open: usize,
ready: bool,
need: u64,
outcome: Option<Flushed>,
handed: Option<u64>,
}
struct Call<'a, P: Platform>
where
P::Queue: Send,
{
set: &'a StoreSet<P>,
tickets: &'a [&'a WriteTicket],
states: Vec<Ticket>,
store_of: Vec<usize>,
parts: Vec<Part>,
answers: Arc<Answers>,
seq: u64,
sleeps: u64,
fallbacks: u64,
}
impl<'a, P: Platform> Call<'a, P>
where
P::Queue: Send,
{
fn new(set: &'a StoreSet<P>, tickets: &'a [&'a WriteTicket]) -> Result<Self, Error> {
let Spare {
answers,
mut states,
mut store_of,
mut parts,
} = Spare::take();
for t in tickets {
let at = set
.stores
.iter()
.position(|s| s.inner.volume == t.volume && s.inner.epoch == t.epoch);
let Some(i) = at else {
Spare {
answers,
states,
store_of,
parts,
}
.give_back();
return Err(not_written(NotWrittenCause::ForeignPosition, ctx(t)));
};
store_of.push(i);
}
parts.resize_with(set.stores.len(), Part::default);
for (t, &i) in tickets.iter().zip(&store_of) {
let state = Self::matched(&set.stores[i], t);
if !matches!(state, Ticket::Done(_)) {
parts[i].open += 1;
}
states.push(state);
}
let seq = CALLS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
answers.reset(seq, set.stores.len());
Ok(Self {
set,
tickets,
states,
store_of,
parts,
answers,
seq,
sleeps: 0,
fallbacks: 0,
})
}
fn matched(store: &Store<P>, t: &WriteTicket) -> Ticket {
let c = ctx(t);
let found = store
.inner
.regions
.lock()
.unwrap_or_else(PoisonError::into_inner)
.iter()
.find(|r| r.id == t.region)
.map(Arc::clone);
let Some(region) = found else {
return Ticket::Done(Err(not_written(NotWrittenCause::NotReady, c)));
};
if region.generation != t.generation || region.gate.check().is_err() {
return Ticket::Done(Err(not_written(NotWrittenCause::StaleGeneration, c)));
}
let flushes = store.inner.policy.flush;
let synced = flushes || region.forced();
let Some(f) = region.frontier.as_ref() else {
return Ticket::Page { synced };
};
let durable = if synced && !flushes {
f.synced()
} else {
f.durable()
};
if durable >= t.end {
store.inner.domain.count_already_durable();
return Ticket::Done(Ok(store.receipt(®ion, 0, durable, 0, true, synced)));
}
Ticket::Append {
region,
synced,
snapshot: None,
}
}
fn run(&mut self) {
let mut lead: Option<usize> = None;
loop {
for i in 0..self.parts.len() {
if self.parts[i].open == 0 || self.parts[i].ready || !self.is_ready(i) {
continue;
}
if self.ready(i) {
if let Some(prev) = lead.replace(i) {
self.hand_off(prev);
}
}
}
if self.parts.iter().all(|p| p.open == 0 || p.ready) {
break;
}
if let Some(prev) = lead.take() {
self.hand_off(prev);
}
if let Some(waiting) = self.first_unready() {
self.wait_ready(waiting);
}
}
let mut budget = (0, 0);
if let Some(i) = lead {
let need = self.parts[i].need;
let store = &self.set.stores[i];
let timed = self.parts.iter().any(|p| p.handed.is_some());
let clock = || {
if timed {
store.inner.platform.monotonic_ns()
} else {
0
}
};
let start = clock();
self.parts[i].outcome = Some(store.barrier_to(need).map(|()| need));
let end = clock();
budget = (end, end.saturating_sub(start));
}
self.collect(lead, budget);
}
fn is_ready(&self, i: usize) -> bool {
if self.set.stores[i].inner.domain.poisoned().is_some() {
return true;
}
self.states
.iter()
.zip(self.tickets)
.zip(&self.store_of)
.all(|((s, t), &j)| match s {
Ticket::Append { region, .. } if j == i => region
.frontier
.as_ref()
.is_none_or(|f| f.completed() >= t.end),
_ => true,
})
}
fn ready(&mut self, i: usize) -> bool {
let store = &self.set.stores[i];
let domain = &store.inner.domain;
let mut need = 0;
let mut appends = false;
let mut flush = store.inner.policy.flush;
for ((s, t), &j) in self.states.iter_mut().zip(self.tickets).zip(&self.store_of) {
if j != i {
continue;
}
match s {
Ticket::Append {
region,
synced,
snapshot,
} => {
*snapshot = region.frontier.as_ref().map(|f| f.completed());
appends = true;
flush |= *synced;
}
Ticket::Page { synced } => {
need = need.max(t.need);
flush |= *synced;
}
Ticket::Done(_) => {}
}
}
if appends {
need = need.max(domain.ticket());
}
let part = &mut self.parts[i];
part.ready = true;
part.need = need;
if let Some(first) = domain.poisoned() {
part.outcome = Some(Err(Error::Poisoned { first }));
return false;
}
if !flush {
part.outcome = Some(Ok(u64::MAX));
return false;
}
if domain.join_if_done(need) {
part.outcome = Some(Ok(need));
return false;
}
true
}
fn first_unready(&self) -> Option<(usize, usize)> {
self.states.iter().enumerate().find_map(|(k, s)| match s {
Ticket::Append { region, .. } => {
let i = self.store_of[k];
let done = region
.frontier
.as_ref()
.is_none_or(|f| f.completed() >= self.tickets[k].end);
(!self.parts[i].ready && !done).then_some((i, k))
}
_ => None,
})
}
fn wait_ready(&self, (i, k): (usize, usize)) {
let Ticket::Append { region, .. } = &self.states[k] else {
return;
};
let domain = &self.set.stores[i].inner.domain;
if let Some(f) = region.frontier.as_ref() {
let _reached = f.wait_completed(self.tickets[k].end, || domain.poisoned().is_some());
}
}
fn hand_off(&mut self, i: usize) {
let store = &self.set.stores[i];
let need = self.parts[i].need;
if let Some(f) = store.flusher() {
let waker: Arc<dyn PoisonWaker> = Arc::clone(&self.answers) as Arc<dyn PoisonWaker>;
let key = store.inner.domain.on_poison(waker);
let tag = (self.seq << INDEX_BITS) | i as u64;
if f.request(
need,
store_io_core::IoClass::Commit,
store.inner.domain.arrival(),
tag,
Arc::clone(&self.answers) as Arc<dyn Answer>,
) {
self.parts[i].handed = Some(key);
return;
}
store.inner.domain.forget_poison_waker(key);
}
self.fallbacks += 1;
self.parts[i].outcome = Some(store.barrier_to(need).map(|()| need));
}
fn collect(&mut self, lead: Option<usize>, (start, budget): (u64, u64)) {
let want = self.parts.iter().filter(|p| p.handed.is_some()).count() as u64;
if want == 0 {
return;
}
let answers = Arc::clone(&self.answers);
let all_posted = || {
crate::test_hook::step(crate::test_hook::Step::AnswersYield);
answers.posted.load(Ordering::SeqCst) >= want
|| answers.poisons.load(Ordering::SeqCst) > 0
};
let patience = &self.set.patience;
let reached = match lead {
Some(i) => {
let platform = &self.set.stores[i].inner.platform;
patience.yield_within(start, budget, || platform.monotonic_ns(), all_posted)
}
None => patience.yield_until(all_posted),
};
if !reached || answers.posted.load(Ordering::SeqCst) < want {
let slept = wait_settled(&answers, |st| self.settled(st));
self.sleeps += slept;
}
let mut st = lock_answers(&answers);
for (i, part) in self.parts.iter_mut().enumerate() {
if part.handed.is_none() {
continue;
}
let store = &self.set.stores[i];
part.outcome = Some(st.slots[i].take().unwrap_or_else(|| {
Err(Error::Poisoned {
first: store.inner.domain.poisoned().unwrap_or(FirstCause {
op: None,
raw: None,
}),
})
}));
}
drop(st);
}
fn settled(&self, st: &AnswerState) -> bool {
self.parts.iter().enumerate().all(|(i, p)| {
p.handed.is_none()
|| st.slots[i].is_some()
|| self.set.stores[i].inner.domain.poisoned().is_some()
})
}
fn stores_waited(&self) -> u64 {
self.parts.iter().filter(|p| p.ready).count() as u64
}
fn finish(mut self) -> Vec<Result<DurableReceipt, Error>> {
for (i, part) in self.parts.iter_mut().enumerate() {
if let Some(Ok(n)) = part.outcome {
if n < part.need {
let store = &self.set.stores[i];
store.inner.domain.poison(FirstCause {
op: None,
raw: None,
});
store.wake_frontiers();
part.outcome = Some(Err(Error::Poisoned {
first: store.inner.domain.poisoned().unwrap_or(FirstCause {
op: None,
raw: None,
}),
}));
}
}
}
let mut out = Vec::with_capacity(self.tickets.len());
let mut states = std::mem::take(&mut self.states);
for ((s, t), &i) in states.drain(..).zip(self.tickets).zip(&self.store_of) {
let store = &self.set.stores[i];
let part = &self.parts[i];
out.push(match s {
Ticket::Done(r) => r,
Ticket::Append {
region,
synced,
snapshot,
} => match &part.outcome {
Some(Ok(_)) => {
let need = if synced { part.need } else { u64::MAX };
let through = snapshot.unwrap_or(0);
Ok(sync_tail(store, ®ion, through, need, synced))
}
Some(Err(e)) => failed_append(store, ®ion, t, synced, e),
None => Err(Error::Poisoned {
first: FirstCause {
op: None,
raw: None,
},
}),
},
Ticket::Page { synced } => match &part.outcome {
Some(Ok(_)) => {
let need = if synced { part.need } else { u64::MAX };
Ok(store.receipt_for(t, need))
}
Some(Err(e)) => failed_page(store, t, e),
None => Err(Error::Poisoned {
first: FirstCause {
op: None,
raw: None,
},
}),
},
});
}
self.states = states;
out
}
}
impl<P: Platform> Drop for Call<'_, P>
where
P::Queue: Send,
{
fn drop(&mut self) {
for (i, part) in self.parts.iter_mut().enumerate() {
if let Some(key) = part.handed.take() {
self.set.stores[i].inner.domain.forget_poison_waker(key);
}
}
Spare {
answers: Arc::clone(&self.answers),
states: std::mem::take(&mut self.states),
store_of: std::mem::take(&mut self.store_of),
parts: std::mem::take(&mut self.parts),
}
.give_back();
}
}
fn failed_append<P: Platform>(
store: &Store<P>,
region: &LiveRegion,
t: &WriteTicket,
synced: bool,
e: &Error,
) -> Result<DurableReceipt, Error>
where
P::Queue: Send,
{
let flushes = store.inner.policy.flush;
if let Some(f) = region.frontier.as_ref() {
let durable = if synced && !flushes {
f.synced()
} else {
f.durable()
};
if durable >= t.end {
return Ok(store.receipt(region, 0, durable, 0, true, synced));
}
}
failed_page(store, t, e)
}
fn failed_page<P: Platform>(
store: &Store<P>,
t: &WriteTicket,
e: &Error,
) -> Result<DurableReceipt, Error>
where
P::Queue: Send,
{
if store.inner.domain.join_if_done(t.need) {
Ok(store.receipt_for(t, t.need))
} else {
Err(in_range(e.clone(), t))
}
}
fn ctx(t: &WriteTicket) -> ErrorContext {
ErrorContext {
region: Some(t.region),
range: Some(store_io_core::error::ByteRange {
start: t.start,
end: t.end,
}),
}
}
#[cfg(all(test, loom))]
mod loom_tests {
use super::*;
use crate::domain::Domain;
fn answers(seq: u64) -> Arc<Answers> {
let a = Arc::new(Answers {
state: Mutex::new(AnswerState {
seq: 0,
slots: Vec::new(),
}),
ready: Condvar::new(),
posted: AtomicU64::new(0),
poisons: AtomicU64::new(0),
});
a.reset(seq, 1);
a
}
fn wait(a: &Answers, d: Option<&Domain>) -> Option<Flushed> {
let _slept = wait_settled(a, |st| {
st.slots[0].is_some() || d.is_some_and(|d| d.poisoned().is_some())
});
lock_answers(a).slots[0].take()
}
#[test]
fn loom_reused_answers_drop_a_late_outcome() {
loom::model(|| {
let a = answers(1);
let late = {
let a = Arc::clone(&a);
loom::thread::spawn(move || {
a.post(1 << INDEX_BITS, Ok(7));
a.signal();
})
};
a.reset(2, 1);
let own = {
let a = Arc::clone(&a);
loom::thread::spawn(move || {
a.post(2 << INDEX_BITS, Ok(9));
a.signal();
})
};
assert!(matches!(wait(&a, None), Some(Ok(9))));
let _l = late.join();
let _o = own.join();
});
}
#[test]
fn loom_a_poison_around_the_registration_ends_the_wait() {
loom::model(|| {
let d = Arc::new(Domain::new());
let a = answers(1);
let poisoner = {
let d = Arc::clone(&d);
loom::thread::spawn(move || {
d.poison(FirstCause {
op: None,
raw: None,
});
})
};
let key = d.on_poison(Arc::clone(&a) as Arc<dyn PoisonWaker>);
assert!(wait(&a, Some(&d)).is_none());
d.forget_poison_waker(key);
let _p = poisoner.join();
});
}
}