scx_rustland 1.1.1

A BPF component (dispatcher) that implements the low level sched-ext functionalities and a user-space counterpart (scheduler), written in Rust, that implements the actual scheduling policy. This is used within sched_ext, which is a Linux kernel feature which enables implementing kernel thread schedulers in BPF and dynamically loading them. https://github.com/sched-ext/scx/tree/main
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

use std::io::Write;
use std::time::Duration;

use anyhow::Result;
use scx_stats::prelude::*;
use scx_stats_derive::stat_doc;
use scx_stats_derive::Stats;
use serde::Deserialize;
use serde::Serialize;

#[stat_doc]
#[derive(Clone, Debug, Default, Serialize, Deserialize, Stats)]
#[stat(top)]
pub struct Metrics {
    #[stat(desc = "Number of online CPUs")]
    pub nr_cpus: u64,
    #[stat(desc = "Amount of tasks currently running")]
    pub nr_running: u64,
    #[stat(desc = "Amount of tasks queued to the user-space scheduler")]
    pub nr_queued: u64,
    #[stat(desc = "Amount of tasks in the user-space scheduler waiting to be dispatched")]
    pub nr_scheduled: u64,
    #[stat(desc = "Amount of user-space scheduler's page faults (should be always 0)")]
    pub nr_page_faults: u64,
    #[stat(desc = "Number of task dispatched by the user-space scheduler")]
    pub nr_user_dispatches: u64,
    #[stat(desc = "Number of task dispatched directly by the kernel")]
    pub nr_kernel_dispatches: u64,
    #[stat(desc = "Number of cancelled dispatches")]
    pub nr_cancel_dispatches: u64,
    #[stat(desc = "Number of dispatches bounced to another DSQ")]
    pub nr_bounce_dispatches: u64,
    #[stat(desc = "Number of failed dispatches")]
    pub nr_failed_dispatches: u64,
    #[stat(desc = "Number of scheduler congestion events")]
    pub nr_sched_congested: u64,
}

impl Metrics {
    fn format<W: Write>(&self, w: &mut W) -> Result<()> {
        writeln!(
            w,
            "[{}] tasks -> r: {:>2}/{:<2} w: {:<2}/{:<2} | pf: {:<5} | dispatch -> u: {:<5} k: {:<5} c: {:<5} b: {:<5} f: {:<5} | cg: {:<5}",
            crate::SCHEDULER_NAME,
            self.nr_running,
            self.nr_cpus,
            self.nr_queued,
            self.nr_scheduled,
            self.nr_page_faults,
            self.nr_user_dispatches,
            self.nr_kernel_dispatches,
            self.nr_cancel_dispatches,
            self.nr_bounce_dispatches,
            self.nr_failed_dispatches,
            self.nr_sched_congested,
        )?;
        Ok(())
    }

    fn delta(&self, rhs: &Self) -> Self {
        Self {
            nr_user_dispatches: self.nr_user_dispatches - rhs.nr_user_dispatches,
            nr_kernel_dispatches: self.nr_kernel_dispatches - rhs.nr_kernel_dispatches,
            nr_cancel_dispatches: self.nr_cancel_dispatches - rhs.nr_cancel_dispatches,
            nr_bounce_dispatches: self.nr_bounce_dispatches - rhs.nr_bounce_dispatches,
            nr_failed_dispatches: self.nr_failed_dispatches - rhs.nr_failed_dispatches,
            nr_sched_congested: self.nr_sched_congested - rhs.nr_sched_congested,
            ..self.clone()
        }
    }
}

pub fn server_data() -> StatsServerData<(), Metrics> {
    let open: Box<dyn StatsOpener<(), Metrics>> = Box::new(move |(req_ch, res_ch)| {
        req_ch.send(())?;
        let mut prev = res_ch.recv()?;

        let read: Box<dyn StatsReader<(), Metrics>> = Box::new(move |_args, (req_ch, res_ch)| {
            req_ch.send(())?;
            let cur = res_ch.recv()?;
            let delta = cur.delta(&prev);
            prev = cur;
            delta.to_json()
        });

        Ok(read)
    });

    StatsServerData::new()
        .add_meta(Metrics::meta())
        .add_ops("top", StatsOps { open, close: None })
}

pub fn monitor(intv: Duration) -> Result<()> {
    scx_utils::monitor_stats::<Metrics>(
        &[],
        intv,
        || false,
        |metrics| metrics.format(&mut std::io::stdout()),
    )
}