ax-task 0.8.0

OS-independent IRQ-safe SMP task scheduling core
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use super::*;

/// Mutually exclusive GRUB activity owned with one rq assignment.
///
/// The zero-lag timestamp exists only in the non-contending state. This makes
/// it impossible for wake, timer expiry, policy replacement, or CPU hotplug to
/// publish the old independent `activity` and `zero_lag` fields out of sync.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum DeadlineBandwidthActivity {
    Inactive,
    Contending,
    NonContending { zero_lag: SchedulerTimestamp },
}

/// Linux `dl_rq::{this_bw,running_bw}` membership of one admitted task.
#[derive(Debug)]
pub(in crate::sched::system) struct DeadlineBandwidthState {
    reservation_owner: Option<CpuId>,
    reservation_scaled: u64,
    activity: DeadlineBandwidthActivity,
}

impl DeadlineBandwidthState {
    const fn new(reservation_scaled: u64) -> Self {
        Self {
            reservation_owner: None,
            reservation_scaled,
            activity: DeadlineBandwidthActivity::Inactive,
        }
    }

    pub(in crate::sched::system) const fn reservation_owner(&self) -> Option<CpuId> {
        self.reservation_owner
    }

    pub(in crate::sched::system) const fn reservation_scaled(&self) -> u64 {
        self.reservation_scaled
    }

    pub(in crate::sched::system) const fn activity(&self) -> DeadlineActivity {
        match self.activity {
            DeadlineBandwidthActivity::Inactive => DeadlineActivity::Inactive,
            DeadlineBandwidthActivity::Contending => DeadlineActivity::ActiveContending,
            DeadlineBandwidthActivity::NonContending { .. } => {
                DeadlineActivity::ActiveNonContending
            }
        }
    }

    pub(in crate::sched::system) const fn is_active(&self) -> bool {
        !matches!(self.activity, DeadlineBandwidthActivity::Inactive)
    }

    pub(in crate::sched::system) const fn is_contending(&self) -> bool {
        matches!(self.activity, DeadlineBandwidthActivity::Contending)
    }

    pub(in crate::sched::system) const fn zero_lag(&self) -> Option<SchedulerTimestamp> {
        match self.activity {
            DeadlineBandwidthActivity::NonContending { zero_lag } => Some(zero_lag),
            DeadlineBandwidthActivity::Inactive | DeadlineBandwidthActivity::Contending => None,
        }
    }

    pub(in crate::sched::system) fn attach(&mut self, owner: CpuId) {
        assert!(
            self.reservation_owner.replace(owner).is_none(),
            "one Deadline reservation cannot belong to two runqueues"
        );
    }

    pub(in crate::sched::system) fn detach(&mut self, owner: CpuId) {
        assert_eq!(
            self.reservation_owner.take(),
            Some(owner),
            "Deadline reservation detach must name its owner rq"
        );
    }

    pub(in crate::sched::system) fn activate_contending(&mut self) {
        self.activity = DeadlineBandwidthActivity::Contending;
    }

    pub(in crate::sched::system) fn mark_non_contending(&mut self, zero_lag: SchedulerTimestamp) {
        assert!(
            self.is_contending(),
            "only a contending Deadline reservation can become non-contending"
        );
        self.activity = DeadlineBandwidthActivity::NonContending { zero_lag };
    }

    pub(in crate::sched::system) fn deactivate(&mut self) {
        self.activity = DeadlineBandwidthActivity::Inactive;
    }

    /// Installs a new policy reservation after the old rq membership was
    /// detached. Admission was already committed by the pending policy
    /// transaction, so owner apply changes no root-domain counter here.
    pub(in crate::sched::system) fn replace_detached_reservation(
        &mut self,
        reservation_scaled: u64,
    ) {
        assert!(
            self.reservation_owner.is_none(),
            "Deadline policy replacement requires detached rq bandwidth"
        );
        self.reservation_scaled = reservation_scaled;
        self.activity = DeadlineBandwidthActivity::Inactive;
    }
}

/// Deadline admission, runqueue ownership, and typed timer registrations.
#[derive(Debug)]
pub(in crate::sched::system) struct ThreadDeadlineState {
    pub(in crate::sched::system) server: crate::thread::DeadlineServer,
    pub(in crate::sched::system) bandwidth: DeadlineBandwidthState,
    pub(in crate::sched::system) cbs_timer: Option<TaskDeadlineRegistration>,
    pub(in crate::sched::system) zero_lag_timer: Option<TaskDeadlineRegistration>,
    pub(in crate::sched::system) overrun_events: u64,
}

impl ThreadDeadlineState {
    pub(super) fn new(server: crate::thread::DeadlineServer, reservation: u64) -> Self {
        Self {
            server,
            bandwidth: DeadlineBandwidthState::new(reservation),
            cbs_timer: None,
            zero_lag_timer: None,
            overrun_events: 0,
        }
    }
}