use std::fmt::Debug;
use thread_aware::ThreadAware;
use crate::BytesBuf;
use crate::mem::Memory;
#[derive(Clone, ThreadAware)]
pub struct CallbackMemory<D: ThreadAware + Clone + Send + Sync + 'static> {
data: D,
#[thread_aware(skip)]
reserve_fn: fn(&D, usize) -> BytesBuf,
}
impl<D: ThreadAware + Clone + Send + Sync + 'static> Debug for CallbackMemory<D> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CallbackMemory")
.field("reserve_fn", &self.reserve_fn)
.finish_non_exhaustive()
}
}
impl<D: ThreadAware + Clone + Send + Sync + 'static> CallbackMemory<D> {
#[must_use]
pub fn new(data: D, reserve_fn: fn(&D, usize) -> BytesBuf) -> Self {
Self { data, reserve_fn }
}
#[must_use]
pub fn reserve(&self, min_bytes: usize) -> BytesBuf {
(self.reserve_fn)(&self.data, min_bytes)
}
}
impl<D: ThreadAware + Clone + Send + Sync + 'static> Memory for CallbackMemory<D> {
#[cfg_attr(test, mutants::skip)] fn reserve(&self, min_bytes: usize) -> BytesBuf {
self.reserve(min_bytes)
}
}
#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use std::sync::Arc;
use std::sync::atomic::{self, AtomicUsize};
use static_assertions::assert_impl_all;
use thread_aware::affinity::{Affinity, pinned_affinities};
use super::*;
use crate::mem::MemoryShared;
use crate::mem::testing::TransparentMemory;
assert_impl_all!(CallbackMemory<TransparentMemory>: MemoryShared);
#[derive(Clone, Debug, ThreadAware)]
struct CountingData {
inner: TransparentMemory,
#[thread_aware(skip)]
reserve_calls: Arc<AtomicUsize>,
}
impl CountingData {
fn new() -> Self {
Self {
inner: TransparentMemory::new(),
reserve_calls: Arc::new(AtomicUsize::new(0)),
}
}
}
#[derive(Clone, Debug)]
struct RelocationObserver {
inner: TransparentMemory,
relocations: Arc<AtomicUsize>,
}
impl ThreadAware for RelocationObserver {
fn relocate(&mut self, _source: Option<Affinity>, _destination: Affinity) {
self.relocations.fetch_add(1, atomic::Ordering::SeqCst);
}
}
fn count_reserve(data: &CountingData, min_bytes: usize) -> BytesBuf {
data.reserve_calls.fetch_add(1, atomic::Ordering::SeqCst);
data.inner.reserve(min_bytes)
}
#[test]
fn calls_back_to_provided_fn() {
let data = CountingData::new();
let reserve_calls = Arc::clone(&data.reserve_calls);
let provider = CallbackMemory::new(data, count_reserve);
_ = Memory::reserve(&provider, 100);
assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 1);
}
#[test]
fn clone_shares_behavior() {
let data = CountingData::new();
let reserve_calls = Arc::clone(&data.reserve_calls);
let provider = CallbackMemory::new(data, count_reserve);
let cloned_provider = provider.clone();
_ = Memory::reserve(&provider, 50);
assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 1);
_ = Memory::reserve(&cloned_provider, 75);
assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 2);
}
#[test]
fn reserve_produces_capacity() {
let provider = CallbackMemory::new(TransparentMemory::new(), TransparentMemory::reserve);
let buf = provider.reserve(64);
assert!(buf.capacity() >= 64);
}
#[test]
fn multi_field_tuple_data() {
const EXTRA: usize = 16;
let provider = CallbackMemory::new(
(TransparentMemory::new(), EXTRA),
|(inner, extra): &(TransparentMemory, usize), min_bytes| inner.reserve(min_bytes + *extra),
);
let buf = provider.reserve(64);
assert_eq!(buf.capacity(), 64 + EXTRA);
}
#[test]
fn relocate_forwards_to_data() {
let relocations = Arc::new(AtomicUsize::new(0));
let mut provider = CallbackMemory::new(
RelocationObserver {
inner: TransparentMemory::new(),
relocations: Arc::clone(&relocations),
},
|observer: &RelocationObserver, min_bytes| observer.inner.reserve(min_bytes),
);
let affinities = pinned_affinities(&[2]);
provider.relocate(Some(affinities[0]), affinities[1]);
assert_eq!(relocations.load(atomic::Ordering::SeqCst), 1);
assert!(provider.reserve(32).capacity() >= 32);
}
#[test]
fn works_with_non_debug_data() {
#[derive(Clone, ThreadAware)]
struct NotDebug {
inner: TransparentMemory,
}
let provider = CallbackMemory::new(
NotDebug {
inner: TransparentMemory::new(),
},
|data: &NotDebug, min_bytes| data.inner.reserve(min_bytes),
);
assert!(Memory::reserve(&provider, 64).capacity() >= 64);
let rendered = format!("{provider:?}");
assert!(rendered.contains("CallbackMemory"));
}
}