use crate::semantics::{rec_members, MKind, SharedText, SlotState, Value};
use serde::Serialize;
use std::collections::HashSet;
use std::rc::Rc;
pub const CACHE_LINE_BYTES: usize = 64;
pub const SMALL_PAGE_BYTES: usize = 4 * 1024;
pub const LARGE_PAGE_BYTES: usize = 16 * 1024;
pub const SEGMENT_BYTES: usize = 2 * 1024 * 1024;
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct Distances {
pub pairs: u64,
pub up_to_64: u64,
pub up_to_4_kib: u64,
pub up_to_16_kib: u64,
pub up_to_2_mib: u64,
pub beyond_2_mib: u64,
pub total_bytes: u64,
}
impl Distances {
fn record(&mut self, a: usize, b: usize) {
let distance = a.abs_diff(b);
self.pairs += 1;
self.total_bytes = self.total_bytes.saturating_add(distance as u64);
let bucket = if distance <= CACHE_LINE_BYTES {
&mut self.up_to_64
} else if distance <= SMALL_PAGE_BYTES {
&mut self.up_to_4_kib
} else if distance <= LARGE_PAGE_BYTES {
&mut self.up_to_16_kib
} else if distance <= SEGMENT_BYTES {
&mut self.up_to_2_mib
} else {
&mut self.beyond_2_mib
};
*bucket += 1;
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct TextCensus {
pub values: u64,
pub bytes: u64,
pub distinct_descriptors: u64,
pub distinct_characters: u64,
pub descriptor_to_characters: Distances,
pub consecutive_descriptors: Distances,
pub consecutive_characters: Distances,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct KeyCensus {
pub count: u64,
pub bytes: u64,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct ValueCounts {
pub nulls: u64,
pub booleans: u64,
pub integers: u64,
pub floats: u64,
pub text: u64,
pub quantities: u64,
pub references: u64,
pub arrays: u64,
pub maps: u64,
pub records: u64,
pub raw_arrays: u64,
pub raw_objects: u64,
pub unevaluated_raw_values: u64,
pub omitted: u64,
pub raw_null_substitutions: u64,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct SerializationCensus {
pub values: ValueCounts,
pub keys: KeyCensus,
pub text: TextCensus,
pub max_depth: u32,
}
pub fn census(value: &Value, settable_only: bool) -> SerializationCensus {
let mut walker = Walker::default();
walker.typed(value, settable_only);
walker.census.text.distinct_descriptors = walker.descriptors.len() as u64;
walker.census.text.distinct_characters = walker.characters.len() as u64;
walker.census
}
#[derive(Default)]
struct Walker {
census: SerializationCensus,
descriptors: HashSet<usize>,
characters: HashSet<usize>,
previous: Option<(usize, usize)>,
depth: u32,
}
impl Walker {
fn text(&mut self, text: &SharedText) {
let descriptor = text.as_rc() as *const Rc<str> as usize;
let characters = text.as_ptr() as usize;
let record = &mut self.census.text;
record.values += 1;
record.bytes += text.len() as u64;
record
.descriptor_to_characters
.record(descriptor, characters);
if let Some((descriptor_before, characters_before)) = self.previous {
record
.consecutive_descriptors
.record(descriptor_before, descriptor);
record
.consecutive_characters
.record(characters_before, characters);
}
self.previous = Some((descriptor, characters));
self.descriptors.insert(descriptor);
self.characters.insert(characters);
}
fn key(&mut self, key: &str) {
self.census.keys.count += 1;
self.census.keys.bytes += key.len() as u64;
}
fn enter(&mut self) {
self.depth += 1;
self.census.max_depth = self.census.max_depth.max(self.depth);
}
fn typed(&mut self, value: &Value, settable_only: bool) -> bool {
let counts = &mut self.census.values;
match value {
Value::Null => counts.nulls += 1,
Value::Bool(_) => counts.booleans += 1,
Value::Int(_) => counts.integers += 1,
Value::Float(_) => counts.floats += 1,
Value::Str(text) => {
counts.text += 1;
self.text(text);
}
Value::Q(_) => counts.quantities += 1,
Value::Ref(_) => counts.references += 1,
Value::Arr(array) => {
counts.arrays += 1;
self.enter();
for item in &array.borrow().items {
self.typed(item, settable_only);
}
self.depth -= 1;
}
Value::Map(map) => {
counts.maps += 1;
self.enter();
for (key, item) in &map.borrow().entries {
if self.typed(item, settable_only) {
self.key(key);
}
}
self.depth -= 1;
}
Value::Rec(record) => {
counts.records += 1;
self.enter();
let record = record.borrow();
let mut done: HashSet<&str> = HashSet::new();
for name in record.entry_order.iter() {
done.insert(name);
if let Some(extra) = record.extra(name) {
self.key(name);
self.raw(extra);
continue;
}
let Some(slot) = record.slot(name) else {
continue;
};
if matches!(slot.state, SlotState::Invalid | SlotState::Absent)
|| slot.kind == MKind::Der
{
continue;
}
if self.typed(&slot.value, settable_only) {
self.key(name);
}
}
for member in rec_members(&record.rt).iter() {
if done.contains(member.name.as_str()) && member.kind != MKind::Der {
continue;
}
if settable_only && member.kind == MKind::Der {
continue;
}
let Some(slot) = record.slot(&member.name) else {
continue;
};
if slot.hidden
|| matches!(
slot.state,
SlotState::Invalid
| SlotState::Absent
| SlotState::Unforced
| SlotState::Deferred
)
{
continue;
}
if self.typed(&slot.value, settable_only) {
self.key(&member.name);
}
}
self.depth -= 1;
}
Value::JObj(_) | Value::JArr(_) => self.raw(value),
_ => {
counts.omitted += 1;
return false;
}
}
true
}
fn raw(&mut self, value: &Value) {
match value {
Value::JArr(items) => {
self.census.values.raw_arrays += 1;
self.enter();
for item in items.iter() {
self.raw(item);
}
self.depth -= 1;
}
Value::JObj(entries) => {
self.census.values.raw_objects += 1;
self.enter();
for (key, item) in entries.iter() {
self.key(key);
self.raw(item);
}
self.depth -= 1;
}
Value::PreVal(_) => self.census.values.unevaluated_raw_values += 1,
other => {
if !self.typed(other, false) {
self.census.values.raw_null_substitutions += 1;
}
}
}
}
}
#[cfg(test)]
#[path = "../tests/private/serialization_diagnostics_test.rs"]
mod tests;