Struct CellManager 

pub struct CellManager {
    cell_parent_path: PathBuf,
    inotify: Inotify,
    cells: HashMap<u64, CellInfo>,
    cell_id_to_cgid: HashMap<u32, u64>,
    free_cell_ids: Vec<u32>,
    next_cell_id: u32,
    max_cells: u32,
    all_cpus: Cpumask,
    exclude_names: HashSet<String>,
}

Manages cells for direct child cgroups of a specified parent

Fields

cell_parent_path: PathBuf

inotify: Inotify

cells: HashMap<u64, CellInfo>

Maps cgroup ID to cell info

cell_id_to_cgid: HashMap<u32, u64>

Maps cell ID to cgroup ID (for reverse lookup)

free_cell_ids: Vec<u32>

Freed cell IDs available for reuse

next_cell_id: u32

max_cells: u32

all_cpus: Cpumask

Cpumask of all CPUs in the system (from topology)

exclude_names: HashSet<String>

Cgroup directory names to exclude from cell creation

Implementations

impl CellManager

pub fn new( cell_parent_path: &str, max_cells: u32, all_cpus: Cpumask, exclude: HashSet<String>, ) -> Result<Self>

fn new_with_path( path: PathBuf, max_cells: u32, all_cpus: Cpumask, exclude: HashSet<String>, ) -> Result<Self>

fn should_exclude(&self, path: &Path) -> bool

fn scan_existing_children(&mut self) -> Result<Vec<(u64, u32)>>

pub fn process_events(&mut self) -> Result<(Vec<(u64, u32)>, Vec<u32>)>

Process pending inotify events. Returns list of (cgid, cell_id) for new cells and list of cell_ids that were destroyed.

Rather than processing individual events, we simply check if any events occurred and then rescan the directory to reconcile state. This is simpler and handles edge cases like inotify queue overflow gracefully.

fn reconcile_cells(&mut self) -> Result<(Vec<(u64, u32)>, Vec<u32>)>

Reconcile our tracked cells with the actual cgroup directory contents. Returns (new_cells, destroyed_cells).

fn create_cell_for_cgroup( &mut self, path: &Path, cgid: u64, ) -> Result<(u64, u32)>

fn read_cpuset(cgroup_path: &Path) -> Result<Option<Cpumask>>

Read cpuset.cpus from a cgroup path. Returns None if empty or unavailable.

fn allocate_cell_id(&mut self) -> Result<u32>

pub fn compute_cpu_assignments( &self, compute_borrowable: bool, ) -> Result<Vec<CpuAssignment>>

Compute CPU assignments for all cells.

When cpusets overlap, contested CPUs are divided proportionally among claimants. Unclaimed CPUs go to cell 0 and any unpinned cells (cells without cpusets).

If compute_borrowable is true, each assignment includes a borrowable cpumask (all system CPUs minus the cell’s own, intersected with cpuset if present). Without demand data, borrowable masks are uncapped.

Returns a Vec of CpuAssignment, or an error if any cell would receive zero CPUs (which indicates too many cells for available CPUs).

pub fn compute_demand_cpu_assignments( &self, cell_demands: &HashMap<u32, f64>, compute_borrowable: bool, ) -> Result<Vec<CpuAssignment>>

Compute CPU assignments weighted by per-cell demand.

cell_demands maps cell_id -> smoothed_util_pct. All active cells must be present in the map; missing entries or negative weights are errors.

If compute_borrowable is true, each assignment includes a borrowable cpumask (all system CPUs minus the cell’s own, intersected with cpuset if present).

fn compute_cpu_assignments_inner( &self, cell_demands: Option<&HashMap<u32, f64>>, compute_borrowable: bool, ) -> Result<Vec<CpuAssignment>>

Internal implementation shared by equal-weight and demand-weighted assignment.

pub fn get_cell_assignments(&self) -> Vec<(u64, u32)>

Returns all cell assignments as (cgid, cell_id) pairs. Used to configure BPF with cgroup-to-cell mappings.

pub fn format_cell_config(&self, cpu_assignments: &[CpuAssignment]) -> String

Format the cell configuration as a compact string for logging. Example output: “[0: 0-7] [1(container-a): 8-15] [2(container-b): 16-23]”

pub fn refresh_cpusets(&mut self) -> Result<bool>

Re-read cpuset.cpus for all cells and update stored cpusets. Returns true if any cell’s cpuset changed.

Trait Implementations

impl AsFd for CellManager

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.