Struct CaptionTrace 

pub struct CaptionTrace {

    pub preprocess_ms: f64,
    pub tower_ms: f64,
    pub tower_per_tile_ms: Vec<f64>,
    pub assemble_ms: f64,
    pub prefill_ms: f64,
    pub step_ms: Vec<f64>,
    pub detokenize_ms: f64,
    pub tiles: usize,
    pub rows: usize,
    pub cols: usize,
    pub tile: usize,
    pub image_tokens: usize,
    pub text_tokens: usize,
    pub prompt_tokens: usize,
    pub max_positions: usize,
    pub split: bool,
    pub resized_to: Vec<(usize, usize)>,
}

Where the time went, stage by stage, for one caption.

Why this exists on the engine rather than in the caller

A caller can time describe_image and get one number. That number is almost useless for a VLM, because it is dominated by a cost the caller cannot see: the vision tower runs once per tile, and a still image is seventeen tiles. A reader looking at “4.2 seconds” concludes the language model is slow. The truth is usually that they handed it a picture.

So the split is reported by the code that knows it, and the alternative — a demo or a profiler reassembling the pipeline out of the public pieces to time each one — is exactly the drift this crate spent §16 avoiding.

Fields

preprocess_ms: f64

Image -> pixel_values: two Lanczos resizes, the tile cut, normalise.

tower_ms: f64

SigLIP + connector, summed over every tile of every image.

tower_per_tile_ms: Vec<f64>

One entry per tile, in the order the tower saw them. The last belongs to the global thumbnail.

assemble_ms: f64

Chat template, tokenize, embed, splice.

prefill_ms: f64

One forward pass over the whole prompt.

step_ms: Vec<f64>

One entry per generated token.

detokenize_ms: f64

Detokenize and trim.

tiles: usize

rows: usize

cols: usize

tile: usize

Tile edge in pixels (512 for this checkpoint).

image_tokens: usize

tiles * tokens_per_tile — what the picture costs the prompt.

text_tokens: usize

Whatever is left of the prompt once the images are counted out.

prompt_tokens: usize

max_positions: usize

The tower’s own token budget, so a reader can see the headroom.

split: bool

Was tile splitting on? Off means video framing — 1 tile per image.

resized_to: Vec<(usize, usize)>

The size each image was resized to before tiling, in order.

Implementations

impl CaptionTrace

pub fn decode_ms(&self) -> f64

Time in the decode loop, excluding prefill.

pub fn total_ms(&self) -> f64

Everything this engine spent, decode of the source file excluded — that happens before the engine is called.

pub fn tokens_per_sec(&self) -> f64

Generated tokens per second, prefill excluded — see [DecodeTrace].

Trait Implementations

impl Clone for CaptionTrace

fn clone(&self) -> CaptionTrace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CaptionTrace

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

Formats the value using the given formatter.

impl Default for CaptionTrace

fn default() -> CaptionTrace

Returns the “default value” for a type.

impl PartialEq for CaptionTrace

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CaptionTrace