use store_io_core::error::{Error, NotWrittenCause, Op};
use store_io_platform::{IoBuf, Platform};
use crate::io::{Chunks, Placed, ctx, ctx_range, not_written};
use crate::mapped::Mapped;
use crate::receipt::{DurableReceipt, RegionPos, WriteTicket};
use crate::region::{AppendRegion, PageRegion};
use crate::settle::{Wrote, settle_pumped};
use crate::store::Store;
pub struct AppendBatch<P: Platform> {
region: AppendRegion<P>,
chunks: Vec<IoBuf>,
bytes: u64,
records: usize,
}
impl<P: Platform> AppendBatch<P>
where
P::Queue: Send,
{
pub(crate) fn new(region: AppendRegion<P>) -> Self {
Self {
region,
chunks: Vec::new(),
bytes: 0,
records: 0,
}
}
fn store(&self) -> &Store<P> {
self.region.store()
}
fn room(&self) -> usize {
let chunk = self.store().chunk();
self.chunks.last().map_or(0, |b| chunk - b.len())
}
fn grow(&mut self) -> Result<(), Error> {
let mut buf = self
.store()
.take(self.store().chunk(), ctx(self.region.state()))?;
let _empty = buf.set_len(0);
self.chunks.push(buf);
Ok(())
}
fn truncate(&mut self, len: u64) {
let mut total: u64 = self.chunks.iter().map(|b| b.len() as u64).sum();
while let Some(last) = self.chunks.last_mut() {
let l = last.len() as u64;
if total - l >= len {
total -= l;
let _dropped = self.chunks.pop();
continue;
}
let _fits = last.set_len((len - (total - l)) as usize);
break;
}
}
pub fn append(&mut self, data: &[u8]) -> Result<u64, Error> {
if data.is_empty() {
return Err(not_written(
NotWrittenCause::Empty,
ctx(self.region.state()),
));
}
let at = self.bytes;
let mut rest = data;
while !rest.is_empty() {
let room = self.room();
if room == 0 {
if let Err(e) = self.grow() {
self.truncate(at);
return Err(e);
}
continue;
}
let n = room.min(rest.len());
if let Some(last) = self.chunks.last_mut() {
let l = last.len();
last.as_mut_capacity()[l..l + n].copy_from_slice(&rest[..n]);
let _fits = last.set_len(l + n);
}
rest = &rest[n..];
}
self.bytes += data.len() as u64;
self.records += 1;
Ok(at)
}
pub fn append_with(&mut self, len: usize, fill: impl FnOnce(&mut [u8])) -> Result<u64, Error> {
let c = ctx(self.region.state());
if len == 0 {
return Err(not_written(NotWrittenCause::Empty, c));
}
if len > self.max_in_place() {
return Err(not_written(NotWrittenCause::TooLarge, c));
}
if self.room() < len {
let block = self.store().block() as usize;
let mut fresh = self.store().take(self.store().chunk(), c)?;
let mut carried = 0;
if let Some(last) = self.chunks.last_mut() {
let l = last.len();
carried = l % block;
fresh.as_mut_capacity()[..carried].copy_from_slice(&last.as_slice()[l - carried..]);
let _fits = last.set_len(l - carried);
}
let _fits = fresh.set_len(carried);
if self.chunks.last().is_some_and(IoBuf::is_empty) {
let _emptied = self.chunks.pop();
}
self.chunks.push(fresh);
}
if let Some(last) = self.chunks.last_mut() {
let l = last.len();
let slot = &mut last.as_mut_capacity()[l..l + len];
slot.fill(0);
fill(slot);
let _fits = last.set_len(l + len);
}
let at = self.bytes;
self.bytes += len as u64;
self.records += 1;
Ok(at)
}
#[must_use]
pub fn max_in_place(&self) -> usize {
self.store().chunk() - self.store().block() as usize
}
#[must_use]
pub fn len(&self) -> usize {
self.records
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.records == 0
}
#[must_use]
pub fn bytes(&self) -> u64 {
self.bytes
}
pub fn clear(&mut self) {
self.chunks.clear();
self.bytes = 0;
self.records = 0;
}
pub fn write(&mut self) -> Result<(RegionPos, WriteTicket), Error> {
let c = ctx(self.region.state());
if self.records == 0 {
return Err(not_written(NotWrittenCause::Empty, c));
}
let (f, _pass) = self.region.writable()?;
let s = self.region.store();
let state = self.region.state();
let block = s.block() as usize;
let (mut lane, reserved) = s.lane_and_reservation(state, f, self.bytes, c)?;
let r = reserved.range();
if let Some(last) = self.chunks.last_mut() {
let l = last.len();
let padded = l.div_ceil(block) * block;
last.as_mut_capacity()[l..padded].fill(0);
let _fits = last.set_len(padded);
}
let mut src = Chunks {
bufs: self.chunks.drain(..),
offset: r.start,
};
let outcome = s.pump(&mut lane, &mut Mapped::new(&state.map, &mut src));
drop(src);
self.bytes = 0;
self.records = 0;
let r = reserved.disarm();
let ticket = settle_pumped(s, state, Wrote::Append(r), outcome)?;
Ok((ticket.pos(), ticket))
}
pub fn commit(&mut self) -> Result<(RegionPos, DurableReceipt), Error> {
let (pos, ticket) = self.write()?;
let receipt = self.region.sync_through(&ticket)?;
Ok((pos, receipt))
}
}
pub struct PageBatch<P: Platform> {
region: PageRegion<P>,
writes: Vec<(u64, IoBuf)>,
}
impl<P: Platform> PageBatch<P>
where
P::Queue: Send,
{
pub(crate) fn new(region: PageRegion<P>) -> Self {
Self {
region,
writes: Vec::new(),
}
}
pub fn write(&mut self, pos: RegionPos, data: &[u8]) -> Result<(), Error> {
let end = self.region.check(&pos, data.len())?;
let s = self.region.store();
let c = ctx_range(self.region.state(), pos.offset, end);
let chunk = s.chunk();
let before = self.writes.len();
for (i, piece) in data.chunks(chunk).enumerate() {
match s.take(piece.len(), c) {
Ok(mut buf) => {
buf.as_mut_slice().copy_from_slice(piece);
self.writes.push((pos.offset + (i * chunk) as u64, buf));
}
Err(e) => {
self.writes.truncate(before);
return Err(e);
}
}
}
Ok(())
}
pub fn write_with(
&mut self,
pos: RegionPos,
len: usize,
fill: impl FnOnce(&mut [u8]),
) -> Result<(), Error> {
let end = self.region.check(&pos, len)?;
let s = self.region.store();
let c = ctx_range(self.region.state(), pos.offset, end);
if len > s.chunk() {
return Err(not_written(NotWrittenCause::TooLarge, c));
}
let mut buf = s.take(len, c)?;
let slot = buf.as_mut_slice();
slot.fill(0);
fill(slot);
self.writes.push((pos.offset, buf));
Ok(())
}
#[must_use]
pub fn len(&self) -> usize {
self.writes.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.writes.is_empty()
}
pub fn clear(&mut self) {
self.writes.clear();
}
pub fn commit(&mut self) -> Result<DurableReceipt, Error> {
let state = self.region.state();
let c = ctx(state);
if self.writes.is_empty() {
return Err(not_written(NotWrittenCause::Empty, c));
}
let s = self.region.store();
let _pass = self.region.pass()?;
s.ready_for(state)?;
self.writes.sort_unstable_by_key(|(at, _)| *at);
let overlap = self
.writes
.windows(2)
.any(|w| w[0].0 + w[0].1.len() as u64 > w[1].0);
if overlap {
return Err(not_written(NotWrittenCause::Overlap, c));
}
let start = self.writes.first().map_or(0, |(at, _)| *at);
let end = self.writes.last().map_or(0, |(at, b)| at + b.len() as u64);
let mut lane = if self.writes.len() > 1 {
s.par_lane(state, Op::Write)?
} else {
s.lane(state, Op::Write)?
};
let mut src = Placed {
writes: self.writes.drain(..),
};
let outcome = s.pump(&mut lane, &mut Mapped::new(&state.map, &mut src));
drop(src);
let _span = settle_pumped(s, state, Wrote::Page { start, end }, outcome)?;
drop(lane);
let (need, synced) = s.barrier_for(state)?;
Ok(s.receipt(state, start, end, need, false, synced))
}
}
impl<P: Platform> core::fmt::Debug for AppendBatch<P> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("AppendBatch")
.field("region", &self.region)
.field("records", &self.records)
.field("bytes", &self.bytes)
.finish()
}
}
impl<P: Platform> core::fmt::Debug for PageBatch<P> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("PageBatch")
.field("region", &self.region)
.field("writes", &self.writes.len())
.finish()
}
}