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.rsindex 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.rsindex 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)}}