Struct VectorClock 

pub struct VectorClock { /* private fields */ }

Vector clock for happens-before analysis.

A vector clock is a mapping from thread IDs to logical timestamps. It implements a partial order on events in concurrent/distributed systems.

The happens-before relation is defined as:

• A <= B if for all threads t: clock_A[t] <= clock_B[t]
• A < B if A <= B and exists t where clock_A[t] < clock_B[t]
• A concurrent with B if neither A <= B nor B <= A

Fields

• clocks - HashMap mapping thread_id -> logical timestamp

Implementations

impl VectorClock

pub fn new() -> Self

Create a new empty vector clock.

All threads start with implicit timestamp 0.

Example

use sqlitegraph::algo::observability::VectorClock;

let vc = VectorClock::new();
assert!(vc.is_empty());

pub fn is_empty(&self) -> bool

Check if the vector clock is empty (no threads recorded).

pub fn get(&self, thread_id: i64) -> u64

Get the clock value for a specific thread.

Returns 0 if the thread is not in the clock (implicit value).

pub fn increment(&mut self, thread_id: i64)

Increment the clock for a specific thread.

Returns self for method chaining.

Arguments

• thread_id - Thread whose clock should be incremented

Example

use sqlitegraph::algo::observability::VectorClock;

let mut vc = VectorClock::new();
vc.increment(1);
assert_eq!(vc.get(1), 1);
vc.increment(1);
assert_eq!(vc.get(1), 2);

pub fn incremented(self, thread_id: i64) -> Self

Return a new vector clock with the given thread incremented.

Convenience method for creating incremented copies without mutation.

Arguments

• thread_id - Thread whose clock should be incremented

pub fn merge(&mut self, other: &VectorClock)

Merge another vector clock into this one.

Takes the element-wise maximum of both clocks. Used after thread synchronization (e.g., after acquiring a lock).

Arguments

• other - Vector clock to merge with

Example

use sqlitegraph::algo::observability::VectorClock;

let mut vc1 = VectorClock::new().incremented(1);
let vc2 = VectorClock::new().incremented(2);

vc1.merge(&vc2);
assert_eq!(vc1.get(1), 1);
assert_eq!(vc1.get(2), 1);

pub fn happens_before(&self, other: &VectorClock) -> bool

Check if this vector clock happens-before another.

Returns true if for all threads t: self[t] <= other[t], and there exists at least one thread where self[t] < other[t].

This is the strict partial order: this event MUST complete before the other event can occur.

Arguments

• other - Vector clock to compare against

Returns

true if this clock happens-before the other, false otherwise (including when clocks are equal or concurrent).

Example

use sqlitegraph::algo::observability::VectorClock;

let vc1 = VectorClock::new().incremented(1);
let mut vc2 = VectorClock::new().incremented(1);
vc2.increment(1);  // Thread 1: vc1 = 1, vc2 = 2

assert!(vc1.happens_before(&vc2));
assert!(!vc2.happens_before(&vc1));

pub fn is_concurrent(&self, other: &VectorClock) -> bool

Check if this vector clock is concurrent with another.

Two clocks are concurrent if neither happens-before the other. This means there exist threads t1, t2 such that:

• self[t1] > other[t1]
• self[t2] < other[t2]

Concurrent events may execute in either order (potential race).

Arguments

• other - Vector clock to compare against

Returns

true if clocks are concurrent (neither happens-before the other).

Example

use sqlitegraph::algo::observability::VectorClock;

let vc1 = VectorClock::new().incremented(1);  // Thread 1: 1, Thread 2: 0
let vc2 = VectorClock::new().incremented(2);  // Thread 1: 0, Thread 2: 1

assert!(vc1.is_concurrent(&vc2));

pub fn threads(&self) -> impl Iterator<Item = i64> + '_

Get all thread IDs with non-zero clocks.

pub fn len(&self) -> usize

Get the number of threads with non-zero clocks.

Trait Implementations

impl Clone for VectorClock

fn clone(&self) -> VectorClock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VectorClock

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

Formats the value using the given formatter.

impl Default for VectorClock

fn default() -> Self

Returns the “default value” for a type.

impl Eq for VectorClock

impl PartialEq for VectorClock

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for VectorClock