Upload runner.py

runner.py

@@ -0,0 +1,73 @@
+"""Episode runner with persistent pheromone across churn."""
+import numpy as np, sim, schedulers as sch
+
+SCHEDULERS = {
+    "RoundRobin": lambda ctx, st, **k: sch.round_robin(ctx),
+    "LeastConn":  lambda ctx, st, **k: sch.least_connection(ctx),
+    "ACO":        lambda ctx, st, **k: sch.standalone_aco(ctx, iters=k["iters"], state=st),
+    "PSO":        lambda ctx, st, **k: sch.standalone_pso(ctx, iters=k["iters"]),
+    "WOA":        lambda ctx, st, **k: sch.woa(ctx, iters=k["iters"]),
+    "AdaptiSwarm": lambda ctx, st, **k: sch.adaptiswarm_edge(ctx, iters=k["iters"], sigma_u=k.get("sigma_u",0.0), state=st),
+    "Abl_ACOonly": lambda ctx, st, **k: sch.adaptiswarm_edge(ctx, iters=k["iters"], use_pso=False, sigma_u=k.get("sigma_u",0.0), state=st),
+    "Abl_PSOrand": lambda ctx, st, **k: sch.adaptiswarm_edge(ctx, iters=k["iters"], use_aco_seed=False, use_adaptive=False, sigma_u=k.get("sigma_u",0.0), state=st),
+    "Abl_PSOseed": lambda ctx, st, **k: sch.adaptiswarm_edge(ctx, iters=k["iters"], use_adaptive=False, sigma_u=k.get("sigma_u",0.0), state=st),
+}
+
+def run_episode(name, n_nodes, lam, seed, n_steps=15, iters=40,
+                alpha=0.5, beta=0.3, gamma=0.2, churn=True, probe_step=8):
+    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)
+    active = np.ones(n_nodes, dtype=bool); backlog = np.zeros(n_nodes); state = {}
+    agg = dict(latency=[], energy=[], util=[], jain=[], A_met=[], all_met=[], sigma=[])
+    conv_curve = None; prev_util = np.zeros(n_nodes)
+    for step in range(n_steps):
+        if churn and n_nodes >= 5:
+            if rng.random() < 0.3:
+                idx = rng.integers(n_nodes); active[idx] = not active[idx]
+            if active.sum() < max(2, n_nodes // 3):
+                active[:] = True
+        act_idx = np.where(active)[0]
+        a_cap = cap[act_idx]; a_mem = mem[act_idx]; a_link = link_lat[act_idx]
+        a_pidle = p_idle[act_idx]; a_ppeak = p_peak[act_idx]; a_backlog = backlog[act_idx]
+        n_arr = rng.poisson(lam * sim.DT)
+        demand, tmem, deadline, cls = sim.make_tasks(n_arr, rng)
+        sigma_u_live = float(np.std(prev_util[act_idx])) if act_idx.size else 0.0
+        ctx = sch.Ctx(demand, tmem, deadline, cls, a_backlog, a_cap, a_link,
+                      a_pidle, a_ppeak, alpha, beta, gamma, rng, node_mem=a_mem)
+        local_state = {}
+        for gkey in ("aco", "adapti"):
+            gtau = state.get("global_" + gkey)
+            if gtau is not None: local_state[gkey] = gtau[act_idx].copy()
+        assign, curve = SCHEDULERS[name](ctx, local_state, iters=iters, sigma_u=sigma_u_live)
+        for gkey in ("aco", "adapti"):
+            if gkey in local_state:
+                gtau = state.get("global_" + gkey)
+                if gtau is None: gtau = np.ones(n_nodes)
+                gtau[act_idx] = local_state[gkey]; state["global_" + gkey] = gtau
+        if n_arr > 0:
+            mtr = sim.evaluate(assign, demand, tmem, deadline, cls, a_backlog,
+                               a_cap, a_link, a_pidle, a_ppeak, alpha, beta,
+                               gamma, return_metrics=True, node_mem=a_mem)
+            for k,mk in [("latency","avg_latency"),("energy","energy"),("util","utilization"),
+                         ("jain","jain"),("A_met","classA_deadline_met"),("all_met","all_deadline_met"),("sigma","sigma_u")]:
+                agg[k].append(mtr[mk])
+            added = np.zeros(len(act_idx))
+            for j,n in enumerate(assign): added[n] += demand[j]
+            backlog[act_idx] = np.maximum(a_backlog + added - a_cap * sim.DT, 0.0)
+            prev_util = np.zeros(n_nodes); prev_util[act_idx] = mtr["served"] / (a_cap * sim.DT)
+        else:
+            backlog[act_idx] = np.maximum(a_backlog - a_cap * sim.DT, 0.0)
+        if step == probe_step and len(curve) > 1: conv_curve = curve
+    def stat(key):
+        v = np.array(agg[key]) if agg[key] else np.array([0.0]); return v.mean()
+    conv_iter = iters
+    if conv_curve is not None and len(conv_curve) > 1:
+        final = conv_curve[-1]; rs = abs(conv_curve[0] - final) + 1e-9
+        for i,f in enumerate(conv_curve):
+            if abs(f - final) <= 0.02 * rs: conv_iter = i + 1; break
+    return dict(latency_ms=stat("latency")*1000.0, utilization=stat("util")*100.0,
+                energy=stat("energy"), jain=stat("jain"),
+                A_deadline=stat("A_met")*100.0, all_deadline=stat("all_met")*100.0,
+                conv_iter=conv_iter, conv_curve=conv_curve)