Struct LogDiffSummary 

pub struct LogDiffSummary {
    pub diff_found: bool,
    pub compared_left: usize,
    pub compared_right: usize,
    pub first_divergent_scheduler_turn: Option<u64>,
    pub first_divergent_virtual_nanoseconds: Option<u64>,
    pub first_divergent_record: Option<usize>,
    pub matched_prefix_messages: Option<usize>,
    pub first_divergent_syscall: Option<u64>,
    pub first_divergent_left_message: Option<String>,
    pub first_divergent_right_message: Option<String>,
    pub refusal_reason: Option<String>,
}

What a log comparison actually compared, alongside whether it differed.

A bare “no difference found” boolean cannot distinguish “the two message streams were compared and matched” from “there were no messages to compare”. Both selected lists being empty is a NO-RESULT, not a match, so the counts travel with the verdict and a parity consumer can require nonzero execution before believing a green.

Fields

diff_found: bool

True if a substantive difference was found between the two runs.

compared_left: usize

Number of messages actually selected for comparison from the first run.

compared_right: usize

Number of messages actually selected for comparison from the second run.

first_divergent_scheduler_turn: Option<u64>

Scheduler turn at the first different selected message, when the first run has a preceding scheduler COMMIT message that identifies it.

first_divergent_virtual_nanoseconds: Option<u64>

Virtual nanoseconds at that same scheduler COMMIT, when its time is present and parseable.

first_divergent_record: Option<usize>

1-based index of the first record that differs. “Diverged somewhere in the first N records” is a bound, not a location, and on a long run the two are far apart; this is the location.

matched_prefix_messages: Option<usize>

Number of leading COMPARED messages that are equal on both sides, in the same units as Self::compared_left and Self::compared_right.

Equal to both compared counts when the streams match. When one stream is a strict prefix of the other it is the shorter length, because the extra messages are the divergence. None when the comparison was refused, and when the verdict came from the git diff -w comparator and the exact prefix scan disagrees with it (a match over unequal counts, or a divergence with nothing unmatched); see the private matched_prefix_for_verdict in this module.

This is not Self::first_divergent_record minus one: that field is a raw log-record index, which also counts records outside the compared stream.

first_divergent_syscall: Option<u64>

How many syscalls the guest had COMPLETED when the divergence appeared, as detcore’s own finish syscall #N counter. The fourth unit: a divergence located at record 108 is easier to act on when you also know the guest was 37 syscalls in.

first_divergent_left_message: Option<String>

The first differing compared message from the left execution, after removing only the syscall number, scheduler turn, and committed virtual time that are already recorded in separate fields.

first_divergent_right_message: Option<String>

The corresponding first differing compared message from the right execution, with the same narrowly scoped removals.

refusal_reason: Option<String>

The reason the comparison was REFUSED rather than performed, so there is no verdict about whether the runs agree. None means the comparison ran. Keeping the cause here, rather than only printing it, lets every caller carry the producer’s diagnosis into its typed result.

Self::diff_found is also set, because a refusal must never read as a match on any existing predicate. But the two are not the same fact: a difference is something observed, whereas a refusal is the absence of an observation. A caller that reports the outcome must be able to tell them apart – otherwise a run that compared nothing is announced as a run that found the two executions differing, which is a claim nothing supports.

Set today by exactly one condition: an input log that ends at the bounded writer’s truncation marker.

Implementations

impl LogDiffSummary

pub fn matched_with_evidence(&self) -> bool

True only when the comparison both ran on a nonempty selection and found no difference. An empty-vs-empty comparison is never a match.

Trait Implementations

impl Clone for LogDiffSummary

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 LogDiffSummary

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

Formats the value using the given formatter.

impl Eq for LogDiffSummary

impl PartialEq for LogDiffSummary

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LogDiffSummary