Struct Scheduler

pub(crate) struct Scheduler<'a> {
    pub(crate) skel: BpfSkel<'a>,
    pub(crate) struct_ops: Option<Link>,
    pub(crate) cpu_pool: CpuPool,
    pub(crate) cells: BTreeMap<u32, Cell>,
    pub(crate) cgroup_to_cell: HashMap<String, u32>,
    pub(crate) prev_percpu_cell_cycles: Vec<[u64; 16]>,
    pub(crate) last_reconfiguration: Instant,
    pub(crate) last_cpu_rebalancing: Instant,
    pub(crate) reconfiguration_interval: Duration,
    pub(crate) cpu_rebalancing_interval: Duration,
    pub(crate) monitor_interval: Duration,
}

Fields

skel: BpfSkel<'a>

struct_ops: Option<Link>

cpu_pool: CpuPool

cells: BTreeMap<u32, Cell>

cgroup_to_cell: HashMap<String, u32>

prev_percpu_cell_cycles: Vec<[u64; 16]>

last_reconfiguration: Instant

last_cpu_rebalancing: Instant

reconfiguration_interval: Duration

cpu_rebalancing_interval: Duration

monitor_interval: Duration

Implementations

impl<'a> Scheduler<'a>

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 update_cgroup_to_cell_assignment(&mut self) -> Result<()>

pub(crate) fn trigger_reconfiguration(&mut self)

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

Iterate through each cg in the cgroupfs, read its load from BPF and update the cells map

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

Output various debugging data like per cell stats, per-cpu stats, etc.

pub(crate) fn reconfigure(&mut self) -> Result<Option<SplitOrMerge>>

This determines what action to take (split a cell or merge two)

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

pub(crate) fn assign_cpus(&mut self, total_load: f64) -> Result<()>

Assign CPUs based on per-cell load

pub(crate) fn split(&mut self, split: Split) -> Result<()>

Execute a split, allocating a new cell, assigning cgroups

pub(crate) fn merge(&mut self, merge: Merge) -> Result<()>

Execute a merge, combining two cells into one

pub(crate) fn find_best_split( &self, cell: &Cell, cell_idx: u32, ) -> Result<Option<Split>>

This is largely a placeholder, it views the Cell as a fully-connected graph of cgroups where edges are the score of the pair (see score_cgroup_pair) and then identifies the max-cut of that graph.

pub(crate) fn score_cgroup_pair(&self, c1: &Cgroup, c2: &Cgroup) -> f64

This is a straight-up placeholder - can take into account cgroup tree distance, weights, etc. The idea is that higher scoring pairs should be in separate cells.

Trait Implementations

impl Drop for Scheduler<'_>

fn drop(&mut self)

Executes the destructor for this type.