use std::collections::BTreeMap;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use tokio::sync::Mutex;
use tracing::debug;
use crate::error::Result;
const DEFAULT_MAX_SIZE_BYTES: usize = 16 * 1024 * 1024;
pub(crate) mod read_path;
pub(crate) mod write_path;
#[cfg(test)]
mod tests;
#[derive(Clone)]
pub struct CacheEntry {
offset: u64,
data: bytes::Bytes, dirty: bool,
seq: u64,
}
impl CacheEntry {
pub fn offset(&self) -> u64 {
self.offset
}
pub fn data(&self) -> &[u8] {
&self.data
}
pub fn is_dirty(&self) -> bool {
self.dirty
}
pub fn into_data(self) -> bytes::Bytes {
self.data
}
pub(crate) fn size_bytes(&self) -> usize {
self.data.len()
}
}
pub struct WrDiskCache {
pub(crate) entries: Mutex<BTreeMap<u64, CacheEntry>>,
pub(crate) flush_gate: Mutex<()>,
pub(crate) max_size_bytes: usize,
pub(crate) total_cached_bytes: AtomicUsize,
pub(crate) next_seq: AtomicU64,
}
impl Default for WrDiskCache {
fn default() -> Self {
Self::with_max_size_bytes(DEFAULT_MAX_SIZE_BYTES)
}
}
impl WrDiskCache {
pub fn new(max_size_mb: usize) -> Self {
let max_size_bytes = max_size_mb * 1024 * 1024;
debug!(
"Initializing write-back disk cache, max capacity: {} MB ({} bytes)",
max_size_mb, max_size_bytes
);
WrDiskCache {
entries: Mutex::new(BTreeMap::new()),
flush_gate: Mutex::new(()),
max_size_bytes,
total_cached_bytes: AtomicUsize::new(0),
next_seq: AtomicU64::new(0),
}
}
pub fn with_max_size_bytes(max_size_bytes: usize) -> Self {
debug!(
"Initializing write-back disk cache, max capacity: {} bytes",
max_size_bytes
);
WrDiskCache {
entries: Mutex::new(BTreeMap::new()),
flush_gate: Mutex::new(()),
max_size_bytes,
total_cached_bytes: AtomicUsize::new(0),
next_seq: AtomicU64::new(0),
}
}
pub fn max_size_bytes(&self) -> usize {
self.max_size_bytes
}
pub fn current_size_bytes(&self) -> usize {
self.total_cached_bytes.load(Ordering::Relaxed)
}
pub async fn size(&self) -> usize {
self.total_cached_bytes.load(Ordering::Relaxed)
}
pub async fn is_empty(&self) -> bool {
self.size().await == 0
}
pub async fn count(&self) -> usize {
self.entries.lock().await.len()
}
pub async fn dirty_count(&self) -> usize {
self.entries
.lock()
.await
.values()
.filter(|e| e.dirty)
.count()
}
pub async fn flush_to(
&self,
writer: &mut dyn crate::filesystem::disk_writer::SeekableDiskWriter,
) -> Result<()> {
let _flush_guard = self.flush_gate.lock().await;
let pending: Vec<_> = {
let entries = self.entries.lock().await;
entries
.values()
.filter(|entry| entry.dirty)
.map(|entry| (entry.offset, entry.data.clone(), entry.seq))
.collect()
};
for (offset, data, _) in &pending {
writer.write_bytes_at(*offset, data.clone()).await?;
}
writer.flush().await?;
let mut entries = self.entries.lock().await;
for (offset, _, seq) in pending {
if let Some(entry) = entries.get_mut(&offset)
&& entry.seq == seq
{
entry.dirty = false;
}
}
Ok(())
}
pub async fn clear(&self) -> Result<()> {
let _flush_guard = self.flush_gate.lock().await;
let mut entries = self.entries.lock().await;
let cleared_bytes: usize = entries.values().map(|e| e.size_bytes()).sum();
entries.clear();
self.total_cached_bytes
.fetch_sub(cleared_bytes, Ordering::Relaxed);
debug!("Cleared cache ({} bytes)", cleared_bytes);
Ok(())
}
}