Performance improvements

Author: togglebyte

CHANGES.md

@@ -1,6 +1,8 @@
 * 0.2.12
     * Clamping is now true by default on overflow
     * Globals can now be registered with the runtime
+    * `attributes.value_as::<T>` is now available on `Attributes`
+    * Performance improvements
 * 0.2.11
     * FEATURE: ranges 
     * `padding` function

Cargo.toml

@@ -31,7 +31,7 @@ anathema-testutils = { path = "anathema-testutils" }
 
 [features]
 default = []
-profile = ["anathema-runtime/profile", "anathema-widgets/profile", "anathema-backend/profile"]
+profile = ["anathema-runtime/profile", "anathema-widgets/profile", "anathema-backend/profile", "anathema-value-resolver/profile"]
 serde = ["anathema-state/serde", "anathema-store/serde"]
 # filelog = ["anathema-debug/filelog", "anathema-widgets/filelog", "anathema-runtime/filelog"]
 

anathema-backend/src/lib.rs

@@ -7,7 +7,9 @@ use anathema_widgets::components::events::Event;
 use anathema_widgets::error::Result;
 use anathema_widgets::layout::{Constraints, LayoutCtx, LayoutFilter, PositionFilter, Viewport};
 use anathema_widgets::paint::PaintFilter;
-use anathema_widgets::{GlyphMap, LayoutForEach, PaintChildren, PositionChildren, WidgetTreeView};
+use anathema_widgets::{
+    DirtyWidgets, GlyphMap, Layout, LayoutForEach, PaintChildren, PositionChildren, WidgetTreeView,
+};
 
 pub mod testing;
 pub mod tui;
@@ -55,14 +57,7 @@ impl<'rt, 'bp, T: Backend> WidgetCycle<'rt, 'bp, T> {
         }
     }
 
-    fn fixed(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
-        // -----------------------------------------------------------------------------
-        //   - Layout -
-        // -----------------------------------------------------------------------------
-        if needs_layout {
-            self.layout(ctx, LayoutFilter)?;
-        }
-
+    fn fixed(&mut self, ctx: &mut LayoutCtx<'_, 'bp>) -> Result<()> {
         // -----------------------------------------------------------------------------
         //   - Position -
         // -----------------------------------------------------------------------------
@@ -90,24 +85,107 @@ impl<'rt, 'bp, T: Backend> WidgetCycle<'rt, 'bp, T> {
         Ok(())
     }
 
-    pub fn run(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, needs_layout: bool) -> Result<()> {
-        self.fixed(ctx, needs_layout)?;
+    pub fn run(
+        &mut self,
+        ctx: &mut LayoutCtx<'_, 'bp>,
+        force_layout: bool,
+        dirty_widgets: &mut DirtyWidgets,
+    ) -> Result<()> {
+        // -----------------------------------------------------------------------------
+        //   - Layout -
+        // -----------------------------------------------------------------------------
+        self.layout(ctx, LayoutFilter, dirty_widgets, force_layout)?;
+
+        // -----------------------------------------------------------------------------
+        //   - Position and paint -
+        // -----------------------------------------------------------------------------
+        self.fixed(ctx)?;
         self.floating(ctx)?;
         Ok(())
     }
 
-    fn layout(&mut self, ctx: &mut LayoutCtx<'_, 'bp>, filter: LayoutFilter) -> Result<()> {
+    fn layout(
+        &mut self,
+        ctx: &mut LayoutCtx<'_, 'bp>,
+        filter: LayoutFilter,
+        dirty_widgets: &mut DirtyWidgets,
+        force_layout: bool,
+    ) -> Result<()> {
         #[cfg(feature = "profile")]
         puffin::profile_function!();
-        let tree = self.tree.view();
-
-        let scope = Scope::root();
-        let mut for_each = LayoutForEach::new(tree, &scope, filter, None);
-        let constraints = self.constraints;
-        _ = for_each.each(ctx, |ctx, widget, children| {
-            _ = widget.layout(children, constraints, ctx)?;
-            Ok(ControlFlow::Break(()))
-        })?;
+
+        let mut tree = self.tree.view();
+
+        if force_layout {
+            // Perform a layout across the entire tree
+            let scope = Scope::root();
+            let mut for_each = LayoutForEach::new(tree, &scope, filter);
+            let constraints = self.constraints;
+            _ = for_each.each(ctx, |ctx, widget, children| {
+                _ = widget.layout(children, constraints, ctx)?;
+                Ok(ControlFlow::Break(()))
+            })?;
+            return Ok(());
+        }
+
+        // If a widget has changed, mark the parent as dirty
+
+        // Layout only changed widgets.
+        // These are the parents of changed widgets.
+        //
+        // Investigate the possibility of attaching an offset as existing widgets don't need
+        // to reflow unless the constraint has changed.
+        //
+        // This means `additional_widgets` needs to store (key, offset) where offset can be None
+        //
+        // If this is going to work we need to consider `expand` and `spacer`
+        //
+        // Since widgets can be made by anyone and they are always guaranteed to give
+        // access to all their children this might not be a possibility.
+        //
+        // parent
+        //     widget 0
+        //     widget 1
+        //     widget 2 |  <- if this changes, only reflow this, three and four
+        //     widget 3 |-- reflow
+        //     widget 4 |
+
+        // TODO: make `additional_widgets` a scratch buffer part of `DirtyWidgets`.
+        //       Also ensure that it tracks last id as well
+        //       ... and removes it when done!
+        let mut additional_widgets = vec![];
+
+        loop {
+            for widget_id in dirty_widgets.drain() {
+                if !tree.contains(widget_id) {
+                    continue;
+                }
+                tree.with_value_mut(widget_id, |_, widget, children| {
+                    let scope = Scope::root();
+                    let mut children = LayoutForEach::new(children, &scope, filter);
+                    children.parent_element = Some(widget_id);
+                    let parent_id = widget.parent_widget;
+                    let anathema_widgets::WidgetKind::Element(widget) = &mut widget.kind else { return };
+
+                    let constraints = widget.constraints();
+                    if let Ok(Layout::Changed(_)) = widget.layout(children, constraints, ctx) {
+                        // write into scratch buffer
+                        if let Some(id) = parent_id {
+                            additional_widgets.push(id);
+                        }
+                    }
+                });
+            }
+
+            // merge the scratch if it's not empty
+
+            if additional_widgets.is_empty() {
+                break;
+            }
+
+            dirty_widgets.inner.append(&mut additional_widgets);
+        }
+
         Ok(())
     }
 

anathema-default-widgets/src/testing.rs

@@ -11,7 +11,7 @@ use anathema_widgets::layout::{Constraints, LayoutCtx, Viewport};
 use anathema_widgets::paint::{Glyph, paint};
 use anathema_widgets::query::{Children, Elements};
 use anathema_widgets::{
-    Components, Factory, FloatingWidgets, GlyphMap, Style, WidgetKind, WidgetRenderer, WidgetTree, eval_blueprint,
+    Components, DirtyWidgets, Factory, FloatingWidgets, GlyphMap, Style, WidgetRenderer, WidgetTree, eval_blueprint,
     update_widget,
 };
 
@@ -235,7 +235,7 @@ impl<'bp> TestInstance<'bp> {
             function_table,
         );
 
-        let mut ctx = ctx.eval_ctx(None);
+        let mut ctx = ctx.eval_ctx(None, None);
         let mut view = tree.view();
 
         eval_blueprint(blueprint, &mut ctx, &scope, &[], &mut view).unwrap();
@@ -291,11 +291,12 @@ impl<'bp> TestInstance<'bp> {
             sub.iter().for_each(|value_id| {
                 let widget_id = value_id.key();
 
-                if let Some(widget) = tree.get_mut(widget_id) {
-                    if let WidgetKind::Element(element) = &mut widget.kind {
-                        element.invalidate_cache();
-                    }
-                }
+                // TODO: review if this is still needed: - TB 2025-08-27
+                // if let Some(widget) = tree.get_mut(widget_id) {
+                //     if let WidgetKind::Element(element) = &mut widget.kind {
+                //         element.invalidate_cache();
+                //     }
+                // }
 
                 // check that the node hasn't already been removed
                 if !tree.contains(widget_id) {
@@ -304,7 +305,7 @@ impl<'bp> TestInstance<'bp> {
 
                 _ = tree
                     .with_value_mut(value_id.key(), |_path, widget, tree| {
-                        update_widget(widget, value_id, change, tree, &mut ctx)
+                        update_widget(widget, value_id, change, tree, &mut ctx, &mut DirtyWidgets::empty())
                     })
                     .unwrap();
             })
@@ -333,7 +334,7 @@ impl<'bp> TestInstance<'bp> {
         );
 
         let mut cycle = WidgetCycle::new(self.backend, self.tree.view(), constraints);
-        _ = cycle.run(&mut ctx, true);
+        _ = cycle.run(&mut ctx, true, &mut DirtyWidgets::empty());
 
         self.backend.render(&mut self.glyph_map);
 
@@ -355,8 +356,8 @@ impl<'bp> TestInstance<'bp> {
         // let path = &[0, 0, 0];
 
         let tree = self.tree.view();
-        let mut update = true;
-        let mut children = Children::new(tree, &mut self.attribute_storage, &mut update);
+        let mut dirty_widgets = DirtyWidgets::empty();
+        let mut children = Children::new(tree, &mut self.attribute_storage, &mut dirty_widgets);
         let elements = children.elements();
         f(elements);
         self

anathema-default-widgets/src/text.rs

@@ -97,8 +97,8 @@ impl Widget for Text {
             let Some(_span) = child.try_to_ref::<Span>() else {
                 return Ok(ControlFlow::Continue(()));
             };
-            self.strings.set_style(child.id());
 
+            self.strings.set_style(child.id());
             let attributes = ctx.attributes(child.id());
             if let Some(text) = attributes.value() {
                 text.strings(|s| match self.strings.add_str(s) {

anathema-geometry/src/region.rs

@@ -49,12 +49,19 @@ impl Region {
     }
 
     /// Check if a region contains a position.
-    /// Regions are exclusive, so a region from 0,0 to 10, 10 contains `Pos::ZERO`
+    /// The check is exclusive, so a region from 0,0 to 10, 10 contains `Pos::ZERO`
     /// but not `Pos::New(10, 10)`
     pub const fn contains(&self, pos: Pos) -> bool {
         pos.x >= self.from.x && pos.x < self.to.x && pos.y >= self.from.y && pos.y < self.to.y
     }
 
+    /// Check if a region contains a position.
+    /// The check is inclusive, so a region from 0,0 to 10, 10 contains `Pos::ZERO`
+    /// as well as `Pos::New(10, 10)`
+    pub const fn icontains(&self, pos: Pos) -> bool {
+        pos.x >= self.from.x && pos.x <= self.to.x && pos.y >= self.from.y && pos.y <= self.to.y
+    }
+
     /// Constrain a region to fit within another region
     pub fn constrain(&mut self, other: &Region) {
         self.from.x = self.from.x.max(other.from.x);