ax-task 0.6.10

ArceOS task management module
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

//! Task interruption publication state.

use core::sync::atomic::{AtomicU64, Ordering};

/// A task interruption observation captured before an owner-side safe-point scan.
///
/// Obtain a snapshot through [`crate::TaskInner::interrupt_snapshot`] and pass it
/// to [`crate::TaskInner::acknowledge_interrupt`] after that scan completes.
#[derive(Debug, Clone, Copy)]
pub struct InterruptSnapshot(u64);

/// Sticky interruption publication shared by remote producers and one task.
pub(crate) struct InterruptState {
    published: AtomicU64,
    acknowledged: AtomicU64,
}

impl InterruptState {
    pub(crate) const fn new() -> Self {
        Self {
            published: AtomicU64::new(0),
            acknowledged: AtomicU64::new(0),
        }
    }

    pub(crate) fn publish(&self) {
        self.published
            .try_update(Ordering::Release, Ordering::Relaxed, |generation| {
                generation.checked_add(1)
            })
            .expect("task interruption generation exhausted");
    }

    pub(crate) fn consume(&self) -> bool {
        self.acknowledge(self.snapshot())
    }

    pub(crate) fn is_pending(&self) -> bool {
        self.published.load(Ordering::Acquire) > self.acknowledged.load(Ordering::Acquire)
    }

    pub(crate) fn snapshot(&self) -> InterruptSnapshot {
        InterruptSnapshot(self.published.load(Ordering::Acquire))
    }

    pub(crate) fn acknowledge(&self, snapshot: InterruptSnapshot) -> bool {
        let mut acknowledged = self.acknowledged.load(Ordering::Acquire);
        while acknowledged < snapshot.0 {
            match self.acknowledged.compare_exchange_weak(
                acknowledged,
                snapshot.0,
                Ordering::AcqRel,
                Ordering::Acquire,
            ) {
                Ok(_) => return true,
                Err(current) => acknowledged = current,
            }
        }
        false
    }
}

#[cfg(test)]
mod tests {
    use super::InterruptState;

    #[test]
    fn publication_after_snapshot_survives_acknowledgement() {
        let state = InterruptState::new();
        state.publish();
        let scanned = state.snapshot();

        state.publish();
        let _advanced = state.acknowledge(scanned);

        assert!(
            state.is_pending(),
            "acknowledging an older scan must not erase a later publication"
        );
    }

    #[test]
    fn snapshot_acknowledges_only_visible_publications() {
        let state = InterruptState::new();
        state.publish();

        let scanned = state.snapshot();

        assert!(state.acknowledge(scanned));
        assert!(!state.is_pending());
    }

    #[test]
    fn older_acknowledgement_cannot_regress_a_consumer() {
        let state = InterruptState::new();
        let old = state.snapshot();
        state.publish();

        assert!(state.consume());
        assert!(!state.acknowledge(old));
        assert!(!state.is_pending());
    }
}