Struct CpuManager 

struct CpuManager<'a> {
    domain: &'a Cpumask,
    cpu_to_partition: Option<&'a HashMap<usize, usize>>,
}

Generic CPU allocator over a fixed domain of CPUs.

Fields

domain: &'a Cpumask

cpu_to_partition: Option<&'a HashMap<usize, usize>>

Optional CPU -> topology partition mapping used only to rank CPUs when a requested minimum must displace preferential claims.

Implementations

impl<'a> CpuManager<'a>

fn with_partitions( domain: &'a Cpumask, cpu_to_partition: &'a HashMap<usize, usize>, ) -> Self

fn compute_targets( total_cpus: usize, recipients: &[(u32, f64)], ) -> Result<HashMap<u32, usize>>

Compute the global target CPU count for each recipient.

Each recipient gets a floor of 1 CPU, with the remainder distributed proportionally by weight. Returns only counts, not actual CPU assignments.

fn distribute_cpus_proportional( cpus: &[usize], recipients: &[(u32, f64)], ) -> Result<HashMap<u32, Vec<usize>>>

Distribute CPUs among recipients proportionally by weight.

Recipients with weight 0 receive 0 CPUs. If all weights are 0, falls back to equal division. As a post-processing step, if any positive-weight recipient got 0 CPUs, 1 CPU is stolen from the recipient with the highest allocation (that has

1. to prevent starvation.

fn reserve_requested_minimums( &self, recipients: &[CpuRecipient], contention: &HashMap<usize, Vec<u32>>, ) -> Result<HashMap<u32, Cpumask>>

Reserve best-effort requested minima before weighted allocation.

Prefer CPUs without a claim. If those are insufficient, displace claims only where every claimant remains above its protected minimum. The optional topology partition map is a tie-breaker after exclusive CPUs: prefer taking from the partition split across the most claimants.

fn compute_assignments( &self, recipients: &[CpuRecipient], compute_borrowable: bool, ) -> Result<Vec<CpuAssignment>>

Compute CPU assignments over domain for a generic set of recipients.

allowed is hard eligibility while claimed expresses preferential ownership. Recipients without claims normally receive from the unclaimed pool, but may reserve a requested minimum from anywhere they are allowed without violating another recipient’s protected minimum.

When claimed masks overlap, contested CPUs are divided proportionally among claimants. Unclaimed CPUs go to unpinned recipients.

If compute_borrowable is true, each assignment includes a borrowable cpumask consisting of domain - primary, intersected with allowed if present.