Struct Opts 

pub(crate) struct Opts {
    pub(crate) slice_us: u64,
    pub(crate) slice_us_min: u64,
    pub(crate) percpu_local: bool,
    pub(crate) partial: bool,
    pub(crate) exit_dump_len: u32,
    pub(crate) verbose: bool,
    pub(crate) stats: Option<f64>,
    pub(crate) monitor: Option<f64>,
    pub(crate) help_stats: bool,
    pub(crate) version: bool,
    pub libbpf: LibbpfOpts,
}

scx_rustland: user-space scheduler written in Rust

scx_rustland is designed to prioritize interactive workloads over background CPU-intensive workloads. For this reason the typical use case of this scheduler involves low-latency interactive applications, such as gaming, video conferencing and live streaming.

scx_rustland is also designed to be an “easy to read” template that can be used by any developer to quickly experiment more complex scheduling policies fully implemented in Rust.

The scheduler is based on scx_rustland_core, which implements the low level sched-ext functionalities.

The scheduling policy implemented in user-space is a based on a deadline, evaluated as following:

  deadline = vruntime + exec_runtime

Where, vruntime reflects the task’s total runtime scaled by weight (ensuring fairness), while exec_runtime accounts the CPU time used since the last sleep (capturing responsiveness). Tasks are then dispatched from the lowest to the highest deadline.

This approach favors latency-sensitive tasks: those that frequently sleep will accumulate less exec_runtime, resulting in earlier deadlines. In contrast, CPU-intensive tasks that don’t sleep accumulate a larger exec_runtime and thus get scheduled later.

All the tasks are stored in a BTreeSet (TaskTree), using the deadline as the ordering key. Once the order of execution is determined all tasks are sent back to the BPF counterpart (scx_rustland_core) to be dispatched.

The BPF dispatcher is completely agnostic of the particular scheduling policy implemented in user-space. For this reason developers that are willing to use this scheduler to experiment scheduling policies should be able to simply modify the Rust component, without having to deal with any internal kernel / BPF details.

=== Troubleshooting ===

• Reduce the time slice (option -s) if you experience lag or cracking audio.

Fields

slice_us: u64

Scheduling slice duration in microseconds.

slice_us_min: u64

Scheduling minimum slice duration in microseconds.

percpu_local: bool

If set, per-CPU tasks are dispatched directly to their only eligible CPU. This can help enforce affinity-based isolation for better performance.

partial: bool

If specified, only tasks which have their scheduling policy set to SCHED_EXT using sched_setscheduler(2) are switched. Otherwise, all tasks are switched.

exit_dump_len: u32

Exit debug dump buffer length. 0 indicates default.

verbose: bool

Enable verbose output, including libbpf details. Moreover, BPF scheduling events will be reported in tracefs (e.g., /sys/kernel/tracing/trace_pipe).

stats: Option<f64>

Enable stats monitoring with the specified interval.

monitor: Option<f64>

Run in stats monitoring mode with the specified interval. Scheduler is not launched.

help_stats: bool

Show descriptions for statistics.

version: bool

Print scheduler version and exit.

libbpf: LibbpfOpts

Trait Implementations

impl Args for Opts

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl CommandFactory for Opts

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for Opts

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Opts

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Opts

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.