Struct Scheduler 

pub(crate) struct Scheduler<'a> {

    pub(crate) skel: BpfSkel<'a>,
    pub(crate) monitor_interval: Duration,
    pub(crate) cells: HashMap<u32, Cell>,
    pub(crate) prev_cell_stats: [[u64; 6]; 256],
    pub(crate) prev_cell_running_ns: [u64; 256],
    pub(crate) prev_cell_own_ns: [u64; 256],
    pub(crate) prev_cell_lent_ns: [u64; 256],
    pub(crate) metrics: Metrics,
    pub(crate) stats_server: Option<StatsServer<(), Metrics>>,
    pub(crate) last_configuration_seq: Option<u32>,
    pub(crate) last_cpuset_seq: u32,
    pub(crate) cell_manager: Option<CellManager>,
    pub(crate) enable_borrowing: bool,
    pub(crate) enable_rebalancing: bool,
    pub(crate) rebalance_threshold: f64,
    pub(crate) rebalance_cooldown: Duration,
    pub(crate) demand_smoothing: f64,
    pub(crate) smoothed_util: [f64; 256],
    pub(crate) last_rebalance: Instant,
    pub(crate) rebalance_count: u64,
    pub(crate) epoll: Epoll,
    pub(crate) stats_waker: EventFd,
}

Fields

skel: BpfSkel<'a>

monitor_interval: Duration

cells: HashMap<u32, Cell>

prev_cell_stats: [[u64; 6]; 256]

prev_cell_running_ns: [u64; 256]

prev_cell_own_ns: [u64; 256]

prev_cell_lent_ns: [u64; 256]

metrics: Metrics

stats_server: Option<StatsServer<(), Metrics>>

last_configuration_seq: Option<u32>

last_cpuset_seq: u32

Last observed cpuset_seq for cpuset change detection

cell_manager: Option<CellManager>

Optional cell manager for –cell-parent-cgroup mode

enable_borrowing: bool

Whether CPU borrowing is enabled

enable_rebalancing: bool

Whether demand-based rebalancing is enabled

rebalance_threshold: f64

Utilization spread threshold for triggering rebalancing

rebalance_cooldown: Duration

Minimum duration between rebalancing events

demand_smoothing: f64

EWMA smoothing factor for demand tracking

smoothed_util: [f64; 256]

EWMA-smoothed utilization per cell

last_rebalance: Instant

Last time rebalancing was performed

rebalance_count: u64

Number of rebalancing events

epoll: Epoll

Epoll instance for waiting on multiple fds (inotify, stats wakeup)

stats_waker: EventFd

EventFd to wake up main loop when stats are requested

Implementations

impl<'a> Scheduler<'a>

pub(crate) fn validate_args(opts: &Opts) -> Result<()>

pub(crate) fn init( opts: &Opts, open_object: &'a mut MaybeUninit<OpenObject>, ) -> Result<Self>

pub(crate) fn run(&mut self, shutdown: Arc<AtomicBool>) -> Result<UserExitInfo>

pub(crate) fn apply_initial_cells(&mut self) -> Result<()>

Apply initial cell assignments discovered at startup

pub(crate) fn process_cell_events(&mut self) -> Result<()>

Process cell manager events (new/destroyed cgroups)

pub(crate) fn compute_and_apply_cell_config( &mut self, new_cell_ids: &[u32], ) -> Result<Vec<CpuAssignment>>

Compute cell configuration from CellManager and apply it to BPF.

When rebalancing is enabled and there is existing utilization data, uses demand-weighted CPU assignment instead of equal-weight. New cells (listed in new_cell_ids) are seeded to the average smoothed_util of existing cells so they start with a fair share rather than zero.

Returns the CPU assignments for use with format_cell_config.

pub(crate) fn maybe_rebalance(&mut self) -> Result<()>

Check if rebalancing should be triggered and apply demand-weighted CPU assignments.

pub(crate) fn apply_cell_config( &mut self, cell_assignments: &[(u64, u32)], cpu_assignments: &[CpuAssignment], ) -> Result<()>

Apply cell configuration to BPF.

Writes the cell and CPU assignments to the BPF config struct and triggers the BPF program to apply the configuration.

pub(crate) fn get_metrics(&self) -> Metrics

pub(crate) fn calculate_distribution_stats( &self, queue_counts: &[u64; 4], global_queue_decisions: u64, scope_queue_decisions: u64, scope_affn_viols: u64, scope_steals: u64, ) -> Result<DistributionStats>

pub(crate) fn update_and_log_global_queue_stats( &mut self, global_queue_decisions: u64, cell_stats_delta: &[[u64; 6]; 256], ) -> Result<()>

pub(crate) fn update_and_log_cell_queue_stats( &mut self, global_queue_decisions: u64, cell_stats_delta: &[[u64; 6]; 256], ) -> Result<()>

pub(crate) fn log_all_queue_stats( &mut self, cell_stats_delta: &[[u64; 6]; 256], ) -> Result<()>

pub(crate) fn calculate_cell_stat_delta( &mut self, cpu_ctxs: &[cpu_ctx], ) -> Result<[[u64; 6]; 256]>

pub(crate) fn collect_metrics(&mut self) -> Result<()>

Collect metrics and out various debugging data like per cell stats, per-cpu stats, etc.

pub(crate) fn collect_demand_metrics( &mut self, cpu_ctxs: &[cpu_ctx], ) -> Result<()>

Compute per-cell demand metrics (utilization, borrowed, lent) from BPF running_ns counters.

pub(crate) fn check_cpuset_changes(&mut self) -> Result<()>

Check if any cell’s cpuset was modified and recompute if so.

pub(crate) fn refresh_bpf_cells(&mut self) -> Result<()>