| """Convergence harness: ONE fixed instance per seed, shared fitness target.""" |
| import numpy as np, sim, schedulers as sch |
|
|
| def build_instance(n_nodes, lam, seed): |
| rng = np.random.default_rng(seed) |
| nodes = sim.make_nodes(n_nodes, rng) |
| cap, mem, p_idle, p_peak = sim.node_arrays(nodes) |
| link_lat = sim.make_link_latency(n_nodes, rng) |
| n_arr = rng.poisson(lam * sim.DT * 3) |
| demand, tmem, deadline, cls = sim.make_tasks(max(n_arr, 8), rng) |
| backlog = rng.uniform(0, cap * sim.DT * 0.5) |
| return dict(demand=demand, tmem=tmem, deadline=deadline, cls=cls, |
| backlog=backlog, cap=cap, mem=mem, link_lat=link_lat, |
| p_idle=p_idle, p_peak=p_peak) |
|
|
| def _ctx(inst, seed): |
| return sch.Ctx(inst["demand"], inst["tmem"], inst["deadline"], inst["cls"], |
| inst["backlog"], inst["cap"], inst["link_lat"], |
| inst["p_idle"], inst["p_peak"], 0.5, 0.3, 0.2, |
| np.random.default_rng(seed + 1000), node_mem=inst["mem"]) |
|
|
| METHODS = { |
| "ACO": lambda c,it: sch.standalone_aco(c, iters=it), |
| "PSO": lambda c,it: sch.standalone_pso(c, iters=it), |
| "WOA": lambda c,it: sch.woa(c, iters=it), |
| "AdaptiSwarm": lambda c,it: sch.adaptiswarm_edge(c, iters=it, sigma_u=0.2), |
| "Abl_ACOonly": lambda c,it: sch.adaptiswarm_edge(c, iters=it, use_pso=False, sigma_u=0.2), |
| "Abl_PSOrand": lambda c,it: sch.adaptiswarm_edge(c, iters=it, use_aco_seed=False, use_adaptive=False, sigma_u=0.2), |
| "Abl_PSOseed": lambda c,it: sch.adaptiswarm_edge(c, iters=it, use_adaptive=False, sigma_u=0.2), |
| } |
|
|
| def run_curves(n_nodes=25, lam=100, seed=7, iters=40, methods=None): |
| if methods is None: methods = ["ACO","PSO","WOA","AdaptiSwarm"] |
| inst = build_instance(n_nodes, lam, seed) |
| curves = {} |
| for m in methods: |
| _, c = METHODS[m](_ctx(inst, seed), iters) |
| c = list(c) |
| if len(c) < iters: c = c + [c[-1]] * (iters - len(c)) |
| curves[m] = np.array(c[:iters], dtype=float) |
| best_final = min(c[-1] for c in curves.values()) |
| worst_start = max(c[0] for c in curves.values()) |
| span = abs(worst_start - best_final) + 1e-9 |
| target = best_final + 0.02 * span |
| conv = {} |
| for k, c in curves.items(): |
| hit = np.where(c <= target)[0] |
| conv[k] = int(hit[0] + 1) if hit.size else iters |
| return curves, conv, target |
|
|
