rib: a reader counts the table once a poll, not once a shard

A router with many peers has a reader of the table's journal for each
session that is sent learned routes, seventy on ddln, and every change
to the table wakes them all. Each pass of a reader went round every
shard, and for each shard took a count on the table (an Arc clone) to
hold it while the shard was read, and gave it back after: two atomic
adds on one cache line, by seventy readers, 256 shards a pass. A
profile of ddln taking a table from the other router had the reader's
poll as the top function at two to three cores, and in the Linux VM
with 64 such sessions half of all CPU time was in the two atomic add
instructions. The sessions writing to the table waited behind it: the
table came in at 58,000 routes a second.

The count is now taken once a poll. And each journal keeps its latest
sequence number in an atomic the table holds the other end of, so that
a reader can tell a shard with nothing new for it from one with
something without the shard's lock, and pass over it: on a quiet
table, which is what the readers see most of the time, a pass is a
load a shard and no lock. An exporter that is sent little of a table,
as one to a peer at an exchange is, no longer makes a verdict of
nothing for a prefix the peer does not hold, which cost a map insert
and a lookup on the way out, and tells a route that came down or
across (RFC 9234) from its attributes' bytes before parsing them.

Testing: the mesh benchmark can have any number of collector sessions
of the first router (BENCH_COLLECTORS): peers in the sense of RFC 9234,
sent learned routes, with the feeders' routes marked as having come
across from a peer, so that each has a reader following the table
while it fills and passes nearly all of it over, as a router with many
peers at exchanges has. In the Linux VM with 64 of them, three rounds
alternating with the previous commit, the routers' exchange of their
tables takes 11 s instead of 20 s, at 86 s of CPU time instead of
155 s; without them it is unchanged. The table's tests, the server
tests, the integration tests, the kernel tests and every lab phase
pass.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

crates/bench/benches/mesh.rs

@@ -20,7 +20,12 @@
 //! part is skipped on macOS. With `BENCH_RECEIVER_EARLY=1` the new peer
 //! comes as the feeders start instead, so that its exporter goes
 //! through the table while the table is being filled, as a router's
-//! do after a restart.
+//! do after a restart. `BENCH_COLLECTORS` (default 0) more peers of the
+//! first router, from 127.0.1.0/24, are peers in the sense of RFC 9234
+//! told of learned routes, and the feeders' routes are marked as having
+//! come across from a peer, so none of them goes: as many exporters
+//! following the table while it fills and passing nearly all of it
+//! over, as a router with many peers at exchanges has.
 
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::sync::Arc;
@@ -31,10 +36,11 @@ use bgp_bench::{Prefixes, Shape, announcements, encoded, env};
 use bgp_integration_tests::peer_config;
 use bgp_integration_tests::test_peer::TestPeer;
 use bgp_integration_tests::test_server::TestServer;
+use bgp_packet::attributes::PathAttribute;
 use bgp_packet::open::{AddPathEntry, Capability, SendReceive};
 use bgp_server::config::PeerConfig;
 use bgp_server::family::SUPPORTED;
-use bgp_server::policy::{ExportPolicy, ImportPolicy};
+use bgp_server::policy::{ExportPolicy, ImportPolicy, PeerRole};
 use bgp_server::session::SessionRegistry;
 use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader};
 
@@ -44,6 +50,14 @@ const ASN: u32 = 4_200_000_000;
 /// Where the peer that takes the whole table connects from.
 const RECEIVER: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 2);
 
+/// Where the collectors connect from: this and the addresses after it.
+fn collector_address(n: u32) -> Ipv4Addr {
+    Ipv4Addr::new(127, 0, 1, n as u8)
+}
+
+/// The collectors' AS numbers start here.
+const COLLECTOR_ASN: u32 = 65000;
+
 /// What the routers send each other, and the receiver: every path.
 fn every_path() -> Arc<ExportPolicy> {
     Arc::new(ExportPolicy {
@@ -70,6 +84,7 @@ async fn router(
     port: u16,
     other: u16,
     with_receiver: bool,
+    collectors: u32,
 ) -> TestServer {
     TestServer::start_with(ASN, |c| {
         // Two routers of one AS must not share a BGP identifier.
@@ -96,6 +111,21 @@ async fn router(
                 ..peer_config("receiver", SocketAddr::new(RECEIVER.into(), 179), ASN)
             });
         }
+        for n in 1..=collectors {
+            c.peers.push(PeerConfig {
+                role: Some(PeerRole::Peer),
+                export: Arc::new(ExportPolicy {
+                    learned_routes: true,
+                    all_paths: false,
+                    ..ExportPolicy::default()
+                }),
+                ..peer_config(
+                    "collector",
+                    SocketAddr::new(collector_address(n).into(), 179),
+                    COLLECTOR_ASN + n,
+                )
+            });
+        }
         c.connect_retry = Duration::from_millis(200);
     })
     .await
@@ -110,10 +140,21 @@ async fn feeders(
     shape: Shape,
     first: u32,
     count: u32,
+    marked: bool,
 ) -> Vec<(TestPeer, Vec<u8>)> {
     let mut sessions = Vec::new();
     for peer in first..first + count {
-        let stream: Vec<u8> = encoded(&announcements(prefixes, shape, peer))
+        let mut updates = announcements(prefixes, shape, peer);
+        if marked {
+            // As having come across from a peer (RFC 9234): not for the
+            // collectors, which are peers too.
+            for update in &mut updates {
+                update
+                    .path_attributes
+                    .push(PathAttribute::OnlyToCustomer(64512 + peer));
+            }
+        }
+        let stream: Vec<u8> = encoded(&updates)
             .iter()
             .flat_map(|m| m.iter().copied())
             .collect();
@@ -152,13 +193,46 @@ fn main() {
         .expect("a runtime");
     runtime.block_on(async {
         let (port_a, port_b) = (free_port(), free_port());
-        let a = router("b", 1, port_a, port_b, true).await;
-        let b = router("a", 2, port_b, port_a, false).await;
+        let collectors = env("BENCH_COLLECTORS", 0) as u32;
+        let a = router("b", 1, port_a, port_b, true, collectors).await;
+        let b = router("a", 2, port_b, port_a, false, 0).await;
         a.wait_for_sessions(1).await.expect("the mesh session at A");
         b.wait_for_sessions(1).await.expect("the mesh session at B");
+        // The collectors are there before the feeders, as a router's
+        // peers are before its tables arrive after a restart.
+        let mut draining = Vec::new();
+        for n in 1..=collectors {
+            let socket = tokio::net::TcpSocket::new_v4().expect("a socket");
+            if let Err(e) = socket.bind(SocketAddr::new(collector_address(n).into(), 0)) {
+                println!(
+                    "collectors: skipped, {} is not ours ({e})",
+                    collector_address(n)
+                );
+                break;
+            }
+            let stream = socket.connect(a.addr).await.expect("A listens");
+            let mut session = TestPeer::from_stream(stream);
+            session
+                .handshake(COLLECTOR_ASN + n, Ipv4Addr::new(192, 0, 3, n as u8), 0)
+                .await
+                .expect("A takes a collector's session");
+            let (mut reader, writer) = session.into_stream().into_split();
+            draining.push((
+                writer,
+                tokio::spawn(async move {
+                    let mut sink = vec![0u8; 1 << 16];
+                    while matches!(reader.read(&mut sink).await, Ok(n) if n > 0) {}
+                }),
+            ));
+        }
+        if collectors > 0 {
+            a.wait_for_sessions(1 + draining.len())
+                .await
+                .expect("the collectors' sessions at A");
+        }
 
-        let feed_a = feeders(&a, &prefixes, shape, 1, peers_a).await;
-        let feed_b = feeders(&b, &prefixes, shape, 1 + peers_a, peers_b).await;
+        let feed_a = feeders(&a, &prefixes, shape, 1, peers_a, collectors > 0).await;
+        let feed_b = feeders(&b, &prefixes, shape, 1 + peers_a, peers_b, false).await;
         let own_a = per_peer * peers_a as usize;
         let own_b = per_peer * peers_b as usize;
 
@@ -258,6 +332,7 @@ fn main() {
             None => resync(a.addr, a.registry.clone(), receiver_routes).await,
         }
         drop(feeders);
+        drop(draining);
     });
 }