Struct Opts 

pub(crate) struct Opts {

    pub(crate) verbose: u8,
    pub(crate) log_level: String,
    pub(crate) exit_dump_len: u32,
    pub(crate) reconfiguration_interval_s: u64,
    pub(crate) rebalance_cpus_interval_s: u64,
    pub(crate) monitor_interval_s: u64,
    pub(crate) monitor: Option<f64>,
    pub(crate) version: bool,
    pub(crate) run_id: Option<u64>,
    pub(crate) debug_events: bool,
    pub(crate) exiting_task_workaround: bool,
    pub(crate) cpu_controller_disabled: bool,
    pub(crate) reject_multicpu_pinning: bool,
    pub(crate) enable_llc_awareness: bool,
    pub(crate) enable_work_stealing: bool,
    pub(crate) cell_parent_cgroup: Option<String>,
    pub(crate) cell_exclude: Vec<String>,
    pub(crate) enable_borrowing: bool,
    pub(crate) use_lockless_peek: bool,
    pub(crate) enable_rebalancing: bool,
    pub(crate) rebalance_threshold: f64,
    pub(crate) rebalance_cooldown_s: u64,
    pub(crate) demand_smoothing: f64,
    pub(crate) dynamic_affinity_cpu_selection: bool,
    pub(crate) enable_slice_shrinking: bool,
    pub(crate) slice_shrink_max_us: u64,
    pub(crate) slice_shrink_min_us: u64,
    pub libbpf: LibbpfOpts,
}

scx_mitosis: A dynamic affinity scheduler

Cgroups are assigned to a dynamic number of Cells which are assigned to a dynamic set of CPUs. The BPF part does simple vtime scheduling for each cell.

Userspace makes the dynamic decisions of which Cells should be merged or split and which CPUs they should be assigned to.

Fields

verbose: u8

Deprecated, noop, use RUST_LOG or –log-level instead.

log_level: String

Specify the logging level. Accepts rust’s envfilter syntax for modular logging: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#example-syntax. Examples: [“info”, “warn,tokio=info”]

exit_dump_len: u32

Exit debug dump buffer length. 0 indicates default.

reconfiguration_interval_s: u64

Interval to consider reconfiguring the Cells (e.g. merge or split)

rebalance_cpus_interval_s: u64

Interval to consider rebalancing CPUs to Cells

monitor_interval_s: u64

Interval to report monitoring information

monitor: Option<f64>

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

version: bool

Print scheduler version and exit.

run_id: Option<u64>

Optional run ID for tracking scheduler instances.

debug_events: bool

Enable debug event tracking for cgroup_init, init_task, and cgroup_exit. Events are recorded in a ring buffer and output in dump().

exiting_task_workaround: bool

Enable workaround for exiting tasks with offline cgroups during scheduler load. This works around a kernel bug where tasks can be initialized with cgroups that were never initialized. Disable this once the kernel bug is fixed.

cpu_controller_disabled: bool

Disable SCX cgroup callbacks (for when CPU cgroup controller is disabled). Uses tracepoints and cgroup iteration instead.

reject_multicpu_pinning: bool

Reject tasks with multi-CPU pinning that doesn’t cover the entire cell. By default, these tasks are allowed but may have degraded performance.

enable_llc_awareness: bool

Enable LLC-awareness. This will populate the scheduler’s LLC maps and cause it to use LLC-aware scheduling.

enable_work_stealing: bool

Enable work stealing. This is only relevant when LLC-awareness is enabled.

cell_parent_cgroup: Option<String>

Parent cgroup path whose direct children become cells. When specified, cells are created for each direct child cgroup of this parent, with CPUs divided equally among cells. Example: –cell-parent-cgroup /workloads

cell_exclude: Vec<String>

Exact directory name of a direct child cgroup to exclude from cell creation (excluded cgroups remain in cell 0). Matched against the directory basename, not the full path. Can be specified multiple times. Requires –cell-parent-cgroup. Example: –cell-exclude systemd-workaround.service

enable_borrowing: bool

Enable CPU borrowing: cells can use idle CPUs from other cells. Only meaningful with –cell-parent-cgroup and multiple cells.

use_lockless_peek: bool

Use lockless scx_bpf_dsq_peek() instead of the default iterator-based peek.

enable_rebalancing: bool

Enable demand-based CPU rebalancing between cells.

rebalance_threshold: f64

Utilization spread (max - min) that triggers rebalancing (default: 20%)

rebalance_cooldown_s: u64

Minimum seconds between rebalancing events (default: 5)

demand_smoothing: f64

EWMA smoothing factor for demand tracking. Higher = more responsive (default: 0.3)

dynamic_affinity_cpu_selection: bool

Dynamically reassign multi-CPU affinitized tasks on each wake: prefer an idle CPU within the mask, fall back to random. Redistribute at enqueue if the target CPU already has queued work.

enable_slice_shrinking: bool

Enable slice shrinking for CPU-pinned tasks. Uses per-task EWMA runtime to shrink the running task’s slice when pinned waiters are queued.

slice_shrink_max_us: u64

Upper bound for shrink limit (us). Used when the proportional value (avg_runtime * K) exceeds it.

slice_shrink_min_us: u64

Minimum shrink limit (us). Slices are never shrunk below this value. In practice, the resolution here is determined by the kernel’s tick period.

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.