Struct Opts

pub(crate) struct Opts {

    pub(crate) exit_dump_len: u32,
    pub(crate) slice_us: u64,
    pub(crate) slice_us_min: u64,
    pub(crate) slice_us_lag: u64,
    pub(crate) slice_lag_scaling: bool,
    pub(crate) run_us_lag: u64,
    pub(crate) max_avg_nvcsw: u64,
    pub(crate) cpu_busy_thresh: i64,
    pub(crate) throttle_us: u64,
    pub(crate) idle_resume_us: i64,
    pub(crate) tickless: bool,
    pub(crate) rr_sched: bool,
    pub(crate) no_builtin_idle: bool,
    pub(crate) local_pcpu: bool,
    pub(crate) direct_dispatch: bool,
    pub(crate) sticky_cpu: bool,
    pub(crate) native_priority: bool,
    pub(crate) local_kthreads: bool,
    pub(crate) no_wake_sync: bool,
    pub(crate) primary_domain: String,
    pub(crate) disable_l2: bool,
    pub(crate) disable_l3: bool,
    pub(crate) disable_smt: bool,
    pub(crate) disable_numa: bool,
    pub(crate) cpufreq: bool,
    pub(crate) stats: Option<f64>,
    pub(crate) monitor: Option<f64>,
    pub(crate) debug: bool,
    pub(crate) verbose: bool,
    pub(crate) version: bool,
    pub(crate) help_stats: bool,
}

Fields

exit_dump_len: u32

Exit debug dump buffer length. 0 indicates default.

slice_us: u64

Maximum scheduling slice duration in microseconds.

slice_us_min: u64

Minimum scheduling slice duration in microseconds.

slice_us_lag: u64

Maximum runtime budget that a task can accumulate while sleeping (in microseconds).

Increasing this value can help to enhance the responsiveness of interactive tasks, but it can also make performance more “spikey”.

slice_lag_scaling: bool

Dynamically adjust task’s maximum sleep budget based on CPU utilization.

Enabling this option allows to increase the throughput of highly message passing workloads, but it can also reduce the overall system responsiveness.

run_us_lag: u64

Maximum runtime penalty that a task can accumulate while running (in microseconds).

Increasing this value can help to enhance the responsiveness of interactive tasks, but it can also make performance more “spikey”.

max_avg_nvcsw: u64

Maximum rate of voluntary context switches.

Increasing this value can help prioritize interactive tasks with a higher sleep frequency over interactive tasks with lower sleep frequency.

Decreasing this value makes the scheduler more robust and fair.

(0 = disable voluntary context switch prioritization).

cpu_busy_thresh: i64

Utilization percentage to consider a CPU as busy (-1 = auto).

A value close to 0 forces tasks to migrate quickier, increasing work conservation and potentially system responsiveness.

A value close to 100 makes tasks more sticky to their CPU, increasing cache-sensivite and server-type workloads.

In auto mode (-1) the scheduler autoomatically tries to determine the optimal value in function of the current workload.

throttle_us: u64

Throttle the running CPUs by periodically injecting idle cycles.

This option can help extend battery life on portable devices, reduce heating, fan noise and overall energy consumption (0 = disable).

idle_resume_us: i64

Set CPU idle QoS resume latency in microseconds (-1 = disabled).

Setting a lower latency value makes CPUs less likely to enter deeper idle states, enhancing performance at the cost of higher power consumption. Alternatively, increasing the latency value may reduce performance, but also improve power efficiency.

tickless: bool

Enable tickless mode.

This option enables tickless mode: tasks get an infinite time slice and they are preempted only in case of CPU contention. This can help reduce the OS noise and provide a better level of performance isolation.

rr_sched: bool

Enable round-robin scheduling.

Each task is given a fixed time slice (defined by –slice-us) and run in a cyclic, fair order.

no_builtin_idle: bool

Disable in-kernel idle CPU selection policy.

Set this option to disable the in-kernel built-in idle CPU selection policy and rely on the custom CPU selection policy.

local_pcpu: bool

Enable per-CPU tasks prioritization.

Enabling this option allows to prioritize per-CPU tasks that usually tend to be de-prioritized, since they can’t be migrated when their only usable CPU is busy. This improves fairness, but it can also reduce the overall system throughput.

This option is recommended for gaming or latency-sensitive workloads.

direct_dispatch: bool

Always allow direct dispatch to idle CPUs.

By default tasks are not directly dispatched to idle CPUs if there are other tasks waiting in the scheduler’s queues. This prevents potential starvation of the already queued tasks.

Enabling this option allows tasks to be always dispatched directly to idle CPUs, potentially bypassing the scheduler queues.

This allows to improve system throughput, especially with server workloads, but it can introduce unfairness and potentially trigger stall conditions.

sticky_cpu: bool

Enable CPU stickiness.

Enabling this option can reduce the amount of task migrations, but it can also make performance less consistent on systems with hybrid cores.

This option has no effect if the primary scheduling domain includes all the CPUs (e.g., --primary-domain all).

native_priority: bool

Native tasks priorities.

By default, the scheduler normalizes task priorities to avoid large gaps that could lead to stalls or starvation. This option disables normalization and uses the default Linux priority range instead.

local_kthreads: bool

Enable per-CPU kthread prioritization.

Enabling this can improve system performance, but it may also introduce interactivity issues or unfairness in scenarios with high kthread activity, such as heavy I/O or network traffic.

no_wake_sync: bool

Disable direct dispatch during synchronous wakeups.

Enabling this option can lead to a more uniform load distribution across available cores, potentially improving performance in certain scenarios. However, it may come at the cost of reduced efficiency for pipe-intensive workloads that benefit from tighter producer-consumer coupling.

primary_domain: String

Specifies the initial set of CPUs, represented as a bitmask in hex (e.g., 0xff), that the scheduler will use to dispatch tasks, until the system becomes saturated, at which point tasks may overflow to other available CPUs.

Special values:

• “auto” = automatically detect the CPUs based on the active power profile
• “turbo” = automatically detect and prioritize the CPUs with the highest max frequency
• “performance” = automatically detect and prioritize the fastest CPUs
• “powersave” = automatically detect and prioritize the slowest CPUs
• “all” = all CPUs assigned to the primary domain
• “none” = no prioritization, tasks are dispatched on the first CPU available

disable_l2: bool

Disable L2 cache awareness.

disable_l3: bool

Disable L3 cache awareness.

disable_smt: bool

Disable SMT awareness.

disable_numa: bool

Disable NUMA rebalancing.

cpufreq: bool

Enable CPU frequency control (only with schedutil governor).

With this option enabled the CPU frequency will be automatically scaled based on the load.

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.

debug: bool

Enable BPF debugging via /sys/kernel/tracing/trace_pipe.

verbose: bool

Enable verbose output, including libbpf details.

version: bool

Print scheduler version and exit.

help_stats: bool

Show descriptions for statistics.

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.