use crate::class::{self, SPAN_BYTES};
use crate::pagemap::{SpanMeta, pages_of_slot, slots_of_page};
use crate::segment::{FIRST_DATA_SPAN, SPANS_PER_SEGMENT};
use crate::snapshot::{Unassigned, unassigned_bucket};
pub(crate) const DATA_SPANS: u64 = (SPANS_PER_SEGMENT - FIRST_DATA_SPAN) as u64;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Tally {
pub(crate) segments: u64,
pub(crate) virgin_spans: u64,
pub(crate) returned_spans: u64,
pub(crate) held_spans: u64,
pub(crate) empty_spans: u64,
pub(crate) touched: u64,
pub(crate) returned: u64,
}
impl Tally {
pub(crate) const NEW: Self = Self {
segments: 0,
virgin_spans: 0,
returned_spans: 0,
held_spans: 0,
empty_spans: 0,
touched: 0,
returned: 0,
};
pub(crate) fn segment_mapped(&mut self) {
self.segments += 1;
self.virgin_spans += DATA_SPANS;
}
pub(crate) fn assigned_spans(&self) -> u64 {
self.segments * DATA_SPANS - self.virgin_spans - self.returned_spans - self.held_spans
}
pub(crate) fn span_claimed(&mut self, meta: &SpanMeta) {
match unassigned_bucket(meta.retired, meta.discarded) {
Unassigned::Virgin => self.virgin_spans -= 1,
Unassigned::Returned => self.returned_spans -= 1,
Unassigned::Held => self.held_spans -= 1,
}
self.empty_spans += 1;
}
pub(crate) fn span_retired(&mut self, discarded: bool) {
self.empty_spans -= 1;
if discarded {
self.returned_spans += 1;
} else {
self.held_spans += 1;
}
}
#[cold]
pub(crate) fn span_emptied(&mut self, meta: &SpanMeta, c: usize) {
let slot = class::size_of(c) as u64;
self.empty_spans += 1;
self.touched -= u64::from(meta.high_water) * slot;
self.returned -= u64::from(meta.returned_slots) * slot;
}
pub(crate) fn span_refilled(&mut self, meta: &SpanMeta, old_hw: u16, c: usize) {
let slot = class::size_of(c) as u64;
self.empty_spans -= 1;
self.touched += u64::from(old_hw) * slot;
self.returned += u64::from(meta.returned_slots) * slot;
}
}
fn returned_in(
first: u32,
last: u32,
hw: u16,
slot: usize,
discarded: u16,
was_live: impl Fn(u32) -> bool,
) -> u16 {
let mut n = 0;
for i in first..(last + 1).min(u32::from(hw)) {
if was_live(i) {
continue;
}
let (pa, pb) = pages_of_slot(i, slot);
if (pa..=pb).all(|p| discarded & (1u16 << p) != 0) {
n += 1;
}
}
n
}
fn slot_range(pages: u16, slot: usize, cap: u32) -> (u32, u32) {
let lo = pages.trailing_zeros() as usize;
let hi = 15 - pages.leading_zeros() as usize;
(slots_of_page(lo, slot, cap).0, slots_of_page(hi, slot, cap).1)
}
pub(crate) fn unreturn_claim(meta: &mut SpanMeta, word: u8, claimed: u64, old_hw: u16) -> u16 {
let slot = class::size_of(meta.class as usize);
let lo = u32::from(word) * 64 + claimed.trailing_zeros();
let hi = u32::from(word) * 64 + (63 - claimed.leading_zeros());
let (pa, _) = pages_of_slot(lo, slot);
let (_, pb) = pages_of_slot(hi, slot);
let mut pages = 0u16;
for p in pa..=pb {
pages |= 1u16 << p;
}
let (first, last) = slot_range(pages, slot, meta.capacity());
let m: &SpanMeta = meta;
let claimed_now = |i: u32| i / 64 == u32::from(word) && claimed & (1u64 << (i % 64)) != 0;
let before =
returned_in(first, last, old_hw, slot, m.discarded, |i| m.is_live(i) && !claimed_now(i));
meta.discarded &= !pages;
let m: &SpanMeta = meta;
let after = returned_in(first, last, m.high_water, slot, m.discarded, |i| m.is_live(i));
let gone = before - after;
meta.returned_slots -= gone;
gone
}
pub(crate) fn returned_after_discard(meta: &mut SpanMeta, fresh: u16) -> u16 {
if fresh == 0 {
return 0;
}
let slot = class::size_of(meta.class as usize);
let (first, last) = slot_range(fresh, slot, meta.capacity());
let m: &SpanMeta = meta;
let hw = m.high_water;
let before = returned_in(first, last, hw, slot, m.discarded & !fresh, |i| m.is_live(i));
let after = returned_in(first, last, hw, slot, m.discarded, |i| m.is_live(i));
let gained = after - before;
meta.returned_slots += gained;
gained
}
pub(crate) const SPAN: u64 = SPAN_BYTES as u64;
#[cfg(test)]
#[path = "tally_tests.rs"]
mod tests;