cache heads

To reduce the number of write locks, heads are now cached.

3 files changed, 11 insertions, 6 deletions

diff --git a/src/swarm/peer.rs b/src/swarm/peer.rs
index dd70bbb..3d7da32 100644
--- a/src/swarm/peer.rs
+++ b/src/swarm/peer.rs
@@ -108,12 +108,12 @@ pub(crate) async fn send_ping(state: &AppState, peer: &str) -> Result<()> {
 
 /// Our keepalive for `peer`.
 pub(crate) async fn local_keepalive(state: &AppState, peer: &str) -> transport::Keepalive {
-    // AutoCommit::get_heads takes &mut self (it closes the pending transaction).
-    // Heads and epoch come from the same locked replica, so they always match.
+    // Heads and epoch come from the same locked replica, so they always match. The heads
+    // are cached (`Replica`), so the read lock is enough.
     let (heads, epoch) = {
-        let mut replica = state.doc.write().await;
+        let replica = state.doc.read().await;
         (
-            transport::HeadsSummary::of(replica.doc.get_heads()),
+            transport::HeadsSummary::of(replica.heads().to_vec()),
             replica.epoch,
         )
     };
diff --git a/src/swarm/relay.rs b/src/swarm/relay.rs
index 454a46a..492b59d 100644
--- a/src/swarm/relay.rs
+++ b/src/swarm/relay.rs
@@ -52,6 +52,10 @@ pub(crate) async fn pull_if_behind(state: &AppState, peer: &str, remote: &transp
     if remote.epoch != state.local_epoch() || !topology::is_neighbour(state, peer) {
         return;
     }
+    // The common case, the same heads, needs only the cached heads (read lock).
+    if HeadsSummary::of(state.doc.read().await.heads().to_vec()) == remote.heads {
+        return;
+    }
     let missing = match &remote.heads {
         HeadsSummary::Heads(heads) => {
             // AutoCommit's lookups take &mut self.
diff --git a/src/swarm/sync.rs b/src/swarm/sync.rs
index 17e25c4..80d6d56 100644
--- a/src/swarm/sync.rs
+++ b/src/swarm/sync.rs
@@ -343,7 +343,7 @@ pub(crate) async fn handle_sync(
 
             let mut peer_state = peer_state_mutex.blocking_lock();
             peer_state.reports_ready = Some(from_ready);
-            let heads_before = replica.doc.get_heads();
+            let heads_before = replica.heads().to_vec();
 
             replica
                 .doc
@@ -360,7 +360,8 @@ pub(crate) async fn handle_sync(
             peer_state.sync.reply_settled();
 
             resend_if_needed(&peer, &mut peer_state.sync.state);
-            let heads_after = replica.doc.get_heads();
+            replica.refresh_heads();
+            let heads_after = replica.heads().to_vec();
             stats.heads_seen(heads_after.len());
             let changed = heads_after != heads_before;
             if changed && measure_propagation {