facts.rs 59.1%

55 of 93 lines run, 10 of 22 functions · run #191 on main · run missed

//! What a runner measures about itself (spec §11.1, docs/jetstream.md §6):
//! free disk, load and the kernel each claim, cheaply; and its speed, from
//! a short fixed benchmark run at start and again while idle.

use crate::home::Home;
use flow_core::api::Facts;
use std::time::Instant;

/// The benchmark's time on the reference machine (Earth), in ms: a runner
/// that takes as long scores 100.
const REFERENCE_MS: f64 = 225.0;

/// The cheap facts, with the last speed measured.
pub fn now(home: &Home, speed: Option<u32>) -> Facts {
    Facts {
        free_disk_mib: free_disk_mib(&home.root),
        load_x100: load_x100(),
        speed,
        speed_class: speed.map(Facts::class_of),
        kernel: kernel(),
    }
}

/// The kernel's release, as uname says. Not read from /proc: an Android
/// app may not read it there, and is refused (and logged) every claim.
/// None on Windows (oxygenflow#83).
#[cfg(unix)]
pub fn kernel() -> Option<String> {
    let mut u: libc::utsname = unsafe { std::mem::zeroed() };
    // SAFETY: `u` is a writable utsname.
    if unsafe { libc::uname(&mut u) } != 0 {
        return None;
    }
    // SAFETY: uname writes NUL-terminated strings.
    let release = unsafe { std::ffi::CStr::from_ptr(u.release.as_ptr()) };
    Some(release.to_string_lossy().into_owned())
}

#[cfg(not(unix))]
pub fn kernel() -> Option<String> {
    None
}

/// Free space for an unprivileged writer on the file system holding `path`,
/// in MiB.
#[cfg(unix)]
pub fn free_disk_mib(path: &std::path::Path) -> Option<u64> {
    use std::os::unix::ffi::OsStrExt;
    let c = std::ffi::CString::new(path.as_os_str().as_bytes()).ok()?;
    let mut s: libc::statvfs = unsafe { std::mem::zeroed() };
    // SAFETY: `c` is a valid NUL-terminated path and `s` a writable statvfs.
    if unsafe { libc::statvfs(c.as_ptr(), &mut s) } != 0 {
        return None;
    }
    Some((s.f_bavail as u64).saturating_mul(s.f_frsize as u64) >> 20)
}

#[cfg(windows)]
pub fn free_disk_mib(path: &std::path::Path) -> Option<u64> {
    use std::os::windows::ffi::OsStrExt;
    let wide: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
    let mut free: u64 = 0;
    // SAFETY: `wide` is a NUL-terminated path and `free` a writable u64;
    // the totals it may also fill are not asked for.
    let ok = unsafe {
        windows_sys::Win32::Storage::FileSystem::GetDiskFreeSpaceExW(wide.as_ptr(), &mut free, std::ptr::null_mut(), std::ptr::null_mut())
    };
    (ok != 0).then_some(free >> 20)
}

/// The disk the files under `dir` take (their blocks, not their sizes: a
/// job's disks are sparse), in MiB; links are not followed.
pub fn allocated_mib(dir: &std::path::Path) -> Option<u64> {
    let mut total: u64 = 0;
    let mut stack = vec![dir.to_path_buf()];
    while let Some(d) = stack.pop() {
        for e in std::fs::read_dir(&d).ok()?.flatten() {
            let m = std::fs::symlink_metadata(e.path()).ok()?;
            if m.is_dir() {
                stack.push(e.path());
            } else {
                total = total.saturating_add(crate::portable::disk_bytes(&m));
            }
        }
    }
    Some(total >> 20)
}

/// A process's peak resident memory (`VmHWM`), in MiB.
pub fn peak_rss_mib(pid: u32) -> Option<u64> {
    let text = std::fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
    let kib: u64 = text.lines().find_map(|l| l.strip_prefix("VmHWM:"))?.trim().trim_end_matches("kB").trim().parse().ok()?;
    Some(kib / 1024)
}

/// The 1-minute load average, times 100, from sysinfo (the kernel's own
/// numbers behind /proc/loadavg, which an Android app may not read); not
/// measured on Windows.
#[cfg(not(unix))]
pub fn load_x100() -> Option<u32> {
    None
}

#[cfg(unix)]
pub fn load_x100() -> Option<u32> {
    let mut i: libc::sysinfo = unsafe { std::mem::zeroed() };
    // SAFETY: `i` is a writable sysinfo.
    if unsafe { libc::sysinfo(&mut i) } != 0 {
        return None;
    }
    // Fixed point with 16 fraction bits (SI_LOAD_SHIFT).
    Some(((i.loads[0] as f64) / 65536.0 * 100.0).round() as u32)
}

/// The benchmark, one thread: BLAKE3 over 256 MiB (spec §11.1), and a sort
/// of 4 Mi pseudo-random words for the integer and memory side. Answers
/// the score, 100 on the reference machine, and the time it took.
pub fn bench() -> (u32, u128) {
    let start = Instant::now();
    let buf: Vec<u8> = (0..32u32 << 20).map(|i| (i.wrapping_mul(2_654_435_761) >> 13) as u8).collect();
    let mut h = blake3::Hasher::new();
    for _ in 0..8 {
        h.update(&buf);
    }
    std::hint::black_box(h.finalize());
    drop(buf);
    let mut x: u64 = 0x9e37_79b9_7f4a_7c15;
    let mut words: Vec<u64> = (0..4u64 << 20)
        .map(|_| {
            x ^= x << 13;
            x ^= x >> 7;
            x ^= x << 17;
            x
        })
        .collect();
    words.sort_unstable();
    std::hint::black_box(&words);
    let ms = start.elapsed().as_millis().max(1);
    ((REFERENCE_MS * 100.0 / ms as f64).round() as u32, ms)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn the_cheap_facts_are_read_and_classes_double() {
        assert!(free_disk_mib(std::path::Path::new("/")).is_some());
        // The same numbers /proc gives, read without it (an Android app may not).
        let proc_load: f64 = std::fs::read_to_string("/proc/loadavg").unwrap().split_whitespace().next().unwrap().parse().unwrap();
        let load = load_x100().unwrap() as f64 / 100.0;
        assert!((load - proc_load).abs() < 1.0 + proc_load / 4.0, "sysinfo {load}, /proc {proc_load}");
        assert_eq!(kernel().unwrap(), std::fs::read_to_string("/proc/sys/kernel/osrelease").unwrap().trim());
        assert!(peak_rss_mib(std::process::id()).is_some_and(|m| m > 0));
        let dir = tempfile::tempdir().unwrap();
        let f = std::fs::File::create(dir.path().join("sparse")).unwrap();
        f.set_len(1 << 30).unwrap();
        std::fs::write(dir.path().join("full"), vec![7u8; 3 << 20]).unwrap();
        let mib = allocated_mib(dir.path()).unwrap();
        assert!((3..=4).contains(&mib), "the sparse gigabyte takes nothing, the written 3 MiB do: {mib}");
        assert_eq!(Facts::class_of(100), 3, "the reference machine");
        assert_eq!((Facts::class_of(50), Facts::class_of(200), Facts::class_of(500), Facts::class_of(10)), (2, 4, 5, 1));
    }
}

1		//! What a runner measures about itself (spec §11.1, docs/jetstream.md §6):
2		//! free disk, load and the kernel each claim, cheaply; and its speed, from
3		//! a short fixed benchmark run at start and again while idle.
4
5		use crate::home::Home;
6		use flow_core::api::Facts;
7		use std::time::Instant;
8
9		/// The benchmark's time on the reference machine (Earth), in ms: a runner
10		/// that takes as long scores 100.
11		const REFERENCE_MS: f64 = 225.0;
12
13		/// The cheap facts, with the last speed measured.
14	0×	pub fn now(home: &Home, speed: Option<u32>) -> Facts {
15	0×	Facts {
16	0×	free_disk_mib: free_disk_mib(&home.root),
17	0×	load_x100: load_x100(),
18	0×	speed,
19	0×	speed_class: speed.map(Facts::class_of),
20	0×	kernel: kernel(),
21	0×	}
22	0×	}
23
24		/// The kernel's release, as uname says. Not read from /proc: an Android
25		/// app may not read it there, and is refused (and logged) every claim.
26		/// None on Windows (oxygenflow#83).
27		#[cfg(unix)]
28	1×	pub fn kernel() -> Option<String> {
29	1×	let mut u: libc::utsname = unsafe { std::mem::zeroed() };
30		// SAFETY: `u` is a writable utsname.
31	1×	if unsafe { libc::uname(&mut u) } != 0 {
32	0×	return None;
33	1×	}
34		// SAFETY: uname writes NUL-terminated strings.
35	1×	let release = unsafe { std::ffi::CStr::from_ptr(u.release.as_ptr()) };
36	1×	Some(release.to_string_lossy().into_owned())
37	1×	}
38
39		#[cfg(not(unix))]
40		pub fn kernel() -> Option<String> {
41		None
42		}
43
44		/// Free space for an unprivileged writer on the file system holding `path`,
45		/// in MiB.
46		#[cfg(unix)]
47	1×	pub fn free_disk_mib(path: &std::path::Path) -> Option<u64> {
48		use std::os::unix::ffi::OsStrExt;
49	1×	let c = std::ffi::CString::new(path.as_os_str().as_bytes()).ok()?;
50	1×	let mut s: libc::statvfs = unsafe { std::mem::zeroed() };
51		// SAFETY: `c` is a valid NUL-terminated path and `s` a writable statvfs.
52	1×	if unsafe { libc::statvfs(c.as_ptr(), &mut s) } != 0 {
53	0×	return None;
54	1×	}
55	1×	Some((s.f_bavail as u64).saturating_mul(s.f_frsize as u64) >> 20)
56	1×	}
57
58		#[cfg(windows)]
59		pub fn free_disk_mib(path: &std::path::Path) -> Option<u64> {
60		use std::os::windows::ffi::OsStrExt;
61		let wide: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
62		let mut free: u64 = 0;
63		// SAFETY: `wide` is a NUL-terminated path and `free` a writable u64;
64		// the totals it may also fill are not asked for.
65		let ok = unsafe {
66		windows_sys::Win32::Storage::FileSystem::GetDiskFreeSpaceExW(wide.as_ptr(), &mut free, std::ptr::null_mut(), std::ptr::null_mut())
67		};
68		(ok != 0).then_some(free >> 20)
69		}
70
71		/// The disk the files under `dir` take (their blocks, not their sizes: a
72		/// job's disks are sparse), in MiB; links are not followed.
73	1×	pub fn allocated_mib(dir: &std::path::Path) -> Option<u64> {
74	1×	let mut total: u64 = 0;
75	1×	let mut stack = vec![dir.to_path_buf()];
76	2×	while let Some(d) = stack.pop() {
77	2×	for e in std::fs::read_dir(&d).ok()?.flatten() {
78	2×	let m = std::fs::symlink_metadata(e.path()).ok()?;
79	2×	if m.is_dir() {
80	0×	stack.push(e.path());
81	2×	} else {
82	2×	total = total.saturating_add(crate::portable::disk_bytes(&m));
83	2×	}
84		}
85		}
86	1×	Some(total >> 20)
87	1×	}
88
89		/// A process's peak resident memory (`VmHWM`), in MiB.
90	16×	pub fn peak_rss_mib(pid: u32) -> Option<u64> {
91	16×	let text = std::fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
92	336×	let kib: u64 = text.lines().find_map(\|l\| l.strip_prefix("VmHWM:"))?.trim().trim_end_matches("kB").trim().parse().ok()?;
93	16×	Some(kib / 1024)
94	16×	}
95
96		/// The 1-minute load average, times 100, from sysinfo (the kernel's own
97		/// numbers behind /proc/loadavg, which an Android app may not read); not
98		/// measured on Windows.
99		#[cfg(not(unix))]
100		pub fn load_x100() -> Option<u32> {
101		None
102		}
103
104		#[cfg(unix)]
105	1×	pub fn load_x100() -> Option<u32> {
106	1×	let mut i: libc::sysinfo = unsafe { std::mem::zeroed() };
107		// SAFETY: `i` is a writable sysinfo.
108	1×	if unsafe { libc::sysinfo(&mut i) } != 0 {
109	0×	return None;
110	1×	}
111		// Fixed point with 16 fraction bits (SI_LOAD_SHIFT).
112	1×	Some(((i.loads[0] as f64) / 65536.0 * 100.0).round() as u32)
113	1×	}
114
115		/// The benchmark, one thread: BLAKE3 over 256 MiB (spec §11.1), and a sort
116		/// of 4 Mi pseudo-random words for the integer and memory side. Answers
117		/// the score, 100 on the reference machine, and the time it took.
118	0×	pub fn bench() -> (u32, u128) {
119	0×	let start = Instant::now();
120	0×	let buf: Vec<u8> = (0..32u32 << 20).map(\|i\| (i.wrapping_mul(2_654_435_761) >> 13) as u8).collect();
121	0×	let mut h = blake3::Hasher::new();
122	0×	for _ in 0..8 {
123	0×	h.update(&buf);
124	0×	}
125	0×	std::hint::black_box(h.finalize());
126	0×	drop(buf);
127	0×	let mut x: u64 = 0x9e37_79b9_7f4a_7c15;
128	0×	let mut words: Vec<u64> = (0..4u64 << 20)
129	0×	.map(\|_\| {
130	0×	x ^= x << 13;
131	0×	x ^= x >> 7;
132	0×	x ^= x << 17;
133	0×	x
134	0×	})
135	0×	.collect();
136	0×	words.sort_unstable();
137	0×	std::hint::black_box(&words);
138	0×	let ms = start.elapsed().as_millis().max(1);
139	0×	((REFERENCE_MS * 100.0 / ms as f64).round() as u32, ms)
140	0×	}
141
142		#[cfg(test)]
143		mod tests {
144		use super::*;
145
146		#[test]
147	1×	fn the_cheap_facts_are_read_and_classes_double() {
148	1×	assert!(free_disk_mib(std::path::Path::new("/")).is_some());
149		// The same numbers /proc gives, read without it (an Android app may not).
150	1×	let proc_load: f64 = std::fs::read_to_string("/proc/loadavg").unwrap().split_whitespace().next().unwrap().parse().unwrap();
151	1×	let load = load_x100().unwrap() as f64 / 100.0;
152	1×	assert!((load - proc_load).abs() < 1.0 + proc_load / 4.0, "sysinfo {load}, /proc {proc_load}");
153	1×	assert_eq!(kernel().unwrap(), std::fs::read_to_string("/proc/sys/kernel/osrelease").unwrap().trim());
154	1×	assert!(peak_rss_mib(std::process::id()).is_some_and(\|m\| m > 0));
155	1×	let dir = tempfile::tempdir().unwrap();
156	1×	let f = std::fs::File::create(dir.path().join("sparse")).unwrap();
157	1×	f.set_len(1 << 30).unwrap();
158	1×	std::fs::write(dir.path().join("full"), vec![7u8; 3 << 20]).unwrap();
159	1×	let mib = allocated_mib(dir.path()).unwrap();
160	1×	assert!((3..=4).contains(&mib), "the sparse gigabyte takes nothing, the written 3 MiB do: {mib}");
161	1×	assert_eq!(Facts::class_of(100), 3, "the reference machine");
162	1×	assert_eq!((Facts::class_of(50), Facts::class_of(200), Facts::class_of(500), Facts::class_of(10)), (2, 4, 5, 1));
163	1×	}
164		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/flow/src/facts.rs 59.1%

Keyboard