gpui: Remove unused hash-based text layout cache (#66152)

The hash-based text layout interface was introduced for an earlier Delta
editor prototype, but neither Zed nor Delta has any remaining callers.
Let's remove it and re-introduce it proper when needed.

Release Notes:

- [GPUI] Removed an unused hash-based text layout cache interface.
This commit is contained in:
Lukas Wirth
2026-10-26 10:49:55 +00:00
committed by GitHub
parent 772a8a9100
commit 2a74c8dff6
2 changed files with 0 additions and 462 deletions
-192
View File
@@ -711,74 +711,6 @@ impl WindowTextSystem {
}
}
/// Shape the given line using a caller-provided content hash as the cache key.
///
/// This enables cache hits without materializing a contiguous `SharedString` for the text.
/// If the cache misses, `materialize_text` is invoked to produce the `SharedString` for shaping.
///
/// Contract (caller enforced):
/// - Same `text_hash` implies identical text content (collision risk accepted by caller).
/// - `text_len` should be the UTF-8 byte length of the text (helps reduce accidental collisions).
///
/// Like [`Self::shape_line`], this must be used only for single-line text (no `\n`).
pub fn shape_line_by_hash(
&self,
text_hash: u64,
text_len: usize,
font_size: Pixels,
runs: &[TextRun],
force_width: Option<Pixels>,
materialize_text: impl FnOnce() -> SharedString,
) -> ShapedLine {
let mut decoration_runs = SmallVec::<[DecorationRun; 32]>::new();
for run in runs {
if let Some(last_run) = decoration_runs.last_mut()
&& last_run.color == run.color
&& last_run.underline == run.underline
&& last_run.strikethrough == run.strikethrough
&& last_run.background_color == run.background_color
{
last_run.len += run.len as u32;
continue;
}
decoration_runs.push(DecorationRun {
len: run.len as u32,
color: run.color,
background_color: run.background_color,
underline: run.underline,
strikethrough: run.strikethrough,
});
}
let mut used_force_width = force_width;
let layout = self.layout_line_by_hash(
text_hash,
text_len,
font_size,
runs,
used_force_width,
|| {
let text = materialize_text();
debug_assert!(
text.find('\n').is_none(),
"text argument should not contain newlines"
);
text
},
);
// We only materialize actual text on cache miss; on hit we avoid allocations.
// Since `ShapedLine` carries a `SharedString`, use an empty placeholder for hits.
// NOTE: Callers must not rely on `ShapedLine.text` for content when using this API.
let text: SharedString = SharedString::new_static("");
ShapedLine {
layout,
text,
decoration_runs,
}
}
/// Shape a multi line string of text, at the given font_size, for painting to the screen.
/// Subsets of the text can be styled independently with the `runs` parameter.
/// If `wrap_width` is provided, the line breaks will be adjusted to fit within the given width.
@@ -990,130 +922,6 @@ impl WindowTextSystem {
pub fn em_layout_width(&self, font_id: FontId, font_size: Pixels) -> Pixels {
self.layout_width(font_id, font_size, 'm')
}
/// Probe the line layout cache using a caller-provided content hash, without allocating.
///
/// Returns `Some(layout)` if the layout is already cached in either the current frame
/// or the previous frame. Returns `None` if it is not cached.
///
/// Contract (caller enforced):
/// - Same `text_hash` implies identical text content (collision risk accepted by caller).
/// - `text_len` should be the UTF-8 byte length of the text (helps reduce accidental collisions).
pub fn try_layout_line_by_hash(
&self,
text_hash: u64,
text_len: usize,
font_size: Pixels,
runs: &[TextRun],
force_width: Option<Pixels>,
) -> Option<Arc<LineLayout>> {
let mut last_run = None::<&TextRun>;
let mut font_runs = mem::take(&mut *self.font_runs_buffer.borrow_mut());
font_runs.clear();
for run in runs.iter() {
let decoration_changed = if let Some(last_run) = last_run
&& last_run.color == run.color
&& last_run.underline == run.underline
&& last_run.strikethrough == run.strikethrough
// we do not consider differing background color relevant, as it does not affect glyphs
// && last_run.background_color == run.background_color
{
false
} else {
last_run = Some(run);
true
};
let font_id = self.resolve_font(&run.font);
if let Some(font_run) = font_runs.last_mut()
&& font_id == font_run.font_id
&& !decoration_changed
{
font_run.len += run.len;
} else {
font_runs.push(FontRun {
len: run.len,
font_id,
});
}
}
let layout = self.line_layout_cache.try_layout_line_by_hash(
text_hash,
text_len,
font_size,
&font_runs,
force_width,
);
*self.font_runs_buffer.borrow_mut() = font_runs;
layout
}
/// Layout the given line of text using a caller-provided content hash as the cache key.
///
/// This enables cache hits without materializing a contiguous `SharedString` for the text.
/// If the cache misses, `materialize_text` is invoked to produce the `SharedString` for shaping.
///
/// Contract (caller enforced):
/// - Same `text_hash` implies identical text content (collision risk accepted by caller).
/// - `text_len` should be the UTF-8 byte length of the text (helps reduce accidental collisions).
pub fn layout_line_by_hash(
&self,
text_hash: u64,
text_len: usize,
font_size: Pixels,
runs: &[TextRun],
force_width: Option<Pixels>,
materialize_text: impl FnOnce() -> SharedString,
) -> Arc<LineLayout> {
let mut last_run = None::<&TextRun>;
let mut font_runs = mem::take(&mut *self.font_runs_buffer.borrow_mut());
font_runs.clear();
for run in runs.iter() {
let decoration_changed = if let Some(last_run) = last_run
&& last_run.color == run.color
&& last_run.underline == run.underline
&& last_run.strikethrough == run.strikethrough
// we do not consider differing background color relevant, as it does not affect glyphs
// && last_run.background_color == run.background_color
{
false
} else {
last_run = Some(run);
true
};
let font_id = self.resolve_font(&run.font);
if let Some(font_run) = font_runs.last_mut()
&& font_id == font_run.font_id
&& !decoration_changed
{
font_run.len += run.len;
} else {
font_runs.push(FontRun {
len: run.len,
font_id,
});
}
}
let layout = self.line_layout_cache.layout_line_by_hash(
text_hash,
text_len,
font_size,
&font_runs,
force_width,
materialize_text,
);
*self.font_runs_buffer.borrow_mut() = font_runs;
layout
}
}
#[derive(Hash, Eq, PartialEq)]
-270
View File
@@ -476,17 +476,6 @@ struct FrameCache {
wrapped_lines: FxHashMap<Arc<CacheKey>, Arc<WrappedLineLayout>>,
used_lines: Vec<Arc<CacheKey>>,
used_wrapped_lines: Vec<Arc<CacheKey>>,
// Content-addressable caches keyed by caller-provided text hash + layout params.
// These allow cache hits without materializing a contiguous `SharedString`.
//
// IMPORTANT: To support allocation-free lookups, we store these maps using a key type
// (`HashedCacheKeyRef`) that can be computed without building a contiguous `&str`/`SharedString`.
// On miss, we allocate once and store under an owned `HashedCacheKey`.
lines_by_hash: FxHashMap<Arc<HashedCacheKey>, Arc<LineLayout>>,
wrapped_lines_by_hash: FxHashMap<Arc<HashedCacheKey>, Arc<WrappedLineLayout>>,
used_lines_by_hash: Vec<Arc<HashedCacheKey>>,
used_wrapped_lines_by_hash: Vec<Arc<HashedCacheKey>>,
}
#[derive(Clone, Default)]
@@ -494,8 +483,6 @@ pub(crate) struct LineLayoutIndex {
font_generation: usize,
lines_index: usize,
wrapped_lines_index: usize,
lines_by_hash_index: usize,
wrapped_lines_by_hash_index: usize,
}
impl LineLayoutCache {
@@ -520,8 +507,6 @@ impl LineLayoutCache {
font_generation,
lines_index: frame.used_lines.len(),
wrapped_lines_index: frame.used_wrapped_lines.len(),
lines_by_hash_index: frame.used_lines_by_hash.len(),
wrapped_lines_by_hash_index: frame.used_wrapped_lines_by_hash.len(),
}
}
@@ -553,24 +538,6 @@ impl LineLayoutCache {
}
current_frame.used_wrapped_lines.push(key.clone());
}
for key in &previous_frame.used_lines_by_hash
[range.start.lines_by_hash_index..range.end.lines_by_hash_index]
{
if let Some((key, line)) = previous_frame.lines_by_hash.remove_entry(key) {
current_frame.lines_by_hash.insert(key, line);
}
current_frame.used_lines_by_hash.push(key.clone());
}
for key in &previous_frame.used_wrapped_lines_by_hash
[range.start.wrapped_lines_by_hash_index..range.end.wrapped_lines_by_hash_index]
{
if let Some((key, line)) = previous_frame.wrapped_lines_by_hash.remove_entry(key) {
current_frame.wrapped_lines_by_hash.insert(key, line);
}
current_frame.used_wrapped_lines_by_hash.push(key.clone());
}
}
pub fn truncate_layouts(&self, index: LineLayoutIndex) {
@@ -584,12 +551,6 @@ impl LineLayoutCache {
current_frame
.used_wrapped_lines
.truncate(index.wrapped_lines_index);
current_frame
.used_lines_by_hash
.truncate(index.lines_by_hash_index);
current_frame
.used_wrapped_lines_by_hash
.truncate(index.wrapped_lines_by_hash_index);
}
pub fn finish_frame(&self) {
@@ -603,11 +564,6 @@ impl LineLayoutCache {
current_frame.wrapped_lines.clear();
current_frame.used_lines.clear();
current_frame.used_wrapped_lines.clear();
current_frame.lines_by_hash.clear();
current_frame.wrapped_lines_by_hash.clear();
current_frame.used_lines_by_hash.clear();
current_frame.used_wrapped_lines_by_hash.clear();
}
pub fn layout_wrapped_line<Text>(
@@ -738,164 +694,6 @@ impl LineLayoutCache {
}
}
/// Try to retrieve a previously-shaped line layout using a caller-provided content hash.
///
/// This is a *non-allocating* cache probe: it does not materialize any text. If the layout
/// is not already cached in either the current frame or previous frame, returns `None`.
///
/// Contract (caller enforced):
/// - Same `text_hash` implies identical text content (collision risk accepted by caller).
/// - `text_len` should be the UTF-8 byte length of the text (helps reduce accidental collisions).
pub fn try_layout_line_by_hash(
&self,
text_hash: u64,
text_len: usize,
font_size: Pixels,
runs: &[FontRun],
force_width: Option<Pixels>,
) -> Option<Arc<LineLayout>> {
let _font_generation = self.clear_if_font_generation_changed();
let key_ref = HashedCacheKeyRef {
text_hash,
text_len,
font_size,
runs,
wrap_width: None,
force_width,
};
let state = self.state.borrow();
if let Some((_, layout)) = state.current_frame.lines_by_hash.iter().find(|(key, _)| {
HashedCacheKeyRef {
text_hash: key.text_hash,
text_len: key.text_len,
font_size: key.font_size,
runs: key.runs.as_slice(),
wrap_width: key.wrap_width,
force_width: key.force_width,
} == key_ref
}) {
return Some(layout.clone());
}
if let Some((_, layout)) = state.previous_frame.lines_by_hash.iter().find(|(key, _)| {
HashedCacheKeyRef {
text_hash: key.text_hash,
text_len: key.text_len,
font_size: key.font_size,
runs: key.runs.as_slice(),
wrap_width: key.wrap_width,
force_width: key.force_width,
} == key_ref
}) {
return Some(layout.clone());
}
None
}
/// Layout a line of text using a caller-provided content hash as the cache key.
///
/// This enables cache hits without materializing a contiguous `SharedString` for `text`.
/// If the cache misses, `materialize_text` is invoked to produce the `SharedString` for shaping.
///
/// Contract (caller enforced):
/// - Same `text_hash` implies identical text content (collision risk accepted by caller).
/// - `text_len` should be the UTF-8 byte length of the text (helps reduce accidental collisions).
pub fn layout_line_by_hash(
&self,
text_hash: u64,
text_len: usize,
font_size: Pixels,
runs: &[FontRun],
force_width: Option<Pixels>,
materialize_text: impl FnOnce() -> SharedString,
) -> Arc<LineLayout> {
let _font_generation = self.clear_if_font_generation_changed();
let key_ref = HashedCacheKeyRef {
text_hash,
text_len,
font_size,
runs,
wrap_width: None,
force_width,
};
// Fast path: already cached (no allocation).
let mut state = self.state.borrow_mut();
if let Some((_, layout)) = state.current_frame.lines_by_hash.iter().find(|(key, _)| {
HashedCacheKeyRef {
text_hash: key.text_hash,
text_len: key.text_len,
font_size: key.font_size,
runs: key.runs.as_slice(),
wrap_width: key.wrap_width,
force_width: key.force_width,
} == key_ref
}) {
return layout.clone();
}
// Try to reuse from previous frame without allocating; do a linear scan to find a matching key.
// (We avoid `drain()` here because it would eagerly move all entries.)
if let Some(existing_key) = state
.previous_frame
.used_lines_by_hash
.iter()
.find(|key| {
HashedCacheKeyRef {
text_hash: key.text_hash,
text_len: key.text_len,
font_size: key.font_size,
runs: key.runs.as_slice(),
wrap_width: key.wrap_width,
force_width: key.force_width,
} == key_ref
})
.cloned()
{
if let Some((key, layout)) = state
.previous_frame
.lines_by_hash
.remove_entry(&existing_key)
{
state
.current_frame
.lines_by_hash
.insert(key.clone(), layout.clone());
state.current_frame.used_lines_by_hash.push(key);
return layout;
}
}
drop(state);
let text = materialize_text();
let mut layout = self
.platform_text_system
.layout_line(&text, font_size, runs);
if let Some(force_width) = force_width {
apply_force_width_to_layout(&mut layout, force_width);
}
let key = Arc::new(HashedCacheKey {
text_hash,
text_len,
font_size,
runs: SmallVec::from(runs),
wrap_width: None,
force_width,
});
let layout = Arc::new(layout);
let mut state = self.state.borrow_mut();
state
.current_frame
.lines_by_hash
.insert(key.clone(), layout.clone());
state.current_frame.used_lines_by_hash.push(key);
layout
}
fn clear_if_font_generation_changed(&self) -> usize {
let font_generation = self.font_generation.load(Ordering::Acquire);
if self.cached_font_generation.load(Ordering::Acquire) == font_generation {
@@ -974,80 +772,12 @@ struct CacheKeyRef<'a> {
force_width: Option<Pixels>,
}
#[derive(Clone, Debug)]
struct HashedCacheKey {
text_hash: u64,
text_len: usize,
font_size: Pixels,
runs: SmallVec<[FontRun; 1]>,
wrap_width: Option<Pixels>,
force_width: Option<Pixels>,
}
#[derive(Copy, Clone)]
struct HashedCacheKeyRef<'a> {
text_hash: u64,
text_len: usize,
font_size: Pixels,
runs: &'a [FontRun],
wrap_width: Option<Pixels>,
force_width: Option<Pixels>,
}
impl PartialEq for dyn AsCacheKeyRef + '_ {
fn eq(&self, other: &dyn AsCacheKeyRef) -> bool {
self.as_cache_key_ref() == other.as_cache_key_ref()
}
}
impl PartialEq for HashedCacheKey {
fn eq(&self, other: &Self) -> bool {
self.text_hash == other.text_hash
&& self.text_len == other.text_len
&& self.font_size == other.font_size
&& self.runs.as_slice() == other.runs.as_slice()
&& self.wrap_width == other.wrap_width
&& self.force_width == other.force_width
}
}
impl Eq for HashedCacheKey {}
impl Hash for HashedCacheKey {
fn hash<H: Hasher>(&self, state: &mut H) {
self.text_hash.hash(state);
self.text_len.hash(state);
self.font_size.hash(state);
self.runs.as_slice().hash(state);
self.wrap_width.hash(state);
self.force_width.hash(state);
}
}
impl PartialEq for HashedCacheKeyRef<'_> {
fn eq(&self, other: &Self) -> bool {
self.text_hash == other.text_hash
&& self.text_len == other.text_len
&& self.font_size == other.font_size
&& self.runs == other.runs
&& self.wrap_width == other.wrap_width
&& self.force_width == other.force_width
}
}
impl Eq for HashedCacheKeyRef<'_> {}
impl Hash for HashedCacheKeyRef<'_> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.text_hash.hash(state);
self.text_len.hash(state);
self.font_size.hash(state);
self.runs.hash(state);
self.wrap_width.hash(state);
self.force_width.hash(state);
}
}
impl Eq for dyn AsCacheKeyRef + '_ {}
impl Hash for dyn AsCacheKeyRef + '_ {