diff --git a/Cargo.lock b/Cargo.lock index b943640..7c89b3d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14,6 +14,7 @@ dependencies = [ "we-image", "we-js", "we-layout", + "we-memory", "we-net", "we-platform", "we-render", @@ -34,6 +35,9 @@ version = "0.1.0" [[package]] name = "we-dom" version = "0.1.0" +dependencies = [ + "we-memory", +] [[package]] name = "we-encoding" @@ -74,6 +78,10 @@ dependencies = [ "we-text", ] +[[package]] +name = "we-memory" +version = "0.1.0" + [[package]] name = "we-net" version = "0.1.0" @@ -107,6 +115,7 @@ dependencies = [ "we-css", "we-dom", "we-html", + "we-memory", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 3766fac..b2ddead 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,7 @@ members = [ "crates/render", "crates/js", "crates/svg", + "crates/memory", "crates/browser", ] diff --git a/crates/browser/Cargo.toml b/crates/browser/Cargo.toml index a7d895a..065e7a3 100644 --- a/crates/browser/Cargo.toml +++ b/crates/browser/Cargo.toml @@ -27,3 +27,4 @@ we-url = { path = "../url" } we-encoding = { path = "../encoding" } we-image = { path = "../image" } we-svg = { path = "../svg" } +we-memory = { path = "../memory" } diff --git a/crates/browser/src/lib.rs b/crates/browser/src/lib.rs index 1eb0027..b8ed525 100644 --- a/crates/browser/src/lib.rs +++ b/crates/browser/src/lib.rs @@ -8,5 +8,6 @@ pub mod iframe_loader; pub mod img_loader; pub mod indexeddb; pub mod loader; +pub mod memory_stats; pub mod script_loader; pub mod storage; diff --git a/crates/browser/src/memory_stats.rs b/crates/browser/src/memory_stats.rs new file mode 100644 index 0000000..0db9b9a --- /dev/null +++ b/crates/browser/src/memory_stats.rs @@ -0,0 +1,110 @@ +//! Debug memory statistics: aggregates memory usage from all browser subsystems. +//! +//! Call [`collect_memory_report`] to gather a snapshot of current memory usage +//! across DOM, layout, style, JS heap, glyph cache, network, and display list. + +use we_dom::Document; +use we_layout::LayoutTree; +use we_memory::intern; +use we_memory::stats::{MemoryReport, SubsystemStats}; +use we_render::atlas::GlyphAtlas; +use we_render::layer::LayerTree; + +/// Collect a full memory report from all available subsystems. +/// +/// Pass `None` for any subsystem that is not currently active. +pub fn collect_memory_report( + doc: Option<&Document>, + layout_tree: Option<&LayoutTree>, + layer_tree: Option<&LayerTree>, + glyph_atlas: Option<&GlyphAtlas>, +) -> MemoryReport { + let mut report = MemoryReport::new(); + + // DOM + if let Some(doc) = doc { + report.add( + SubsystemStats::new("DOM tree") + .with_count(doc.len()) + .with_bytes(doc.memory_usage()) + .with_detail("elements", doc.element_count()) + .with_detail("text_nodes", doc.text_node_count()), + ); + } + + // Layout + if let Some(tree) = layout_tree { + report.add( + SubsystemStats::new("Layout tree") + .with_count(tree.box_count()) + .with_bytes(tree.memory_usage()) + .with_detail("prev_box_count", tree.hints.prev_box_count), + ); + } + + // String interner + report.add( + SubsystemStats::new("String interner") + .with_count(intern::interned_count()) + .with_bytes(intern::interner_memory_usage()), + ); + + // Display list / layer tree + if let Some(lt) = layer_tree { + report.add( + SubsystemStats::new("Display list") + .with_count(lt.display_list_command_count()) + .with_bytes(lt.memory_usage()), + ); + } + + // Glyph atlas + if let Some(atlas) = glyph_atlas { + report.add( + SubsystemStats::new("Glyph atlas") + .with_count(atlas.glyph_count()) + .with_bytes(atlas.memory_usage()) + .with_detail("pages", atlas.page_count()) + .with_detail("utilization", format!("{:.1}%", atlas.utilization())), + ); + } + + report +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn empty_report() { + let report = collect_memory_report(None, None, None, None); + // Should at least have the string interner entry + assert!(!report.subsystems.is_empty()); + } + + #[test] + fn report_with_dom() { + let mut doc = Document::new(); + let root = doc.root(); + let div = doc.create_element("div"); + doc.append_child(root, div); + + let report = collect_memory_report(Some(&doc), None, None, None); + let dom_stats = report + .subsystems + .iter() + .find(|s| s.name == "DOM tree") + .unwrap(); + assert!(dom_stats.estimated_bytes > 0); + assert_eq!(dom_stats.item_count, 2); // root + div + } + + #[test] + fn report_display_format() { + let report = collect_memory_report(None, None, None, None); + let s = format!("{report}"); + assert!(s.contains("Memory Report")); + assert!(s.contains("Total:")); + } +} diff --git a/crates/dom/Cargo.toml b/crates/dom/Cargo.toml index 2ec1be7..f0fc12f 100644 --- a/crates/dom/Cargo.toml +++ b/crates/dom/Cargo.toml @@ -6,3 +6,6 @@ edition.workspace = true [lib] name = "we_dom" path = "src/lib.rs" + +[dependencies] +we-memory = { path = "../memory" } diff --git a/crates/dom/src/lib.rs b/crates/dom/src/lib.rs index aff7dbb..fdab9b2 100644 --- a/crates/dom/src/lib.rs +++ b/crates/dom/src/lib.rs @@ -2,9 +2,14 @@ //! //! Arena-based DOM tree with Document, Element, Text, and Comment node types. //! Each node is stored in a flat `Vec` and referenced by `NodeId`. +//! +//! Tag names and attribute names are interned via `Atom` for memory efficiency: +//! thousands of `
` elements share one string allocation instead of one each. use std::fmt; +use we_memory::intern::Atom; + /// A handle to a node in the DOM tree. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct NodeId(usize); @@ -22,22 +27,27 @@ impl NodeId { } /// An HTML/XML attribute (name-value pair). +/// +/// The `name` is an interned `Atom` (shared across identical attribute names). +/// The `value` is a regular `String` (typically unique per element). #[derive(Debug, Clone, PartialEq, Eq)] pub struct Attribute { - pub name: String, + pub name: Atom, pub value: String, } /// The data specific to each node type. +/// +/// Element tag names and namespaces are interned `Atom` values. #[derive(Debug, Clone, PartialEq, Eq)] pub enum NodeData { /// The root document node. Document, /// An element node with tag name, attributes, and optional namespace. Element { - tag_name: String, + tag_name: Atom, attributes: Vec, - namespace: Option, + namespace: Option, }, /// A text node containing character data. Text { data: String }, @@ -101,9 +111,9 @@ impl Document { /// Create an element node with an optional namespace. pub fn create_element_ns(&mut self, tag_name: &str, namespace: Option<&str>) -> NodeId { self.push_node(NodeData::Element { - tag_name: tag_name.to_string(), + tag_name: Atom::new(tag_name), attributes: Vec::new(), - namespace: namespace.map(|s| s.to_string()), + namespace: namespace.map(Atom::new), }) } @@ -235,7 +245,7 @@ impl Document { match &self.nodes[node.0].data { NodeData::Element { attributes, .. } => attributes .iter() - .find(|a| a.name == name) + .find(|a| *a.name == *name) .map(|a| a.value.as_str()), _ => None, } @@ -245,11 +255,11 @@ impl Document { /// its value is replaced. Does nothing if `node` is not an element. pub fn set_attribute(&mut self, node: NodeId, name: &str, value: &str) { if let NodeData::Element { attributes, .. } = &mut self.nodes[node.0].data { - if let Some(attr) = attributes.iter_mut().find(|a| a.name == name) { + if let Some(attr) = attributes.iter_mut().find(|a| *a.name == *name) { attr.value = value.to_string(); } else { attributes.push(Attribute { - name: name.to_string(), + name: Atom::new(name), value: value.to_string(), }); } @@ -261,7 +271,7 @@ impl Document { pub fn remove_attribute(&mut self, node: NodeId, name: &str) -> bool { if let NodeData::Element { attributes, .. } = &mut self.nodes[node.0].data { let len_before = attributes.len(); - attributes.retain(|a| a.name != name); + attributes.retain(|a| *a.name != *name); attributes.len() < len_before } else { false @@ -416,6 +426,46 @@ impl Document { self.nodes[node.0].prev_sibling = None; self.nodes[node.0].next_sibling = None; } + + /// Estimated heap bytes used by the DOM tree. + pub fn memory_usage(&self) -> usize { + let node_struct_size = std::mem::size_of::(); + let vec_overhead = self.nodes.capacity() * node_struct_size; + let string_bytes: usize = self.nodes.iter().map(|n| node_heap_bytes(&n.data)).sum(); + vec_overhead + string_bytes + } + + /// Number of element nodes in the tree. + pub fn element_count(&self) -> usize { + self.nodes + .iter() + .filter(|n| matches!(n.data, NodeData::Element { .. })) + .count() + } + + /// Number of text nodes in the tree. + pub fn text_node_count(&self) -> usize { + self.nodes + .iter() + .filter(|n| matches!(n.data, NodeData::Text { .. })) + .count() + } +} + +/// Heap bytes used by a NodeData's dynamic fields. +fn node_heap_bytes(data: &NodeData) -> usize { + match data { + NodeData::Document => 0, + NodeData::Element { attributes, .. } => { + // Atom tag_name and namespace share allocations via Rc, so we don't + // count them here — they're tracked by the interner. + let attrs: usize = attributes.iter().map(|a| a.value.capacity()).sum(); + let attr_vec = attributes.capacity() * std::mem::size_of::(); + attrs + attr_vec + } + NodeData::Text { data } => data.capacity(), + NodeData::Comment { data } => data.capacity(), + } } impl Default for Document { @@ -448,7 +498,7 @@ mod tests { fn new_document_has_root() { let doc = Document::new(); assert_eq!(doc.root(), NodeId(0)); - assert_eq!(*doc.node_data(doc.root()), NodeData::Document); + assert!(matches!(doc.node_data(doc.root()), NodeData::Document)); assert!(doc.children(doc.root()).next().is_none()); } @@ -902,4 +952,20 @@ mod tests { assert_eq!(children, vec![comment, div]); assert_eq!(doc.text_content(comment), Some("TODO: add content")); } + + #[test] + fn atom_interning_shares_memory() { + let mut doc = Document::new(); + let div1 = doc.create_element("div"); + let div2 = doc.create_element("div"); + // Both should have the same tag name + assert_eq!(doc.tag_name(div1), doc.tag_name(div2)); + // And the atoms should share the same Rc allocation + match (doc.node_data(div1), doc.node_data(div2)) { + (NodeData::Element { tag_name: t1, .. }, NodeData::Element { tag_name: t2, .. }) => { + assert!(t1.ptr_eq(t2)); + } + _ => panic!("expected elements"), + } + } } diff --git a/crates/js/src/dom_bridge.rs b/crates/js/src/dom_bridge.rs index 3065fc6..7b5c696 100644 --- a/crates/js/src/dom_bridge.rs +++ b/crates/js/src/dom_bridge.rs @@ -1199,7 +1199,7 @@ pub fn resolve_dom_get( let mut attr_obj = ObjectData::new(); attr_obj.insert_property( "name".to_string(), - Property::data(Value::String(attr.name.clone())), + Property::data(Value::String(attr.name.to_string())), shapes, ); attr_obj.insert_property( diff --git a/crates/js/src/gc.rs b/crates/js/src/gc.rs index 70f8421..b062c78 100644 --- a/crates/js/src/gc.rs +++ b/crates/js/src/gc.rs @@ -70,6 +70,15 @@ pub struct Gc { /// Initial collection threshold. const INITIAL_THRESHOLD: usize = 256; +/// Minimum growth factor after collection (1.5x = less memory pressure than 2x). +const MIN_GROWTH_FACTOR: f64 = 1.5; + +/// Maximum threshold to avoid unbounded growth. +const MAX_THRESHOLD: usize = 1 << 20; // ~1M objects + +/// If free slots exceed this ratio of total slots, compact the heap. +const COMPACT_RATIO: f64 = 0.5; + impl Gc { /// Create a new, empty GC heap. pub fn new() -> Self { @@ -136,9 +145,33 @@ impl Gc { self.sweep(); self.collections += 1; - // Grow threshold so we don't collect too often. - if self.live_count >= self.threshold { - self.threshold = self.live_count * 2; + // Adaptive threshold: use 1.5x growth factor instead of 2x to reduce + // peak memory. Cap at MAX_THRESHOLD to prevent unbounded growth. + let next = ((self.live_count as f64) * MIN_GROWTH_FACTOR) as usize; + self.threshold = next.clamp(INITIAL_THRESHOLD, MAX_THRESHOLD); + + // Compact the heap if the free list is disproportionately large. + // This reclaims memory when many objects were freed. + if self.heap.len() > INITIAL_THRESHOLD { + let free_ratio = self.free_list.len() as f64 / self.heap.len() as f64; + if free_ratio > COMPACT_RATIO { + self.compact(); + } + } + } + + /// Compact the heap by removing trailing free slots and rebuilding the free list. + fn compact(&mut self) { + // Trim trailing None slots. + while self.heap.last().is_some_and(|s| s.is_none()) { + self.heap.pop(); + } + // Rebuild the free list from remaining None slots. + self.free_list.clear(); + for (i, slot) in self.heap.iter().enumerate() { + if slot.is_none() { + self.free_list.push(i as u32); + } } } @@ -151,6 +184,19 @@ impl Gc { } } + /// Estimated heap bytes used by the GC. + pub fn memory_usage(&self) -> usize { + let slot_size = std::mem::size_of::>>(); + let heap_vec = self.heap.capacity() * slot_size; + let free_list = self.free_list.capacity() * std::mem::size_of::(); + heap_vec + free_list + } + + /// Current collection threshold. + pub fn threshold(&self) -> usize { + self.threshold + } + /// Mark phase: starting from roots, color all reachable objects black. fn mark(&mut self, roots: &[GcRef]) { let mut gray_stack: Vec = Vec::new(); diff --git a/crates/layout/src/lib.rs b/crates/layout/src/lib.rs index 5634cc9..2e949b3 100644 --- a/crates/layout/src/lib.rs +++ b/crates/layout/src/lib.rs @@ -295,12 +295,22 @@ impl<'a> Iterator for LayoutBoxIter<'a> { } } +/// Hints from the previous frame's layout, used to pre-allocate +/// buffers and avoid repeated allocations across frames. +#[derive(Debug, Clone, Default)] +pub struct LayoutHints { + /// Number of layout boxes in the previous frame. + pub prev_box_count: usize, +} + /// The result of laying out a document. #[derive(Debug)] pub struct LayoutTree { pub root: LayoutBox, pub width: f32, pub height: f32, + /// Hints for the next layout pass. + pub hints: LayoutHints, } impl LayoutTree { @@ -308,6 +318,51 @@ impl LayoutTree { pub fn iter(&self) -> LayoutBoxIter<'_> { self.root.iter() } + + /// Total number of layout boxes in the tree. + pub fn box_count(&self) -> usize { + self.root.iter().count() + } + + /// Estimated heap bytes used by the layout tree. + pub fn memory_usage(&self) -> usize { + self.root.memory_usage() + } +} + +impl LayoutBox { + /// Estimated heap bytes used by this box and all its descendants. + pub fn memory_usage(&self) -> usize { + let self_size = std::mem::size_of::(); + let children_vec = self.children.capacity() * std::mem::size_of::(); + let lines_vec = self.lines.capacity() * std::mem::size_of::(); + let line_strings: usize = self.lines.iter().map(|l| l.text.capacity()).sum(); + let box_type_strings = match &self.box_type { + BoxType::TextRun { text, .. } => text.capacity(), + _ => 0, + }; + let grid_vecs = self.grid_template_columns.capacity() + * std::mem::size_of::() + + self.grid_template_rows.capacity() * std::mem::size_of::() + + self + .grid_template_areas + .iter() + .map(|row| { + row.capacity() * std::mem::size_of::() + + row.iter().map(|s| s.capacity()).sum::() + }) + .sum::() + + self.grid_template_areas.capacity() * std::mem::size_of::>(); + let children_deep: usize = self.children.iter().map(|c| c.memory_usage()).sum(); + + self_size + + children_vec + + lines_vec + + line_strings + + box_type_strings + + grid_vecs + + children_deep + } } // --------------------------------------------------------------------------- @@ -3627,6 +3682,7 @@ pub fn layout( root: LayoutBox::new(BoxType::Anonymous, &ComputedStyle::default()), width: viewport_width, height: 0.0, + hints: LayoutHints::default(), }; } }; @@ -3655,10 +3711,14 @@ pub fn layout( ); let height = root.margin_box_height(); + let box_count = root.iter().count(); LayoutTree { root, width: viewport_width, height, + hints: LayoutHints { + prev_box_count: box_count, + }, } } diff --git a/crates/memory/Cargo.toml b/crates/memory/Cargo.toml new file mode 100644 index 0000000..ac8da6e --- /dev/null +++ b/crates/memory/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "we-memory" +version = "0.1.0" +edition.workspace = true +license.workspace = true + +[dependencies] diff --git a/crates/memory/src/arena.rs b/crates/memory/src/arena.rs new file mode 100644 index 0000000..c35fef6 --- /dev/null +++ b/crates/memory/src/arena.rs @@ -0,0 +1,177 @@ +//! Typed bump arena: allocate many objects, free all at once. +//! +//! `Arena` stores objects in a contiguous `Vec`, returning `ArenaId` +//! handles. Clearing the arena resets the length but preserves capacity, +//! making subsequent layout passes allocation-free when the page hasn't grown. + +use std::fmt; + +/// A handle to an object in an `Arena`. +#[derive(Clone, Copy, PartialEq, Eq, Hash)] +pub struct ArenaId(u32); + +impl ArenaId { + /// The underlying index. + pub fn index(self) -> usize { + self.0 as usize + } + + /// Create from a raw index. + pub fn from_raw(index: u32) -> Self { + ArenaId(index) + } +} + +impl fmt::Debug for ArenaId { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "ArenaId({})", self.0) + } +} + +/// A typed bump arena. Objects are allocated sequentially and freed all at once. +pub struct Arena { + items: Vec, +} + +impl Arena { + /// Create an empty arena. + pub fn new() -> Self { + Self { items: Vec::new() } + } + + /// Create an arena with pre-allocated capacity. + pub fn with_capacity(cap: usize) -> Self { + Self { + items: Vec::with_capacity(cap), + } + } + + /// Allocate an item in the arena, returning its handle. + pub fn alloc(&mut self, item: T) -> ArenaId { + let id = self.items.len() as u32; + self.items.push(item); + ArenaId(id) + } + + /// Get a reference to an item by its handle. + pub fn get(&self, id: ArenaId) -> &T { + &self.items[id.0 as usize] + } + + /// Get a mutable reference to an item by its handle. + pub fn get_mut(&mut self, id: ArenaId) -> &mut T { + &mut self.items[id.0 as usize] + } + + /// Number of items in the arena. + pub fn len(&self) -> usize { + self.items.len() + } + + /// Returns true if the arena is empty. + pub fn is_empty(&self) -> bool { + self.items.is_empty() + } + + /// Current capacity (number of items that can be held without reallocation). + pub fn capacity(&self) -> usize { + self.items.capacity() + } + + /// Clear all items, keeping the allocated memory for reuse. + pub fn clear(&mut self) { + self.items.clear(); + } + + /// Estimated heap bytes used by the arena. + pub fn memory_usage(&self) -> usize { + self.items.capacity() * std::mem::size_of::() + } + + /// Iterate over all items. + pub fn iter(&self) -> impl Iterator { + self.items.iter() + } + + /// Iterate over all items mutably. + pub fn iter_mut(&mut self) -> impl Iterator { + self.items.iter_mut() + } +} + +impl Default for Arena { + fn default() -> Self { + Self::new() + } +} + +impl fmt::Debug for Arena { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Arena") + .field("len", &self.items.len()) + .field("capacity", &self.items.capacity()) + .finish() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn alloc_and_get() { + let mut arena = Arena::new(); + let a = arena.alloc(42i32); + let b = arena.alloc(99); + + assert_eq!(*arena.get(a), 42); + assert_eq!(*arena.get(b), 99); + assert_eq!(arena.len(), 2); + } + + #[test] + fn clear_preserves_capacity() { + let mut arena = Arena::new(); + for i in 0..100 { + arena.alloc(i); + } + let cap = arena.capacity(); + arena.clear(); + assert_eq!(arena.len(), 0); + assert_eq!(arena.capacity(), cap); + } + + #[test] + fn mutate() { + let mut arena = Arena::new(); + let id = arena.alloc(10); + *arena.get_mut(id) = 20; + assert_eq!(*arena.get(id), 20); + } + + #[test] + fn with_capacity() { + let arena = Arena::::with_capacity(100); + assert!(arena.capacity() >= 100); + assert!(arena.is_empty()); + } + + #[test] + fn memory_usage_scales() { + let mut arena = Arena::new(); + for i in 0..50u64 { + arena.alloc(i); + } + assert!(arena.memory_usage() >= 50 * std::mem::size_of::()); + } + + #[test] + fn iter() { + let mut arena = Arena::new(); + arena.alloc(1); + arena.alloc(2); + arena.alloc(3); + let v: Vec<_> = arena.iter().copied().collect(); + assert_eq!(v, vec![1, 2, 3]); + } +} diff --git a/crates/memory/src/compact_string.rs b/crates/memory/src/compact_string.rs new file mode 100644 index 0000000..19a5682 --- /dev/null +++ b/crates/memory/src/compact_string.rs @@ -0,0 +1,273 @@ +//! Small-string optimization: inline storage for strings up to 22 bytes. +//! +//! `CompactString` avoids heap allocation for short strings (class names, IDs, +//! short attribute values). Strings longer than 22 bytes fall back to a regular +//! `String`. The enum representation is safe Rust (no `unsafe`). + +use std::fmt; +use std::hash::{Hash, Hasher}; + +/// Maximum number of bytes that can be stored inline. +const INLINE_CAP: usize = 22; + +/// A string that stores short values inline (up to 22 bytes) and falls back +/// to heap allocation for longer strings. +#[derive(Clone)] +pub enum CompactString { + /// Strings up to 22 bytes stored inline (no heap allocation). + Inline { len: u8, data: [u8; INLINE_CAP] }, + /// Longer strings stored on the heap. + Heap(String), +} + +impl CompactString { + /// Create a new `CompactString` from a `&str`. + pub fn new(s: &str) -> Self { + if s.len() <= INLINE_CAP { + let mut data = [0u8; INLINE_CAP]; + data[..s.len()].copy_from_slice(s.as_bytes()); + CompactString::Inline { + len: s.len() as u8, + data, + } + } else { + CompactString::Heap(s.to_string()) + } + } + + /// Borrow the string contents as a `&str`. + pub fn as_str(&self) -> &str { + match self { + CompactString::Inline { len, data } => { + let bytes = &data[..*len as usize]; + // Safety: we only ever store valid UTF-8 (from &str input). + // This is guaranteed by construction — new() only accepts &str. + std::str::from_utf8(bytes).expect("CompactString: invalid UTF-8") + } + CompactString::Heap(s) => s.as_str(), + } + } + + /// Returns true if the string is stored inline. + pub fn is_inline(&self) -> bool { + matches!(self, CompactString::Inline { .. }) + } + + /// Length in bytes. + pub fn len(&self) -> usize { + match self { + CompactString::Inline { len, .. } => *len as usize, + CompactString::Heap(s) => s.len(), + } + } + + /// Returns true if the string is empty. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Estimated heap bytes used (0 for inline strings). + pub fn heap_bytes(&self) -> usize { + match self { + CompactString::Inline { .. } => 0, + CompactString::Heap(s) => s.capacity(), + } + } +} + +impl Default for CompactString { + fn default() -> Self { + CompactString::Inline { + len: 0, + data: [0; INLINE_CAP], + } + } +} + +impl From<&str> for CompactString { + fn from(s: &str) -> Self { + CompactString::new(s) + } +} + +impl From for CompactString { + fn from(s: String) -> Self { + if s.len() <= INLINE_CAP { + CompactString::new(&s) + } else { + CompactString::Heap(s) + } + } +} + +impl AsRef for CompactString { + fn as_ref(&self) -> &str { + self.as_str() + } +} + +impl std::ops::Deref for CompactString { + type Target = str; + fn deref(&self) -> &str { + self.as_str() + } +} + +impl fmt::Debug for CompactString { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(self.as_str(), f) + } +} + +impl fmt::Display for CompactString { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(self.as_str()) + } +} + +impl PartialEq for CompactString { + fn eq(&self, other: &Self) -> bool { + self.as_str() == other.as_str() + } +} + +impl Eq for CompactString {} + +impl PartialEq for CompactString { + fn eq(&self, other: &str) -> bool { + self.as_str() == other + } +} + +impl PartialEq<&str> for CompactString { + fn eq(&self, other: &&str) -> bool { + self.as_str() == *other + } +} + +impl PartialEq for CompactString { + fn eq(&self, other: &String) -> bool { + self.as_str() == other.as_str() + } +} + +impl PartialOrd for CompactString { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for CompactString { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.as_str().cmp(other.as_str()) + } +} + +impl Hash for CompactString { + fn hash(&self, state: &mut H) { + self.as_str().hash(state); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn short_string_is_inline() { + let s = CompactString::new("div"); + assert!(s.is_inline()); + assert_eq!(s.as_str(), "div"); + assert_eq!(s.len(), 3); + assert_eq!(s.heap_bytes(), 0); + } + + #[test] + fn exactly_22_bytes_is_inline() { + let s = CompactString::new("abcdefghijklmnopqrstuv"); // 22 chars + assert!(s.is_inline()); + assert_eq!(s.as_str(), "abcdefghijklmnopqrstuv"); + } + + #[test] + fn long_string_is_heap() { + let s = CompactString::new("abcdefghijklmnopqrstuvw"); // 23 chars + assert!(!s.is_inline()); + assert_eq!(s.as_str(), "abcdefghijklmnopqrstuvw"); + assert!(s.heap_bytes() > 0); + } + + #[test] + fn empty_string() { + let s = CompactString::new(""); + assert!(s.is_inline()); + assert!(s.is_empty()); + assert_eq!(s.len(), 0); + } + + #[test] + fn equality() { + let a = CompactString::new("hello"); + let b = CompactString::new("hello"); + let c = CompactString::new("world"); + assert_eq!(a, b); + assert_ne!(a, c); + assert_eq!(a, "hello"); + } + + #[test] + fn from_string() { + let s = CompactString::from("short".to_string()); + assert!(s.is_inline()); + + let long = "a".repeat(30); + let s = CompactString::from(long.clone()); + assert!(!s.is_inline()); + assert_eq!(s.as_str(), long); + } + + #[test] + fn clone_preserves_variant() { + let a = CompactString::new("inline"); + let b = a.clone(); + assert!(b.is_inline()); + assert_eq!(a, b); + } + + #[test] + fn display_and_debug() { + let s = CompactString::new("test"); + assert_eq!(format!("{s}"), "test"); + assert_eq!(format!("{s:?}"), "\"test\""); + } + + #[test] + fn default_is_empty() { + let s = CompactString::default(); + assert!(s.is_empty()); + assert!(s.is_inline()); + } + + #[test] + fn hash_matches_str() { + use std::collections::hash_map::DefaultHasher; + + let text = "hello"; + let cs = CompactString::new(text); + + let mut h1 = DefaultHasher::new(); + cs.hash(&mut h1); + + let mut h2 = DefaultHasher::new(); + text.hash(&mut h2); + + assert_eq!(h1.finish(), h2.finish()); + } + + #[test] + fn deref_to_str() { + let s = CompactString::new("slice me"); + assert!(s.starts_with("slice")); + assert!(s.ends_with("me")); + } +} diff --git a/crates/memory/src/intern.rs b/crates/memory/src/intern.rs new file mode 100644 index 0000000..af3ed2c --- /dev/null +++ b/crates/memory/src/intern.rs @@ -0,0 +1,257 @@ +//! String interning: deduplicate repeated strings (tag names, attribute names, +//! CSS property names) by mapping them to compact `Atom` handles. +//! +//! An `Atom` wraps an `Rc`, so identical strings share a single heap +//! allocation. `Atom` dereferences to `&str` for seamless use in comparisons, +//! pattern matching, and string methods. + +use std::cell::RefCell; +use std::collections::HashMap; +use std::fmt; +use std::hash::{Hash, Hasher}; +use std::ops::Deref; +use std::rc::Rc; + +/// An interned, reference-counted string. +/// +/// - 8 bytes on the stack (single `Rc` pointer). +/// - Identical strings share a single heap allocation. +/// - Dereferences to `&str` — works naturally with `.eq_ignore_ascii_case()`, +/// pattern matching, `match atom.as_ref()`, etc. +/// - Cloning is O(1) (increments a reference count). +#[derive(Clone)] +pub struct Atom(Rc); + +impl Atom { + /// Create an atom from a string slice, interning it globally. + pub fn new(s: &str) -> Self { + intern(s) + } + + /// Create an atom without interning (private allocation). + /// Use this only when you know the string is unique and short-lived. + pub fn from_string(s: String) -> Self { + Atom(Rc::from(s.as_str())) + } + + /// Get the string contents. + pub fn as_str(&self) -> &str { + &self.0 + } + + /// Pointer-based identity check: true if both atoms point to the same + /// underlying allocation. Faster than string comparison. + pub fn ptr_eq(&self, other: &Atom) -> bool { + Rc::ptr_eq(&self.0, &other.0) + } +} + +impl Deref for Atom { + type Target = str; + fn deref(&self) -> &str { + &self.0 + } +} + +impl AsRef for Atom { + fn as_ref(&self) -> &str { + &self.0 + } +} + +impl PartialEq for Atom { + fn eq(&self, other: &Self) -> bool { + // Fast path: same pointer means same string. + Rc::ptr_eq(&self.0, &other.0) || *self.0 == *other.0 + } +} + +impl Eq for Atom {} + +impl PartialEq for Atom { + fn eq(&self, other: &str) -> bool { + self.as_str() == other + } +} + +impl PartialEq<&str> for Atom { + fn eq(&self, other: &&str) -> bool { + self.as_str() == *other + } +} + +impl PartialEq for Atom { + fn eq(&self, other: &String) -> bool { + self.as_str() == other.as_str() + } +} + +impl PartialEq for str { + fn eq(&self, other: &Atom) -> bool { + self == other.as_str() + } +} + +impl PartialEq for &str { + fn eq(&self, other: &Atom) -> bool { + *self == other.as_str() + } +} + +impl Hash for Atom { + fn hash(&self, state: &mut H) { + self.as_str().hash(state); + } +} + +impl fmt::Debug for Atom { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(self.as_str(), f) + } +} + +impl fmt::Display for Atom { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(self.as_str()) + } +} + +impl From<&str> for Atom { + fn from(s: &str) -> Self { + intern(s) + } +} + +impl From for Atom { + fn from(s: String) -> Self { + intern(&s) + } +} + +// --------------------------------------------------------------------------- +// Global intern table +// --------------------------------------------------------------------------- + +thread_local! { + static INTERN_TABLE: RefCell, Rc>> = RefCell::new(HashMap::new()); +} + +/// Intern a string, returning a shared `Atom`. If the string was already +/// interned, returns a clone of the existing `Rc` (no new allocation). +pub fn intern(s: &str) -> Atom { + INTERN_TABLE.with(|table| { + let mut table = table.borrow_mut(); + if let Some(existing) = table.get(s) { + return Atom(Rc::clone(existing)); + } + let rc: Rc = Rc::from(s); + table.insert(Box::from(s), Rc::clone(&rc)); + Atom(rc) + }) +} + +/// Number of unique interned strings. +pub fn interned_count() -> usize { + INTERN_TABLE.with(|table| table.borrow().len()) +} + +/// Estimated heap bytes used by the global intern table. +pub fn interner_memory_usage() -> usize { + INTERN_TABLE.with(|table| { + let table = table.borrow(); + let overhead = table.capacity() + * (std::mem::size_of::>() + std::mem::size_of::>() + 8); + let strings: usize = table.keys().map(|k| k.len()).sum(); + // Each Rc has a header (strong + weak counts) + string data. + // The Box key duplicates the string data. + overhead + strings * 2 + table.len() * 16 + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn intern_deduplicates() { + let a = intern("div"); + let b = intern("div"); + let c = intern("span"); + + assert!(a.ptr_eq(&b)); + assert!(!a.ptr_eq(&c)); + } + + #[test] + fn equality_with_str() { + let a = intern("hello"); + assert_eq!(a, "hello"); + assert_eq!("hello", a); + assert_eq!(a, *"hello"); + assert_ne!(a, "world"); + } + + #[test] + fn deref_to_str() { + let a = intern("test"); + assert!(a.starts_with("te")); + assert!(a.ends_with("st")); + assert_eq!(a.len(), 4); + assert!(a.eq_ignore_ascii_case("TEST")); + } + + #[test] + fn display_and_debug() { + let a = intern("foo"); + assert_eq!(format!("{a}"), "foo"); + assert_eq!(format!("{a:?}"), "\"foo\""); + } + + #[test] + fn clone_is_cheap() { + let a = intern("shared"); + let b = a.clone(); + assert!(a.ptr_eq(&b)); + } + + #[test] + fn from_string() { + let a = Atom::from("div".to_string()); + let b = intern("div"); + assert_eq!(a, b); + } + + #[test] + fn hash_consistent_with_str() { + use std::collections::hash_map::DefaultHasher; + + let text = "hello"; + let atom = intern(text); + + let mut h1 = DefaultHasher::new(); + atom.hash(&mut h1); + + let mut h2 = DefaultHasher::new(); + text.hash(&mut h2); + + assert_eq!(h1.finish(), h2.finish()); + } + + #[test] + fn interned_count_tracks() { + let before = interned_count(); + let _ = intern("unique_test_string_1234"); + assert!(interned_count() > before); + } + + #[test] + fn match_on_as_ref() { + let atom = intern("div"); + let result = match atom.as_ref() { + "div" => "found div", + "span" => "found span", + _ => "other", + }; + assert_eq!(result, "found div"); + } +} diff --git a/crates/memory/src/lib.rs b/crates/memory/src/lib.rs new file mode 100644 index 0000000..f1dd028 --- /dev/null +++ b/crates/memory/src/lib.rs @@ -0,0 +1,9 @@ +//! Memory profiling, string interning, compact strings, and arena allocation. +//! +//! Standalone crate (no workspace dependencies). Provides shared memory +//! optimization primitives used across the browser engine. + +pub mod arena; +pub mod compact_string; +pub mod intern; +pub mod stats; diff --git a/crates/memory/src/stats.rs b/crates/memory/src/stats.rs new file mode 100644 index 0000000..3b5739a --- /dev/null +++ b/crates/memory/src/stats.rs @@ -0,0 +1,126 @@ +//! Memory accounting: per-subsystem statistics. + +use std::fmt; + +/// Memory statistics for a single subsystem. +#[derive(Debug, Clone, Default)] +pub struct SubsystemStats { + /// Human-readable name of the subsystem. + pub name: &'static str, + /// Number of live objects/items. + pub item_count: usize, + /// Estimated heap bytes used by this subsystem. + pub estimated_bytes: usize, + /// Additional key-value details (e.g. cache hit rate, utilization). + pub details: Vec<(&'static str, String)>, +} + +impl SubsystemStats { + pub fn new(name: &'static str) -> Self { + Self { + name, + item_count: 0, + estimated_bytes: 0, + details: Vec::new(), + } + } + + pub fn with_count(mut self, count: usize) -> Self { + self.item_count = count; + self + } + + pub fn with_bytes(mut self, bytes: usize) -> Self { + self.estimated_bytes = bytes; + self + } + + pub fn with_detail(mut self, key: &'static str, value: impl fmt::Display) -> Self { + self.details.push((key, value.to_string())); + self + } +} + +/// Aggregated memory statistics across all browser subsystems. +#[derive(Debug, Clone, Default)] +pub struct MemoryReport { + pub subsystems: Vec, +} + +impl MemoryReport { + pub fn new() -> Self { + Self { + subsystems: Vec::new(), + } + } + + pub fn add(&mut self, stats: SubsystemStats) { + self.subsystems.push(stats); + } + + /// Total estimated bytes across all subsystems. + pub fn total_bytes(&self) -> usize { + self.subsystems.iter().map(|s| s.estimated_bytes).sum() + } +} + +impl fmt::Display for MemoryReport { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + writeln!(f, "=== Memory Report ===")?; + writeln!(f)?; + for sub in &self.subsystems { + writeln!( + f, + "{}: {} items, {} bytes ({:.1} KB)", + sub.name, + sub.item_count, + sub.estimated_bytes, + sub.estimated_bytes as f64 / 1024.0, + )?; + for (key, val) in &sub.details { + writeln!(f, " {key}: {val}")?; + } + } + writeln!(f)?; + writeln!( + f, + "Total: {} bytes ({:.1} KB)", + self.total_bytes(), + self.total_bytes() as f64 / 1024.0, + )?; + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn report_total() { + let mut report = MemoryReport::new(); + report.add(SubsystemStats::new("DOM").with_bytes(1000).with_count(10)); + report.add( + SubsystemStats::new("Layout") + .with_bytes(2000) + .with_count(20), + ); + assert_eq!(report.total_bytes(), 3000); + } + + #[test] + fn report_display() { + let mut report = MemoryReport::new(); + report.add( + SubsystemStats::new("DOM") + .with_bytes(1024) + .with_count(5) + .with_detail("elements", 3) + .with_detail("text_nodes", 2), + ); + let s = format!("{report}"); + assert!(s.contains("DOM")); + assert!(s.contains("1024 bytes")); + assert!(s.contains("elements: 3")); + } +} diff --git a/crates/net/src/client.rs b/crates/net/src/client.rs index 49f5275..aff8882 100644 --- a/crates/net/src/client.rs +++ b/crates/net/src/client.rs @@ -244,6 +244,32 @@ impl HttpClient { } } + /// Estimated heap bytes used by the HTTP client's connection pool and buffers. + pub fn memory_usage(&self) -> usize { + use std::mem::size_of; + let pool_conns: usize = self + .pool + .connections + .iter() + .map(|(k, v)| k.host.capacity() + v.capacity() * size_of::()) + .sum(); + let pool_overhead = self.pool.connections.capacity() + * (size_of::() + size_of::>() + 8); + let h2_conns = self.h2_connections.capacity() * (size_of::() + 256); // estimate for Http2Connection + let h2_keys: usize = self.h2_connections.keys().map(|k| k.host.capacity()).sum(); + pool_conns + pool_overhead + h2_conns + h2_keys + } + + /// Number of pooled idle HTTP/1.1 connections. + pub fn pooled_connection_count(&self) -> usize { + self.pool.connections.values().map(|v| v.len()).sum() + } + + /// Number of active HTTP/2 connections. + pub fn h2_connection_count(&self) -> usize { + self.h2_connections.len() + } + /// Get a reference to the cookie jar. pub fn cookie_jar(&self) -> &CookieJar { &self.cookie_jar diff --git a/crates/render/src/atlas.rs b/crates/render/src/atlas.rs index a39dc06..23e8742 100644 --- a/crates/render/src/atlas.rs +++ b/crates/render/src/atlas.rs @@ -315,6 +315,41 @@ impl GlyphAtlas { self.entries.clear(); } + /// Estimated heap bytes used by the atlas (pixel data + metadata). + pub fn memory_usage(&self) -> usize { + let page_pixels: usize = self.pages.iter().map(|p| p.pixels.capacity()).sum(); + let page_shelves: usize = self + .pages + .iter() + .map(|p| p.shelves.capacity() * std::mem::size_of::()) + .sum(); + let page_structs = self.pages.capacity() * std::mem::size_of::(); + let entry_map = self.entries.capacity() + * (std::mem::size_of::() + std::mem::size_of::() + 8); + page_pixels + page_shelves + page_structs + entry_map + } + + /// Utilization percentage: fraction of allocated atlas pixels actually used by glyphs. + pub fn utilization(&self) -> f32 { + if self.pages.is_empty() { + return 0.0; + } + let total_pixels: u64 = self + .pages + .iter() + .map(|p| p.width as u64 * p.height as u64) + .sum(); + if total_pixels == 0 { + return 0.0; + } + let used_pixels: u64 = self + .entries + .values() + .map(|r| r.width as u64 * r.height as u64) + .sum(); + (used_pixels as f32 / total_pixels as f32) * 100.0 + } + /// Build textured quads for a `TextLine`, inserting any missing glyphs. /// /// Each glyph in the text becomes a `TexturedQuad` with UV coordinates diff --git a/crates/render/src/layer.rs b/crates/render/src/layer.rs index f4ffa6a..8539b12 100644 --- a/crates/render/src/layer.rs +++ b/crates/render/src/layer.rs @@ -15,7 +15,9 @@ use we_dom::NodeId; use we_layout::{LayoutBox, LayoutTree, Rect}; use we_style::computed::{Overflow, Position, Visibility}; -use crate::{build_display_list_with_page_scroll, node_id_from_box_type, DisplayList, ScrollState}; +use crate::{ + build_display_list_into, node_id_from_box_type, DisplayList, PaintCommand, ScrollState, +}; // --------------------------------------------------------------------------- // Damage rectangles @@ -290,9 +292,13 @@ impl LayerTree { /// After calling this, use [`damage_rects`] to query which regions need /// repainting, and [`display_list`] to get the full display list. pub fn update(&mut self, tree: &LayoutTree, page_scroll_y: f32, scroll_state: &ScrollState) { - // Always rebuild the full display list. - let new_list = build_display_list_with_page_scroll(tree, page_scroll_y, scroll_state); - self.cached_display_list = new_list; + // Reuse the display list buffer: clear and refill instead of drop and alloc. + build_display_list_into( + tree, + page_scroll_y, + scroll_state, + &mut self.cached_display_list, + ); if self.first_frame { let mut new_fingerprints = HashMap::new(); @@ -400,6 +406,32 @@ impl LayerTree { Some(rects) => !rects.is_empty(), } } + + /// Number of paint commands in the cached display list. + pub fn display_list_command_count(&self) -> usize { + self.cached_display_list.len() + } + + /// Estimated heap bytes used by the layer tree. + pub fn memory_usage(&self) -> usize { + use std::mem::size_of; + let fingerprints = self.prev_fingerprints.capacity() + * (size_of::() + size_of::() + 8); + let damage = self + .damage + .as_ref() + .map_or(0, |v| v.capacity() * size_of::()); + let display_list = self.cached_display_list.capacity() * size_of::(); + let dl_strings: usize = self + .cached_display_list + .iter() + .map(|cmd| match cmd { + PaintCommand::DrawGlyphs { line, .. } => line.text.capacity(), + _ => 0, + }) + .sum(); + fingerprints + damage + display_list + dl_strings + } } // --------------------------------------------------------------------------- diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs index f92963f..0a97b1d 100644 --- a/crates/render/src/lib.rs +++ b/crates/render/src/lib.rs @@ -129,6 +129,20 @@ pub fn build_display_list_with_page_scroll( list } +/// Build a display list into an existing buffer (clear + refill). +/// +/// Reuses the buffer's allocated capacity, avoiding repeated allocation +/// when the display list size is stable across frames. +pub fn build_display_list_into( + tree: &LayoutTree, + page_scroll_y: f32, + scroll_state: &ScrollState, + list: &mut DisplayList, +) { + list.clear(); + paint_box(&tree.root, list, (0.0, -page_scroll_y), scroll_state, 0.0); +} + /// Returns `true` if a box is positioned (absolute or fixed). fn is_positioned(b: &LayoutBox) -> bool { b.position == Position::Absolute || b.position == Position::Fixed diff --git a/crates/style/Cargo.toml b/crates/style/Cargo.toml index 55133de..610fc10 100644 --- a/crates/style/Cargo.toml +++ b/crates/style/Cargo.toml @@ -10,6 +10,7 @@ path = "src/lib.rs" [dependencies] we-dom = { path = "../dom" } we-css = { path = "../css" } +we-memory = { path = "../memory" } [dev-dependencies] we-html = { path = "../html" } diff --git a/crates/style/src/computed.rs b/crates/style/src/computed.rs index 3578890..8fce5e3 100644 --- a/crates/style/src/computed.rs +++ b/crates/style/src/computed.rs @@ -21,6 +21,7 @@ use we_css::transitions::{ }; use we_css::values::{expand_shorthand, parse_value, Color, CssValue, LengthUnit, MathExpr}; use we_dom::{Document, NodeData, NodeId}; +use we_memory::intern::Atom; use crate::matching::collect_matching_rules; @@ -64,6 +65,29 @@ impl StyleCache { misses: 0, } } + + /// Number of cached computed styles. + pub fn len(&self) -> usize { + self.entries.len() + } + + /// Returns true if the cache is empty. + pub fn is_empty(&self) -> bool { + self.entries.is_empty() + } + + /// Estimated heap bytes used by the cache. + pub fn memory_usage(&self) -> usize { + let entry_size = + std::mem::size_of::() + std::mem::size_of::<(ComputedStyle, u64)>(); + let map_overhead = self.entries.capacity() * (entry_size + 8); // 8 for hash bucket overhead + let style_strings: usize = self + .entries + .values() + .map(|(style, _)| style.heap_bytes()) + .sum(); + map_overhead + style_strings + } } /// Compute a 64-bit hash of the matched rule set. @@ -476,7 +500,7 @@ pub struct ComputedStyle { pub font_size: f32, pub font_weight: FontWeight, pub font_style: FontStyle, - pub font_family: String, + pub font_family: Atom, pub text_align: TextAlign, pub text_decoration: TextDecoration, pub line_height: f32, @@ -589,7 +613,7 @@ impl Default for ComputedStyle { font_size: 16.0, font_weight: FontWeight(400.0), font_style: FontStyle::Normal, - font_family: String::new(), + font_family: Atom::new(""), text_align: TextAlign::Left, text_decoration: TextDecoration::None, line_height: 19.2, // 1.2 * 16 @@ -648,6 +672,43 @@ impl Default for ComputedStyle { } } +impl ComputedStyle { + /// Estimated heap bytes used by dynamically-sized fields. + pub fn heap_bytes(&self) -> usize { + // font_family is an Atom (Rc), shared via interning — not counted here. + let grid_cols = + self.grid_template_columns.capacity() * std::mem::size_of::(); + let grid_rows = self.grid_template_rows.capacity() * std::mem::size_of::(); + let grid_areas: usize = self + .grid_template_areas + .iter() + .map(|row| { + row.capacity() * std::mem::size_of::() + + row.iter().map(|s| s.capacity()).sum::() + }) + .sum::() + + self.grid_template_areas.capacity() * std::mem::size_of::>(); + let transitions = + self.transition.transitions.capacity() * std::mem::size_of::(); + let animations = + self.animation.animations.capacity() * std::mem::size_of::(); + let anim_strings: usize = self + .animation + .animations + .iter() + .map(|a| a.name.capacity()) + .sum(); + let custom_props: usize = self + .custom_properties + .iter() + .map(|(k, v)| k.capacity() + v.capacity() * std::mem::size_of::()) + .sum::() + + self.custom_properties.capacity() + * (std::mem::size_of::() + std::mem::size_of::>() + 8); + grid_cols + grid_rows + grid_areas + transitions + animations + anim_strings + custom_props + } +} + // --------------------------------------------------------------------------- // Property classification: inherited vs non-inherited // --------------------------------------------------------------------------- @@ -1344,7 +1405,7 @@ fn apply_property( // Font-family (inherited) "font-family" => { if let CssValue::String(s) | CssValue::Keyword(s) = value { - style.font_family = s.clone(); + style.font_family = Atom::new(s); } } diff --git a/crates/text/src/font/cache.rs b/crates/text/src/font/cache.rs index 594e5cc..ae97000 100644 --- a/crates/text/src/font/cache.rs +++ b/crates/text/src/font/cache.rs @@ -49,6 +49,14 @@ impl GlyphCache { pub fn is_empty(&self) -> bool { self.entries.is_empty() } + + /// Estimated heap bytes used by cached bitmaps. + pub fn memory_usage(&self) -> usize { + let entry_overhead = self.entries.capacity() + * (std::mem::size_of::() + std::mem::size_of::() + 8); + let bitmap_data: usize = self.entries.values().map(|bm| bm.data.capacity()).sum(); + entry_overhead + bitmap_data + } } impl Default for GlyphCache {