Struct LoadBalancer

pub struct LoadBalancer<'a, 'b> {
    skel: &'a mut BpfSkel<'b>,
    dom_group: Arc<DomainGroup>,
    skip_kworkers: bool,
    infeas_threshold: f64,
    nodes: SortedVec<NumaNode>,
    lb_apply_weight: bool,
    balance_load: bool,
}

Fields

skel: &'a mut BpfSkel<'b>

dom_group: Arc<DomainGroup>

skip_kworkers: bool

infeas_threshold: f64

nodes: SortedVec<NumaNode>

lb_apply_weight: bool

balance_load: bool

Implementations

impl<'a, 'b> LoadBalancer<'a, 'b>

pub fn new( skel: &'a mut BpfSkel<'b>, dom_group: Arc<DomainGroup>, skip_kworkers: bool, lb_apply_weight: bool, balance_load: bool, ) -> Self

pub fn load_balance(&mut self) -> Result<()>

Perform load balancing calculations. When load balancing is enabled, also perform rebalances between NUMA nodes (when running on a multi-socket host) and domains.

pub fn get_stats(&self) -> BTreeMap<usize, NodeStats>

fn create_domain_hierarchy(&mut self) -> Result<()>

fn calculate_load_avgs(&mut self) -> Result<LoadLedger>

fn bucket_range(&self, bucket: u64) -> (f64, f64)

fn bucket_weight(&self, bucket: u64) -> usize

fn populate_tasks_by_load(&mut self, dom: &mut Domain) -> Result<()>

@dom needs to push out tasks to balance loads. Make sure its tasks_by_load is populated so that the victim tasks can be picked.

fn find_first_candidate<'d, I>(tasks_by_load: I) -> Option<&'d TaskInfo>

where I: IntoIterator<Item = &'d TaskInfo>,

fn try_find_move_task( &mut self, (push_dom, to_push): (&mut Domain, f64), (pull_dom, to_pull): (&mut Domain, f64), task_filter: impl Fn(&TaskInfo, u32) -> bool, to_xfer: f64, ) -> Result<Option<f64>>

Try to find a task in @push_dom to be moved into @pull_dom. If a task is found, move the task between the domains, and return the amount of load transferred between the two.

fn transfer_between_nodes( &mut self, push_node: &mut NumaNode, pull_node: &mut NumaNode, ) -> Result<f64>

fn balance_between_nodes(&mut self) -> Result<()>

fn balance_within_node(&mut self, node: &mut NumaNode) -> Result<()>

fn perform_balancing(&mut self) -> Result<()>