Skip to content

armgit / zed

Public Imported from GitHub
0

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.rs
index 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.rs
index 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 {
where
T: '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.rs
index 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.rs
index 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.rs
index 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(),
});
}