Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
gpui: Keep subscriptions for entities read by reused cached views (#65952)
Anthony Eiddecd2399b180
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rsindex e247dd45b4e..75da2eb6e50 100644--- a/crates/gpui/src/app.rs+++ b/crates/gpui/src/app.rs@@ -1460,16 +1460,9 @@ impl App {&mut self,callback: impl FnOnce(&mut App) -> R,) -> (R, FxHashSet<EntityId>) {- let accessed_entities_start = self.entities.accessed_entities.get_mut().clone();+ self.entities.push_access_scope();let result = callback(self);- let entities_accessed_in_callback = self- .entities- .accessed_entities- .get_mut()- .difference(&accessed_entities_start)- .copied()- .collect::<FxHashSet<EntityId>>();- (result, entities_accessed_in_callback)+ (result, self.entities.pop_access_scope())}pub(crate) fn record_entities_accessed(diff --git a/crates/gpui/src/app/entity_map.rs b/crates/gpui/src/app/entity_map.rsindex 129b30438e0..93e5be0bfa3 100644--- a/crates/gpui/src/app/entity_map.rs+++ b/crates/gpui/src/app/entity_map.rs@@ -11,6 +11,7 @@ use std::{fmt::{self, Display},hash::{Hash, Hasher},marker::PhantomData,+ mem,num::NonZeroU64,sync::{Arc, Weak,@@ -55,10 +56,32 @@ impl Display for EntityId {pub(crate) struct EntityMap {entities: SecondaryMap<EntityId, Box<dyn Any>>,- pub accessed_entities: RefCell<FxHashSet<EntityId>>,+ accessed_entities: RefCell<AccessedEntities>,ref_counts: Arc<RwLock<EntityRefCounts>>,}+/// The entities accessed during the current draw. An access is recorded only+/// in the innermost open scope, or in `frame` outside any scope, and a scope's+/// accesses are added to the one around it when it ends. Each scope therefore+/// collects exactly what was accessed inside it, without copying what the+/// draw accessed before it began, and `frame` ends up with every access.+struct AccessedEntities {+ /// Every entity accessed during the draw: the window subscribes to+ /// exactly this set when the draw ends. Accesses outside any scope land+ /// here directly, and a scope's accesses reach it when the outermost open+ /// scope ends. It is the innermost set only while no scope is open, and+ /// unlike a scope it is never ended.+ frame: FxHashSet<EntityId>,+ /// The scopes currently recording, innermost last.+ scopes: Vec<FxHashSet<EntityId>>,+}++impl AccessedEntities {+ fn innermost(&mut self) -> &mut FxHashSet<EntityId> {+ self.scopes.last_mut().unwrap_or(&mut self.frame)+ }+}+#[doc(hidden)]pub(crate) struct EntityRefCounts {counts: SlotMap<EntityId, AtomicUsize>,@@ -75,7 +98,10 @@ impl EntityMap {pub fn new() -> Self {Self {entities: SecondaryMap::new(),- accessed_entities: RefCell::new(FxHashSet::default()),+ accessed_entities: RefCell::new(AccessedEntities {+ frame: FxHashSet::default(),+ scopes: Vec::new(),+ }),ref_counts: Arc::new(RwLock::new(EntityRefCounts {counts: SlotMap::with_key(),dropped_entity_ids: Vec::new(),@@ -125,8 +151,10 @@ impl EntityMap {whereT: 'static,{- let accessed_entities = self.accessed_entities.get_mut();- accessed_entities.insert(slot.entity_id);+ self.accessed_entities+ .get_mut()+ .innermost()+ .insert(slot.entity_id);let handle = slot.0;self.entities.insert(handle.entity_id, Box::new(entity));@@ -177,14 +205,58 @@ impl EntityMap {);}- pub fn extend_accessed(&mut self, entities: &FxHashSet<EntityId>) {+ /// Records entities accessed by a reused draw. Entities released since it+ /// recorded them are skipped, because the window would otherwise subscribe+ /// to them again after `App` has cleaned up their subscriptions, and+ /// nothing would clean those up.+ pub fn extend_accessed(&mut self, entities: impl IntoIterator<Item = EntityId>) {+ let ref_counts = self.ref_counts.read();+ self.accessed_entities.get_mut().innermost().extend(+ entities+ .into_iter()+ .filter(|entity_id| ref_counts.counts.contains_key(*entity_id)),+ );+ }++ /// Clears the accessed entities and ends any scope left open.+ pub fn clear_accessed(&mut self) {+ let accessed_entities = self.accessed_entities.get_mut();+ accessed_entities.scopes.clear();+ accessed_entities.frame.clear();+ }++ pub fn push_access_scope(&mut self) {self.accessed_entities.get_mut()- .extend(entities.iter().copied());+ .scopes+ .push(FxHashSet::default());}- pub fn clear_accessed(&mut self) {- self.accessed_entities.get_mut().clear();+ /// Ends the innermost scope, adds its accessed entities to the scope+ /// around it, and returns them.+ pub fn pop_access_scope(&mut self) -> FxHashSet<EntityId> {+ let accessed_entities = self.accessed_entities.get_mut();+ let Some(scope) = accessed_entities.scopes.pop() else {+ debug_assert!(false, "popped an access scope that wasn't pushed");+ return FxHashSet::default();+ };+ accessed_entities.innermost().extend(scope.iter().copied());+ scope+ }++ /// Takes every entity accessed during the draw, to be handed back with+ /// [`Self::restore_accessed`].+ pub fn take_accessed(&mut self) -> FxHashSet<EntityId> {+ let accessed_entities = self.accessed_entities.get_mut();+ debug_assert!(+ accessed_entities.scopes.is_empty(),+ "access scope left open"+ );+ mem::take(&mut accessed_entities.frame)+ }++ pub fn restore_accessed(&mut self, entities: FxHashSet<EntityId>) {+ self.accessed_entities.get_mut().frame = entities;}pub fn take_dropped(&mut self) -> Vec<(EntityId, Box<dyn Any>)> {@@ -200,7 +272,10 @@ impl EntityMap {0,"dropped an entity that was referenced");- accessed_entities.remove(&entity_id);+ accessed_entities.frame.remove(&entity_id);+ for scope in &mut accessed_entities.scopes {+ scope.remove(&entity_id);+ }// If the EntityId was allocated with `Context::reserve`,// the entity may not have been inserted.Some((entity_id, self.entities.remove(entity_id)?))@@ -210,14 +285,19 @@ impl EntityMap {#[inline(never)]fn read_inner(&self, entity_id: EntityId) -> Option<&dyn Any> {- let mut accessed_entities = self.accessed_entities.borrow_mut();- accessed_entities.insert(entity_id);+ self.accessed_entities+ .borrow_mut()+ .innermost()+ .insert(entity_id);self.entities.get(entity_id).map(Box::as_ref)}#[inline(never)]fn lease_inner(&mut self, entity_id: EntityId) -> Option<Box<dyn Any>> {- self.accessed_entities.get_mut().insert(entity_id);+ self.accessed_entities+ .get_mut()+ .innermost()+ .insert(entity_id);self.entities.remove(entity_id)}@@ -1215,11 +1295,44 @@ impl fmt::Debug for BacktraceFormatter {#[cfg(test)]mod test {use crate::EntityMap;+ use collections::FxHashSet;struct TestEntity {pub i: i32,}+ #[test]+ fn test_accessed_entity_scopes() {+ let mut entity_map = EntityMap::new();+ let slot = entity_map.reserve::<TestEntity>();+ let first = entity_map.insert(slot, TestEntity { i: 1 });+ let slot = entity_map.reserve::<TestEntity>();+ let second = entity_map.insert(slot, TestEntity { i: 2 });+ entity_map.clear_accessed();++ entity_map.read(&first);+ entity_map.push_access_scope();+ entity_map.read(&first);+ entity_map.push_access_scope();+ entity_map.read(&second);+ let inner = entity_map.pop_access_scope();+ let outer = entity_map.pop_access_scope();++ assert_eq!(inner, FxHashSet::from_iter([second.entity_id()]));+ let both = FxHashSet::from_iter([first.entity_id(), second.entity_id()]);+ assert_eq!(outer, both);+ assert_eq!(entity_map.take_accessed(), both);++ drop(second);+ entity_map.take_dropped();+ entity_map.extend_accessed(both);+ assert_eq!(+ entity_map.take_accessed(),+ FxHashSet::from_iter([first.entity_id()]),+ "a released entity shouldn't be recorded again"+ );+ }+#[test]fn test_entity_map_slot_assignment_before_cleanup() {// Tests that slots are not re-used before take_dropped.diff --git a/crates/gpui/src/elements/deferred.rs b/crates/gpui/src/elements/deferred.rsindex ddf324a6b26..3496268a532 100644--- a/crates/gpui/src/elements/deferred.rs+++ b/crates/gpui/src/elements/deferred.rs@@ -97,11 +97,124 @@ impl Deferred {#[cfg(test)]mod tests {+ use std::{cell::Cell, rc::Rc};+use crate::{Context, Entity, StyleRefinement, TestAppContext, Window, anchored, deferred, div, point,prelude::*, px, size,};+ struct SubscriptionLeaf {+ value: usize,+ output: Rc<Cell<usize>>,+ }++ struct SubscriptionPanel {+ leaf: Entity<SubscriptionLeaf>,+ deferred_child: bool,+ renders: Rc<Cell<usize>>,+ }++ impl Render for SubscriptionPanel {+ fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {+ self.renders.set(self.renders.get() + 1);+ let leaf = self.leaf.clone();+ let child = crate::canvas(+ |_, _, _| {},+ move |_, _, _, cx| {+ let leaf = leaf.read(cx);+ leaf.output.set(leaf.value);+ },+ )+ .size(px(50.));+ if self.deferred_child {+ deferred(child).into_any_element()+ } else {+ child.into_any_element()+ }+ }+ }++ struct SubscriptionRoot {+ panel: Entity<SubscriptionPanel>,+ deferred_panel: bool,+ renders: Rc<Cell<usize>>,+ }++ impl Render for SubscriptionRoot {+ fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {+ self.renders.set(self.renders.get() + 1);+ let panel = self+ .panel+ .clone()+ .cached(StyleRefinement::default().size(px(100.)));+ if self.deferred_panel {+ deferred(panel).into_any_element()+ } else {+ panel.into_any_element()+ }+ }+ }++ #[gpui::test]+ fn test_cached_reuse_keeps_entity_subscriptions(cx: &mut TestAppContext) {+ for deferred_child in [true, false] {+ for deferred_panel in [false, true] {+ let output = Rc::new(Cell::new(0));+ let renders = Rc::new(Cell::new(0));+ let root_renders = Rc::new(Cell::new(0));+ let leaf = cx.new(|_| SubscriptionLeaf {+ value: 1,+ output: output.clone(),+ });+ let panel = cx.new(|_| SubscriptionPanel {+ leaf: leaf.clone(),+ deferred_child,+ renders: renders.clone(),+ });+ let window = cx.open_window(size(px(800.), px(600.)), |_, _| SubscriptionRoot {+ panel,+ deferred_panel,+ renders: root_renders.clone(),+ });+ cx.run_until_parked();+ assert_eq!(output.get(), 1);+ let initial_renders = renders.get();+ for _ in 0..2 {+ window+ .update(cx, |_, _, cx| cx.notify())+ .expect("notify root");+ cx.run_until_parked();+ assert_eq!(+ renders.get(),+ initial_renders,+ "panel should reuse its cache"+ );+ }++ let renders_before_notify = root_renders.get();+ leaf.update(cx, |leaf, cx| {+ leaf.value = 2;+ cx.notify();+ });+ cx.run_until_parked();+ let context =+ format!("deferred child {deferred_child}, deferred panel {deferred_panel}");+ assert!(+ root_renders.get() > renders_before_notify,+ "leaf notification should redraw: {context}"+ );+ // A plain entity read has no dispatch-tree path to invalidate the+ // cached panel, so refresh to run the paint callback again.+ window+ .update(cx, |_, window, _| window.refresh())+ .expect("refresh canvas");+ cx.run_until_parked();+ assert_eq!(output.get(), 2, "{context}");+ }+ }+ }+/// A stand-in for a dock panel hosting a popover (deferred draw) whose/// content opens another popover (a deferred draw created while/// prepainting the first one's content).diff --git a/crates/gpui/src/view.rs b/crates/gpui/src/view.rsindex b613805658d..37418510d9c 100644--- a/crates/gpui/src/view.rs+++ b/crates/gpui/src/view.rs@@ -324,6 +324,8 @@ struct ViewElementState {prepaint_range: Range<PrepaintStateIndex>,paint_range: Range<PaintIndex>,cache_key: ViewElementCacheKey,+ /// The entities the view accessed while it was last drawn, in any phase,+ /// restored when its prepaint is reused so the window stays subscribed.accessed_entities: FxHashSet<EntityId>,}@@ -558,7 +560,7 @@ fn prepaint_view(let prepaint_start = window.prepaint_index();window.reuse_prepaint(element_state.prepaint_range.clone());cx.entities- .extend_accessed(&element_state.accessed_entities);+ .extend_accessed(element_state.accessed_entities.iter().copied());let prepaint_end = window.prepaint_index();element_state.prepaint_range = prepaint_start..prepaint_end;@@ -636,7 +638,9 @@ fn paint_view(// redrawn on the next frame.if let Some(element) = element {let refreshing = mem::replace(&mut window.refreshing, true);- element.paint(window, cx);+ let ((), accessed_entities) =+ cx.detect_accessed_entities(|cx| element.paint(window, cx));+ element_state.accessed_entities.extend(accessed_entities);window.refreshing = refreshing;element_state.cache_key.opacity = opacity;} else {diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rsindex 79b204c6e19..12eb24ea1e1 100644--- a/crates/gpui/src/window.rs+++ b/crates/gpui/src/window.rs@@ -56,7 +56,7 @@ use std::{hash::{Hash, Hasher},marker::PhantomData,mem,- ops::{DerefMut, Range},+ ops::Range,rc::Rc,sync::{Arc, Weak,@@ -1033,6 +1033,9 @@ pub(crate) struct DeferredDraw {absolute_offset: Point<Pixels>,prepaint_range: Range<PrepaintStateIndex>,paint_range: Range<PaintIndex>,+ /// The entities the deferred element accessed while it was last drawn, in+ /// any phase, restored when its prepaint is reused.+ accessed_entities: FxHashSet<EntityId>,}pub(crate) struct Frame {@@ -3813,8 +3816,7 @@ impl Window {}fn record_entities_accessed(&mut self, cx: &mut App) {- let mut entities_ref = cx.entities.accessed_entities.get_mut();- let mut entities = mem::take(entities_ref.deref_mut());+ let entities = cx.entities.take_accessed();let handle = self.handle;cx.record_entities_accessed(handle,@@ -3822,8 +3824,7 @@ impl Window {self.invalidator.clone(),&entities,);- let mut entities_ref = cx.entities.accessed_entities.get_mut();- mem::swap(&mut entities, entities_ref.deref_mut());+ cx.entities.restore_accessed(entities);}fn invalidate_entities(&mut self) {@@ -4148,15 +4149,25 @@ impl Window {let prepaint_start = self.prepaint_index();if let Some(mut element) = element {- self.with_rendered_view(current_view, |window| {- window.with_rem_size(Some(rem_size), |window| {- window.with_absolute_element_offset(absolute_offset, |window| {- element.prepaint(window, cx);+ let ((), accessed_entities) = cx.detect_accessed_entities(|cx| {+ self.with_rendered_view(current_view, |window| {+ window.with_rem_size(Some(rem_size), |window| {+ window.with_absolute_element_offset(absolute_offset, |window| {+ element.prepaint(window, cx);+ });});});});+ self.next_frame.deferred_draws[deferred_draw_ix].accessed_entities =+ accessed_entities;self.next_frame.deferred_draws[deferred_draw_ix].element = Some(element);} else {+ cx.entities.extend_accessed(+ self.next_frame.deferred_draws[deferred_draw_ix]+ .accessed_entities+ .iter()+ .copied(),+ );self.reuse_prepaint(prepaint_range);}let prepaint_end = self.prepaint_index();@@ -4192,13 +4203,16 @@ impl Window {let paint_start = self.paint_index();let content_mask = deferred_draw.content_mask;if let Some(element) = deferred_draw.element.as_mut() {- self.with_rendered_view(deferred_draw.current_view, |window| {- window.with_content_mask(content_mask, |window| {- window.with_rem_size(Some(deferred_draw.rem_size), |window| {- element.paint(window, cx);- });+ let ((), accessed_entities) = cx.detect_accessed_entities(|cx| {+ self.with_rendered_view(deferred_draw.current_view, |window| {+ window.with_content_mask(content_mask, |window| {+ window.with_rem_size(Some(deferred_draw.rem_size), |window| {+ element.paint(window, cx);+ });+ })})- })+ });+ deferred_draw.accessed_entities.extend(accessed_entities);} else {self.reuse_paint(deferred_draw.paint_range.clone());}@@ -4274,6 +4288,7 @@ impl Window {absolute_offset: deferred_draw.absolute_offset,prepaint_range: deferred_draw.prepaint_range.clone(),paint_range: deferred_draw.paint_range.clone(),+ accessed_entities: deferred_draw.accessed_entities.clone(),}),);}@@ -4756,6 +4771,7 @@ impl Window {absolute_offset,prepaint_range: PrepaintStateIndex::default()..PrepaintStateIndex::default(),paint_range: PaintIndex::default()..PaintIndex::default(),+ accessed_entities: FxHashSet::default(),});}