matrix-rust-sdk

public

Star0

Fork 0

Watch0

24 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `892fd89cfa63`

tarball

atagen <boss@atagen.co>2026-10-25 08:58 UTC

2 files changed+28-11

event-cache: load the history candidate once per history operation

history_candidate decrypts every stored chunk under the state write lock, and both a recent load and a fill built it twice, once to read their starting point. The recent anchor now comes from newest_retained_event_id and a fill finds its gap in memory first, falling back to the candidate only when the gap is not loaded. Fetched events are inserted in runs instead of one positional search each.

Modified file: crates/matrix-sdk/src/event_cache/caches/room/history.rs+25 additions−10 deletions@@ -232,10 +232,7 @@ impl RoomEventCache {
         &self,
         mut cancellation: watch::Receiver<bool>,
     ) -> Result<RecentHistoryOutcome> {
-        let anchor = {
-            let state = self.inner.state.write().await?;
-            state.history_candidate().await?.revents().find_map(|(_, event)| event.event_id())
-        };
+        let anchor = self.inner.state.write().await?.newest_retained_event_id().await?;
         let room = self.inner.weak_room.get().ok_or(EventCacheError::ClientDropped)?;
         let mut cursor = None;
         let mut visited = Vec::new();
@@ -328,22 +325,25 @@ impl RoomEventCache {
             }
 
             let mut inserted = Vec::new();
+            let mut run = Vec::new();
             let mut before = first_arrival.clone();
             for event in events.into_iter().rev() {
                 let id = event.event_id();
                 if id.as_ref().is_none_or(|id| known.insert(id.clone())) {
-                    candidate.insert_history_before(before.as_deref(), vec![event.clone()], None);
-                    inserted.push(event);
-                }
-                if id.is_some() {
+                    inserted.push(event.clone());
+                    run.push(event);
+                } else {
+                    insert_run(&mut candidate, before.as_deref(), &mut run);
                     before = id;
                 }
             }
+            insert_run(&mut candidate, before.as_deref(), &mut run);
+            let before = oldest_fetched.clone().or(first_arrival.clone());
 
             let history = anchor.as_ref().filter(|_| !joined).map(|anchor| HistoryGap {
                 id: TransactionId::new(),
                 older_boundary: Some(anchor.clone()),
-                newer_boundary: oldest_fetched.or(first_arrival.clone()),
+                newer_boundary: before.clone(),
                 status: if cursor.is_none() {
                     HistoryGapStatus::Unavailable
                 } else if stalled {
@@ -487,7 +487,10 @@ impl RoomEventCache {
     ) -> Result<HistoryGapFillOutcome> {
         let initial = {
             let state = self.inner.state.write().await?;
-            find_gap(&state.history_candidate().await?, &gap_id)
+            match find_gap(state.room_linked_chunk(), &gap_id) {
+                Some(gap) => Some(gap),
+                None => find_gap(&state.history_candidate().await?, &gap_id),
+            }
         };
         let Some(initial) = initial else {
             return Ok(HistoryGapFillOutcome::NotFound);
@@ -543,6 +546,18 @@ impl RoomEventCache {
     }
 }
 
+fn insert_run(
+    candidate: &mut EventLinkedChunk,
+    before: Option<&ruma::EventId>,
+    run: &mut Vec<Event>,
+) {
+    if !run.is_empty() {
+        let mut events = std::mem::take(run);
+        events.reverse();
+        candidate.insert_history_before(before, events, None);
+    }
+}
+
 fn gaps(candidate: &EventLinkedChunk) -> Vec<HistoryGap> {
     candidate
         .chunks()

Modified file: crates/matrix-sdk/src/event_cache/caches/room/state.rs+3 additions−1 deletions@@ -801,7 +801,9 @@ impl<'a> RoomEventCacheStateLockWriteGuard<'a> {
     }
 
     /// Memory can hold no events at all, after a shrink to a trailing gap.
-    async fn newest_retained_event_id(&self) -> Result<Option<OwnedEventId>, EventCacheError> {
+    pub(super) async fn newest_retained_event_id(
+        &self,
+    ) -> Result<Option<OwnedEventId>, EventCacheError> {
         let chunk = &self.state.room_linked_chunk;
         if let Some(id) = chunk.revents().find_map(|(_, event)| event.event_id()) {
             return Ok(Some(id));

matrix-rust-sdk

Commit 892fd89cfa63

Commit `892fd89cfa63`