#![allow(unsafe_code)]
use windows_sys::Win32::Foundation::{CloseHandle, HANDLE};
use windows_sys::Win32::System::JobObjects::{
IsProcessInJob, JOB_OBJECT_LIMIT_JOB_MEMORY, JOB_OBJECT_LIMIT_PROCESS_MEMORY,
JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JobObjectExtendedLimitInformation,
QueryInformationJobObject,
};
use windows_sys::Win32::System::ProcessStatus::{GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS};
use windows_sys::Win32::System::SystemInformation::{GlobalMemoryStatusEx, MEMORYSTATUSEX};
use windows_sys::Win32::System::Threading::{
GetCurrentProcess, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
};
pub(crate) fn peak_working_set() -> Result<u64, String> {
let counters = memory_counters(current_process())?;
u64::try_from(counters.PeakWorkingSetSize).map_err(|error| error.to_string())
}
pub(crate) fn held_bytes(pid: Option<u32>) -> Result<u64, String> {
let counters = match pid {
None => memory_counters(current_process())?,
Some(pid) => {
let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
if handle.is_null() {
return Err(format!(
"OpenProcess {pid}: {}",
std::io::Error::last_os_error()
));
}
let counters = memory_counters(handle);
unsafe { CloseHandle(handle) };
counters?
}
};
let held = counters.WorkingSetSize.max(counters.PagefileUsage);
u64::try_from(held).map_err(|error| error.to_string())
}
fn current_process() -> HANDLE {
unsafe { GetCurrentProcess() }
}
pub(crate) fn job_memory_limit() -> Result<Option<u64>, String> {
let mut in_job = 0;
let read = unsafe { IsProcessInJob(current_process(), std::ptr::null_mut(), &mut in_job) };
if read == 0 {
return Err(format!(
"IsProcessInJob: {}",
std::io::Error::last_os_error()
));
}
if in_job == 0 {
return Ok(None);
}
let mut limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default();
let size = u32::try_from(std::mem::size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>())
.map_err(|error| error.to_string())?;
let read = unsafe {
QueryInformationJobObject(
std::ptr::null_mut(),
JobObjectExtendedLimitInformation,
std::ptr::from_mut(&mut limits).cast(),
size,
std::ptr::null_mut(),
)
};
if read == 0 {
return Err(format!(
"QueryInformationJobObject: {}",
std::io::Error::last_os_error()
));
}
let flags = limits.BasicLimitInformation.LimitFlags;
let process =
(flags & JOB_OBJECT_LIMIT_PROCESS_MEMORY != 0).then_some(limits.ProcessMemoryLimit);
let job = (flags & JOB_OBJECT_LIMIT_JOB_MEMORY != 0).then_some(limits.JobMemoryLimit);
let lowest = match (process, job) {
(Some(process), Some(job)) => Some(process.min(job)),
(process, job) => process.or(job),
};
lowest
.map(|bytes| u64::try_from(bytes).map_err(|error| error.to_string()))
.transpose()
}
pub(crate) fn physical_memory() -> Result<u64, String> {
let mut status = MEMORYSTATUSEX {
dwLength: u32::try_from(std::mem::size_of::<MEMORYSTATUSEX>())
.map_err(|error| error.to_string())?,
..MEMORYSTATUSEX::default()
};
match unsafe { GlobalMemoryStatusEx(&mut status) } {
0 => Err(format!(
"GlobalMemoryStatusEx: {}",
std::io::Error::last_os_error()
)),
_ => Ok(status.ullTotalPhys),
}
}
fn memory_counters(handle: HANDLE) -> Result<PROCESS_MEMORY_COUNTERS, String> {
let mut counters = PROCESS_MEMORY_COUNTERS::default();
let size = u32::try_from(std::mem::size_of::<PROCESS_MEMORY_COUNTERS>())
.map_err(|error| error.to_string())?;
match unsafe { GetProcessMemoryInfo(handle, &mut counters, size) } {
0 => Err(format!(
"GetProcessMemoryInfo: {}",
std::io::Error::last_os_error()
)),
_ => Ok(counters),
}
}