| """Benchmark the routers on identical scenarios.
|
|
|
| python examples/benchmark_routers.py # data/
|
| python examples/benchmark_routers.py --data data_small --reference potential --csv figures/benchmark.csv
|
|
|
| Every episode is replayed under every router, so the comparison is *paired*: for each router the
|
| script reports its per-episode difference to a reference router (loss ratio, mean delay) with a
|
| bootstrap 95 % confidence interval over episodes and the fraction of episodes it wins, then
|
| breaks the loss ratio down by each design factor and the flow-level path stretch and queueing
|
| delay. The script also asserts the structural properties the analysis relies on (every episode
|
| present under every router, aligned pairs), so it doubles as an end-to-end read test.
|
| """
|
| import argparse
|
| import sys
|
| from pathlib import Path
|
|
|
| import numpy as np
|
| import pandas as pd
|
|
|
| ROOT = Path(__file__).resolve().parents[1]
|
| sys.path.insert(0, str(ROOT))
|
|
|
| from src.dataset import FACTORS, Dataset
|
|
|
| METRICS = ["loss_ratio", "mean_delay", "p99_delay", "link_utilisation", "link_saturation", "route_changes"]
|
|
|
|
|
| def bootstrap_ci(values: np.ndarray, rng: np.random.Generator, samples: int = 2000, level: float = 0.95):
|
| """Percentile bootstrap confidence interval of the mean over episodes."""
|
| means = rng.choice(values, size=(samples, len(values)), replace=True).mean(axis=1)
|
| lo, hi = np.percentile(means, [50 * (1 - level), 50 * (1 + level)])
|
| return values.mean(), lo, hi
|
|
|
|
|
| def paired_table(summary: pd.DataFrame, reference: str, rng: np.random.Generator) -> pd.DataFrame:
|
| wide = {m: summary.pivot(index="episode_id", columns="router", values=m) for m in ("loss_ratio", "mean_delay")}
|
| rows = []
|
| for router in wide["loss_ratio"].columns:
|
| if router == reference:
|
| continue
|
| d_loss = (wide["loss_ratio"][router] - wide["loss_ratio"][reference]).to_numpy()
|
| pair = wide["mean_delay"][[router, reference]].dropna()
|
| d_delay = (pair[router] - pair[reference]).to_numpy()
|
| m, lo, hi = bootstrap_ci(d_loss, rng)
|
| md, dlo, dhi = bootstrap_ci(d_delay, rng)
|
| rows.append({"router": router, "episodes": len(d_loss),
|
| "loss_diff": m, "loss_ci_low": lo, "loss_ci_high": hi,
|
| "wins_loss": np.mean(d_loss < 0), "ties_loss": np.mean(d_loss == 0),
|
| "delay_diff": md, "delay_ci_low": dlo, "delay_ci_high": dhi,
|
| "wins_delay": np.mean(d_delay < 0)})
|
| return pd.DataFrame(rows).set_index("router")
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
| parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
|
| parser.add_argument("--reference", default="shortest_path", help="router the others are compared with")
|
| parser.add_argument("--csv", type=Path, default=None, help="write the per-episode joined summary here")
|
| parser.add_argument("--seed", type=int, default=0, help="bootstrap seed")
|
| args = parser.parse_args()
|
| pd.set_option("display.width", 160)
|
| pd.set_option("display.precision", 4)
|
|
|
| ds = Dataset(args.data)
|
| summary = ds.summary("router_summary")
|
| routers = list(ds.routers)
|
| assert set(summary.router) == set(routers), "router_summary does not contain every configured router"
|
| per_episode = summary.groupby("episode_id").router.nunique()
|
| assert (per_episode == len(routers)).all(), "every episode must be present under every router"
|
| assert args.reference in routers, f"--reference must be one of {routers}"
|
| print(f"{ds.path}: {summary.episode_id.nunique()} episodes x {len(routers)} routers, "
|
| f"{len(ds.config.cells)} design cells\n")
|
|
|
| print("Mean over episodes:")
|
| print(summary.groupby("router")[METRICS].mean().loc[routers].to_string(), "\n")
|
|
|
| print(f"Paired differences to '{args.reference}' (negative = better; bootstrap 95 % CI over episodes):")
|
| print(paired_table(summary, args.reference, np.random.default_rng(args.seed)).to_string(), "\n")
|
|
|
| for factor in FACTORS:
|
| if summary[factor].nunique() > 1:
|
| print(f"Mean loss ratio by {factor}:")
|
| print(summary.pivot_table(index=factor, columns="router", values="loss_ratio", aggfunc="mean")[routers]
|
| .to_string(), "\n")
|
|
|
| flows = ds.summary("flow_summary")
|
| delivered = flows[flows.delivered > 0].copy()
|
| delivered["path_stretch"] = delivered.mean_hops / delivered.min_hops
|
| delivered["latency_stretch"] = delivered.mean_path_latency / delivered.min_latency
|
| print("Flow level (flows with at least one delivered packet):")
|
| print(delivered.groupby("router").agg(flows=("flow", "size"), lossless_share=("dropped", lambda d: np.mean(d == 0)),
|
| path_stretch=("path_stretch", "mean"),
|
| latency_stretch=("latency_stretch", "mean"),
|
| queueing_delay=("mean_queueing_delay", "mean"),
|
| p99_delay=("p99_delay", "mean")).loc[routers].to_string(), "\n")
|
|
|
| if args.csv:
|
| args.csv.parent.mkdir(parents=True, exist_ok=True)
|
| summary.to_csv(args.csv, index=False)
|
| print(f"Per-episode summary written to {args.csv}")
|
| print("All checks passed.")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
