use std::path::{Path, PathBuf};
use crate::memory_budget::constants::{
CGROUP_V1_LIMIT, CGROUP_V1_ROOT, CGROUP_V2_LIMIT, CGROUP_V2_PREFIX, CGROUP_V2_ROOT,
MEMINFO_TOTAL, MEMINFO_UNIT, MEMORY_CONTROLLER, PROC_CGROUP, PROC_MEMINFO, UNLIMITED,
};
use crate::memory_budget::models::{LimitOrigin, MemoryLimit};
use crate::number_text::constants::BINARY_UNIT;
pub(crate) fn memory_limit() -> Result<Option<MemoryLimit>, String> {
let physical = physical_memory()?;
let set = match job_limit()? {
Some(bytes) => Some((bytes, LimitOrigin::JobObject)),
None => container_limit()?.map(|bytes| (bytes, LimitOrigin::Container)),
};
Ok(lower_limit(set, physical))
}
pub(crate) fn lower_limit(
limit: Option<(u64, LimitOrigin)>,
physical: Option<u64>,
) -> Option<MemoryLimit> {
match (limit, physical) {
(Some((bytes, origin)), Some(physical)) if bytes < physical => {
Some(MemoryLimit { bytes, origin })
}
(Some((bytes, origin)), None) => Some(MemoryLimit { bytes, origin }),
(_, physical) => physical.map(|bytes| MemoryLimit {
bytes,
origin: LimitOrigin::Machine,
}),
}
}
pub(crate) fn container_limit() -> Result<Option<u64>, String> {
match read_text(Path::new(PROC_CGROUP))? {
Some(groups) => match cgroup_limit(&groups, Path::new(CGROUP_V2_ROOT))? {
Some(limit) => Ok(Some(limit)),
None => cgroup_v1_limit(&groups),
},
None => Ok(None),
}
}
pub(crate) fn cgroup_limit(groups: &str, root: &Path) -> Result<Option<u64>, String> {
let Some(path) = groups
.lines()
.find_map(|line| line.strip_prefix(CGROUP_V2_PREFIX))
else {
return Ok(None);
};
let mut folder: PathBuf = root.join(path.trim().trim_start_matches('/'));
let mut lowest: Option<u64> = None;
loop {
lowest = match (lowest, limit_file(&folder.join(CGROUP_V2_LIMIT))?) {
(Some(lowest), Some(limit)) => Some(lowest.min(limit)),
(lowest, limit) => lowest.or(limit),
};
if folder.as_path() == root || !folder.pop() || !folder.starts_with(root) {
return Ok(lowest);
}
}
}
pub(crate) fn physical_memory() -> Result<Option<u64>, String> {
if cfg!(windows) {
return windows_memory();
}
if let Some(meminfo) = read_text(Path::new(PROC_MEMINFO))? {
return meminfo_total(&meminfo);
}
if !cfg!(target_os = "macos") {
return Ok(None);
}
let output = std::process::Command::new("sysctl")
.args(["-n", "hw.memsize"])
.output()
.map_err(|error| format!("sysctl hw.memsize: {error}"))?;
String::from_utf8_lossy(&output.stdout)
.trim()
.parse()
.map(Some)
.map_err(|error| format!("sysctl hw.memsize: {error}"))
}
pub(crate) fn job_limit() -> Result<Option<u64>, String> {
#[cfg(windows)]
return crate::peak_memory::_helpers::windows::job_memory_limit();
#[cfg(not(windows))]
Ok(None)
}
#[cfg(windows)]
fn windows_memory() -> Result<Option<u64>, String> {
crate::peak_memory::_helpers::windows::physical_memory().map(Some)
}
#[cfg(not(windows))]
fn windows_memory() -> Result<Option<u64>, String> {
Ok(None)
}
fn cgroup_v1_limit(groups: &str) -> Result<Option<u64>, String> {
let Some(path) = groups.lines().find_map(memory_group) else {
return Ok(None);
};
let root = Path::new(CGROUP_V1_ROOT);
match limit_file(
&root
.join(path.trim().trim_start_matches('/'))
.join(CGROUP_V1_LIMIT),
)? {
Some(limit) => Ok(Some(limit)),
None => limit_file(&root.join(CGROUP_V1_LIMIT)),
}
}
fn memory_group(line: &str) -> Option<&str> {
let mut parts = line.splitn(3, ':');
let (_, controllers, path) = (parts.next()?, parts.next()?, parts.next()?);
controllers
.split(',')
.any(|name| name == MEMORY_CONTROLLER)
.then_some(path)
}
fn meminfo_total(meminfo: &str) -> Result<Option<u64>, String> {
let Some(total) = meminfo
.lines()
.find_map(|line| line.strip_prefix(MEMINFO_TOTAL))
else {
return Ok(None);
};
let kilobytes = total.trim().trim_end_matches(MEMINFO_UNIT).trim();
kilobytes
.parse::<u64>()
.map(|kilobytes| Some(kilobytes.saturating_mul(BINARY_UNIT)))
.map_err(|error| format!("{PROC_MEMINFO}: MemTotal {kilobytes:?}: {error}"))
}
fn limit_file(path: &Path) -> Result<Option<u64>, String> {
let Some(text) = read_text(path)? else {
return Ok(None);
};
match text.trim() {
UNLIMITED => Ok(None),
number => number
.parse()
.map(Some)
.map_err(|error| format!("{}: {number:?}: {error}", path.display())),
}
}
fn read_text(path: &Path) -> Result<Option<String>, String> {
match std::fs::read_to_string(path) {
Ok(text) => Ok(Some(text)),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
Err(error) => Err(format!("{}: {error}", path.display())),
}
}