Struct Opts 

pub(crate) struct Opts {

    pub(crate) exit_dump_len: u32,
    pub(crate) slice_us: u64,
    pub(crate) slice_lag_us: u64,
    pub(crate) cpu_busy_thresh: u64,
    pub(crate) polling_ms: u64,
    pub(crate) primary_domain: Option<String>,
    pub(crate) enable_numa: bool,
    pub(crate) disable_cpufreq: bool,
    pub(crate) flat_idle_scan: bool,
    pub(crate) preferred_idle_scan: bool,
    pub(crate) disable_smt: bool,
    pub(crate) avoid_smt: bool,
    pub(crate) no_wake_sync: bool,
    pub(crate) no_deferred_wakeup: bool,
    pub(crate) mm_affinity: bool,
    pub(crate) stats: Option<f64>,
    pub(crate) monitor: Option<f64>,
    pub(crate) verbose: bool,
    pub(crate) version: bool,
    pub(crate) help_stats: bool,
    pub libbpf: LibbpfOpts,
}

Fields

exit_dump_len: u32

Exit debug dump buffer length. 0 indicates default.

slice_us: u64

Maximum scheduling slice duration in microseconds.

slice_lag_us: u64

Maximum runtime (since last sleep) that can be charged to a task in microseconds.

cpu_busy_thresh: u64

CPU busy threshold.

Specifies the CPU utilization percentage (0-100%) at which the scheduler considers the system to be busy.

When the average CPU utilization reaches this threshold, the scheduler switches from using multiple per-CPU round-robin dispatch queues (which favor locality and reduced locking contention) to a global deadline-based dispatch queue (which improves load balancing).

The global dispatch queue can increase task migrations and improve responsiveness for interactive tasks under heavy load. Lower values make the scheduler switch to deadline mode sooner, improving overall responsiveness at the cost of reducing single-task performance due to the additional migrations. Higher values makes task more “sticky” to their CPU, improving workloads that benefit from cache locality.

A higher value is recommended for server-type workloads, while a lower value is recommended for interactive-type workloads.

polling_ms: u64

Polling time (ms) to refresh the CPU utilization.

This interval determines how often the scheduler refreshes the CPU utilization that is compared with the CPU busy threshold (option -c) to decide if the system is busy or not and trigger the switch between using multiple per-CPU dispatch queues or a single global deadline-based dispatch queue.

Value is clamped to the range [10 .. 1000].

0 = disabled.

primary_domain: Option<String>

Specifies a list of CPUs to prioritize.

Accepts a comma-separated list of CPUs or ranges (i.e., 0-3,12-15) or the following special keywords:

“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.

By default “all” CPUs are used.

enable_numa: bool

Enable NUMA optimizations.

disable_cpufreq: bool

Disable CPU frequency control.

flat_idle_scan: bool

Enable flat idle CPU scanning.

This option can help reducing some overhead when trying to allocate idle CPUs and it can be quite effective with simple CPU topologies.

preferred_idle_scan: bool

Enable preferred idle CPU scanning.

With this option enabled, the scheduler will prioritize assigning tasks to higher-ranked cores before considering lower-ranked ones.

disable_smt: bool

Disable SMT.

This option can only be used together with –flat-idle-scan or –preferred-idle-scan, otherwise it is ignored.

avoid_smt: bool

SMT contention avoidance.

When enabled, the scheduler aggressively avoids placing tasks on sibling SMT threads. This may increase task migrations and lower overall throughput, but can lead to more consistent performance by reducing contention on shared SMT cores.

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.

no_deferred_wakeup: bool

Disable deferred wakeups.

Enabling this option can reduce throughput and performance for certain workloads, but it can also reduce power consumption (useful on battery-powered systems).

mm_affinity: bool

Enable address space affinity.

This option allows to keep tasks that share the same address space (e.g., threads of the same process) on the same CPU across wakeups.

This can improve locality and performance in certain cache-sensitive workloads.

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.

verbose: bool

Enable verbose output, including libbpf details.

version: bool

Print scheduler version and exit.

help_stats: bool

Show descriptions for statistics.

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.