Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

gpui: Remove mutex from dynamic font loading (#64204)

Cameron Mcloughlinb68add5b37a1
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index b0b83862d98..2888824c96a 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -2123,13 +2123,17 @@ impl App {
/// detection. The callback runs on the foreground executor after shaping has
/// released its internal locks. Dropping its subscription disables detection until
/// another callback is registered.
+ ///
+ /// Reports are queued without blocking shaping, then deduplicated before delivery.
+ /// The bounded queue can drop reports on overflow. Dropped reports may be reported
+ /// again when the text is reshaped; no retry is scheduled automatically.
pub fn on_missing_glyphs(
&self,
callback: impl FnMut(&[MissingGlyph], &mut App) + 'static,
) -> Subscription {
let registration = self.missing_glyph_callback.replace(Box::new(callback));
- if let Some(receiver) = self.text_system.take_missing_glyph_receiver() {
+ if let Some(mut receiver) = self.text_system.take_missing_glyph_receiver() {
let callback = self.missing_glyph_callback.clone();
self.spawn(async move |cx| {
while let Ok(missing_glyphs) = receiver.recv().await {
diff --git a/crates/gpui/src/text_system.rs b/crates/gpui/src/text_system.rs
index bb42fd8d0fb..6c445a8920f 100644
--- a/crates/gpui/src/text_system.rs
+++ b/crates/gpui/src/text_system.rs
@@ -102,6 +102,14 @@ struct MissingGlyphState {
generation: usize,
}
+impl MissingGlyphState {
+ fn reset(&mut self, generation: usize) {
+ self.reported.clear();
+ self.reported_order.clear();
+ self.generation = generation;
+ }
+}
+
struct QueuedMissingGlyph {
generation: usize,
missing_glyph: MissingGlyph,
@@ -109,7 +117,7 @@ struct QueuedMissingGlyph {
/// Collects missing-glyph reports without invoking application code during layout.
struct MissingGlyphReporter {
- state: Arc<Mutex<MissingGlyphState>>,
+ generation: Arc<AtomicUsize>,
sender: async_channel::Sender<QueuedMissingGlyph>,
}
@@ -119,31 +127,16 @@ impl MissingGlyphSink for MissingGlyphReporter {
return;
}
- let mut state = self.state.lock();
- for missing_glyph in missing_glyphs {
- if state.reported.contains(&missing_glyph) {
- continue;
- }
+ let generation = self.generation.load(Ordering::Acquire);
+ // Repetitions within a line must not fill the queue before its other
+ // missing glyphs. Cross-report deduplication belongs to the receiver.
+ for missing_glyph in missing_glyphs.into_iter().unique() {
let queued = QueuedMissingGlyph {
- generation: state.generation,
- missing_glyph: missing_glyph.clone(),
+ generation,
+ missing_glyph,
};
- match self.sender.try_send(queued) {
- Ok(()) => {
- state.reported.insert(missing_glyph.clone());
- state.reported_order.push_back(missing_glyph);
- while state.reported.len() > MAX_REPORTED_MISSING_GLYPHS {
- if let Some(expired) = state.reported_order.pop_front() {
- state.reported.remove(&expired);
- }
- }
- }
- Err(async_channel::TrySendError::Full(_)) => break,
- Err(async_channel::TrySendError::Closed(_)) => {
- state.reported.clear();
- state.reported_order.clear();
- return;
- }
+ if self.sender.try_send(queued).is_err() {
+ break;
}
}
}
@@ -151,16 +144,14 @@ impl MissingGlyphSink for MissingGlyphReporter {
impl MissingGlyphReporter {
fn reset(&self) {
- let mut state = self.state.lock();
- state.reported.clear();
- state.reported_order.clear();
- state.generation = state.generation.wrapping_add(1);
+ self.generation.fetch_add(1, Ordering::AcqRel);
}
}
/// Receives batches of grapheme clusters that exhausted font fallback.
pub(crate) struct MissingGlyphReceiver {
- state: Arc<Mutex<MissingGlyphState>>,
+ state: MissingGlyphState,
+ generation: Arc<AtomicUsize>,
receiver: async_channel::Receiver<QueuedMissingGlyph>,
}
@@ -171,35 +162,58 @@ impl MissingGlyphReceiver {
///
/// Returns [`async_channel::RecvError`] if the reporting channel is closed.
pub(crate) async fn recv(
- &self,
+ &mut self,
) -> std::result::Result<Vec<MissingGlyph>, async_channel::RecvError> {
loop {
let queued = self.receiver.recv().await?;
let mut missing_glyphs = Vec::new();
- if queued.generation == self.state.lock().generation {
+ for queued in std::iter::once(queued)
+ .chain(std::iter::from_fn(|| self.receiver.try_recv().ok()))
+ .take(MAX_REPORTED_MISSING_GLYPHS)
+ {
+ let generation = self.generation.load(Ordering::Acquire);
+ if self.state.generation != generation {
+ self.state.reset(generation);
+ missing_glyphs.clear();
+ }
+ if queued.generation != generation
+ || !self.state.reported.insert(queued.missing_glyph.clone())
+ {
+ continue;
+ }
+ self.state
+ .reported_order
+ .push_back(queued.missing_glyph.clone());
missing_glyphs.push(queued.missing_glyph);
- }
- while missing_glyphs.len() < MAX_REPORTED_MISSING_GLYPHS {
- let Ok(queued) = self.receiver.try_recv() else {
- break;
- };
- if queued.generation == self.state.lock().generation {
- missing_glyphs.push(queued.missing_glyph);
+ if self.state.reported.len() > MAX_REPORTED_MISSING_GLYPHS
+ && let Some(expired) = self.state.reported_order.pop_front()
+ {
+ self.state.reported.remove(&expired);
}
}
if !missing_glyphs.is_empty() {
return Ok(missing_glyphs);
}
+ // A producer can keep refilling the queue with already-reported
+ // glyphs. Bound work per poll even when every report is filtered out.
+ let mut yielded = false;
+ std::future::poll_fn(|cx| {
+ if std::mem::replace(&mut yielded, true) {
+ std::task::Poll::Ready(())
+ } else {
+ cx.waker().wake_by_ref();
+ std::task::Poll::Pending
+ }
+ })
+ .await;
}
}
}
impl Drop for MissingGlyphReceiver {
fn drop(&mut self) {
+ self.receiver.close();
while self.receiver.try_recv().is_ok() {}
- let mut state = self.state.lock();
- state.reported.clear();
- state.reported_order.clear();
}
}
@@ -221,7 +235,7 @@ impl TextSystem {
/// Create a new TextSystem with the given platform text system.
pub fn new(platform_text_system: Arc<dyn PlatformTextSystem>) -> Self {
let (sender, receiver) = async_channel::bounded(MAX_REPORTED_MISSING_GLYPHS);
- let missing_glyph_state = Arc::<Mutex<MissingGlyphState>>::default();
+ let missing_glyph_generation = Arc::<AtomicUsize>::default();
TextSystem {
platform_text_system,
font_metrics: RwLock::default(),
@@ -244,11 +258,12 @@ impl TextSystem {
],
font_generation: Arc::default(),
missing_glyph_reporter: Arc::new(MissingGlyphReporter {
- state: missing_glyph_state.clone(),
+ generation: missing_glyph_generation.clone(),
sender,
}),
missing_glyph_receiver: Mutex::new(Some(MissingGlyphReceiver {
- state: missing_glyph_state,
+ state: MissingGlyphState::default(),
+ generation: missing_glyph_generation,
receiver,
})),
}
@@ -279,9 +294,11 @@ impl TextSystem {
/// Takes the receiver for missing-glyph reports.
///
/// Only one receiver is available for each text system. Returns `None` when
- /// the receiver was already taken.
+ /// the receiver was already taken or another caller is taking it.
pub(crate) fn take_missing_glyph_receiver(&self) -> Option<MissingGlyphReceiver> {
- self.missing_glyph_receiver.lock().take()
+ self.missing_glyph_receiver
+ .try_lock()
+ .and_then(|mut receiver| receiver.take())
}
pub(crate) fn enable_missing_glyph_reporting(&self) {
@@ -1423,15 +1440,11 @@ pub fn font_name_with_fallbacks_shared<'a>(
#[cfg(test)]
mod missing_glyph_tests {
use super::*;
+ use futures::FutureExt as _;
#[test]
fn bounds_retained_missing_glyphs() {
- let (sender, receiver) = async_channel::bounded(MAX_REPORTED_MISSING_GLYPHS);
- let state = Arc::<Mutex<MissingGlyphState>>::default();
- let reporter = MissingGlyphReporter {
- state: state.clone(),
- sender,
- };
+ let (reporter, mut receiver) = missing_glyph_channel();
reporter.report(
(0..MAX_REPORTED_MISSING_GLYPHS)
.map(|index| {
@@ -1439,12 +1452,13 @@ mod missing_glyph_tests {
})
.collect(),
);
- assert!(receiver.try_recv().is_ok());
+ assert!(receiver.recv().now_or_never().unwrap().is_ok());
let newest = MissingGlyph::new("newest".into(), FallbackFontClass::Monospace);
reporter.report(vec![newest.clone()]);
+ assert!(receiver.recv().now_or_never().unwrap().is_ok());
- let state = state.lock();
+ let state = &receiver.state;
assert_eq!(state.reported.len(), MAX_REPORTED_MISSING_GLYPHS);
assert_eq!(state.reported_order.len(), MAX_REPORTED_MISSING_GLYPHS);
assert!(state.reported.contains(&newest));
@@ -1452,26 +1466,31 @@ mod missing_glyph_tests {
#[test]
fn dropping_receiver_closes_and_clears_reports() {
+ let (reporter, receiver) = missing_glyph_channel();
+ reporter.report(vec![missing_glyph("missing")]);
+
+ drop(receiver);
+
+ assert!(reporter.sender.is_closed());
+ assert!(reporter.sender.is_empty());
+ }
+
+ fn missing_glyph_channel() -> (MissingGlyphReporter, MissingGlyphReceiver) {
let (sender, receiver) = async_channel::bounded(MAX_REPORTED_MISSING_GLYPHS);
- let state = Arc::<Mutex<MissingGlyphState>>::default();
+ let generation = Arc::<AtomicUsize>::default();
let reporter = MissingGlyphReporter {
- state: state.clone(),
+ generation: generation.clone(),
sender,
};
let receiver = MissingGlyphReceiver {
- state: state.clone(),
+ state: MissingGlyphState::default(),
+ generation,
receiver,
};
- reporter.report(vec![MissingGlyph::new(
- "missing".into(),
- FallbackFontClass::Proportional,
- )]);
-
- drop(receiver);
+ (reporter, receiver)
+ }
- assert!(reporter.sender.is_closed());
- let state = state.lock();
- assert!(state.reported.is_empty());
- assert!(state.reported_order.is_empty());
+ fn missing_glyph(grapheme: &'static str) -> MissingGlyph {
+ MissingGlyph::new(grapheme.into(), FallbackFontClass::Proportional)
}
}