Struct tor_circmgr::timeouts::pareto::ParetoTimeoutEstimator

pub(crate) struct ParetoTimeoutEstimator {
    history: History,
    timeouts: Option<(Duration, Duration)>,
    fallback_timeouts: (Duration, Duration),
    p: Params,
}

Tor’s default circuit build timeout estimator.

This object records a set of observed circuit build times, and uses it to determine good values for how long we should allow circuits to build.

For full details of the algorithms used, see path-spec.txt.

Fields

history: History

Our observations for circuit build times and success/failure history.

timeouts: Option<(Duration, Duration)>

Our most recent timeout estimate, if we have one that is up-to-date.

(We reset this to None whenever we get a new observation.)

fallback_timeouts: (Duration, Duration)

The timeouts that we use when we do not have sufficient observations to conclude anything about our circuit build times.

These start out as p.default_thresholds, but can be adjusted depending on how many timeouts we’ve been seeing.

p: Params

A set of parameters to use in computing circuit build timeout estimates.

Implementations

impl ParetoTimeoutEstimator

fn from_history(history: History) -> Self

Construct a new ParetoTimeoutEstimator from the provided history object.

pub(crate) fn from_state(state: ParetoTimeoutState) -> Self

Create a new ParetoTimeoutEstimator based on a loaded ParetoTimeoutState.

fn base_timeouts(&mut self) -> (Duration, Duration)

Compute an unscaled basic pair of timeouts for a circuit of the “normal” length.

Return a cached value if we have no observations since the last time this function was called.

Trait Implementations

impl Default for ParetoTimeoutEstimator

fn default() -> Self

Returns the “default value” for a type.

impl TimeoutEstimator for ParetoTimeoutEstimator

fn update_params(&mut self, p: &NetParameters)

Replace the network parameters used by this estimator (if any) with ones derived from params.

fn note_hop_completed(&mut self, hop: u8, delay: Duration, is_last: bool)

Record that a given circuit hop has completed.

fn note_circ_timeout(&mut self, hop: u8, delay: Duration)

Record that a circuit failed to complete because it took too long.

fn timeouts(&mut self, action: &Action) -> (Duration, Duration)

Return the current estimation for how long we should wait for a given Action to complete.

fn learning_timeouts(&self) -> bool

Return true if we’re currently trying to learn more timeouts by launching testing circuits.

fn build_state(&mut self) -> Option<ParetoTimeoutState>

Construct a new ParetoTimeoutState to represent the current state of this estimator, if it is possible to store the state to disk.