mirror of
https://github.com/jmcorgan/fips.git
synced 2026-07-22 07:48:26 +00:00
8aab71af86
Measures the per-forwarded-packet cost of routing candidate assembly (routing_candidates over a synthetic RoutingView) against a zero-alloc reference across 8/32/128/256 peers, with per-call allocation counts via a counting allocator. Criterion harness; no production code change.
366 lines
13 KiB
Rust
366 lines
13 KiB
Rust
//! Micro-benchmark quantifying the per-forwarded-packet heap-allocation cost
|
|
//! of the routing next-hop candidate-assembly path.
|
|
//!
|
|
//! `find_next_hop` runs once per forwarded data packet. Its sans-IO core
|
|
//! assembles a `Vec<Candidate>` by enumerating every peer through the
|
|
//! `RoutingView` seam: `peer_addrs()` materializes a `Vec<NodeAddr>` of all
|
|
//! peers, the survivors are snapshotted (each cloning its `TreeCoordinate`),
|
|
//! and the result is collected into a second `Vec`. This bench measures that
|
|
//! per-call allocation against a fused zero-alloc reference that iterates the
|
|
//! peer map directly and borrows coordinates instead of cloning.
|
|
//!
|
|
//! Visibility caveat: the production `routing_candidates` / `select_best_candidate`
|
|
//! / `RoutingView` / `Candidate` are `pub(crate)` (src/proto/routing/core.rs)
|
|
//! and are not re-exported at the crate root, so an external bench crate cannot
|
|
//! name them. Rather than change production visibility, this file reproduces
|
|
//! that path verbatim over the real public `NodeAddr` / `TreeCoordinate` /
|
|
//! `CoordEntry` / `BloomFilter` types with the same iterator chain and the same
|
|
//! `HashMap`-backed view the shell uses (src/node/mod.rs NodeRoutingView). The
|
|
//! allocation behavior is therefore identical to production by construction;
|
|
//! only the symbol identity differs.
|
|
|
|
use std::alloc::{GlobalAlloc, Layout, System};
|
|
use std::collections::HashMap;
|
|
use std::hint::black_box;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
|
|
use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
|
|
use fips::{BloomFilter, NodeAddr, TreeCoordinate};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Counting global allocator: bumps a process-global counter on every heap
|
|
// allocation operation (alloc / alloc_zeroed / realloc). Sampled tightly and
|
|
// single-threaded in `report_allocs` so no unrelated allocations are captured.
|
|
// ---------------------------------------------------------------------------
|
|
struct CountingAlloc;
|
|
|
|
static ALLOCS: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
unsafe impl GlobalAlloc for CountingAlloc {
|
|
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
|
|
ALLOCS.fetch_add(1, Ordering::Relaxed);
|
|
unsafe { System.alloc(layout) }
|
|
}
|
|
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
|
|
unsafe { System.dealloc(ptr, layout) }
|
|
}
|
|
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
|
|
ALLOCS.fetch_add(1, Ordering::Relaxed);
|
|
unsafe { System.alloc_zeroed(layout) }
|
|
}
|
|
unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
|
|
ALLOCS.fetch_add(1, Ordering::Relaxed);
|
|
unsafe { System.realloc(ptr, layout, new_size) }
|
|
}
|
|
}
|
|
|
|
#[global_allocator]
|
|
static GLOBAL: CountingAlloc = CountingAlloc;
|
|
|
|
const PEER_COUNTS: [usize; 4] = [8, 32, 128, 256];
|
|
/// Fraction of peers whose bloom filter reports the destination reachable.
|
|
const REACH_NUMERATOR: usize = 1;
|
|
const REACH_DENOMINATOR: usize = 2;
|
|
/// Tree depth for synthetic coordinates (self..root), a realistic mesh depth.
|
|
const COORD_DEPTH: usize = 8;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Reproduction of the pub(crate) routing seam (src/proto/routing/core.rs).
|
|
// ---------------------------------------------------------------------------
|
|
trait RoutingView {
|
|
fn peer_addrs(&self) -> Vec<NodeAddr>;
|
|
fn peer_may_reach(&self, peer: &NodeAddr, dest: &NodeAddr) -> bool;
|
|
fn peer_can_send(&self, peer: &NodeAddr) -> bool;
|
|
fn peer_link_cost(&self, peer: &NodeAddr) -> f64;
|
|
fn peer_coords(&self, peer: &NodeAddr) -> Option<TreeCoordinate>;
|
|
}
|
|
|
|
struct Candidate {
|
|
addr: NodeAddr,
|
|
can_send: bool,
|
|
link_cost: f64,
|
|
coords: Option<TreeCoordinate>,
|
|
}
|
|
|
|
/// Verbatim from `routing::routing_candidates` (core.rs). Allocates the
|
|
/// `peer_addrs` Vec, clones each survivor's coords, and collects into a Vec.
|
|
fn routing_candidates(rv: &impl RoutingView, dest: &NodeAddr) -> Vec<Candidate> {
|
|
rv.peer_addrs()
|
|
.into_iter()
|
|
.filter(|peer| rv.peer_may_reach(peer, dest))
|
|
.map(|peer| Candidate {
|
|
can_send: rv.peer_can_send(&peer),
|
|
link_cost: rv.peer_link_cost(&peer),
|
|
coords: rv.peer_coords(&peer),
|
|
addr: peer,
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Verbatim from `routing::select_best_candidate` (core.rs). Pure, no alloc.
|
|
fn select_best_candidate(
|
|
candidates: &[Candidate],
|
|
dest_coords: &TreeCoordinate,
|
|
my_coords: &TreeCoordinate,
|
|
) -> Option<NodeAddr> {
|
|
let my_distance = my_coords.distance_to(dest_coords);
|
|
let mut best: Option<(&Candidate, f64, usize)> = None;
|
|
for candidate in candidates {
|
|
if !candidate.can_send {
|
|
continue;
|
|
}
|
|
let cost = candidate.link_cost;
|
|
let dist = candidate
|
|
.coords
|
|
.as_ref()
|
|
.map(|pc| pc.distance_to(dest_coords))
|
|
.unwrap_or(usize::MAX);
|
|
if dist >= my_distance {
|
|
continue;
|
|
}
|
|
let dominated = match &best {
|
|
None => true,
|
|
Some((_, best_cost, best_dist)) => {
|
|
cost < *best_cost
|
|
|| (cost == *best_cost && dist < *best_dist)
|
|
|| (cost == *best_cost
|
|
&& dist == *best_dist
|
|
&& candidate.addr < best.as_ref().unwrap().0.addr)
|
|
}
|
|
};
|
|
if dominated {
|
|
best = Some((candidate, cost, dist));
|
|
}
|
|
}
|
|
best.map(|(candidate, _, _)| candidate.addr)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Bench-local view, HashMap-backed exactly like src/node/mod.rs NodeRoutingView.
|
|
// ---------------------------------------------------------------------------
|
|
struct BenchPeer {
|
|
bloom: BloomFilter,
|
|
can_send: bool,
|
|
link_cost: f64,
|
|
}
|
|
|
|
struct BenchView {
|
|
peers: HashMap<NodeAddr, BenchPeer>,
|
|
coords: HashMap<NodeAddr, TreeCoordinate>,
|
|
}
|
|
|
|
impl RoutingView for BenchView {
|
|
fn peer_addrs(&self) -> Vec<NodeAddr> {
|
|
self.peers.keys().copied().collect()
|
|
}
|
|
fn peer_may_reach(&self, peer: &NodeAddr, dest: &NodeAddr) -> bool {
|
|
self.peers.get(peer).is_some_and(|p| p.bloom.contains(dest))
|
|
}
|
|
fn peer_can_send(&self, peer: &NodeAddr) -> bool {
|
|
self.peers.get(peer).is_some_and(|p| p.can_send)
|
|
}
|
|
fn peer_link_cost(&self, peer: &NodeAddr) -> f64 {
|
|
self.peers.get(peer).map_or(f64::INFINITY, |p| p.link_cost)
|
|
}
|
|
fn peer_coords(&self, peer: &NodeAddr) -> Option<TreeCoordinate> {
|
|
self.coords.get(peer).cloned()
|
|
}
|
|
}
|
|
|
|
/// Zero-alloc reference: what an iterator/visitor seam would do. Iterates the
|
|
/// peer map directly, fuses the may_reach + can_send filters, borrows coords
|
|
/// instead of cloning, and tracks the best hop inline. No Vec, no coord clone.
|
|
fn resolve_next_hop_zeroalloc(
|
|
view: &BenchView,
|
|
dest: &NodeAddr,
|
|
dest_coords: &TreeCoordinate,
|
|
my_coords: &TreeCoordinate,
|
|
) -> Option<NodeAddr> {
|
|
let my_distance = my_coords.distance_to(dest_coords);
|
|
let mut best: Option<(NodeAddr, f64, usize)> = None;
|
|
for (addr, peer) in &view.peers {
|
|
if !peer.bloom.contains(dest) {
|
|
continue;
|
|
}
|
|
if !peer.can_send {
|
|
continue;
|
|
}
|
|
let cost = peer.link_cost;
|
|
let dist = view
|
|
.coords
|
|
.get(addr)
|
|
.map(|pc| pc.distance_to(dest_coords))
|
|
.unwrap_or(usize::MAX);
|
|
if dist >= my_distance {
|
|
continue;
|
|
}
|
|
let dominated = match &best {
|
|
None => true,
|
|
Some((best_addr, best_cost, best_dist)) => {
|
|
cost < *best_cost
|
|
|| (cost == *best_cost && dist < *best_dist)
|
|
|| (cost == *best_cost && dist == *best_dist && *addr < *best_addr)
|
|
}
|
|
};
|
|
if dominated {
|
|
best = Some((*addr, cost, dist));
|
|
}
|
|
}
|
|
best.map(|(addr, _, _)| addr)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Scenario construction.
|
|
// ---------------------------------------------------------------------------
|
|
fn addr(tag: u8, i: u16) -> NodeAddr {
|
|
let mut b = [0u8; 16];
|
|
b[0] = tag;
|
|
b[1..3].copy_from_slice(&i.to_le_bytes());
|
|
NodeAddr::from_bytes(b)
|
|
}
|
|
|
|
/// A depth-`COORD_DEPTH` coordinate whose leaf is `leaf`, sharing a fixed
|
|
/// interior path and root with `shared_tag`. Peers built with the dest's
|
|
/// shared_tag sit close to the destination (distance 2); a distinct shared_tag
|
|
/// sits far (near the root), modeling our own position.
|
|
fn coord(leaf: NodeAddr, shared_tag: u8) -> TreeCoordinate {
|
|
let mut path = Vec::with_capacity(COORD_DEPTH);
|
|
path.push(leaf);
|
|
for level in 1..(COORD_DEPTH - 1) {
|
|
path.push(addr(shared_tag, level as u16));
|
|
}
|
|
path.push(addr(9, 0)); // common root
|
|
TreeCoordinate::from_addrs(path).expect("valid coord path")
|
|
}
|
|
|
|
struct Scenario {
|
|
view: BenchView,
|
|
dest: NodeAddr,
|
|
dest_coords: TreeCoordinate,
|
|
my_coords: TreeCoordinate,
|
|
}
|
|
|
|
impl Scenario {
|
|
fn new(n: usize) -> Self {
|
|
let dest = addr(2, 0);
|
|
// Destination path uses interior tag 4; peers reuse tag 4 so survivors
|
|
// are close to the destination. Our own coords use tag 5 (far).
|
|
let dest_coords = coord(dest, 4);
|
|
let my_coords = coord(addr(6, 0), 5);
|
|
|
|
let mut peers = HashMap::new();
|
|
let mut coords = HashMap::new();
|
|
for i in 0..n {
|
|
let paddr = addr(1, i as u16);
|
|
let mut bloom = BloomFilter::new();
|
|
// Realistic fill: a handful of unrelated reachable addrs.
|
|
for f in 0..4u16 {
|
|
bloom.insert(&addr(7, i as u16 * 4 + f));
|
|
}
|
|
// A controlled fraction advertise the destination as reachable.
|
|
if (i % REACH_DENOMINATOR) < REACH_NUMERATOR {
|
|
bloom.insert(&dest);
|
|
}
|
|
peers.insert(
|
|
paddr,
|
|
BenchPeer {
|
|
bloom,
|
|
can_send: true,
|
|
link_cost: 1.0 + (i as f64) * 0.01,
|
|
},
|
|
);
|
|
// Peers share the destination's interior path (tag 4) → close.
|
|
coords.insert(paddr, coord(paddr, 4));
|
|
}
|
|
|
|
Self {
|
|
view: BenchView { peers, coords },
|
|
dest,
|
|
dest_coords,
|
|
my_coords,
|
|
}
|
|
}
|
|
|
|
fn survivors(&self) -> usize {
|
|
self.view
|
|
.peers
|
|
.values()
|
|
.filter(|p| p.bloom.contains(&self.dest))
|
|
.count()
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Allocation-per-call report (printed once, before criterion timing).
|
|
// ---------------------------------------------------------------------------
|
|
fn count_allocs<T>(iters: usize, mut f: impl FnMut() -> T) -> f64 {
|
|
for _ in 0..8 {
|
|
black_box(f());
|
|
}
|
|
let start = ALLOCS.load(Ordering::Relaxed);
|
|
for _ in 0..iters {
|
|
black_box(f());
|
|
}
|
|
let end = ALLOCS.load(Ordering::Relaxed);
|
|
(end - start) as f64 / iters as f64
|
|
}
|
|
|
|
fn report_allocs() {
|
|
const ITERS: usize = 2000;
|
|
println!("\n=== allocations per call (heap alloc ops: alloc+alloc_zeroed+realloc) ===");
|
|
println!(
|
|
"{:>6} {:>10} {:>16} {:>16}",
|
|
"peers", "survivors", "current/call", "zero-alloc/call"
|
|
);
|
|
for &n in &PEER_COUNTS {
|
|
let s = Scenario::new(n);
|
|
let survivors = s.survivors();
|
|
let current = count_allocs(ITERS, || {
|
|
let cands = routing_candidates(&s.view, &s.dest);
|
|
select_best_candidate(&cands, &s.dest_coords, &s.my_coords)
|
|
});
|
|
let zero = count_allocs(ITERS, || {
|
|
resolve_next_hop_zeroalloc(&s.view, &s.dest, &s.dest_coords, &s.my_coords)
|
|
});
|
|
println!("{n:>6} {survivors:>10} {current:>16.2} {zero:>16.2}");
|
|
}
|
|
println!();
|
|
}
|
|
|
|
fn bench_next_hop(c: &mut Criterion) {
|
|
report_allocs();
|
|
|
|
let mut group = c.benchmark_group("find_next_hop");
|
|
for &n in &PEER_COUNTS {
|
|
let scenario = Scenario::new(n);
|
|
group.bench_with_input(BenchmarkId::new("current_alloc", n), &n, |b, _| {
|
|
b.iter(|| {
|
|
let cands = routing_candidates(&scenario.view, &scenario.dest);
|
|
black_box(select_best_candidate(
|
|
&cands,
|
|
&scenario.dest_coords,
|
|
&scenario.my_coords,
|
|
))
|
|
});
|
|
});
|
|
group.bench_with_input(BenchmarkId::new("zero_alloc_ref", n), &n, |b, _| {
|
|
b.iter(|| {
|
|
black_box(resolve_next_hop_zeroalloc(
|
|
&scenario.view,
|
|
&scenario.dest,
|
|
&scenario.dest_coords,
|
|
&scenario.my_coords,
|
|
))
|
|
});
|
|
});
|
|
}
|
|
group.finish();
|
|
}
|
|
|
|
criterion_group! {
|
|
name = benches;
|
|
config = Criterion::default().sample_size(50);
|
|
targets = bench_next_hop
|
|
}
|
|
criterion_main!(benches);
|