Struct Scheduler

pub(crate) struct Scheduler<'a> {

    pub(crate) skel: BpfSkel<'a>,
    pub(crate) struct_ops: Option<Link>,
    pub(crate) layer_specs: Vec<LayerSpec>,
    pub(crate) sched_intv: Duration,
    pub(crate) cpu_pool: CpuPool,
    pub(crate) layers: Vec<Layer>,
    pub(crate) idle_qos_enabled: bool,
    pub(crate) proc_reader: ProcReader,
    pub(crate) sched_stats: Stats,
    pub(crate) nr_layer_cpus_ranges: Vec<(usize, usize)>,
    pub(crate) processing_dur: Duration,
    pub(crate) topo: Arc<Topology>,
    pub(crate) netdevs: BTreeMap<String, NetDev>,
    pub(crate) stats_server: StatsServer<StatsReq, StatsRes>,
}

Fields

skel: BpfSkel<'a>

struct_ops: Option<Link>

layer_specs: Vec<LayerSpec>

sched_intv: Duration

cpu_pool: CpuPool

layers: Vec<Layer>

idle_qos_enabled: bool

proc_reader: ProcReader

sched_stats: Stats

nr_layer_cpus_ranges: Vec<(usize, usize)>

processing_dur: Duration

topo: Arc<Topology>

netdevs: BTreeMap<String, NetDev>

stats_server: StatsServer<StatsReq, StatsRes>

Implementations

impl<'a> Scheduler<'a>

pub(crate) fn init_layers( skel: &mut OpenBpfSkel<'_>, specs: &[LayerSpec], topo: &Topology, ) -> Result<()>

pub(crate) fn init_nodes( skel: &mut OpenBpfSkel<'_>, _opts: &Opts, topo: &Topology, )

pub(crate) fn init_cpu_prox_map(topo: &Topology, cpu_ctxs: &mut [cpu_ctx])

pub(crate) fn convert_cpu_ctxs(cpu_ctxs: Vec<cpu_ctx>) -> Vec<Vec<u8>>

pub(crate) fn init_cpus( skel: &BpfSkel<'_>, layer_specs: &[LayerSpec], topo: &Topology, ) -> Result<()>

pub(crate) fn init_llc_prox_map( skel: &mut BpfSkel<'_>, topo: &Topology, ) -> Result<()>

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

pub(crate) fn update_bpf_layer_cpumask(layer: &Layer, bpf_layer: &mut layer)

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

pub(crate) fn calc_target_nr_cpus(&self) -> Vec<(usize, usize)>

Calculate how many CPUs each layer would like to have if there were no competition. The CPU range is determined by applying the inverse of util_range and then capping by cpus_range. If the current allocation is within the acceptable range, no change is made. Returns (target, min) pair for each layer.

pub(crate) fn weighted_target_nr_cpus( &self, targets: &[(usize, usize)], ) -> Vec<usize>

Given (target, min) pair for each layer which was determined assuming infinite number of CPUs, distribute the actual CPUs according to their weights.

pub(crate) fn compute_target_llcs( target: usize, topo: &Topology, ) -> (usize, usize)

pub(crate) fn recompute_layer_core_order( &mut self, layer_targets: &Vec<(usize, usize)>, )

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

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

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

pub(crate) fn generate_sys_stats( &mut self, stats: &Stats, cpus_ranges: &mut [(usize, usize)], ) -> Result<SysStats>

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

Trait Implementations

impl Drop for Scheduler<'_>

fn drop(&mut self)

Executes the destructor for this type.