Collapse buffers reorder happening within the same second

This reduces CPU-intensive churn, especially at startup

src/buffers/mod.rs

@@ -17,6 +17,7 @@
 use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
+use std::time::{Duration, Instant};
 
 use futures::stream::FuturesUnordered;
 use futures::StreamExt;
@@ -25,6 +26,7 @@ use nonempty::NonEmpty;
 use ratatui::text::Text;
 use smallvec::SmallVec;
 use sorted_vec::SortedVec;
+use tokio::select;
 
 use crate::widgets::Prerender;
 
@@ -33,6 +35,12 @@ pub use log::LogBuffer;
 mod room;
 pub use room::RoomBuffer;
 
+/// Maximum time before reordering the buffer list based on parent/child relationships.
+///
+/// Updates are not applied immediately in order to coalesce multiple changes happening
+/// in a row, as applying an update is (currently) computationally expensive.
+const UPDATE_INTERVAL: Duration = Duration::from_secs(1);
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum FullyReadStatus {
   /// There are some unread messages
@@ -146,6 +154,7 @@ pub trait Buffer: Send + Sync + memuse::DynamicUsage {
 
 pub struct Buffers {
   buffers: Vec<Box<dyn Buffer>>,
+
   /// Set of children of each buffer, sorted so that children explicitly listed by a
   /// space are sorted according to
   /// https://spec.matrix.org/v1.8/client-server-api/#ordering-of-children-within-a-space
@@ -163,6 +172,15 @@ pub struct Buffers {
   /// steal them, even if they are also their child (or it would cause buffers to move
   /// every time we re-sort the buffer list)
   attached_to_parent: HashSet<BufferId>,
+
+  /// When the `buffers` list and `parents`/`children` maps should be recomputed to match
+  /// actual relationships between buffers.
+  ///
+  /// They are not recomputed every time, because the current implementation is
+  /// computationally expensive.
+  next_reorder: Option<Instant>,
+
+  /// Which buffer is currently selected in the UI.
   active_buffer: BufferId,
 }
 
@@ -173,28 +191,55 @@ impl Buffers {
       children: HashMap::new(),
       parents: HashMap::new(),
       attached_to_parent: HashSet::new(),
+      next_reorder: None,
       active_buffer: BufferId::Log,
     }
   }
 
   pub async fn poll_updates(&mut self) {
-    self
-      .iter_mut()
-      .map(|buf| buf.poll_updates())
-      .collect::<FuturesUnordered<_>>()
-      .next()
-      .await
-      .expect("poll_updates reached the end of the never-ending stream");
+    let reorder_now = {
+      let next_reorder = self.next_reorder;
+      let mut updates_future = self
+        .iter_mut()
+        .map(|buf| buf.poll_updates())
+        .collect::<FuturesUnordered<_>>();
 
-    // Reorder buffers in case we just got an update on space relationships
-    // FIXME: do this only when needed
-    let mut buffers = Vec::new();
-    //self.children.clear();
-    //self.parents.clear();
-    self.attached_to_parent.clear();
-    std::mem::swap(&mut self.buffers, &mut buffers);
-    for buf in buffers.into_iter() {
-      self.push(buf);
+      let reorder_future = async {
+        match next_reorder {
+          Some(next_reorder) => tokio::time::sleep(next_reorder - Instant::now()).await,
+          None => std::future::pending().await,
+        }
+      };
+
+      select! {
+        res = updates_future.next() => {
+          res.expect("poll_updates reached the end of the never-ending stream");
+          false
+        },
+        _ = reorder_future => {
+          true
+        }
+      }
+    };
+
+    if reorder_now {
+      // Reorder buffers in case we just got an update on space relationships
+      // FIXME: do this only when needed
+      let mut buffers = Vec::new();
+      //self.children.clear();
+      //self.parents.clear();
+      self.attached_to_parent.clear();
+      std::mem::swap(&mut self.buffers, &mut buffers);
+      for buf in buffers.into_iter() {
+        self.push(buf);
+      }
+      self.next_reorder = None;
+    } else {
+      // We got an update, schedule a reorder for later
+      self.next_reorder = match self.next_reorder {
+        None => Some(Instant::now() + UPDATE_INTERVAL),
+        Some(next_reorder) => Some(next_reorder), // Keep the existing deadline
+      };
     }
   }