ax-task 0.7.1

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

//! Observation under the owning scheduler transaction.

use super::*;

impl TaskSystem {
    /// Returns Deadline budget and PI rescue state for diagnostics and ABI glue.
    pub fn deadline_runtime(&self, thread: ThreadId) -> Result<DeadlineRuntimeSnapshot, TaskError> {
        let core = {
            let state = self.state.lock();
            Arc::clone(&state.thread_record(thread)?.core)
        };
        let sched = core.sched().lock();
        let pi_boosted = sched.pi.deadline_donor.is_some();
        let donor = sched.pi.deadline_donor;
        let local_entity = core.sched().active_option(&sched).map(|active| {
            if pi_boosted {
                active.entity().clone()
            } else {
                active.base_entity().clone()
            }
        });
        let effective_entity = if let Some(entity) = local_entity {
            entity
        } else {
            let owner = sched
                .placement
                .assigned_cpu()
                .ok_or(TaskError::InvalidConfiguration)?;
            let remote = self
                .cpu_remotes
                .get(owner.as_usize())
                .ok_or(TaskError::InvalidConfiguration)?;
            // Keep the task-control lock across the owner-rq observation. This
            // is the read-side equivalent of Linux `task_rq_lock()`: policy,
            // placement, and CBS state come from one ordered transaction.
            let transaction = OwnerRqTxn::begin(self, remote);
            let entity = if pi_boosted {
                transaction.scheduling_entity(thread)
            } else {
                transaction.base_scheduling_entity(thread)
            };
            let Some(entity) = entity else {
                transaction.commit();
                return Err(TaskError::InvalidConfiguration);
            };
            transaction.commit();
            entity
        };
        let deadline = effective_entity
            .deadline()
            .ok_or(TaskError::InvalidConfiguration)?;
        Ok(DeadlineRuntimeSnapshot {
            remaining_runtime_ns: deadline.remaining_runtime_ns(),
            overruns: deadline.overruns(),
            pi_boosted,
            donor,
        })
    }

    /// Returns the thread's GRUB activity, zero-lag, and runqueue ownership.
    pub fn deadline_activity(
        &self,
        thread: ThreadId,
    ) -> Result<DeadlineActivitySnapshot, TaskError> {
        let state = self.state.lock();
        let record = state.thread_record(thread)?;
        let sched = record.sched.lock();
        if !matches!(sched.policy.base, SchedulePolicy::Deadline(_)) {
            return Err(TaskError::InvalidConfiguration);
        }
        Ok(DeadlineActivitySnapshot {
            activity: sched.deadline.bandwidth.activity(),
            bandwidth_cpu: sched.deadline.bandwidth.reservation_owner(),
            zero_lag_ns: sched
                .deadline
                .bandwidth
                .zero_lag()
                .map(SchedulerTimestamp::as_nanos),
        })
    }
}