perf: lock-free hashing for string interns (#3091)

sxyazi · web-flow · commit 0054cf0b878b · 2025-08-21T09:40:52.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/yazi-actor/src/mgr/cd.rs b/yazi-actor/src/mgr/cd.rs
@@ -78,13 +78,13 @@ impl Cd {
 					Ok(s) => {
 						let Ok(url) = UrlBuf::try_from(s).map(expand_url) else { return };
 
-						let Ok(file) = File::new(url.clone()).await else { return };
+						let Ok(file) = File::new(&url).await else { return };
 						if file.is_dir() {
 							return MgrProxy::cd(&url);
 						}
 
 						if let Some(p) = url.parent_url() {
-							FilesOp::Upserting(p, [(url.urn_owned(), file)].into()).emit();
+							FilesOp::Upserting(p.into(), [(url.urn_owned(), file)].into()).emit();
 						}
 						MgrProxy::reveal(&url);
 					}
diff --git a/yazi-actor/src/mgr/create.rs b/yazi-actor/src/mgr/create.rs
@@ -48,16 +48,16 @@ impl Create {
 			provider::create_dir_all(&new).await?;
 		} else if let Some(real) = realname(&new).await {
 			ok_or_not_found(provider::remove_file(&new).await)?;
-			FilesOp::Deleting(parent.clone(), [UrnBuf::from(real)].into()).emit();
+			FilesOp::Deleting(parent.to_owned(), [UrnBuf::from(real)].into()).emit();
 			provider::create(&new).await?;
 		} else {
 			provider::create_dir_all(&parent).await.ok();
 			ok_or_not_found(provider::remove_file(&new).await)?;
 			provider::create(&new).await?;
 		}
 
-		if let Ok(f) = File::new(new.clone()).await {
-			FilesOp::Upserting(parent, [(f.urn_owned(), f)].into()).emit();
+		if let Ok(f) = File::new(&new).await {
+			FilesOp::Upserting(parent.into(), [(f.urn_owned(), f)].into()).emit();
 			MgrProxy::reveal(&new)
 		}
 		Ok(())
diff --git a/yazi-actor/src/mgr/open.rs b/yazi-actor/src/mgr/open.rs
@@ -55,7 +55,7 @@ impl Actor for Open {
 		tokio::spawn(async move {
 			let mut files = Vec::with_capacity(todo.len());
 			for i in todo {
-				if let Ok(f) = File::new(targets[i].0.clone()).await {
+				if let Ok(f) = File::new(&targets[i].0).await {
 					files.push(f);
 				}
 			}
diff --git a/yazi-actor/src/mgr/rename.rs b/yazi-actor/src/mgr/rename.rs
@@ -69,15 +69,15 @@ impl Rename {
 
 		if let Some(o) = overwritten {
 			ok_or_not_found(provider::rename(&p_new.join(&o), &new).await)?;
-			FilesOp::Deleting(p_new.clone(), [UrnBuf::from(o)].into()).emit();
+			FilesOp::Deleting(p_new.to_owned(), [UrnBuf::from(o)].into()).emit();
 		}
 
-		let file = File::new(new.clone()).await?;
+		let file = File::new(&new).await?;
 		if p_new == p_old {
-			FilesOp::Upserting(p_old, [(n_old, file)].into()).emit();
+			FilesOp::Upserting(p_old.into(), [(n_old, file)].into()).emit();
 		} else {
-			FilesOp::Deleting(p_old, [n_old].into()).emit();
-			FilesOp::Upserting(p_new, [(n_new, file)].into()).emit();
+			FilesOp::Deleting(p_old.into(), [n_old].into()).emit();
+			FilesOp::Upserting(p_new.into(), [(n_new, file)].into()).emit();
 		}
 
 		MgrProxy::reveal(&new);
diff --git a/yazi-actor/src/mgr/reveal.rs b/yazi-actor/src/mgr/reveal.rs
@@ -26,7 +26,7 @@ impl Actor for Reveal {
 		// If the child is not hovered, which means it doesn't exist,
 		// create a dummy file
 		if !opt.no_dummy && tab.hovered().is_none_or(|f| &child != f.urn()) {
-			let op = FilesOp::Creating(parent, vec![File::from_dummy(opt.target, None)]);
+			let op = FilesOp::Creating(parent.into(), vec![File::from_dummy(opt.target, None)]);
 			tab.current.update_pub(tab.id, op);
 		}
 
diff --git a/yazi-boot/src/boot.rs b/yazi-boot/src/boot.rs
@@ -32,7 +32,7 @@ impl Boot {
 			};
 
 			if provider::metadata(&entry).await.is_ok_and(|m| m.is_file()) {
-				(parent, child)
+				(parent.into(), child)
 			} else {
 				(entry, UrnBuf::default())
 			}
diff --git a/yazi-core/src/mgr/linked.rs b/yazi-core/src/mgr/linked.rs
@@ -17,13 +17,15 @@ impl DerefMut for Linked {
 }
 
 impl Linked {
-	pub fn from_dir<'a, 'b>(&'a self, url: &'b UrlBuf) -> Box<dyn Iterator<Item = &'a UrlBuf> + 'b>
+	pub fn from_dir<'a, 'b, T>(&'a self, url: T) -> Box<dyn Iterator<Item = &'a UrlBuf> + 'b>
 	where
 		'a: 'b,
+		T: Into<Url<'b>>,
 	{
+		let url = url.into();
 		if url.scheme.is_virtual() {
 			Box::new(iter::empty())
-		} else if let Some(to) = self.get(url) {
+		} else if let Some(to) = self.get(&url) {
 			Box::new(self.iter().filter(move |(k, v)| *v == to && *k != url).map(|(k, _)| k))
 		} else {
 			Box::new(self.iter().filter(move |(_, v)| *v == url).map(|(k, _)| k))
@@ -34,7 +36,7 @@ impl Linked {
 		if url.scheme.is_virtual() {
 			vec![]
 		} else if let Some((parent, urn)) = url.pair() {
-			self.from_dir(&parent).map(|u| u.join(&urn)).collect()
+			self.from_dir(parent).map(|u| u.join(&urn)).collect()
 		} else {
 			vec![]
 		}
diff --git a/yazi-core/src/mgr/watcher.rs b/yazi-core/src/mgr/watcher.rs
@@ -68,9 +68,12 @@ impl Watcher {
 			if !watched.contains(&p) && !LINKED.read().from_dir(&p).any(|u| watched.contains(u)) {
 				continue;
 			}
-			out_tx.send(u).ok();
-			if !parents.contains(&p) {
-				out_tx.send(p.clone()).ok();
+			if parents.contains(&p) {
+				out_tx.send(u).ok();
+			} else {
+				let p = p.to_owned();
+				out_tx.send(u).ok();
+				out_tx.send(p.to_owned()).ok();
 				parents.insert(p);
 			}
 		}
@@ -134,8 +137,8 @@ impl Watcher {
 
 			for u in urls {
 				let Some((parent, urn)) = u.pair() else { continue };
-				let Ok(file) = File::new(u).await else {
-					ops.push(FilesOp::Deleting(parent, [urn].into()));
+				let Ok(file) = File::new(&u).await else {
+					ops.push(FilesOp::Deleting(parent.into(), [urn].into()));
 					continue;
 				};
 
@@ -144,11 +147,11 @@ impl Watcher {
 					|| realname_unchecked(u, &mut cached).await.is_ok_and(|s| urn.as_urn() == s);
 
 				if !eq {
-					ops.push(FilesOp::Deleting(parent, [urn].into()));
+					ops.push(FilesOp::Deleting(parent.into(), [urn].into()));
 					continue;
 				}
 
-				ops.push(FilesOp::Upserting(parent, [(urn, file)].into()));
+				ops.push(FilesOp::Upserting(parent.into(), [(urn, file)].into()));
 			}
 
 			FilesOp::mutate(ops);
diff --git a/yazi-core/src/tab/selected.rs b/yazi-core/src/tab/selected.rs
@@ -72,7 +72,7 @@ impl Selected {
 		self.inner.extend(urls.iter().enumerate().map(|(i, u)| (u.into(), now + i as u64)));
 
 		for u in parents {
-			*self.parents.entry(UrlBufCov(u)).or_insert(0) += self.inner.len() - len;
+			*self.parents.entry_ref(&UrlCov::new(u)).or_default() += self.inner.len() - len;
 		}
 		urls.len()
 	}
diff --git a/yazi-fs/src/file.rs b/yazi-fs/src/file.rs
@@ -1,7 +1,7 @@
 use std::{ffi::OsStr, fs::{FileType, Metadata}, hash::{BuildHasher, Hash, Hasher}, ops::Deref};
 
 use anyhow::Result;
-use yazi_shared::url::{Uri, UrlBuf, Urn, UrnBuf};
+use yazi_shared::url::{Uri, UrlBuf, UrlCow, Urn, UrnBuf};
 
 use crate::{cha::Cha, provider};
 
@@ -21,9 +21,10 @@ impl Deref for File {
 
 impl File {
 	#[inline]
-	pub async fn new(url: UrlBuf) -> Result<Self> {
+	pub async fn new(url: impl Into<UrlCow<'_>>) -> Result<Self> {
+		let url = url.into();
 		let meta = provider::symlink_metadata(&url).await?;
-		Ok(Self::from_follow(url, meta).await)
+		Ok(Self::from_follow(url.into_owned(), meta).await)
 	}
 
 	#[inline]
diff --git a/yazi-fs/src/op.rs b/yazi-fs/src/op.rs
@@ -55,9 +55,9 @@ impl FilesOp {
 			let Some(o_p) = o.parent_url() else { continue };
 			let Some(n_p) = n.url.parent_url() else { continue };
 			if o_p != n_p {
-				parents.entry(o_p).or_default().0.insert(o.urn_owned());
+				parents.entry_ref(&o_p).or_default().0.insert(o.urn_owned());
 			}
-			parents.entry(n_p).or_default().1.insert(n.urn_owned(), n);
+			parents.entry_ref(&n_p).or_default().1.insert(n.urn_owned(), n);
 		}
 		for (p, (o, n)) in parents {
 			match (o.is_empty(), n.is_empty()) {
@@ -124,7 +124,7 @@ impl FilesOp {
 		} else if maybe_exists(cwd).await {
 			Self::IOErr(cwd.clone(), kind).emit();
 		} else if let Some((p, n)) = cwd.pair() {
-			Self::Deleting(p, [n].into()).emit();
+			Self::Deleting(p.into(), [n].into()).emit();
 		}
 	}
 
diff --git a/yazi-parser/src/mgr/cd.rs b/yazi-parser/src/mgr/cd.rs
@@ -1,6 +1,6 @@
 use mlua::{ExternalError, FromLua, IntoLua, Lua, Value};
 use yazi_fs::path::expand_url;
-use yazi_shared::{event::CmdCow, url::{UrlBuf, UrlCow}};
+use yazi_shared::{event::CmdCow, url::{Url, UrlBuf, UrlCow}};
 
 #[derive(Debug)]
 pub struct CdOpt {
@@ -33,6 +33,10 @@ impl From<(UrlBuf, CdSource)> for CdOpt {
 	}
 }
 
+impl From<(Url<'_>, CdSource)> for CdOpt {
+	fn from((target, source): (Url, CdSource)) -> Self { Self::from((target.to_owned(), source)) }
+}
+
 impl FromLua for CdOpt {
 	fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported".into_lua_err()) }
 }
diff --git a/yazi-scheduler/src/prework/prework.rs b/yazi-scheduler/src/prework/prework.rs
@@ -92,7 +92,7 @@ impl Prework {
 
 					let parent = buf[0].0.parent_url().unwrap();
 					FilesOp::Size(
-						parent,
+						parent.into(),
 						HashMap::from_iter(buf.into_iter().map(|(u, s)| (u.urn_owned(), s))),
 					)
 					.emit();
diff --git a/yazi-shared/src/loc/buf.rs b/yazi-shared/src/loc/buf.rs
@@ -85,16 +85,19 @@ impl LocBuf {
 	}
 
 	pub fn zeroed(path: impl Into<PathBuf>) -> Self {
-		let mut loc = Self::from(path.into());
-		(loc.uri, loc.urn) = (0, 0);
-		loc
+		let loc = Self::from(path.into());
+		let Loc { inner, uri, urn } = Loc::zeroed(&loc.inner);
+
+		debug_assert!(inner.as_os_str() == loc.inner.as_os_str());
+		Self { inner: loc.inner, uri, urn }
 	}
 
 	pub fn floated(path: impl Into<PathBuf>, base: &Path) -> Self {
-		let mut loc = Self::from(path.into());
-		loc.uri =
-			loc.inner.strip_prefix(base).expect("Loc must start with the given base").as_os_str().len();
-		loc
+		let loc = Self::from(path.into());
+		let Loc { inner, uri, urn } = Loc::floated(&loc.inner, base);
+
+		debug_assert!(inner.as_os_str() == loc.inner.as_os_str());
+		Self { inner: loc.inner, uri, urn }
 	}
 
 	#[inline]
diff --git a/yazi-shared/src/loc/loc.rs b/yazi-shared/src/loc/loc.rs
@@ -110,9 +110,25 @@ impl<'a> Loc<'a> {
 		Ok(loc)
 	}
 
+	pub fn zeroed<T: AsRef<Path> + ?Sized>(path: &'a T) -> Self {
+		let mut loc = Self::from(path.as_ref());
+		(loc.uri, loc.urn) = (0, 0);
+		loc
+	}
+
+	pub fn floated<T: AsRef<Path> + ?Sized>(path: &'a T, base: &Path) -> Self {
+		let mut loc = Self::from(path.as_ref());
+		loc.uri =
+			loc.inner.strip_prefix(base).expect("Loc must start with the given base").as_os_str().len();
+		loc
+	}
+
 	#[inline]
 	pub fn as_loc(self) -> Loc<'a> { self }
 
+	#[inline]
+	pub fn as_path(self) -> &'a Path { self.inner }
+
 	#[inline]
 	pub fn uri(self) -> &'a Uri {
 		Uri::new(unsafe {
@@ -161,6 +177,9 @@ impl<'a> Loc<'a> {
 	#[inline]
 	pub fn name(self) -> &'a OsStr { self.inner.file_name().unwrap_or(OsStr::new("")) }
 
+	#[inline]
+	pub fn parent(self) -> Option<&'a Path> { self.inner.parent() }
+
 	#[inline]
 	pub fn triple(self) -> (&'a Path, &'a Path, &'a Path) {
 		let len = self.bytes().len();
diff --git a/yazi-shared/src/pool/mod.rs b/yazi-shared/src/pool/mod.rs
@@ -1,6 +1,13 @@
 yazi_macro::mod_flat!(pool ptr symbol traits);
 
-static SYMBOLS: crate::RoCell<parking_lot::Mutex<hashbrown::HashMap<SymbolPtr, u64>>> =
-	crate::RoCell::new();
+static SYMBOLS: crate::RoCell<
+	parking_lot::Mutex<hashbrown::HashMap<SymbolPtr, u64, foldhash::fast::FixedState>>,
+> = crate::RoCell::new();
 
 pub(super) fn init() { SYMBOLS.with(<_>::default); }
+
+#[inline]
+pub(super) fn compute_hash<T: std::hash::Hash>(value: T) -> u64 {
+	use core::hash::BuildHasher;
+	foldhash::fast::FixedState::default().hash_one(value)
+}
diff --git a/yazi-shared/src/pool/pool.rs b/yazi-shared/src/pool/pool.rs
diff --git a/yazi-shared/src/pool/symbol.rs b/yazi-shared/src/pool/symbol.rs
diff --git a/yazi-shared/src/url/buf.rs b/yazi-shared/src/url/buf.rs
diff --git a/yazi-shared/src/url/cov.rs b/yazi-shared/src/url/cov.rs
diff --git a/yazi-shared/src/url/cow.rs b/yazi-shared/src/url/cow.rs
diff --git a/yazi-shared/src/url/url.rs b/yazi-shared/src/url/url.rs

Original file line number	Diff line number	Diff line change
`@@ -78,13 +78,13 @@ impl Cd {`
`78`	`78`	`Ok(s) => {`
`79`	`79`	`let Ok(url) = UrlBuf::try_from(s).map(expand_url) else { return };`
`80`	`80`
`81`		`- let Ok(file) = File::new(url.clone()).await else { return };`
	`81`	`+ let Ok(file) = File::new(&url).await else { return };`
`82`	`82`	`if file.is_dir() {`
`83`	`83`	`return MgrProxy::cd(&url);`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`if let Some(p) = url.parent_url() {`
`87`		`- FilesOp::Upserting(p, [(url.urn_owned(), file)].into()).emit();`
	`87`	`+ FilesOp::Upserting(p.into(), [(url.urn_owned(), file)].into()).emit();`
`88`	`88`	`}`
`89`	`89`	`MgrProxy::reveal(&url);`
`90`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ impl Actor for Open {`
`55`	`55`	`tokio::spawn(async move {`
`56`	`56`	`let mut files = Vec::with_capacity(todo.len());`
`57`	`57`	`for i in todo {`
`58`		`- if let Ok(f) = File::new(targets[i].0.clone()).await {`
	`58`	`+ if let Ok(f) = File::new(&targets[i].0).await {`
`59`	`59`	`files.push(f);`
`60`	`60`	`}`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ impl Actor for Reveal {`
`26`	`26`	`// If the child is not hovered, which means it doesn't exist,`
`27`	`27`	`// create a dummy file`
`28`	`28`	`if !opt.no_dummy && tab.hovered().is_none_or(\|f\| &child != f.urn()) {`
`29`		`- let op = FilesOp::Creating(parent, vec![File::from_dummy(opt.target, None)]);`
	`29`	`+ let op = FilesOp::Creating(parent.into(), vec![File::from_dummy(opt.target, None)]);`
`30`	`30`	`tab.current.update_pub(tab.id, op);`
`31`	`31`	`}`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ impl Boot {`
`32`	`32`	`};`
`33`	`33`
`34`	`34`	`if provider::metadata(&entry).await.is_ok_and(\|m\| m.is_file()) {`
`35`		`- (parent, child)`
	`35`	`+ (parent.into(), child)`
`36`	`36`	`} else {`
`37`	`37`	`(entry, UrnBuf::default())`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ impl Selected {`
`72`	`72`	`self.inner.extend(urls.iter().enumerate().map(\|(i, u)\| (u.into(), now + i as u64)));`
`73`	`73`
`74`	`74`	`for u in parents {`
`75`		`- *self.parents.entry(UrlBufCov(u)).or_insert(0) += self.inner.len() - len;`
	`75`	`+ *self.parents.entry_ref(&UrlCov::new(u)).or_default() += self.inner.len() - len;`
`76`	`76`	`}`
`77`	`77`	`urls.len()`
`78`	`78`	`}`