A treemap for finding and removing what fills your disk, for Omarchy. Rust + GPUI.
Rust
tree: a node is 88 bytes instead of 120
Joshua Gosse48fc31af485e
diff --git a/AGENTS.md b/AGENTS.mdindex 5ce375e..10890de 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -73,10 +73,13 @@ and `cargo build --release` directly; CI runs the gate on both systems.allocation, alternate data streams included since they go when the filegoes, so for a file with alternate streams it can exceed the walk'snumber.-2. **`own_bytes`/`own_files` are derived, never tracked.** `tree::aggregate`- computes the totals from the children. Hardlink de-duplication zeroes a- duplicate leaf's weight while that pass runs; anything that patches- `bytes` directly will be overwritten.+2. **Totals are derived, never tracked.** A leaf's `bytes` is the only+ input: `tree::aggregate` computes every directory's `bytes`, `files` and+ `dirs` from its children, and `own_bytes()`/`own_files()` read the direct+ children when asked. Hardlink de-duplication zeroes a duplicate leaf's+ `bytes` while that pass runs; anything that patches a directory's `bytes`+ directly will be overwritten. `Node` is paid for tens of millions of+ times, so `a_node_stays_small` holds its size.3. **A directory is only built when its own scan *and* every subdirectory taskhas finished.** That is the `+1` sentinel in `PendingDir::pending`. Buildingearly silently drops whole subtrees — it has happened once.diff --git a/crates/disktree-app/src/views.rs b/crates/disktree-app/src/views.rsindex b3b4b61..a8c5d0c 100644--- a/crates/disktree-app/src/views.rs+++ b/crates/disktree-app/src/views.rs@@ -1009,7 +1009,7 @@ fn scan_totals(app: &Disktree, theme: &Theme) -> Div {let tree = app.tree();let bytes = tree.map_or(app.progress.bytes, |node| node.bytes);let files = tree.map_or(app.progress.files, |node| node.files);- let dirs = tree.map_or(app.progress.dirs, |node| node.dirs);+ let dirs = tree.map_or(app.progress.dirs, |node| u64::from(node.dirs));let errors = app.progress.errors;div().flex()@@ -3205,9 +3205,10 @@ fn node_card("{} files · {} dirs · {} direct",widgets::human_count(node.files),widgets::human_count(- node.dirs.saturating_sub(u64::from(node.is_dir()))+ u64::from(node.dirs)+ .saturating_sub(u64::from(node.is_dir()))),- human_bytes(node.own_bytes)+ human_bytes(node.own_bytes()))),);diff --git a/crates/disktree-core/src/mft.rs b/crates/disktree-core/src/mft.rsindex 54ea26e..0a20044 100644--- a/crates/disktree-core/src/mft.rs+++ b/crates/disktree-core/src/mft.rs@@ -20,6 +20,7 @@use std::fs::{File, OpenOptions};use std::io;+use std::num::NonZeroU64;use std::os::windows::fs::{FileExt as _, OpenOptionsExt as _};use std::path::Path;@@ -1145,7 +1146,8 @@ impl Table<'_> {let mut node = Node::entry(name, kind, size);node.modified = info.modified;if info.names > 1 {- node.inode = Some((0, u64::from(entry.child)));+ node.inode = NonZeroU64::new(u64::from(entry.child))+ .map(|record| (0, record));}Ok(Some(node))}@@ -1685,7 +1687,7 @@ mod tests {assert_eq!(found, expected, "include_hidden {include_hidden}");// Only a file with a second name needs its identity kept.- let inode = |name: &str| root.child_named(name).unwrap().inode;+ let inode = |name: &str| root.child_named(name).unwrap().identity();assert_eq!(inode("linked.txt"), Some((0, 31)));assert_eq!(inode("visible.txt"), None);}diff --git a/crates/disktree-core/src/scan.rs b/crates/disktree-core/src/scan.rsindex 3763920..abf8477 100644--- a/crates/disktree-core/src/scan.rs+++ b/crates/disktree-core/src/scan.rs@@ -19,6 +19,7 @@use std::fs::DirEntry;use std::fs::{self, Metadata};use std::io;+use std::num::NonZeroU64;use std::path::{Path, PathBuf};use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};use std::sync::mpsc::{self, Receiver, TryRecvError};@@ -774,18 +775,16 @@ impl PendingDir {/// Turn a completed directory into a node. Only called when `pending` has/// reached zero, so every child is already in `self.partial`.///- /// `bytes` and `own_bytes` are left at zero on purpose: the walk cannot- /// know the aggregate, and [`crate::tree::aggregate`] derives both from the- /// children once every child is present.+ /// `bytes` is left at zero on purpose: the walk cannot know the+ /// aggregate, and [`crate::tree::aggregate`] derives it from the children+ /// once every child is present.fn build(&self) -> Node {let partial = std::mem::take(&mut *lock(&self.partial));Node {name: partial.name,kind: NodeKind::Directory,bytes: 0,- own_bytes: 0,files: 0,- own_files: 0,dirs: 1,inode: None,read_error: self.read_error.load(Ordering::Relaxed),@@ -842,7 +841,7 @@ fn scan_blocking(root: &Path, context: &Arc<WalkContext>) -> io::Result<Node> {let node = finish_tree(node, &context.options);// The reader counted every file on the volume; the tree may// hold fewer.- progress.settle(node.files, node.dirs, node.bytes);+ progress.settle(node.files, u64::from(node.dirs), node.bytes);return Ok(node);}// The reader gave up, or never started: the walk counts from nothing.@@ -920,7 +919,7 @@ impl Tally {if node.is_dir() {// A subtree taken whole from an earlier scan.self.files += node.files;- self.dirs += node.dirs;+ self.dirs += node.dirs as u64;} else {// A link counts as a file on the meter, as it always has,// though the tree does not count it.@@ -1065,7 +1064,9 @@ fn leaf_node() -> Node {let mut node = Node::entry(name, kind, facts.size);if track {- node.inode = facts.identity;+ node.inode = facts+ .identity+ .and_then(|(device, file)| Some((device, NonZeroU64::new(file)?)));}node.modified = facts.modified;node@@ -1288,8 +1289,8 @@ mod tests {write(root, "sub/deep.bin", 300);let tree = scan_dir(root, &options());- assert_eq!(tree.own_bytes, 700);- assert_eq!(tree.own_files, 1);+ assert_eq!(tree.own_bytes(), 700);+ assert_eq!(tree.own_files(), 1);assert_eq!(tree.bytes, 1000);assert_eq!(tree.files, 2);}@@ -1448,7 +1449,7 @@ mod tests {..options()},);- assert_eq!(tree.own_bytes, 10);+ assert_eq!(tree.own_bytes(), 10);let a = child(&tree, "a");assert_eq!(a.bytes, 20,diff --git a/crates/disktree-core/src/tree.rs b/crates/disktree-core/src/tree.rsindex 6f8e93b..6991a86 100644--- a/crates/disktree-core/src/tree.rs+++ b/crates/disktree-core/src/tree.rs@@ -1,5 +1,6 @@//! The scanned tree.+use std::num::NonZeroU64;use std::path::{Path, PathBuf};use std::sync::atomic::{AtomicU64, Ordering};use std::sync::{LazyLock, Mutex, OnceLock};@@ -54,28 +55,26 @@ impl Metric {/// One entry in the scanned tree.///-/// Totals and direct figures are both kept: `own_bytes` and `own_files` are-/// what sits directly in a directory, `bytes` and `files` are the subtree-/// totals the treemap draws. The selection line needs both, and keeping them means-/// no second traversal when one of them is displayed.+/// `bytes` and `files` are the subtree totals the treemap draws; what sits+/// directly in a directory is [`Self::own_bytes`] and [`Self::own_files`],+/// read from its children when the selection line asks. A disk holds tens+/// of millions of nodes, so every field is paid that many times: the size+/// is held by a test.#[derive(Clone, Debug)]pub struct Node {pub name: Box<str>,pub kind: NodeKind,- /// Subtree total: direct contents plus every descendant.+ /// Subtree total: direct contents plus every descendant. A file's own+ /// size, or nothing for a second name of a file already charged.pub bytes: u64,- /// Bytes of the leaf entries directly in this directory, or this file's- /// own size. Derived by [`aggregate`].- pub own_bytes: u64,/// Files at or beneath this node; `1` for a file.pub files: u64,- /// Files directly in this directory; `1` for a file. Derived by- /// [`aggregate`].- pub own_files: u64,- /// Directories at or beneath this node; `1` for a directory.- pub dirs: u64,- /// `(device, inode)` for files, used to de-duplicate hardlinks.- pub inode: Option<(u64, u64)>,+ /// Directories at or beneath this node; `1` for a directory. Four+ /// billion is more than any volume holds.+ pub dirs: u32,+ /// `(device, inode)` for files, used to de-duplicate hardlinks. No file+ /// has inode zero, which lets `None` cost nothing.+ pub inode: Option<(u64, NonZeroU64)>,/// The directory could not be read; its contents are unknown.pub read_error: bool,/// Newest write time at or beneath this node, in Unix seconds; `0` when@@ -101,9 +100,7 @@ impl Node {name: name.into(),kind: NodeKind::Directory,bytes: 0,- own_bytes: 0,files: 0,- own_files: 0,dirs: 1,inode: None,read_error: false,@@ -124,9 +121,7 @@ impl Node {name: name.into(),kind,bytes,- own_bytes: bytes,files: u64::from(kind == NodeKind::File),- own_files: u64::from(kind == NodeKind::File),dirs: 0,inode: None,read_error: false,@@ -141,6 +136,35 @@ impl Node {self.kind.is_dir()}+ /// Bytes of the leaf entries directly in this directory, or this file's+ /// own size.+ pub fn own_bytes(&self) -> u64 {+ if !self.is_dir() {+ return self.bytes;+ }+ self.children+ .iter()+ .filter(|child| !child.is_dir())+ .fold(0, |sum, child| child.bytes.saturating_add(sum))+ }++ /// Files directly in this directory; `1` for a file.+ pub fn own_files(&self) -> u64 {+ if !self.is_dir() {+ return self.files;+ }+ self.children+ .iter()+ .filter(|child| !child.is_dir())+ .map(|child| child.files)+ .sum()+ }++ /// [`Self::inode`] as the plain pair a platform reports.+ pub fn identity(&self) -> Option<(u64, u64)> {+ self.inode.map(|(device, file)| (device, file.get()))+ }+/// The value a treemap should weight this node by.pub const fn value(&self, metric: Metric) -> u64 {match metric {@@ -231,14 +255,14 @@ impl Node {}}-/// Recompute `bytes`, `files`, `dirs` and the direct totals bottom-up, then-/// order children by `metric`, largest first.+/// Recompute `bytes`, `files` and `dirs` bottom-up, then order children by+/// `metric`, largest first.///-/// `bytes` and `files` are the subtree totals; `own_bytes` and `own_files` are-/// the direct contents, derived from the leaf children rather than tracked-/// separately. Deriving them is what keeps the two consistent: hardlink-/// de-duplication rewrites a leaf's weight, and every total above it —-/// including its parent's "direct" figure — follows without a second pass.+/// A leaf's `bytes` is its measured size and the only input; every total is+/// derived from the leaves, as are the direct figures [`Node::own_bytes`]+/// and [`Node::own_files`]. Deriving them is what keeps them consistent:+/// hardlink de-duplication rewrites a leaf's weight, and every total above+/// it follows without a second pass.pub fn aggregate(node: &mut Node, metric: Metric) {aggregate_at(node, metric, 0, None);}@@ -331,24 +355,19 @@ fn aggregate_at(if !node.is_dir() {// Every name of a file has the file's size, so one that weighs// nothing need not be remembered to be charged once.- if node.own_bytes > 0+ if node.bytes > 0&& let Some(seen) = seen- && let Some(key) = node.inode+ && let Some(key) = node.identity()&& !seen.insert(key){- node.own_bytes = 0;+ node.bytes = 0;}- node.bytes = node.own_bytes;- node.files = node.own_files;- node.dirs = 0;return;}let mut bytes = 0;let mut files = 0;- let mut own_bytes = 0;- let mut own_files = 0;- let mut dirs: u64 = 1;+ let mut dirs: u32 = 1;let mut modified = 0;if depth < PARALLEL_LEVELS {node.children@@ -365,15 +384,9 @@ fn aggregate_at(bytes = child.bytes.saturating_add(bytes);files += child.files;dirs += child.dirs;- if !child.is_dir() {- own_bytes = child.bytes.saturating_add(own_bytes);- own_files += child.files;- }}node.bytes = bytes;node.files = files;- node.own_bytes = own_bytes;- node.own_files = own_files;node.dirs = dirs;node.modified = modified;@@ -414,6 +427,14 @@ mod tests {Node::entry(name, NodeKind::File, bytes)}+ /// A home directory is tens of millions of nodes: every byte here is+ /// tens of megabytes there.+ #[test]+ #[cfg(target_pointer_width = "64")]+ fn a_node_stays_small() {+ assert_eq!(size_of::<Node>(), 88);+ }+#[test]fn seen_charges_an_identity_once_in_either_store() {let seen = Seen::new();@@ -443,7 +464,7 @@ mod tests {("newer again", 8192, newer),] {let mut file = leaf(name, bytes);- file.inode = Some(key);+ file.inode = Some((key.0, NonZeroU64::new(key.1).unwrap()));root.children.push(file);}aggregate_deduped(&mut root, Metric::Bytes, &Seen::new());@@ -460,12 +481,12 @@ mod tests {root.children.push(leaf("small", 9));aggregate(&mut root, Metric::Bytes);- assert_eq!(root.own_bytes, 5 + 9, "direct leaves only");+ assert_eq!(root.own_bytes(), 5 + 9, "direct leaves only");assert_eq!(root.bytes, 5 + 9 + 7);assert_eq!(root.files, 3);- assert_eq!(root.own_files, 2);+ assert_eq!(root.own_files(), 2);assert_eq!(root.dirs, 2);- assert_eq!(child_named(&root, "child").own_bytes, 7);+ assert_eq!(child_named(&root, "child").own_bytes(), 7);assert_eq!(&*root.children[0].name, "small", "9 bytes, largest first");assert_eq!(&*root.children[2].name, "direct");@@ -473,7 +494,7 @@ mod tests {let mut single = leaf("solo", 3);aggregate(&mut single, Metric::Bytes);assert_eq!(single.bytes, 3);- assert_eq!(single.own_bytes, 3);+ assert_eq!(single.own_bytes(), 3);assert_eq!(single.files, 1);assert_eq!(single.dirs, 0);}