use parking_lot::{Condvar, Mutex};
use crate::error::Result;
pub struct GroupFsync {
state: Mutex<GroupFsyncState>,
cv: Condvar,
}
struct GroupFsyncState {
next_ticket: u64,
last_fsynced: u64,
leader_active: bool,
}
impl GroupFsync {
pub(crate) fn new() -> Self {
Self {
state: Mutex::new(GroupFsyncState {
next_ticket: 1,
last_fsynced: 0,
leader_active: false,
}),
cv: Condvar::new(),
}
}
pub(crate) fn fsync<F>(&self, do_fsync: F) -> Result<()>
where
F: FnOnce() -> Result<()>,
{
let my_ticket = {
let mut s = self.state.lock();
let t = s.next_ticket;
s.next_ticket += 1;
if s.last_fsynced >= t {
return Ok(());
}
t
};
let mut do_fsync_slot = Some(do_fsync);
loop {
let mut s = self.state.lock();
if s.last_fsynced >= my_ticket {
return Ok(());
}
if s.leader_active {
self.cv.wait(&mut s);
continue;
}
s.leader_active = true;
let target = s.next_ticket - 1;
drop(s);
let do_fsync = do_fsync_slot
.take()
.expect("BUG: fsync closure consumed twice");
let result = do_fsync();
{
let mut s = self.state.lock();
s.leader_active = false;
if result.is_ok() {
s.last_fsynced = s.last_fsynced.max(target);
}
}
self.cv.notify_all();
return result;
}
}
}
pub(crate) struct WriterPipeline {
pub(crate) commit_fsync: std::sync::Arc<GroupFsync>,
}
impl WriterPipeline {
pub(crate) fn new() -> Self {
Self {
commit_fsync: std::sync::Arc::new(GroupFsync::new()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use std::thread;
use std::time::Duration;
#[test]
fn coalesces_concurrent_fsyncs() {
let g = Arc::new(GroupFsync::new());
let real_fsync_count = Arc::new(AtomicU64::new(0));
let mut handles = Vec::new();
for _ in 0..32 {
let g = Arc::clone(&g);
let counter = Arc::clone(&real_fsync_count);
handles.push(thread::spawn(move || {
g.fsync(|| {
counter.fetch_add(1, Ordering::AcqRel);
thread::sleep(Duration::from_millis(20));
Ok(())
})
.unwrap();
}));
}
for h in handles {
h.join().unwrap();
}
let n = real_fsync_count.load(Ordering::Acquire);
assert!(n < 32, "expected coalescing; got {n} real fsyncs");
assert!(n >= 1);
}
#[test]
fn already_covered_returns_immediately() {
let g = GroupFsync::new();
let ran = std::cell::Cell::new(false);
g.fsync(|| {
ran.set(true);
Ok(())
})
.unwrap();
assert!(ran.get());
let ran2 = std::cell::Cell::new(false);
g.fsync(|| {
ran2.set(true);
Ok(())
})
.unwrap();
assert!(ran2.get());
}
}