Struct IndexProgress 

pub struct IndexProgress { /* private fields */ }

The counter. Every field is an atomic so the hot path pays one relaxed add.

Implementations

impl IndexProgress

pub fn new(root: &str) -> Arc<Self>

A counter for the store rooted at root, registered process-wide.

pub fn detached() -> Arc<Self>

A counter nobody reads, for a caller with no store behind it.

pub fn root(&self) -> &str

pub fn begin(&self, pack_id: u64, bytes_total: u64, resumed: bool)

A pack begins. resumed = the journal queued it, not a push in this process.

pub fn set_total(&self, objects: u64)

The walk is done and the object count is known.

pub fn set_phase(&self, phase: Phase)

pub fn object_done(&self, bytes: u64)

The hot-path call: one object resolved, covering bytes of the pack.

pub fn add_reinflations(&self, n: u64)

pub fn add_pause(&self)

pub fn sample_memory(&self)

Read /proc once and publish it on the counter.

Two file reads, so it is a tick’s work and never the hot path’s: the ticker calls it every TICK, add_pause calls it when a pause opens, and the absorber calls it when a pack ends. Everything else reads the published value out of a Snapshot.

pub fn rate(&self) -> u64

Objects per second since begin, or 0 before the clock has moved.

pub fn finish(&self)

The pack is absorbed (or abandoned): the row goes idle.

pub fn snapshot(&self) -> Snapshot