Struct Propagated 

pub struct Propagated<T: ArrivalBound> {
    pub response_time_jitter: Duration,
    pub input_event_model: T,
}

A simple model of arrivals induced by a precedence relationship.

Suppose two components A and B are connected such that each activation of A subsequently triggers (up to) one activation of B (e.g., A is a producer and B a consumer). Then, if input_event_model is the arrival model of A and activations of A have a maximum response time bounded by response_time_jitter, then this arrival model upper-bounds the activations of B.

Fields

response_time_jitter: Duration

input_event_model: T

Implementations

impl<T: ArrivalBound + Clone> Propagated<T>

pub fn with_jitter(event_model: &T, response_time_jitter: Duration) -> Self

Trait Implementations

impl<T: ArrivalBound + Clone + 'static> ArrivalBound for Propagated<T>

fn number_arrivals(&self, delta: Duration) -> usize

Bound the number of jobs released in any interval of length delta.

fn steps_iter<'a>(&'a self) -> Box<dyn Iterator<Item = Duration> + 'a>

Yield the sequence of interval lengths (i.e., values of delta in ArrivalBound::number_arrivals) for which the arrival bound “steps”, i.e., where it shows an increase in the number of released jobs.

fn clone_with_jitter(&self, added_jitter: Duration) -> Box<dyn ArrivalBound>

Clone the arrival model while accounting for added release jitter. Returns a boxed dyn object because the underlying type may change.

fn brute_force_steps_iter<'a>( &'a self, ) -> Box<dyn Iterator<Item = Duration> + 'a>

Same semantics as ArrivalBound::steps_iter, but provided by a default implementation in the most naive way possible. Avoid if performance is at all important.