Enum Profiler 

pub enum Profiler {
    Active {
        start: Instant,
        interval: Duration,
        embed: Mutex<EmbedState>,
        chunk_counts: Mutex<Vec<usize>>,
        on_progress: Option<Box<dyn Fn(&str) + Send + Sync>>,
        on_embed_tick: Option<Box<dyn Fn(&EmbedProgress) + Send + Sync>>,
    },
    Noop,
}

Variants

Active

Actively collects timing and prints to stderr.

Fields

start: Instant

Wall-clock start of the entire run.

interval: Duration

Reporting interval for embed progress.

embed: Mutex<EmbedState>

Mutable embed-phase state (sequential access only, Mutex for Sync).

chunk_counts: Mutex<Vec<usize>>

Per-rayon-thread chunk counts (parallel access during chunk phase).

on_progress: Option<Box<dyn Fn(&str) + Send + Sync>>

Optional callback for live progress updates.

on_embed_tick: Option<Box<dyn Fn(&EmbedProgress) + Send + Sync>>

Optional callback for per-chunk embed progress (drives progress bars).

Noop

No-op profiler. All methods are empty.

Implementations

impl Profiler

pub fn new(enabled: bool, interval: Duration) -> Self

Create a new profiler. If enabled is false, returns Noop.

pub fn with_callback( interval: Duration, cb: impl Fn(&str) + Send + Sync + 'static, ) -> Self

Create an active profiler that drives a progress callback instead of printing to stderr. The callback receives formatted status messages at each pipeline phase transition and embed progress tick.

pub fn with_embed_tick( self, cb: impl Fn(&EmbedProgress) + Send + Sync + 'static, ) -> Self

Set a callback that fires on every embed chunk completion with (done, total).

Unlike the throttled on_progress callback, this fires for every chunk so progress bars can update smoothly (indicatif handles display rate).

pub fn noop() -> Self

Create a no-op profiler.

pub fn header( &self, version: &str, model_repo: &str, threads: usize, cores: usize, )

Print the system info header line.

pub fn phase(&self, name: &'static str) -> PhaseGuard<'_>

Start timing a named phase. Returns a guard that prints on drop.

pub fn chunk_thread_report(&self, n: usize)

Record that a rayon thread produced n chunks during the chunk phase.

pub fn chunk_summary( &self, total_chunks: usize, total_files: usize, elapsed: Duration, )

Print the chunk phase summary with thread utilization stats.

pub fn embed_begin(&self, total: usize)

Begin the embed phase. Call before the embedding loop.

pub fn embed_begin_update_total(&self, total: usize)

Update the total chunk count for the embed phase.

Used by the streaming pipeline where the total isn’t known at Self::embed_begin time. Only updates if the new total is larger than the current one (monotonic).

pub fn embed_tick(&self, done: usize)

Called after each chunk is embedded. Prints periodic progress.

pub fn embed_tick_bytes( &self, done_chunks: usize, bytes_processed: u64, total_bytes: u64, )

Byte-based progress for streaming mode.

Shows processed_bytes/total_bytes as MB with chunk rate. The total is known from the walk phase (file sizes), so the denominator is stable.

pub fn embed_lock_wait(&self, duration: Duration)

Accumulate time spent waiting for the model mutex lock.

pub fn embed_inference(&self, duration: Duration)

Accumulate time spent in ONNX inference.

pub fn embed_done(&self)

Print the final embed phase summary.

pub fn finish(&self)

Print the total wall-clock time.