use RWLock to font library instead

Author: raphamorim

frontends/rioterm/src/application.rs

@@ -1193,7 +1193,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
         route.window.screen.set_modifiers(*modifiers);
 
         // Process the key event
-        route.window.screen.process_key_event(&key);
+        route.window.screen.process_key_event(key);
 
         // Restore the original modifiers
         route.window.screen.set_modifiers(original_modifiers);

frontends/rioterm/src/renderer/font_cache.rs

@@ -105,11 +105,11 @@ impl FontCache {
             ),
         ];
 
-        if let Some(mut font_ctx) = font_context.inner.try_lock() {
+        if let Some(font_ctx) = font_context.inner.try_read() {
             for &ch in &common_chars {
                 for &attrs in &common_attrs {
                     let key = (ch, attrs);
-                    if self.get(&mut key.clone()).is_none() {
+                    if self.get(&key).is_none() {
                         let style = rio_backend::sugarloaf::FragmentStyle {
                             font_attrs: attrs,
                             ..Default::default()

frontends/rioterm/src/renderer/mod.rs

@@ -371,7 +371,7 @@ impl Renderer {
 
         // Batch font lookups with a single lock acquisition
         if !font_lookups.is_empty() {
-            let mut font_ctx = self.font_context.inner.lock();
+            let font_ctx = self.font_context.inner.read();
             for (style_index, square_content, font_attrs) in font_lookups {
                 let mut width = square_content.width().unwrap_or(1) as f32;
                 let style = &mut styles_and_chars[style_index].0;
@@ -721,7 +721,7 @@ impl Renderer {
 
                     // Batch font lookups with a single lock acquisition
                     if !font_lookups.is_empty() {
-                        let mut font_ctx = self.font_context.inner.lock();
+                        let font_ctx = self.font_context.inner.read();
                         for (style_index, character) in font_lookups {
                             let mut width = character.width().unwrap_or(1) as f32;
                             let char_style = &mut char_styles[style_index].0;

sugarloaf/src/components/filters/runtime/error.rs

@@ -18,9 +18,9 @@ pub enum FilterChainError {
     #[error("shader preprocess error")]
     ShaderPreprocessError(#[from] PreprocessError),
     #[error("shader compile error")]
-    ShaderCompileError(#[from] ShaderCompileError),
+    ShaderCompileError(#[source] Box<ShaderCompileError>),
     #[error("shader reflect error")]
-    ShaderReflectError(#[from] ShaderReflectError),
+    ShaderReflectError(#[source] Box<ShaderReflectError>),
     #[error("lut loading error")]
     LutLoadError(#[from] ImageError),
     #[error("unreachable")]
@@ -29,3 +29,15 @@ pub enum FilterChainError {
 
 /// Result type for wgpu filter chains.
 pub type Result<T> = std::result::Result<T, FilterChainError>;
+
+impl From<ShaderCompileError> for FilterChainError {
+    fn from(error: ShaderCompileError) -> Self {
+        FilterChainError::ShaderCompileError(Box::new(error))
+    }
+}
+
+impl From<ShaderReflectError> for FilterChainError {
+    fn from(error: ShaderReflectError) -> Self {
+        FilterChainError::ShaderReflectError(Box::new(error))
+    }
+}

sugarloaf/src/components/rich_text/image_cache/glyph.rs

@@ -1,11 +1,14 @@
 use super::cache::ImageCache;
 use super::{AddImage, ImageData, ImageId, ImageLocation};
 use crate::font::FontLibrary;
-use crate::font_introspector::scale::{
-    image::{Content, Image as GlyphImage},
-    *,
-};
 use crate::font_introspector::zeno::Format;
+use crate::font_introspector::{
+    scale::{
+        image::{Content, Image as GlyphImage},
+        *,
+    },
+    FontRef,
+};
 use core::borrow::Borrow;
 use core::hash::{Hash, Hasher};
 use rustc_hash::FxHashMap;
@@ -120,16 +123,23 @@ impl GlyphCacheSession<'_> {
         }
 
         self.scaled_image.data.clear();
-        let mut font_library_data = self.font_library.inner.lock();
+        let font_library_data = self.font_library.inner.read();
         let enable_hint = font_library_data.hinting;
         let font_data = font_library_data.get(&self.font);
         let should_embolden = font_data.should_embolden;
         let should_italicize = font_data.should_italicize;
 
-        if let Some(data) = font_library_data.get_data(&self.font) {
+        if let Some((shared_data, offset, cache_key)) =
+            font_library_data.get_data(&self.font)
+        {
+            let font_ref = FontRef {
+                data: shared_data.as_ref(),
+                offset,
+                key: cache_key,
+            };
             let mut scaler = self
                 .scale_context
-                .builder(data)
+                .builder(font_ref)
                 // With the advent of high-DPI displays (displays with >300 pixels per inch),
                 // font hinting has become less relevant, as aliasing effects become
                 // un-noticeable to the human eye.

sugarloaf/src/font/mod.rs

@@ -16,10 +16,8 @@ use crate::font_introspector::text::Script;
 use crate::font_introspector::{CacheKey, FontRef, Synthesis};
 use crate::layout::FragmentStyle;
 use crate::SugarloafErrors;
-use lru::LruCache;
-use parking_lot::FairMutex;
+use parking_lot::RwLock;
 use rustc_hash::FxHashMap;
-use std::num::NonZeroUsize;
 use std::ops::Range;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -29,7 +27,7 @@ pub use crate::font_introspector::{Style, Weight};
 pub fn lookup_for_font_match(
     cluster: &mut CharCluster,
     synth: &mut Synthesis,
-    library: &mut FontLibraryData,
+    library: &FontLibraryData,
     spec_font_attr_opt: Option<&(crate::font_introspector::Style, bool)>,
 ) -> Option<(usize, bool)> {
     let mut search_result = None;
@@ -62,8 +60,13 @@ pub fn lookup_for_font_match(
             }
         }
 
-        if let Some(data) = library.get_data(&font_id) {
-            let charmap = data.charmap();
+        if let Some((shared_data, offset, key)) = library.get_data(&font_id) {
+            let font_ref = FontRef {
+                data: shared_data.as_ref(),
+                offset,
+                key,
+            };
+            let charmap = font_ref.charmap();
             let status = cluster.map(|ch| charmap.map(ch));
             if status != Status::Discard {
                 *synth = font_synth;
@@ -84,7 +87,7 @@ pub fn lookup_for_font_match(
 
 #[derive(Clone)]
 pub struct FontLibrary {
-    pub inner: Arc<FairMutex<FontLibraryData>>,
+    pub inner: Arc<RwLock<FontLibraryData>>,
 }
 
 impl FontLibrary {
@@ -100,7 +103,7 @@ impl FontLibrary {
 
         (
             Self {
-                inner: Arc::new(FairMutex::new(font_library)),
+                inner: Arc::new(RwLock::new(font_library)),
             },
             sugarloaf_errors,
         )
@@ -113,7 +116,7 @@ impl Default for FontLibrary {
         let _fonts_not_found = font_library.load(SugarloafFonts::default());
 
         Self {
-            inner: Arc::new(FairMutex::new(font_library)),
+            inner: Arc::new(RwLock::new(font_library)),
         }
     }
 }
@@ -127,15 +130,13 @@ pub struct FontLibraryData {
     // Standard is fallback for everything, it is also the inner number 0
     pub inner: FxHashMap<usize, FontData>,
     pub symbol_maps: Option<Vec<SymbolMap>>,
-    pub stash: LruCache<usize, SharedData>,
     pub hinting: bool,
 }
 
 impl Default for FontLibraryData {
     fn default() -> Self {
         Self {
             inner: FxHashMap::default(),
-            stash: LruCache::new(NonZeroUsize::new(2).unwrap()),
             hinting: true,
             symbol_maps: None,
         }
@@ -145,7 +146,7 @@ impl Default for FontLibraryData {
 impl FontLibraryData {
     #[inline]
     pub fn find_best_font_match(
-        &mut self,
+        &self,
         ch: char,
         fragment_style: &FragmentStyle,
     ) -> Option<(usize, bool)> {
@@ -205,39 +206,22 @@ impl FontLibraryData {
     }
 
     #[inline]
-    pub fn get(&mut self, font_id: &usize) -> &FontData {
+    pub fn get(&self, font_id: &usize) -> &FontData {
         &self.inner[font_id]
     }
 
-    pub fn get_data<'a>(&'a mut self, font_id: &usize) -> Option<FontRef<'a>> {
+    pub fn get_data(&self, font_id: &usize) -> Option<(SharedData, u32, CacheKey)> {
         if let Some(font) = self.inner.get(font_id) {
-            match &font.data {
-                Some(data) => {
-                    return Some(FontRef {
-                        data: data.as_ref(),
-                        offset: font.offset,
-                        key: font.key,
-                    })
-                }
-                None => {
-                    if !self.stash.contains(font_id) {
-                        if let Some(path) = &font.path {
-                            if let Some(raw_data) = load_from_font_source(path) {
-                                self.stash.put(*font_id, SharedData::new(raw_data));
-                            }
-                        }
-                    }
+            if let Some(data) = &font.data {
+                return Some((data.clone(), font.offset, font.key));
+            } else if let Some(path) = &font.path {
+                // Load font data directly from file when needed
+                if let Some(raw_data) = load_from_font_source(path) {
+                    let shared_data = SharedData::new(raw_data);
+                    return Some((shared_data, font.offset, font.key));
                 }
             }
-
-            if let Some(data) = self.stash.get(font_id) {
-                return Some(FontRef {
-                    data: data.as_ref(),
-                    offset: font.offset,
-                    key: font.key,
-                });
-            }
-        };
+        }
 
         None
     }

sugarloaf/src/layout/content.rs

@@ -5,11 +5,11 @@
 
 use crate::components::rich_text::RichTextBrush;
 use crate::font::FontLibrary;
-use crate::font_introspector::shape::cluster::GlyphCluster;
 use crate::font_introspector::shape::cluster::OwnedGlyphCluster;
 use crate::font_introspector::shape::ShapeContext;
 use crate::font_introspector::text::Script;
 use crate::font_introspector::Metrics;
+use crate::font_introspector::{shape::cluster::GlyphCluster, FontRef};
 use crate::layout::render_data::RenderData;
 use crate::layout::RichTextLayout;
 use crate::Graphics;
@@ -605,11 +605,17 @@ impl Content {
 
             // Process the font data directly without cloning FontRef
             {
-                let font_library = &mut self.fonts.inner.lock();
-                if let Some(data) = font_library.get_data(&font_id) {
+                let font_library = &self.fonts.inner.read();
+                if let Some((shared_data, offset, key)) = font_library.get_data(&font_id)
+                {
+                    let font_ref = FontRef {
+                        data: shared_data.as_ref(),
+                        offset,
+                        key,
+                    };
                     let mut shaper = self
                         .scx
-                        .builder(data) // Use reference directly without cloning
+                        .builder(font_ref) // Use reference directly without cloning
                         .script(script)
                         .size(scaled_font_size)
                         .features(features.iter().copied())