use thread_aware::ThreadAware;
use crate::mem::{Memory, MemoryShared};
#[derive(Debug, ThreadAware)]
pub struct OpaqueMemory {
inner: Box<dyn MemoryShared>,
}
impl OpaqueMemory {
#[must_use]
pub fn new(inner: impl MemoryShared) -> Self {
Self { inner: Box::new(inner) }
}
#[must_use]
pub fn reserve(&self, min_bytes: usize) -> crate::BytesBuf {
self.inner.reserve(min_bytes)
}
}
impl Clone for OpaqueMemory {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone_boxed(),
}
}
}
impl Memory for OpaqueMemory {
#[cfg_attr(test, mutants::skip)] fn reserve(&self, min_bytes: usize) -> crate::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::GlobalPool;
assert_impl_all!(OpaqueMemory: MemoryShared);
#[test]
fn wraps_inner() {
let provider = GlobalPool::new();
let memory = OpaqueMemory::new(provider);
let builder = memory.reserve(1024);
assert!(builder.capacity() >= 1024);
}
#[test]
fn memory_trait() {
let provider = GlobalPool::new();
let memory = OpaqueMemory::new(provider);
let builder = Memory::reserve(&memory, 1024);
assert!(builder.capacity() >= 1024);
}
#[test]
fn relocate_does_not_break_reservation() {
let mut memory = OpaqueMemory::new(GlobalPool::new());
let affinities = pinned_affinities(&[2]);
memory.relocate(Some(affinities[0]), affinities[1]);
let builder = memory.reserve(1024);
assert!(builder.capacity() >= 1024);
}
#[test]
fn relocate_forwards_to_wrapped_provider() {
#[derive(Clone, Debug)]
struct TrackingMemory {
relocated: Arc<AtomicUsize>,
inner: GlobalPool,
}
impl Memory for TrackingMemory {
fn reserve(&self, min_bytes: usize) -> crate::BytesBuf {
self.inner.reserve(min_bytes)
}
}
impl ThreadAware for TrackingMemory {
fn relocate(&mut self, source: Option<Affinity>, destination: Affinity) {
self.relocated.fetch_add(1, atomic::Ordering::SeqCst);
self.inner.relocate(source, destination);
}
}
let relocated = Arc::new(AtomicUsize::new(0));
let mut memory = OpaqueMemory::new(TrackingMemory {
relocated: Arc::clone(&relocated),
inner: GlobalPool::new(),
});
let affinities = pinned_affinities(&[2]);
memory.relocate(Some(affinities[0]), affinities[1]);
assert_eq!(relocated.load(atomic::Ordering::SeqCst), 1);
}
#[test]
fn clone_is_usable_independently() {
let memory = OpaqueMemory::new(GlobalPool::new());
let mut clone = memory.clone();
let affinities = pinned_affinities(&[2]);
clone.relocate(Some(affinities[0]), affinities[1]);
assert!(memory.reserve(64).capacity() >= 64);
assert!(clone.reserve(64).capacity() >= 64);
}
}