use std::sync::Arc;
use std::sync::atomic::Ordering;
use store_io_core::error::{ByteRange, Error, ErrorContext, NotWrittenCause};
use store_io_core::observe::Counter;
use store_io_format::meta::RegionKind;
use store_io_platform::{IoBuf, Platform};
use crate::completion::{Rejected, WriteMode};
use crate::frontier::{self, Earlier};
use crate::gate::OwnedPass;
use crate::io::not_written;
use crate::lifecycle::retired_error;
use crate::receipt::{DurableReceipt, RegionPos, WriteTicket};
use crate::region::{AppendRegion, PageRegion};
use crate::store::{LiveRegion, Store};
use crate::submitter::Submitter;
use crate::test_hook::{self, Step};
pub(crate) struct Checked {
regions: Vec<Arc<LiveRegion>>,
}
pub(crate) struct Passes {
_held: Vec<OwnedPass<LiveRegion>>,
}
fn dep_ctx(d: &DurableReceipt) -> ErrorContext {
ErrorContext {
region: Some(d.region),
range: Some(ByteRange {
start: d.start,
end: d.through,
}),
}
}
pub(crate) fn check_deps<P: Platform>(
deps: &[DurableReceipt],
reach: &[Store<P>],
) -> Result<Checked, Error> {
let mut matched = Vec::with_capacity(deps.len());
for d in deps {
let c = dep_ctx(d);
if d.append && !d.prefix {
return Err(not_written(NotWrittenCause::NotPrefix, c));
}
let mut vouched = true;
let at = match reach
.iter()
.position(|s| s.inner.volume == d.volume && s.inner.epoch == d.epoch)
{
Some(i) => Some(i),
None => match reach.iter().position(|s| s.inner.volume == d.volume) {
Some(i) => match frontier::earlier_open(reach[i].inner.epoch, d.epoch) {
Earlier::Same { vouched: v } => {
vouched = v;
Some(i)
}
Earlier::Other => None,
Earlier::Unknown => {
return Err(not_written(NotWrittenCause::StaleGeneration, c));
}
},
None => None,
},
};
let Some(i) = at else {
continue;
};
let store = &reach[i].inner;
let region = store
.regions
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.iter()
.find(|r| r.id == d.region)
.map(Arc::clone);
let Some(region) = region else {
return Err(not_written(NotWrittenCause::NotReady, c));
};
if region.kind != RegionKind::Slot && region.generation != d.generation {
return Err(not_written(NotWrittenCause::StaleGeneration, c));
}
if d.epoch != store.epoch && region.frontier.is_some() {
if !region.positioned.load(Ordering::Acquire) {
return Err(not_written(NotWrittenCause::NotPositioned, c));
}
if !vouched {
return Err(not_written(NotWrittenCause::StaleGeneration, c));
}
if frontier::resumed_below((d.volume, d.region, d.generation), d.epoch, d.through) {
return Err(not_written(NotWrittenCause::StaleGeneration, c));
}
}
matched.push((i, region));
}
matched.sort_by_key(|(i, _)| *i);
Ok(Checked {
regions: matched.into_iter().map(|(_, r)| r).collect(),
})
}
impl Checked {
pub(crate) fn take_passes(&self) -> Result<Passes, Error> {
test_hook::step(Step::BeforePasses);
let held = self
.regions
.iter()
.map(|r| OwnedPass::enter(r).map_err(|why| retired_error(why, r)))
.collect::<Result<Vec<_>, Error>>()?;
test_hook::step(Step::BeforeReserve);
Ok(Passes { _held: held })
}
}
fn reserved(passes: Passes) {
test_hook::step(Step::Reserved);
drop(passes);
}
fn to_issue(passes: Passes) -> Passes {
test_hook::step(Step::Reserved);
passes
}
fn count<P: Platform>(s: &Store<P>, deps: &[DurableReceipt]) {
s.inner
.observer
.add(Counter::Dependencies, deps.len() as u64);
}
impl<P: Platform> AppendRegion<P>
where
P::Queue: Send,
{
pub fn append_after(&self, deps: &[DurableReceipt], data: &[u8]) -> Result<WriteTicket, Error> {
self.append_after_in(deps, data, core::slice::from_ref(self.store()))
}
pub(crate) fn append_after_in(
&self,
deps: &[DurableReceipt],
data: &[u8],
reach: &[Store<P>],
) -> Result<WriteTicket, Error> {
let checked = check_deps(deps, reach)?;
test_hook::step(Step::BeforeLane);
let ticket = self.append_with(data, || checked.take_passes(), reserved)?;
count(self.store(), deps);
Ok(ticket)
}
}
impl<P: Platform> PageRegion<P>
where
P::Queue: Send,
{
pub fn write_after(
&self,
deps: &[DurableReceipt],
pos: RegionPos,
data: &[u8],
) -> Result<WriteTicket, Error> {
self.write_after_in(deps, pos, data, core::slice::from_ref(self.store()))
}
pub(crate) fn write_after_in(
&self,
deps: &[DurableReceipt],
pos: RegionPos,
data: &[u8],
reach: &[Store<P>],
) -> Result<WriteTicket, Error> {
let checked = check_deps(deps, reach)?;
test_hook::step(Step::BeforeLane);
let ticket = self.write_with(pos, data, || checked.take_passes().map(to_issue))?;
count(self.store(), deps);
Ok(ticket)
}
}
impl<P: Platform> Submitter<P>
where
P::Queue: Send,
{
pub fn append_after(
&mut self,
region: &AppendRegion<P>,
deps: &[DurableReceipt],
buf: IoBuf,
mode: WriteMode,
tag: u64,
) -> Result<RegionPos, Rejected> {
let reach = core::slice::from_ref(region.store());
self.append_after_with(region, deps, buf, mode, tag, reach)
}
pub(crate) fn append_after_with(
&mut self,
region: &AppendRegion<P>,
deps: &[DurableReceipt],
buf: IoBuf,
mode: WriteMode,
tag: u64,
reach: &[Store<P>],
) -> Result<RegionPos, Rejected> {
let checked = match check_deps(deps, reach) {
Ok(checked) => checked,
Err(error) => {
return Err(Rejected {
error,
buf: Some(buf),
});
}
};
test_hook::step(Step::BeforeLane);
let pos = self.append_with(region, buf, mode, tag, || checked.take_passes(), reserved)?;
count(region.store(), deps);
Ok(pos)
}
pub fn write_after(
&mut self,
region: &PageRegion<P>,
deps: &[DurableReceipt],
pos: RegionPos,
buf: IoBuf,
mode: WriteMode,
tag: u64,
) -> Result<(), Rejected> {
let reach = core::slice::from_ref(region.store());
self.write_after_with(region, deps, pos, buf, mode, tag, reach)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn write_after_with(
&mut self,
region: &PageRegion<P>,
deps: &[DurableReceipt],
pos: RegionPos,
buf: IoBuf,
mode: WriteMode,
tag: u64,
reach: &[Store<P>],
) -> Result<(), Rejected> {
let checked = match check_deps(deps, reach) {
Ok(checked) => checked,
Err(error) => {
return Err(Rejected {
error,
buf: Some(buf),
});
}
};
test_hook::step(Step::BeforeLane);
self.write_with(region, pos, buf, mode, tag, || {
checked.take_passes().map(to_issue)
})?;
count(region.store(), deps);
Ok(())
}
}