response-time-analysis 0.3.2

Definitions and algorithms for response-time analysis of real-time systems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use super::SupplyBound;
use crate::time::{Duration, Service};

/// A periodic resource with reduced jitter.
///
/// This model represents a refined variant of of the
/// [Periodic][super::Periodic] supply model wherein the availability
/// of budget within each period is restricted by a constrained
/// relative deadline.
///
/// The client(s) of this supply is/are guaranteed (at least)
/// `budget` time units of processor service every `period` time
/// units within `deadline` time units w.r.t. the start of the
/// period.
#[derive(Debug, Clone, Copy)]
pub struct Constrained {
    pub period: Duration,
    pub budget: Service,
    pub deadline: Duration,
}

impl Constrained {
    /// Construct a new constrained periodic resource model such that
    /// `budget <= deadline <= period`.
    pub fn new(budget: Service, deadline: Duration, period: Duration) -> Self {
        assert!(Duration::from(budget) <= deadline);
        assert!(deadline <= period);
        Constrained {
            period,
            budget,
            deadline,
        }
    }
}

impl SupplyBound for Constrained {
    fn provided_service(&self, delta: Duration) -> Service {
        let budget = Duration::from(self.budget);
        let shift = self.period - budget;
        if shift > delta {
            return Service::none();
        }
        // implicit floor due to integer division
        let full_periods = (delta - shift) / self.period;
        let x = shift + self.period * full_periods + self.deadline - budget;
        let fractional_period = if x < delta {
            self.budget.min(Service::from(delta - x))
        } else {
            Service::none()
        };

        self.budget * full_periods + fractional_period
    }

    fn service_time(&self, demand: Service) -> Duration {
        if demand.is_none() {
            return Duration::zero();
        }

        let budget = Duration::from(self.budget);
        let demand = Duration::from(demand);

        // implicit floor due to integer division
        let full_periods = demand / budget;
        let full_budget = budget * full_periods;
        let fractional_budget = if full_budget < demand {
            demand - full_budget + self.period - budget
        } else {
            Duration::zero()
        };

        self.deadline - budget + self.period * full_periods + fractional_budget
    }
}