Struct ObjectCatalog 

pub(crate) struct ObjectCatalog {
    objects: BTreeMap<u64, Vec<FooterEntry>>,
    regions: BTreeMap<RegionId, BTreeMap<EntryId, (u64, FooterEntry)>>,
    max_entry_ids: HashMap<RegionId, EntryId>,
    watermarks: HashMap<RegionId, EntryId>,
    live_segments: BTreeMap<u64, usize>,
}

Indexes objects by sequence and, per region, the objects that hold entries of that region, and counts the live segments of every object under the obsolete watermarks.

Fields

objects: BTreeMap<u64, Vec<FooterEntry>>

regions: BTreeMap<RegionId, BTreeMap<EntryId, (u64, FooterEntry)>>

The objects that hold a segment of the region, as the sequence and the footer entry of the segment, keyed by the largest entry id of the segment. The entry ranges of a region increase strictly with the object sequence, so this is also sequence order.

max_entry_ids: HashMap<RegionId, EntryId>

Largest entry id ever indexed per region, kept after the object that held it was removed.

watermarks: HashMap<RegionId, EntryId>

The obsolete watermark per region, see obsolete.

live_segments: BTreeMap<u64, usize>

The number of live segments of every indexed object that holds one, see reclaim_boundary.

Implementations

impl ObjectCatalog

pub(crate) fn insert_object( &mut self, object_seq: u64, footer: Vec<FooterEntry>, ) -> Result<()>

Indexes the footer of the object object_seq. Objects may be inserted in any order, which lets recovery index them as it discovers them. Inserting a sequence that is already indexed is rejected, whether or not the footer matches the indexed one. An object without segments holds no entries but still takes its sequence.

pub(crate) fn remove_object( &mut self, object_seq: u64, ) -> Option<Vec<FooterEntry>>

Removes the object object_seq from the index once it was deleted and returns the footer it held, or None if it was not indexed. The largest entry id of every region it held is kept.

pub(crate) fn contains_object(&self, object_seq: u64) -> bool

Returns true while the object object_seq is indexed.

pub(crate) fn obsolete(&mut self, region_id: RegionId, entry_id: EntryId)

Moves the obsolete watermark of region_id up to entry_id; it never moves down. The segments of the region whose largest entry id the watermark reaches stop being live, so a move costs a lookup per segment it reaches, however many segments their objects hold.

fn is_live(&self, entry: &FooterEntry) -> bool

Returns whether a segment is live: its region is not RELEASE_REGION_ID, whose records recovery reads only from the objects it indexes, and either has no watermark or a watermark below the largest entry id of the segment. A region whose watermark is EntryId::MAX holds no live segment.

pub(crate) fn reclaim_boundary(&self, from: u64) -> u64

Returns the reclaim boundary the indexed objects and the obsolete watermarks allow: the first indexed object at or above from that holds a live segment, see is_live, or the sequence after the last indexed object when none does, and never less than from. The objects holding a live segment are tracked as objects are indexed and watermarks move, so the boundary is a lookup.

pub(crate) fn objects_for_entry_range( &self, region_id: RegionId, start_entry_id: u64, end_entry_id: u64, ) -> Result<Vec<(u64, &FooterEntry)>>

Returns the objects that hold entries of region_id overlapping start_entry_id..=end_entry_id, ordered by object sequence. The segments of a region are ordered by entry id, so the lookup seeks to the first segment that ends at or after start_entry_id and stops before the first that starts after end_entry_id, whatever the number of objects the region holds.

pub(crate) fn region_max_entry_id(&self, region_id: RegionId) -> Option<u64>

Returns the largest entry id ever indexed for region_id, which is kept after the object holding it was removed.

pub(crate) fn next_object_seq(&self) -> Result<u64>

Returns the sequence to assign to the next object written after recovery.

An empty catalog starts at zero, so the first object of a prefix always takes sequence zero. Otherwise the sequence continues after the largest indexed one, which recovery discovers regardless of insertion order, and is raised further when the largest entry id of a region lies at or above the ids that sequence would assign: ids assigned under the earlier contiguous scheme carry no object information, and every new id of a region must be greater than every id it already has. A sequence at or above OBJECT_SEQ_LIMIT does not fit an entry id and is rejected.

pub(crate) fn objects_in_order( &self, ) -> impl Iterator<Item = (u64, &[FooterEntry])> + '_

Iterates over the indexed objects ordered by object sequence.

Trait Implementations

impl Debug for ObjectCatalog

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

Formats the value using the given formatter.

impl Default for ObjectCatalog

fn default() -> ObjectCatalog

Returns the “default value” for a type.