use super::{hierarchy::Recipe, identity::ContentIdentity, index::Index, types::Types};
use crate::{Hierarchy, TimeSpan};
pub(super) const CACHE_BYTES: usize = 1024 * 1024 * 1024;
pub(super) struct Validated {
pub(super) identity: Option<ContentIdentity>,
pub(super) hierarchy: Hierarchy,
pub(super) types: Types,
pub(super) recipes: Vec<Recipe>,
pub(super) active: Vec<(u32, usize)>,
pub(super) body_start: u64,
pub(super) version: u8,
pub(super) big_endian: bool,
pub(super) time_span: Option<TimeSpan>,
pub(super) index: Option<Index>,
pub(super) retained_bytes: usize,
}
pub(super) fn retained_bytes(
types: &Types,
recipes: &[Recipe],
recipe_slots: usize,
active_slots: usize,
hierarchy: &Hierarchy,
index: Option<&Index>,
) -> usize {
let mut bytes = std::mem::size_of::<Validated>();
bytes = bytes.saturating_add(hierarchy.validated_bytes());
bytes = bytes.saturating_add(types.retained_bytes());
bytes = bytes.saturating_add(vec_bytes::<Recipe>(recipe_slots));
for recipe in recipes {
bytes = bytes.saturating_add(vec_bytes::<u32>(recipe.ids.capacity()));
}
bytes = bytes.saturating_add(vec_bytes::<(u32, usize)>(active_slots));
if let Some(index) = index {
bytes = bytes.saturating_add(index.retained_bytes());
}
bytes
}
fn vec_bytes<T>(capacity: usize) -> usize {
capacity.saturating_mul(std::mem::size_of::<T>())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Encoding;
use std::io::Cursor;
fn empty_types() -> Types {
let mut wire = crate::backends::ghw::wire::Wire::new(Box::new(Cursor::new(vec![
b'T', b'Y', b'P', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
])))
.unwrap();
Types::read(&mut wire, vec![String::new()]).unwrap()
}
#[test]
fn accounting_counts_reserved_capacity_not_length() {
let types = empty_types();
let hierarchy = Hierarchy::new(Vec::new(), Vec::new(), Vec::new());
let mut recipes = Vec::with_capacity(64);
recipes.push(Recipe {
ids: Vec::with_capacity(32),
encoding: Encoding::Bits { width: 1 },
scalar_type: 0,
vector: false,
});
let mut active = Vec::with_capacity(128);
active.push((1, 0));
let counted = retained_bytes(
&types,
&recipes,
recipes.capacity(),
active.capacity(),
&hierarchy,
None,
);
let reserved = 64 * std::mem::size_of::<Recipe>()
+ 32 * std::mem::size_of::<u32>()
+ 128 * std::mem::size_of::<(u32, usize)>();
assert!(counted >= reserved, "{counted} < {reserved}");
assert!(
counted
> 10 * (std::mem::size_of::<Recipe>()
+ std::mem::size_of::<u32>()
+ std::mem::size_of::<(u32, usize)>())
);
}
}