Struct ObjectUsage 

pub struct ObjectUsage {
    pub segid: SegmentId,
    pub bytes: u64,
    pub live_data_blocks: usize,
    pub live_meta_blocks: usize,
    pub live_bytes: u64,
    pub meta_moves_with_data: bool,
}

How much of one stored object is still pointed into.

Fields

segid: SegmentId

The object, <cno> or <cno>.<part>.

bytes: u64

Its size on storage.

live_data_blocks: usize

Live data blocks in it.

live_meta_blocks: usize

Live metadata nodes in it.

live_bytes: u64

What those occupy, by the container’s own block sizes.

meta_moves_with_data: bool

Whether the live metadata in it is rewritten by rewriting its live data.

True for a data part — any part above 0 — of a StreamSegment container. That layout puts every leaf of the block map in the object holding the data under it, and the nodes above the leaves in part 0 only. A leaf in a data part is therefore live only while none of the blocks it was written with has changed, so those blocks are live and in the same object; relocating them dirties the leaf, and the flush writes it elsewhere with them. Under every other format the nodes sit in part 0 or the one object, apart from the data they describe, and this is false.

Implementations

impl ObjectUsage

pub fn is_dead(&self) -> bool

Nothing points into it: prune can take it, compaction has no work here.

pub fn live_ratio(&self) -> f64

Live bytes over stored bytes. Zero for a dead object, and the cost side of the trade: rewriting this much frees Self::bytes.

pub fn holds_metadata(&self) -> bool

Whether a live metadata node is in it.

Such an object cannot in general be freed by rewriting data blocks: a node is relocated when the flush rewrites it, which happens because something under it was dirtied, and which node covers which keys is not visible from outside the map. Compaction skips these rather than rewriting their data blocks for nothing — unless Self::meta_moves_with_data says the node goes with the data.

Trait Implementations

impl Clone for ObjectUsage

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ObjectUsage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ObjectUsage

impl PartialEq for ObjectUsage

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ObjectUsage