use std::sync::atomic::{fence, AtomicBool, Ordering};
use std::sync::Arc;
use crate::copy;
use crate::error::{Error, Result};
use crate::layout::{align_up, frame_size, max_payload, reserve_block, FRAME_HEADER, PAD};
use crate::mapping::Mapping;
pub struct Producer {
map: Arc<Mapping>,
taken: Arc<AtomicBool>,
local: u64,
cached_reserved: u64,
scratch: Vec<u8>,
}
impl Producer {
pub(crate) fn new(map: Arc<Mapping>, taken: Arc<AtomicBool>) -> Self {
let local = map.published().load(Ordering::Acquire);
let cached_reserved = map.reserved().load(Ordering::Acquire);
Self {
map,
taken,
local,
cached_reserved,
scratch: Vec::new(),
}
}
pub fn max_payload(&self) -> usize {
max_payload(self.map.capacity())
}
pub fn position(&self) -> u64 {
self.local
}
pub fn write(&mut self, payload: &[u8]) -> Result<()> {
self.write_frame(payload)
}
pub fn write_with(&mut self, len: usize, fill: impl FnOnce(&mut [u8])) -> Result<()> {
let max = self.max_payload();
if len > max {
return Err(Error::MessageTooLarge { len, max });
}
if self.scratch.len() < len {
self.scratch.resize(len, 0);
}
let mut scratch = std::mem::take(&mut self.scratch);
scratch[..len].fill(0);
fill(&mut scratch[..len]);
let result = self.write_frame(&scratch[..len]);
self.scratch = scratch;
result
}
fn write_frame(&mut self, payload: &[u8]) -> Result<()> {
let len = payload.len();
let max = self.max_payload();
if len > max {
return Err(Error::MessageTooLarge { len, max });
}
let cap = self.map.capacity();
let mask = self.map.mask();
let size = frame_size(len);
let mut start = self.local;
let idx = start & mask;
let room = cap - idx;
let pad = if size > room { room } else { 0 };
let end = start + pad + size;
if end > self.cached_reserved {
self.cached_reserved = align_up(end, reserve_block(cap));
self.map
.reserved()
.store(self.cached_reserved, Ordering::Release);
}
fence(Ordering::Release);
let base = self.map.buffer_ptr();
if pad != 0 {
unsafe { copy::write_word(base.add(idx as usize), PAD) };
start += pad;
}
let fidx = (start & mask) as usize;
unsafe {
copy::write_word(base.add(fidx), len as u64);
copy::write(base.add(fidx + FRAME_HEADER), payload);
}
self.local = end;
self.map.published().store(end, Ordering::Release);
Ok(())
}
}
impl Drop for Producer {
fn drop(&mut self) {
self.map.release_producer();
self.taken.store(false, Ordering::Release);
}
}