ax-task 0.7.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

//! Deadline diagnostics, deferred callbacks, and owner timer service.

use super::*;
use crate::{
    runtime::cpu::SchedulerDeadlineUpdate,
    sched::algorithm::{SchedulerClockEvent, scheduler_clock_event, scheduler_time_reached},
    time::queue::{KernelTimerAction, KernelTimerEntry},
};

enum OwnerDeadlineTimerPlan {
    Unchanged,
    Cancel,
    Arm(TaskDeadlineArmPlan),
}

#[derive(Clone, Copy)]
struct OwnerDeadlineDue {
    scheduler_now_ns: u64,
    cbs_expired: bool,
    zero_lag_reached: bool,
}

struct OwnerDeadlineReconcile<'a> {
    core: &'a Arc<ThreadCore>,
    sched: &'a mut ThreadSchedState,
    cpu: Pin<&'a mut CpuLocal>,
    due: OwnerDeadlineDue,
}

pub(crate) struct KtimerServiceBatch {
    processed: usize,
    pending: bool,
    update: Option<SchedulerDeadlineUpdate>,
    kernel_timer: Option<KernelTimerExecution>,
    task_timer: Option<ExpiredTaskDeadline>,
    completed_timer: Option<KernelTimerEntry>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct HardTimerServiceBatch {
    processed: usize,
    soft: SoftTimerExpireBatch,
}

pub(crate) struct KernelTimerCompletionBatch {
    completed: Option<KernelTimerEntry>,
    update: Option<SchedulerDeadlineUpdate>,
}

impl KernelTimerCompletionBatch {
    pub(crate) const fn update(&self) -> Option<SchedulerDeadlineUpdate> {
        self.update
    }

    pub(crate) fn take_completed(&mut self) -> Option<KernelTimerEntry> {
        self.completed.take()
    }
}

impl KtimerServiceBatch {
    pub(crate) const fn processed(&self) -> usize {
        self.processed
    }

    pub(crate) const fn pending(&self) -> bool {
        self.pending
    }

    pub(crate) const fn update(&self) -> Option<SchedulerDeadlineUpdate> {
        self.update
    }

    pub(crate) fn take_kernel_timer(&mut self) -> Option<KernelTimerExecution> {
        self.kernel_timer.take()
    }

    pub(crate) fn take_task_timer(&mut self) -> Option<ExpiredTaskDeadline> {
        self.task_timer.take()
    }

    pub(crate) fn take_completed_timer(&mut self) -> Option<KernelTimerEntry> {
        self.completed_timer.take()
    }
}

impl HardTimerServiceBatch {
    pub(crate) const fn processed(self) -> usize {
        self.processed
    }

    pub(crate) const fn soft(self) -> SoftTimerExpireBatch {
        self.soft
    }
}

mod overrun;

mod registration;

mod observation;

mod soft_timer;

mod expiry;

mod clockevent;