YwxApp/RustyDHCP
4
0
Fork 0
mirror of https://github.com/pj1234678/RustyDHCP.git synced 2026-10-15 00:06:42 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
RustyDHCP/examples/bench.rs
T

665 lines
24 KiB
Rust
Raw Permalink Blame History

//! Zero-dependency throughput benchmarks (std only, no criterion).
//!
//! Run: `cargo run --release --example bench`
//! Reports req/s (higher is better) for decode/encode/filter/pools + UDP loopback.
//! Old-vs-new: record numbers before optimization, re-run after; same machine,
//! same build flags, median of 3 runs.
use dhcp4r::{dhcpv6, options, packet, server};
use std::hint::black_box;
use std::net::{Ipv4Addr, Ipv6Addr, UdpSocket};
use std::time::{Duration, Instant};
fn bench_fn(name: &str, iters: u64, mut f: impl FnMut()) -> f64 {
// warmup (not timed)
for _ in 0..5_000 {
f();
}
let t = Instant::now();
for _ in 0..iters {
f();
}
let el = t.elapsed();
let rps = iters as f64 / el.as_secs_f64();
println!(
"{:<28} {:>12.0} req/s ({:.1} ns/req)",
name,
rps,
el.as_nanos() as f64 / iters as f64
);
rps
}
fn discover_packet() -> packet::Packet {
packet::Packet {
reply: false,
hops: 0,
xid: 0x1234_5678,
secs: 0,
broadcast: false,
ciaddr: Ipv4Addr::UNSPECIFIED,
yiaddr: Ipv4Addr::UNSPECIFIED,
siaddr: Ipv4Addr::UNSPECIFIED,
giaddr: Ipv4Addr::UNSPECIFIED,
chaddr: [1, 2, 3, 4, 5, 6],
options: vec![
options::DhcpOption::DhcpMessageType(options::MessageType::Discover),
options::DhcpOption::ParameterRequestList(vec![1, 3, 6, 15]),
options::DhcpOption::HostName("bench-host".to_string()),
],
}
}
fn request_packet() -> packet::Packet {
packet::Packet {
reply: false,
hops: 0,
xid: 0x9abc_def0,
secs: 0,
broadcast: false,
ciaddr: Ipv4Addr::UNSPECIFIED,
yiaddr: Ipv4Addr::UNSPECIFIED,
siaddr: Ipv4Addr::UNSPECIFIED,
giaddr: Ipv4Addr::UNSPECIFIED,
chaddr: [0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff],
options: vec![
options::DhcpOption::DhcpMessageType(options::MessageType::Request),
options::DhcpOption::RequestedIpAddress(Ipv4Addr::new(192, 168, 2, 10)),
options::DhcpOption::ServerIdentifier(Ipv4Addr::new(192, 168, 2, 1)),
options::DhcpOption::ParameterRequestList(vec![1, 3, 6, 51]),
options::DhcpOption::HostName("bench-request-host".to_string()),
options::DhcpOption::IpAddressLeaseTime(3600),
],
}
}
fn offer_options() -> Vec<options::DhcpOption> {
vec![
options::DhcpOption::IpAddressLeaseTime(86400),
options::DhcpOption::SubnetMask(Ipv4Addr::new(255, 255, 255, 0)),
options::DhcpOption::Router(vec![Ipv4Addr::new(192, 168, 2, 1)]),
options::DhcpOption::DomainNameServer(vec![
Ipv4Addr::new(8, 8, 8, 8),
Ipv4Addr::new(8, 8, 4, 4),
]),
]
}
/// reply assembly without sockets: mirrors Server::reply's Vec build
/// (auto [Msg,SrvId] + extend + conditional PRL filter). Isolates the
/// ~80-150ns assembly cost from the ~15µs UDP number.
fn reply_assembly(offer: &[options::DhcpOption], prl: Option<&[u8]>) -> Vec<options::DhcpOption> {
let mut opts = Vec::with_capacity(offer.len() + 2);
opts.push(options::DhcpOption::DhcpMessageType(
options::MessageType::Offer,
));
opts.push(options::DhcpOption::ServerIdentifier(
Ipv4Addr::new(192, 168, 2, 1),
));
opts.extend(offer.iter().cloned());
if let Some(p) = prl {
server::filter_options_by_req(&mut opts, p);
}
opts
}
fn bench_udp_roundtrip() -> f64 {
// Minimal Offer handler over real loopback UDP, exercising
// Server::reply -> filter_options_by_req -> Packet::encode -> send_to.
// Offer options are cached once (like the real server) so the bench
// measures reply/filter/encode/send, not option rebuilds.
struct BenchHandler {
server_ip: Ipv4Addr,
offer: Vec<options::DhcpOption>,
}
impl server::Handler for BenchHandler {
fn handle_request(&mut self, s: &server::Server, p: packet::Packet) {
let _ = s.reply(
options::MessageType::Offer,
self.offer.clone(),
Ipv4Addr::new(192, 168, 2, 10),
p,
);
}
}
let srv_sock = UdpSocket::bind("127.0.0.1:0").expect("bind srv");
let srv_addr = srv_sock.local_addr().unwrap();
srv_sock
.set_read_timeout(Some(Duration::from_millis(5000)))
.ok();
let server_ip = Ipv4Addr::new(127, 0, 0, 1);
let broadcast_ip = Ipv4Addr::new(127, 0, 0, 1);
let offer = offer_options();
std::thread::spawn(move || {
let _ = server::Server::serve(srv_sock, server_ip, broadcast_ip, BenchHandler { server_ip, offer });
});
// Give server a moment to bind.
std::thread::sleep(Duration::from_millis(100));
let cli = UdpSocket::bind("127.0.0.1:0").expect("bind cli");
cli.connect(srv_addr).expect("connect");
cli.set_read_timeout(Some(Duration::from_secs(5))).ok();
let mut buf = [0u8; dhcp4r::packet::WIRE_MAX];
let wire = {
let mut tmp = [0u8; dhcp4r::packet::WIRE_MAX];
discover_packet().encode(&mut tmp).to_vec()
};
// warmup
let mut rx = [0u8; 1500];
for _ in 0..200 {
cli.send(black_box(&wire)).unwrap();
let _ = cli.recv(&mut rx);
}
const N: u64 = 5_000;
let t = Instant::now();
let mut ok = 0u64;
for _ in 0..N {
cli.send(black_box(&wire)).unwrap();
match cli.recv(&mut rx) {
Ok(l) => {
black_box(l);
ok += 1;
}
Err(_) => break,
}
}
let el = t.elapsed();
// Silence unused warning for buf
black_box(&mut buf);
let rps = ok as f64 / el.as_secs_f64();
println!(
"{:<28} {:>12.0} req/s ({:.1} ns/req, {}/{{}} ok)",
"udp/offer-roundtrip",
rps,
el.as_nanos() as f64 / (ok.max(1) as f64),
ok,
);
// Server thread is detached; process exit kills it.
rps
}
fn main() {
println!("=== dhcp4r bench (release, std Instant, black_box) ===");
println!(
"sizeof Packet={} DhcpOption={} RawDhcpOption={} Server={}",
std::mem::size_of::<packet::Packet>(),
std::mem::size_of::<options::DhcpOption>(),
std::mem::size_of::<options::RawDhcpOption>(),
std::mem::size_of::<server::Server>(),
);
// Wire ceiling is WIRE_MAX = 300 (BOOTP minimum: 240 header+cookie,
// up to 59 bytes options + END, PAD to 300); the shipped
// send path already uses [u8; WIRE_MAX], so the bench does too.
let mut encode_buf = [0u8; dhcp4r::packet::WIRE_MAX];
let d = discover_packet();
let r = request_packet();
let d_wire = d.encode(&mut encode_buf).to_vec();
let r_wire = r.encode(&mut encode_buf).to_vec();
// sanity: roundtrip preserves options
assert_eq!(
packet::Packet::from(&d_wire).ok().expect("decode").options,
d.options
);
const N: u64 = 200_000;
bench_fn("decode/discover", N, || {
black_box(packet::Packet::from(black_box(&d_wire)).ok().expect("decode"));
});
bench_fn("decode/request", N, || {
black_box(packet::Packet::from(black_box(&r_wire)).ok().expect("decode"));
});
bench_fn("encode/discover", N, || {
let n = black_box(&d).encode(black_box(&mut encode_buf)).len();
black_box(n);
});
bench_fn("encode/request", N, || {
let n = black_box(&r).encode(black_box(&mut encode_buf)).len();
black_box(n);
});
// filter_options_by_req: typical Offer(4 opts) filtered by PRL[1,3,6]
bench_fn("filter/prl-3", N, || {
let mut o = offer_options();
// prepend auto opts like Server::reply does
o.insert(0, options::DhcpOption::ServerIdentifier(Ipv4Addr::new(192, 168, 2, 1)));
o.insert(
0,
options::DhcpOption::DhcpMessageType(options::MessageType::Offer),
);
server::filter_options_by_req(black_box(&mut o), black_box(&[1u8, 3, 6]));
black_box(o);
});
// options::to_raw throughput (Router x2) for old-vs-new comparison
let router2 = options::DhcpOption::Router(vec![
Ipv4Addr::new(192, 168, 2, 1),
Ipv4Addr::new(192, 168, 2, 2),
]);
bench_fn("options/to_raw-router2", N, || {
black_box(black_box(&router2).to_raw());
});
// DHCPv6 codec
let v6_solicit = dhcpv6::Packet {
msg_type: dhcpv6::MsgType::Solicit,
transaction_id: 0x112233,
options: vec![
dhcpv6::Dhcpv6Option::ClientId(vec![0, 3, 0, 1, 2, 0, 0x5e, 0xaa, 0xbb, 0xcc]),
dhcpv6::Dhcpv6Option::IaNa(dhcpv6::IaNa {
iaid: 1,
t1: 0,
t2: 0,
addrs: vec![],
}),
],
};
let v6_wire = v6_solicit.encode().unwrap();
bench_fn("v6/decode-solicit", N, || {
black_box(dhcpv6::Packet::from(black_box(&v6_wire)).expect("v6 decode"));
});
bench_fn("v6/encode-solicit", N, || {
black_box(black_box(&v6_solicit).encode().unwrap());
});
let v6_reply = dhcpv6::Packet {
msg_type: dhcpv6::MsgType::Reply,
transaction_id: 0x445566,
options: vec![
dhcpv6::Dhcpv6Option::ServerId(vec![0, 3, 0, 1, 2, 0, 0x5e, 0xaa, 0xbb, 0xcc]),
dhcpv6::Dhcpv6Option::ClientId(vec![0, 3, 0, 1, 9, 9, 9, 9, 9, 9]),
dhcpv6::Dhcpv6Option::IaNa(dhcpv6::IaNa {
iaid: 7,
t1: 43200,
t2: 75600,
addrs: vec![dhcpv6::IaAddr {
addr: Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x100),
preferred: 86400,
valid: 86400,
}],
}),
dhcpv6::Dhcpv6Option::DnsServers(vec![Ipv6Addr::new(
0x2001, 0x4860, 0x4860, 0, 0, 0, 0, 0x8888,
)]),
],
};
bench_fn("v6/encode-reply-1addr", N, || {
black_box(black_box(&v6_reply).encode().unwrap());
});
// V6Pool: 1000-entry pool, hit vs miss
{
let mut pool = dhcpv6::V6Pool::new(
Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x100),
1000,
Duration::from_secs(86400),
);
// prefill 1000 leases with distinct DUIDs
for i in 0..1000u32 {
let mut duid = vec![0, 3, 0, 1];
duid.extend_from_slice(&i.to_be_bytes());
let ip = Ipv6Addr::from(u128::from(pool.start_addr()) + i as u128);
pool.insert(ip, duid, Some(Instant::now() + Duration::from_secs(3600)));
}
let owner_duid = {
let mut d = vec![0, 3, 0, 1];
d.extend_from_slice(&42u32.to_be_bytes());
d
};
bench_fn("v6pool/discover-hit-1000", N, || {
black_box(pool.discover(black_box(&owner_duid)));
});
let stranger: Vec<u8> = vec![9, 9, 9, 9, 9, 9, 9, 9];
// exhausted pool: stranger always misses after full scan
bench_fn("v6pool/discover-miss-full", 5_000, || {
black_box(pool.discover(black_box(&stranger)));
});
}
{
// v4-style pool simulation via V6Pool with small count for comparison
let mut pool = dhcpv6::V6Pool::new(
Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x200),
252,
Duration::from_secs(86400),
);
bench_fn("v6pool/discover-miss-empty-252", 20_000, || {
let mut duid = vec![1, 2, 3, 4];
duid.extend_from_slice(&black_box(12345u32).to_be_bytes());
black_box(pool.discover(black_box(&duid)));
});
}
// ---- Round-2 additions: Nak, hostname-63, large PRL, DNS4, combined ----
{
let nak = packet::Packet {
reply: true,
hops: 0,
xid: 0x1234_5678,
secs: 0,
broadcast: false,
ciaddr: Ipv4Addr::UNSPECIFIED,
yiaddr: Ipv4Addr::UNSPECIFIED,
siaddr: Ipv4Addr::UNSPECIFIED,
giaddr: Ipv4Addr::UNSPECIFIED,
chaddr: [1, 2, 3, 4, 5, 6],
options: vec![
options::DhcpOption::DhcpMessageType(options::MessageType::Nak),
options::DhcpOption::ServerIdentifier(Ipv4Addr::new(192, 168, 2, 1)),
options::DhcpOption::Message("Requested IP not available".to_string()),
],
};
bench_fn("encode/nak", N, || {
let n = black_box(&nak).encode(black_box(&mut encode_buf)).len();
black_box(n);
});
let mut h63 = discover_packet();
h63.options
.push(options::DhcpOption::HostName("h".repeat(63)));
let h63_wire = h63.encode(&mut encode_buf).to_vec();
bench_fn("decode/hostname-63", 100_000, || {
black_box(
packet::Packet::from(black_box(&h63_wire))
.ok()
.expect("decode"),
);
});
bench_fn("encode/hostname-63", 100_000, || {
let n = black_box(&h63).encode(black_box(&mut encode_buf)).len();
black_box(n);
});
bench_fn("decode+msgtype/request", N, || {
let p = packet::Packet::from(black_box(&r_wire))
.ok()
.expect("decode");
black_box(p.message_type().ok());
black_box(p.option(50).is_some());
black_box(p.option(12).is_some());
});
}
{
const PRL10: &[u8] = &[1, 3, 6, 15, 51, 54, 58, 59, 42, 12];
bench_fn("filter/prl-10", N, || {
let mut o = offer_options();
o.insert(
0,
options::DhcpOption::ServerIdentifier(Ipv4Addr::new(192, 168, 2, 1)),
);
o.insert(
0,
options::DhcpOption::DhcpMessageType(options::MessageType::Offer),
);
server::filter_options_by_req(black_box(&mut o), black_box(PRL10));
black_box(o);
});
let dns4 = options::DhcpOption::DomainNameServer(vec![
Ipv4Addr::new(8, 8, 8, 8),
Ipv4Addr::new(8, 8, 4, 4),
Ipv4Addr::new(1, 1, 1, 1),
Ipv4Addr::new(9, 9, 9, 9),
]);
bench_fn("options/to_raw-dns4", N, || {
black_box(black_box(&dns4).to_raw());
});
bench_fn("reply/asm-no-prl", N, || {
let o = offer_options();
black_box(reply_assembly(black_box(&o), None));
});
bench_fn("reply/asm-prl-4", N, || {
let o = offer_options();
black_box(reply_assembly(black_box(&o), Some(black_box(&[1u8, 3, 6, 51]))));
});
}
{
let v6_big = dhcpv6::Packet {
msg_type: dhcpv6::MsgType::Solicit,
transaction_id: 0x112233,
options: vec![
dhcpv6::Dhcpv6Option::ClientId(vec![
0, 3, 0, 1, 2, 0, 0x5e, 0xaa, 0xbb, 0xcc,
]),
dhcpv6::Dhcpv6Option::IaNa(dhcpv6::IaNa {
iaid: 9,
t1: 0,
t2: 0,
addrs: vec![
dhcpv6::IaAddr {
addr: Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x101),
preferred: 100,
valid: 200,
},
dhcpv6::IaAddr {
addr: Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x102),
preferred: 100,
valid: 200,
},
dhcpv6::IaAddr {
addr: Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x103),
preferred: 100,
valid: 200,
},
dhcpv6::IaAddr {
addr: Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x104),
preferred: 100,
valid: 200,
},
],
}),
],
};
let big_wire = v6_big.encode().unwrap();
bench_fn("v6/decode-iana-4addr", N, || {
black_box(dhcpv6::Packet::from(black_box(&big_wire)).expect("v6 decode"));
});
bench_fn("v6/encode-iana-4addr", N, || {
black_box(black_box(&v6_big).encode().unwrap());
});
let mut pool = dhcpv6::V6Pool::new(
Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x300),
252,
Duration::from_secs(86400),
);
bench_fn("v6pool/release-hit", 20_000, || {
let mut d = vec![8, 8, 8, 8];
d.extend_from_slice(&black_box(pool.len() as u32).to_be_bytes());
d.extend_from_slice(&black_box(999u32).to_be_bytes());
if let Some(ip) = pool.discover(&d) {
let _ = pool.request(&d, ip);
}
black_box(pool.release(black_box(&d)));
});
}
// ---- Final-round diagnostics: hostile wire + v6 mix (not headlines) ----
{
// 4096B / 1285-option bomb: proves Vec growth stays linear/bounded.
let mut opts = vec![53u8, 1, 1];
for _ in 0..1284 {
opts.extend_from_slice(&[200, 1, 7]);
}
opts.push(255);
let mut raw = vec![0u8; 236];
raw[0] = 1;
raw[1] = 1;
raw[2] = 6;
raw.extend_from_slice(&[99, 130, 83, 99]);
raw.extend_from_slice(&opts);
assert_eq!(raw.len(), 4096);
bench_fn("diag/decode-4096b", 5_000, || {
let p = packet::Packet::from(black_box(&raw)).ok().expect("decode");
black_box(p.options.len());
});
// Mixed reject rate: truncated, bad type, short, bad cookie,
// non-UTF8 hostname, Router fast-fail. No-cliff proof only.
let mut bad_cookie = vec![0u8; 236];
bad_cookie[0] = 1;
bad_cookie[1] = 1;
bad_cookie[2] = 6;
bad_cookie.extend_from_slice(&[9, 9, 9, 9, 53, 1, 1, 255]);
let cases: Vec<Vec<u8>> = vec![
{
let mut v = vec![0u8; 236];
v[0] = 1;
v[1] = 1;
v[2] = 6;
v.extend_from_slice(&[99, 130, 83, 99, 53, 1, 1, 200, 255, 7]);
v
},
{
let mut v = vec![0u8; 236];
v[0] = 1;
v[1] = 1;
v[2] = 6;
v.extend_from_slice(&[99, 130, 83, 99, 53, 1, 9]);
v
},
vec![0u8; 10],
bad_cookie,
];
bench_fn("diag/reject-mixed", 20_000, || {
for c in &cases {
black_box(packet::Packet::from(black_box(c)).is_err());
}
});
}
{
// v6 traffic mix: solicit-fresh / renew-hit / release, half-full pool.
let mut pool = dhcpv6::V6Pool::new(
Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0x400),
252,
Duration::from_secs(86400),
);
for i in 0..126u32 {
let mut duid = vec![0, 3, 0, 1];
duid.extend_from_slice(&i.to_be_bytes());
let ip = Ipv6Addr::from(u128::from(pool.start_addr()) + i as u128);
pool.insert(ip, duid, Some(Instant::now() + Duration::from_secs(3600)));
}
let mut state: u64 = 0x1234_5678_9abc_def0;
let mut next_rand = || {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
state
};
bench_fn("mix/v6-solicit-renew-release", 50_000, || {
let r = next_rand();
let mut duid = vec![0, 3, 0, 1];
duid.extend_from_slice(&((r & 0xFFFF) as u32).to_be_bytes());
match r % 3 {
0 => {
black_box(pool.discover(black_box(&duid)));
}
1 => {
if let Some(ip) = pool.discover(&duid) {
black_box(pool.request(black_box(&duid), black_box(ip)).ok());
}
}
_ => {
black_box(pool.release(black_box(&duid)));
}
}
});
}
// Full UDP loopback (dominant for "requests per second it can do").
bench_udp_roundtrip();
if std::env::var("BENCH_SUSTAINED").is_ok() {
bench_udp_sustained();
}
println!("=== done (median of 3 runs; higher req/s is better) ===");
}
fn bench_udp_sustained() {
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
struct CountHandler {
n: Arc<AtomicU64>,
offer: Vec<options::DhcpOption>,
}
impl server::Handler for CountHandler {
fn handle_request(&mut self, s: &server::Server, p: packet::Packet) {
self.n.fetch_add(1, Ordering::Relaxed);
let _ = s.reply(
options::MessageType::Offer,
self.offer.clone(),
Ipv4Addr::new(192, 168, 2, 10),
p,
);
}
}
let mut medians = vec![];
for _ in 0..1 {
let srv = UdpSocket::bind("127.0.0.1:0").expect("bind srv");
let sa = srv.local_addr().unwrap();
let handled = Arc::new(AtomicU64::new(0));
let h = handled.clone();
let offer = offer_options();
std::thread::spawn(move || {
let _ = server::Server::serve(
srv,
Ipv4Addr::new(127, 0, 0, 1),
Ipv4Addr::new(127, 0, 0, 1),
CountHandler { n: h, offer },
);
});
std::thread::sleep(Duration::from_millis(100));
let tx = UdpSocket::bind("127.0.0.1:0").expect("bind tx");
tx.connect(sa).unwrap();
let rx = tx.try_clone().unwrap();
rx.set_read_timeout(Some(Duration::from_millis(500))).ok();
let wire = {
let mut t = [0u8; dhcp4r::packet::WIRE_MAX];
discover_packet().encode(&mut t).to_vec()
};
let lats = Arc::new(Mutex::new(Vec::with_capacity(1 << 20)));
let run = Arc::new(AtomicBool::new(true));
let rx_lats = lats.clone();
let rx_flag = run.clone();
let rxh = std::thread::spawn(move || {
let mut b = [0u8; 1500];
let mut n = 0u64;
while rx_flag.load(Ordering::Relaxed) {
let t0 = Instant::now();
if rx.recv(&mut b).is_ok() {
n += 1;
rx_lats.lock().unwrap().push(t0.elapsed());
}
}
n
});
let dur = Duration::from_secs(10);
let t0 = Instant::now();
let mut sent = 0u64;
while t0.elapsed() < dur {
tx.send(black_box(&wire)).unwrap();
sent += 1;
}
std::thread::sleep(Duration::from_millis(500));
run.store(false, Ordering::Relaxed);
let got = rxh.join().unwrap();
let hv = handled.load(Ordering::Relaxed);
let mut v = lats.lock().unwrap().clone();
v.sort_unstable();
let pct = |q: f64| v.get((v.len() as f64 * q) as usize).copied().unwrap_or_default();
let loss = 100.0 * (sent.saturating_sub(got) as f64) / (sent.max(1) as f64);
let rps = hv as f64 / dur.as_secs_f64();
println!(
"{:<28} {:>12.0} req/s (sent={} handled={} rx={} loss={:.1}% p50={:?} p99={:?})",
"udp/sustained-10s",
rps,
sent,
hv,
got,
loss,
pct(0.5),
pct(0.99)
);
medians.push(rps);
}
medians.sort_by(|a, b| a.partial_cmp(b).unwrap());
println!(
"{:<28} {:>12.0} req/s (median)",
"udp/sustained-median",
medians[medians.len() / 2]
);
}
Reference in New Issue View Git Blame Copy Permalink