Struct Model

pub struct Model<V>
where
    V: Vector + Debug,
{ /* private fields */ }

A Vivaldi latency model generic over N dimensional vectors.

A single Model should be instantiated for each distinct network of nodes the caller participates in.

Messages exchanged between nodes in the network should include the current model coordinate, and the model should be updated with the measured round-trip time by calling observe.

Implementations

impl<V> Model<V>

where V: Vector + Debug,

pub fn new() -> Model<V>

New initialises a new Vivaldi model.

The model is generic over any implementation of the Vector trait, which should be specified when calling this method:

use vivaldi::{Model, vector::Dimension3};

let model = Model::<Dimension3>::new();

pub fn observe(&mut self, coord: &Coordinate<V>, rtt: Duration)

Observe updates the positional coordinate of the local node.

This method should be called with the coordinate of the remote node and the network round-trip time measured by the caller:

// The remote sends it's current coordinate.
//
// Lets pretend we got this from an RPC response:
let coordinate_from_remote = remote_model.get_coordinate();

// The local application issues a request and measures the response time
let rtt = std::time::Duration::new(0, 42_000);

// And then updates the model with the remote coordinate and rtt
model.observe(&coordinate_from_remote, rtt);

pub fn get_coordinate(&self) -> &Coordinate<V>

Returns the current positional coordinate of the local node.

Trait Implementations

impl<V> Debug for Model<V>

where V: Vector + Debug + Debug,

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

Formats the value using the given formatter.