measure sync envelopes

3 files changed, 35 insertions, 0 deletions

diff --git a/src/simtest/bench.rs b/src/simtest/bench.rs
index 1d6d411..0300825 100644
--- a/src/simtest/bench.rs
+++ b/src/simtest/bench.rs
@@ -332,6 +332,9 @@ impl Totals {
             relay.tree_forwards += stats.relay.tree_forwards;
             relay.delivered += stats.relay.delivered;
             relay.delivered_bytes += stats.relay.delivered_bytes;
+            relay.framed += stats.relay.framed;
+            relay.framing_bytes += stats.relay.framing_bytes;
+            relay.framing_id_bytes += stats.relay.framing_id_bytes;
             relay.nothing_new += stats.relay.nothing_new;
             relay.nothing_new_bytes += stats.relay.nothing_new_bytes;
             relay.nothing_new_along_trees += stats.relay.nothing_new_along_trees;
@@ -718,6 +721,14 @@ fn report(
             news
         ),
     );
+    // What our envelope adds to each Automerge message, beside the message itself.
+    let framed = r1.framed - r0.framed;
+    let _ = writeln!(
+        out,
+        "    sync envelopes: {:.0} bytes each beside the Automerge message, {:.0} of them the swarm ID and the epoch",
+        each(r1.framing_bytes - r0.framing_bytes, framed),
+        each(r1.framing_id_bytes - r0.framing_id_bytes, framed),
+    );
     let (lately, later) = (
         r1.asked_known_lately - r0.asked_known_lately,
         r1.asked_known_later - r0.asked_known_later,
diff --git a/src/swarm/stats.rs b/src/swarm/stats.rs
index 191f4e9..371fe42 100644
--- a/src/swarm/stats.rs
+++ b/src/swarm/stats.rs
@@ -128,6 +128,11 @@ pub(crate) struct Relay {
     /// payload's bytes.
     pub(crate) delivered: u64,
     pub(crate) delivered_bytes: u64,
+    /// Sync messages sent (not offers), the bytes the envelope added to their
+    /// Automerge messages, and of those the swarm ID's and the epoch's.
+    pub(crate) framed: u64,
+    pub(crate) framing_bytes: u64,
+    pub(crate) framing_id_bytes: u64,
     /// Sync messages received that carried changes, all of which we had already, and
     /// their payload's bytes: changes that came twice. Of those, how many came along a
     /// writer's tree (`SyncEnvelope::writer`), and how many were taken as delivered by
@@ -249,6 +254,15 @@ impl NodeStats {
         self.lock().relay.tree_forwards += 1;
     }
 
+    /// A sync message went out whose envelope added `bytes` to its Automerge message,
+    /// `ids` of them the swarm ID and the epoch.
+    pub(crate) fn sync_framing(&self, bytes: usize, ids: usize) {
+        let mut inner = self.lock();
+        inner.relay.framed += 1;
+        inner.relay.framing_bytes += bytes as u64;
+        inner.relay.framing_id_bytes += ids as u64;
+    }
+
     /// A sync message taken as delivered went out, of `bytes` payload.
     pub(crate) fn delivered_sent(&self, bytes: usize) {
         let mut inner = self.lock();
diff --git a/src/swarm/sync.rs b/src/swarm/sync.rs
index 6c67e57..ed4c4da 100644
--- a/src/swarm/sync.rs
+++ b/src/swarm/sync.rs
@@ -238,6 +238,13 @@ async fn deliver_sync_to_peer(state: &AppState, peer: &str) -> Result<()> {
                 let Some(body) = body else {
                     return (session, Ok(None));
                 };
+                // What the envelope adds to an Automerge message (`swarm::stats`), and of
+                // that, the swarm ID and the epoch (msgpack: 36 bytes the epoch).
+                let inner = match &body {
+                    transport::SyncBody::Message(payload) => Some(payload.0.len()),
+                    transport::SyncBody::Delta(_) => None,
+                };
+                let ids = rmp_serde::encode::to_vec(&swarm_id).map_or(0, |id| id.len()) + 36;
                 let envelope = transport::SyncEnvelope {
                     swarm_id,
                     epoch,
@@ -251,6 +258,9 @@ async fn deliver_sync_to_peer(state: &AppState, peer: &str) -> Result<()> {
                 let encoded = transport
                     .encode(&peer_owned, &ParsedMessage::Sync(envelope))
                     .map(Some);
+                if let (Ok(Some(encoded)), Some(inner)) = (&encoded, inner) {
+                    stats.sync_framing(encoded.payload_len.saturating_sub(inner), ids);
+                }
                 (session, encoded)
             },
         )