refactor: improve memory usage

Author: decahedron1

src/cache/entry.rs

@@ -1,134 +1,211 @@
 use std::{
 	any::{Any, TypeId},
+	mem::MaybeUninit,
 	sync::{
 		Arc,
-		atomic::{AtomicBool, AtomicU32, Ordering}
-	}
+		atomic::{AtomicU8, AtomicU32, AtomicU64, Ordering}
+	},
+	time::Duration
 };
 
 use parking_lot::RwLock;
 
 use crate::{
 	error::MismatchedTypeError,
 	fetcher::Fetcher,
-	options::Options,
+	options::StoredOptions,
 	revalidate::RevalidateIntent,
 	runtime::Runtime,
-	util::{AtomicInstant, Instant, TaskSlot}
+	util::{AtomicBitwise, Instant, TaskSlot}
 };
 
+#[repr(transparent)]
+pub struct CacheEntryStatus(AtomicU8);
+
+impl CacheEntryStatus {
+	pub const HAS_DATA: u8 = 1 << 0;
+	pub const HAS_ERROR: u8 = 1 << 1;
+
+	pub const LOADING: u8 = 1 << 2;
+	pub const VALIDATING: u8 = 1 << 3;
+
+	pub const ALIVE: u8 = 1 << 4;
+	pub const USED_THIS_PASS: u8 = 1 << 5;
+
+	pub fn new() -> Self {
+		CacheEntryStatus(AtomicU8::new(0))
+	}
+
+	pub fn load(&self, ordering: Ordering) -> u8 {
+		self.0.load(ordering)
+	}
+
+	pub fn set(&self, bits: u8, ordering: Ordering) -> bool {
+		self.0.bits_set(bits, ordering)
+	}
+
+	pub fn get(&self, bits: u8, ordering: Ordering) -> bool {
+		self.0.bits_get(bits, ordering)
+	}
+
+	pub fn clear(&self, bits: u8, ordering: Ordering) -> bool {
+		self.0.bits_clear(bits, ordering)
+	}
+}
+
 pub struct CacheEntry<F: Fetcher, R: Runtime> {
-	pub key: F::Key,
-	data: Option<CacheEntryData>,
-	pub error: Option<Arc<F::Error>>,
-	pub loading: bool,
-	pub validating: bool,
-
-	pub revalidate_intent: RevalidateIntent,
-	pub used_this_pass: AtomicBool,
-	pub alive: AtomicBool,
-	pub last_draw_time: AtomicInstant,
-	pub last_request_time: Option<Instant>,
+	key: F::Key,
+
+	pub(crate) retry_count: AtomicU8,
+	status: CacheEntryStatus,
+	revalidate_intent: RevalidateIntent,
+	data: MaybeUninit<CacheEntryData>,
+	error: MaybeUninit<Arc<F::Error>>,
+
+	base_time: Instant,
+	// offset from base time in nanos (up to ~584 years for 64 bits)
+	last_draw_time_offset: AtomicU64,
+	// offset from base time in nanos where u64::MAX is None, i.e. no request has been made
+	last_request_time_offset: AtomicU64,
 
 	pub fetch_task: TaskSlot<R>,
 	pub refresh_task: TaskSlot<R>,
-	pub(crate) retry_count: AtomicU32,
 	pub retry_task: TaskSlot<R>,
 
-	pub(crate) persisted_instances: AtomicU32,
-	pub options: RwLock<Options<(), F>>
+	pub(crate) strong_count: AtomicU32,
+	pub options: RwLock<StoredOptions>
 }
 
 impl<F: Fetcher, R: Runtime> CacheEntry<F, R> {
 	pub fn new(runtime: R, key: F::Key) -> Self {
 		Self {
 			key,
-			data: None,
-			error: None,
-			loading: false,
-			validating: false,
 
+			retry_count: AtomicU8::new(0),
+			status: CacheEntryStatus::new(),
 			revalidate_intent: RevalidateIntent::default(),
-			used_this_pass: AtomicBool::new(false),
-			alive: AtomicBool::new(false),
-			last_draw_time: AtomicInstant::now(),
-			last_request_time: None,
+			data: MaybeUninit::uninit(),
+			error: MaybeUninit::uninit(),
+
+			base_time: Instant::now(),
+			last_draw_time_offset: AtomicU64::new(0),
+			last_request_time_offset: AtomicU64::new(u64::MAX),
 
 			fetch_task: TaskSlot::new(runtime.clone()),
 			refresh_task: TaskSlot::new(runtime.clone()),
-			retry_count: AtomicU32::new(0),
 			retry_task: TaskSlot::new(runtime),
 
-			persisted_instances: AtomicU32::new(0),
-			options: RwLock::new(Options::default())
+			strong_count: AtomicU32::new(0),
+			options: RwLock::new(StoredOptions::default())
 		}
 	}
 
 	pub fn data<T: Send + Sync + 'static>(&self) -> Option<Result<Arc<F::Response<T>>, MismatchedTypeError>> {
-		self.data.as_ref().map(|data| match Arc::downcast(data.value.clone()) {
-			Ok(x) => Ok(x),
-			Err(_) => Err(MismatchedTypeError {
-				contained_type: self.data.type_id(),
-				wanted_type: TypeId::of::<T>(),
-
-				#[cfg(debug_assertions)]
-				contained_type_name: data.type_name,
-				#[cfg(debug_assertions)]
-				wanted_type_name: std::any::type_name::<T>()
+		if self.status.get(CacheEntryStatus::HAS_DATA, Ordering::Acquire) {
+			let data = unsafe { self.data.assume_init_ref() };
+			Some(match Arc::downcast(data.value.clone()) {
+				Ok(x) => Ok(x),
+				Err(_) => Err(MismatchedTypeError {
+					contained_type: self.data.type_id(),
+					wanted_type: TypeId::of::<T>(),
+
+					#[cfg(debug_assertions)]
+					contained_type_name: data.type_name,
+					#[cfg(debug_assertions)]
+					wanted_type_name: std::any::type_name::<T>()
+				})
 			})
-		})
+		} else {
+			None
+		}
+	}
+
+	pub fn error(&self) -> Option<&Arc<F::Error>> {
+		if self.status.get(CacheEntryStatus::HAS_ERROR, Ordering::Acquire) {
+			let err = unsafe { self.error.assume_init_ref() };
+			Some(err)
+		} else {
+			None
+		}
 	}
 
 	#[inline]
-	pub fn has_data(&self) -> bool {
-		self.data.is_some()
+	pub fn revalidate_intent(&self) -> &RevalidateIntent {
+		&self.revalidate_intent
 	}
 
-	pub fn insert<T: Send + Sync + 'static>(&mut self, data: Arc<F::Response<T>>) {
+	#[inline]
+	pub fn status(&self) -> &CacheEntryStatus {
+		&self.status
+	}
+
+	#[inline]
+	pub fn key(&self) -> &F::Key {
+		&self.key
+	}
+
+	pub fn insert<T: Send + Sync + 'static>(&mut self, data: Arc<F::Response<T>>) -> Option<CacheEntryData> {
 		self.insert_untyped(
 			data as _,
 			#[cfg(debug_assertions)]
 			std::any::type_name::<T>()
-		);
+		)
 	}
 
-	pub fn insert_untyped(&mut self, data: Arc<dyn Any + Send + Sync>, #[cfg(debug_assertions)] type_name: &'static str) {
-		self.loading = false;
-		self.validating = false;
+	pub fn insert_untyped(&mut self, data: Arc<dyn Any + Send + Sync>, #[cfg(debug_assertions)] type_name: &'static str) -> Option<CacheEntryData> {
+		self.status
+			.clear(CacheEntryStatus::LOADING | CacheEntryStatus::VALIDATING, Ordering::Relaxed); // we have mut
 
-		self.data = Some(CacheEntryData {
+		let old_data = if self.status.set(CacheEntryStatus::HAS_DATA, Ordering::Relaxed) {
+			Some(unsafe { self.data.assume_init_read() })
+		} else {
+			None
+		};
+		self.data.write(CacheEntryData {
 			value: data,
 			#[cfg(debug_assertions)]
 			type_name
 		});
 
-		self.error.take();
-		self.retry_count.store(0, Ordering::Release);
+		if self.status.clear(CacheEntryStatus::HAS_ERROR, Ordering::Relaxed) {
+			unsafe { self.error.assume_init_drop() };
+		}
+
+		self.retry_count.store(0, Ordering::Relaxed);
+		self.last_request_time_offset
+			.store(instant_as_offset(&self.base_time, Instant::now()), Ordering::Relaxed);
 
-		self.last_request_time.replace(Instant::now());
+		old_data
 	}
 
 	pub fn insert_error(&mut self, error: Arc<F::Error>) {
-		self.loading = false;
-		self.validating = false;
+		self.status
+			.clear(CacheEntryStatus::LOADING | CacheEntryStatus::VALIDATING, Ordering::Relaxed); // we have mut
 
-		self.error = Some(error);
-		self.last_request_time.replace(Instant::now());
-	}
+		if self.status.set(CacheEntryStatus::HAS_ERROR, Ordering::Relaxed) {
+			unsafe { self.error.assume_init_drop() };
+		}
+		self.error.write(error);
 
-	pub fn swap<T: Send + Sync + 'static>(&mut self, data: Arc<F::Response<T>>) -> Option<CacheEntryData> {
-		let old_data = self.data.take();
-		self.insert_untyped(
-			data,
-			#[cfg(debug_assertions)]
-			std::any::type_name::<T>()
-		);
-		old_data
+		self.last_request_time_offset
+			.store(instant_as_offset(&self.base_time, Instant::now()), Ordering::Relaxed);
 	}
 
 	pub fn mark_used(&self) {
-		self.last_draw_time.store_now(Ordering::Release);
-		self.used_this_pass.store(true, Ordering::Release);
+		self.last_draw_time_offset
+			.store(instant_as_offset(&self.base_time, Instant::now()), Ordering::Release);
+		self.status.set(CacheEntryStatus::USED_THIS_PASS, Ordering::Release);
+	}
+
+	pub fn last_request_time(&self, order: Ordering) -> Option<Instant> {
+		match self.last_request_time_offset.load(order) {
+			u64::MAX => None,
+			offs => Some(instant_from_offset(&self.base_time, offs))
+		}
+	}
+
+	pub fn last_draw_time(&self, order: Ordering) -> Instant {
+		instant_from_offset(&self.base_time, self.last_draw_time_offset.load(order))
 	}
 }
 
@@ -137,3 +214,14 @@ pub struct CacheEntryData {
 	#[cfg(debug_assertions)]
 	pub type_name: &'static str
 }
+
+fn instant_as_offset(base: &Instant, new_value: Instant) -> u64 {
+	let offset = new_value - *base;
+	offset.as_secs() * 1_000_000_000 + u64::from(offset.subsec_nanos())
+}
+
+fn instant_from_offset(base: &Instant, offset_nanos: u64) -> Instant {
+	let secs = offset_nanos / 1_000_000_000;
+	let subsec_nanos = (offset_nanos % 1_000_000_000) as u32;
+	*base + Duration::new(secs, subsec_nanos)
+}

src/cache/mod.rs

@@ -4,14 +4,17 @@ use parking_lot::{RwLock, RwLockUpgradableReadGuard};
 use slotmap::SlotMap;
 
 mod entry;
-mod slot;
-pub(crate) use self::{entry::CacheEntry, slot::CacheSlot};
+pub(crate) use self::entry::{CacheEntry, CacheEntryStatus};
 use crate::{fetcher::Fetcher, runtime::Runtime};
 
+slotmap::new_key_type! {
+	pub struct CacheSlot;
+}
+
 pub struct Cache<F: Fetcher, R: Runtime> {
 	runtime: R,
-	pub(super) key_to_slot: RwLock<HashMap<F::Key, CacheSlot<F>>>,
-	states: RwLock<SlotMap<CacheSlot<F>, CacheEntry<F, R>>>
+	key_to_slot: RwLock<HashMap<F::Key, CacheSlot>>,
+	states: RwLock<SlotMap<CacheSlot, CacheEntry<F, R>>>
 }
 
 impl<F: Fetcher, R: Runtime> Cache<F, R> {
@@ -23,7 +26,7 @@ impl<F: Fetcher, R: Runtime> Cache<F, R> {
 		}
 	}
 
-	pub fn get<K>(&self, key: &K) -> Option<CacheSlot<F>>
+	pub fn get<K>(&self, key: &K) -> Option<CacheSlot>
 	where
 		K: Hash + Eq + ?Sized,
 		F::Key: Borrow<K>
@@ -32,7 +35,7 @@ impl<F: Fetcher, R: Runtime> Cache<F, R> {
 		key_to_slot.get(key).copied()
 	}
 
-	pub fn get_or_create<K>(&self, key: &K) -> CacheSlot<F>
+	pub fn get_or_create<K>(&self, key: &K) -> CacheSlot
 	where
 		K: Hash + Eq + ?Sized,
 		F::Key: Borrow<K> + for<'k> From<&'k K>
@@ -52,28 +55,37 @@ impl<F: Fetcher, R: Runtime> Cache<F, R> {
 		}
 	}
 
+	pub(crate) fn retain<I: FnMut(CacheSlot, &mut CacheEntry<F, R>) -> bool>(&self, mut cb: I) {
+		let mut key_to_slot = self.key_to_slot.write();
+		let mut states = self.states.write();
+		states.retain(|slot, entry| {
+			if !cb(slot, entry) {
+				key_to_slot.remove(entry.key());
+				false
+			} else {
+				true
+			}
+		})
+	}
+
 	pub fn states(&self) -> StateAccessor<'_, F, R> {
 		StateAccessor { inner: self.states.upgradable_read() }
 	}
 }
 
 pub struct StateAccessor<'c, F: Fetcher, R: Runtime> {
-	inner: RwLockUpgradableReadGuard<'c, SlotMap<CacheSlot<F>, CacheEntry<F, R>>>
+	inner: RwLockUpgradableReadGuard<'c, SlotMap<CacheSlot, CacheEntry<F, R>>>
 }
 
 impl<F: Fetcher, R: Runtime> StateAccessor<'_, F, R> {
-	pub fn get(&self, slot: CacheSlot<F>) -> Option<&CacheEntry<F, R>> {
+	pub fn get(&self, slot: CacheSlot) -> Option<&CacheEntry<F, R>> {
 		self.inner.get(slot)
 	}
 
-	pub fn mutate<M, T>(&mut self, slot: CacheSlot<F>, mutator: M) -> Option<T>
+	pub fn mutate<M, T>(&mut self, slot: CacheSlot, mutator: M) -> Option<T>
 	where
 		M: FnOnce(&mut CacheEntry<F, R>) -> T
 	{
 		self.inner.with_upgraded(|states| states.get_mut(slot).map(mutator))
 	}
-
-	pub fn retain<I: FnMut(CacheSlot<F>, &mut CacheEntry<F, R>) -> bool>(&mut self, cb: I) {
-		self.inner.with_upgraded(|states| states.retain(cb));
-	}
 }