rba_simulation_engine.py

#!/usr/bin/env python3
"""
RBA Synthetic Placeholder Data Generator
=========================================
NOT a simulation of routing physics and NOT a measurement of any real
OpenROAD/TritonRoute run. This is a schema/plot exerciser: it draws RNG
values from hardcoded per-benchmark profiles shaped to land in the numeric
ranges reported by published ISPD 2018/2019 contest results, so that the
JSON schema, plotting code, and GUI have realistic-looking data to render
before a real routing harness exists.

Produces placeholder JSON result files consumed by the GUI and plotting
system. Treat every number this script emits as synthetic, not measured.
"""

import json
import math
import os
import random
import time
from dataclasses import dataclass, field, asdict
from pathlib import Path
from typing import List, Dict, Optional
import numpy as np
import argparse

# ─── ISPD benchmark profiles (from published contest results) ─────────────────

ISPD18_BENCHMARKS = [
    {"name": "ispd18_test1",  "nets": 392_000, "cells": 218_000, "layers": 6,
     "baseline_drc": 4_212,  "baseline_via": 1_024_891, "baseline_wl": 87_432_100},
    {"name": "ispd18_test2",  "nets": 518_000, "cells": 291_000, "layers": 6,
     "baseline_drc": 6_887,  "baseline_via": 1_381_204, "baseline_wl": 124_700_000},
    {"name": "ispd18_test3",  "nets": 608_000, "cells": 341_000, "layers": 6,
     "baseline_drc": 9_134,  "baseline_via": 1_612_441, "baseline_wl": 148_930_000},
    {"name": "ispd18_test4",  "nets": 742_000, "cells": 412_000, "layers": 8,
     "baseline_drc": 14_221, "baseline_via": 2_031_887, "baseline_wl": 193_410_000},
    {"name": "ispd18_test5",  "nets": 892_000, "cells": 501_000, "layers": 8,
     "baseline_drc": 18_943, "baseline_via": 2_441_303, "baseline_wl": 231_200_000},
    {"name": "ispd18_test6",  "nets": 1_020_000,"cells": 572_000,"layers": 9,
     "baseline_drc": 22_317, "baseline_via": 2_788_901, "baseline_wl": 271_840_000},
    {"name": "ispd18_test7",  "nets": 1_156_000,"cells": 641_000,"layers": 9,
     "baseline_drc": 27_041, "baseline_via": 3_122_091, "baseline_wl": 314_000_000},
    {"name": "ispd18_test8",  "nets": 1_304_000,"cells": 729_000,"layers": 10,
     "baseline_drc": 31_818, "baseline_via": 3_524_432, "baseline_wl": 358_100_000},
    {"name": "ispd18_test9",  "nets": 1_521_000,"cells": 849_000,"layers": 10,
     "baseline_drc": 39_204, "baseline_via": 4_011_209, "baseline_wl": 421_700_000},
    {"name": "ispd18_test10", "nets": 1_788_000,"cells": 998_000,"layers": 11,
     "baseline_drc": 51_337, "baseline_via": 4_712_881, "baseline_wl": 512_400_000},
]

ISPD19_BENCHMARKS = [
    {"name": "ispd19_test1",  "nets": 411_000, "cells": 231_000, "layers": 7,
     "baseline_drc": 3_891,  "baseline_via": 1_089_301, "baseline_wl": 91_230_000},
    {"name": "ispd19_test2",  "nets": 571_000, "cells": 311_000, "layers": 7,
     "baseline_drc": 5_943,  "baseline_via": 1_421_009, "baseline_wl": 131_400_000},
    {"name": "ispd19_test3",  "nets": 693_000, "cells": 389_000, "layers": 8,
     "baseline_drc": 8_211,  "baseline_via": 1_712_334, "baseline_wl": 162_000_000},
    {"name": "ispd19_test4",  "nets": 821_000, "cells": 459_000, "layers": 8,
     "baseline_drc": 12_441, "baseline_via": 2_091_887, "baseline_wl": 199_800_000},
    {"name": "ispd19_test5",  "nets": 961_000, "cells": 537_000, "layers": 9,
     "baseline_drc": 15_878, "baseline_via": 2_441_009, "baseline_wl": 238_500_000},
    {"name": "ispd19_test6",  "nets": 1_122_000,"cells": 628_000,"layers": 9,
     "baseline_drc": 21_003, "baseline_via": 2_841_001, "baseline_wl": 289_100_000},
    {"name": "ispd19_test7",  "nets": 1_298_000,"cells": 728_000,"layers": 10,
     "baseline_drc": 26_741, "baseline_via": 3_281_009, "baseline_wl": 341_800_000},
    {"name": "ispd19_test8",  "nets": 1_511_000,"cells": 851_000,"layers": 10,
     "baseline_drc": 34_218, "baseline_via": 3_891_441, "baseline_wl": 412_300_000},
    {"name": "ispd19_test9",  "nets": 1_741_000,"cells": 978_000,"layers": 11,
     "baseline_drc": 47_112, "baseline_via": 4_512_891, "baseline_wl": 492_100_000},
]


# ─── GA Simulation ────────────────────────────────────────────────────────────

def simulate_ga(n_nets: int, n_pop: int = 50, n_gen: int = 80, seed: int = 42):
    """
    Simulate GA net ordering convergence.
    Returns per-generation fitness history and final improvement ratio.
    """
    rng = np.random.default_rng(seed)
    # Surrogate fitness: normalized congestion score
    # Starts high (random order), decreases as ordering improves
    # Models observed empirical convergence: ~30% improvement in 50-80 gens
    initial_fitness = 1.0
    target_improvement = rng.uniform(0.22, 0.38)  # 22–38% improvement

    history = []
    best = initial_fitness

    for g in range(n_gen):
        # Logistic-style convergence + noise
        progress = 1 - math.exp(-4.5 * g / n_gen)
        noise = rng.normal(0, 0.008 * (1 - g/n_gen))
        current = initial_fitness * (1 - target_improvement * progress) + noise
        current = max(current, initial_fitness * (1 - target_improvement))
        best = min(best, current)

        # Stagnation plateau after 60% of gens
        if g > int(0.6 * n_gen) and rng.random() < 0.7:
            current = best + rng.uniform(0, 0.005)

        history.append({
            "generation":       g,
            "best_fitness":     round(best, 6),
            "mean_fitness":     round(current * 1.08, 6),
            "worst_fitness":    round(current * 1.18 + rng.uniform(0, 0.05), 6),
            "diversity":        round(max(0, 1 - g / n_gen * 0.9 + rng.uniform(-0.05, 0.05)), 4),
        })

    improvement_pct = target_improvement * 100
    return history, improvement_pct


# ─── ACO Simulation ───────────────────────────────────────────────────────────

def simulate_aco(n_nets: int, n_ants: int = 20, n_iter: int = 40, seed: int = 7):
    """
    Simulate ACO pheromone convergence and path quality improvement.
    Returns per-iteration metrics and pheromone statistics.
    """
    rng = np.random.default_rng(seed)
    tau_min, tau_max = 1e-4, 10.0
    tau_mean = tau_min

    history = []
    best_path_cost = 1.0

    for i in range(n_iter):
        # Pheromone mean increases as ants reinforce good paths
        reinforcement = (1 - math.exp(-5 * i / n_iter)) * (tau_max * 0.3)
        tau_mean = tau_min + reinforcement + rng.normal(0, reinforcement * 0.05)
        tau_mean = np.clip(tau_mean, tau_min, tau_max)

        # Path cost decreases (better routes found)
        path_improvement = 1 - 0.28 * (1 - math.exp(-4 * i / n_iter))
        noise = rng.normal(0, 0.008)
        best_path_cost = min(best_path_cost, path_improvement + noise)
        best_path_cost = max(0.68, best_path_cost)

        # DRC in found paths (decreases as pheromones guide away from hotspots)
        drc_in_paths = max(0, int(50 * (1 - i/n_iter) ** 1.5 + rng.normal(0, 3)))

        history.append({
            "iteration":            i,
            "tau_mean":             round(float(tau_mean), 5),
            "tau_std":              round(float(rng.uniform(0.01, 0.05) * tau_mean), 6),
            "best_path_cost":       round(best_path_cost, 5),
            "mean_path_cost":       round(best_path_cost * rng.uniform(1.05, 1.12), 5),
            "drc_in_paths":         drc_in_paths,
            "pheromone_entropy":    round(max(0.1, 2.5 - 2.0 * i / n_iter + rng.normal(0,0.1)), 3),
            "ants_found_path":      int(n_ants * min(1.0, 0.3 + 0.7 * i / n_iter)),
        })

    return history


# ─── PSO Simulation ───────────────────────────────────────────────────────────

def simulate_pso(n_particles: int = 20, n_iter: int = 30, seed: int = 99):
    """
    Simulate PSO weight optimization.
    Returns per-iteration gbest fitness + weight trajectories.
    """
    rng = np.random.default_rng(seed)

    # Optimal weights (ground truth — PSO converges toward these)
    w_opt = {"w_wire": 1.8, "w_via": 5.2, "w_cong": 3.1,
             "w_drc_hist": 7.4, "w_layer_pref": 1.3, "w_timing": 0.9}

    # Initial weights (defaults)
    w_cur = {"w_wire": 1.0, "w_via": 4.0, "w_cong": 2.0,
             "w_drc_hist": 5.0, "w_layer_pref": 1.0, "w_timing": 0.5}

    history = []
    gbest_fitness = 1.0

    for i in range(n_iter):
        # Convergence fraction
        prog = 1 - math.exp(-4 * i / max(n_iter-1, 1))

        # Weights converge toward optimum
        for k in w_cur:
            diff = w_opt[k] - w_cur[k]
            w_cur[k] += diff * prog * 0.7 + rng.normal(0, 0.08 * (1 - prog))
            w_cur[k] = max(0.1, min(20.0, w_cur[k]))

        # gbest fitness: routing quality (lower = better DRC+via)
        fitness_noise = rng.normal(0, 0.01 * (1 - prog))
        gbest_fitness = min(gbest_fitness,
                            1.0 - 0.35 * prog + fitness_noise)
        gbest_fitness = max(0.62, gbest_fitness)

        # Particle spread (convergence)
        spread = max(0.02, (1 - prog) * 0.8 + rng.uniform(0, 0.05))

        row = {
            "iteration":     i,
            "gbest_fitness": round(gbest_fitness, 5),
            "pbest_mean":    round(gbest_fitness + rng.uniform(0.01, 0.08), 5),
            "swarm_spread":  round(spread, 4),
            "inertia_omega": round(0.729 - (0.729 - 0.4) * i / max(n_iter-1,1), 4),
        }
        row.update({f"w_{k}": round(v, 3) for k, v in w_cur.items()
                    if k.startswith("w_")})
        history.append(row)

    return history, w_cur


# ─── ABC Simulation ───────────────────────────────────────────────────────────

def simulate_abc(initial_via_count: int, n_bees: int = 20,
                 n_cycles: int = 80, seed: int = 55):
    """Simulate ABC via minimization."""
    rng = np.random.default_rng(seed)

    # Achievable via reduction: 6–14% via ABC (calibrated to literature)
    max_reduction = rng.uniform(0.06, 0.14) * initial_via_count

    history = []
    current_via = initial_via_count
    best_via = initial_via_count
    scout_events = []

    for c in range(n_cycles):
        prog = 1 - math.exp(-3.5 * c / n_cycles)

        # Vias removed this cycle (decreasing marginal returns)
        removed_this_cycle = max(0, int(
            max_reduction * 0.08 * (1 - prog) + rng.normal(0, max_reduction * 0.005)
        ))
        current_via -= removed_this_cycle
        best_via = min(best_via, current_via)

        # Scout events (random restarts)
        is_scout = (c % 20 == 15) and c < n_cycles - 5
        if is_scout:
            scout_events.append(c)
            current_via += int(rng.uniform(0, max_reduction * 0.02))

        # Fitness = 1 / (1 + via_count)
        fitness = 1.0 / (1.0 + best_via)

        history.append({
            "cycle":           c,
            "best_via_count":  int(best_via),
            "current_via":     int(current_via),
            "vias_removed":    int(initial_via_count - best_via),
            "fitness":         round(fitness, 8),
            "scout_event":     is_scout,
            "employed_improvements": int(rng.poisson(2.1 * (1 - prog))),
            "onlooker_improvements": int(rng.poisson(1.4 * (1 - prog))),
        })

    total_removed = initial_via_count - best_via
    pct_removed = total_removed / initial_via_count * 100
    return history, total_removed, pct_removed


# ─── Full routing iteration simulation ───────────────────────────────────────

def simulate_routing_iterations(bench: dict, n_iters: int = 5,
                                  n_runs: int = 5, seed: int = 0):
    """
    Simulate the full RBA outer iteration loop for one benchmark.
    Returns per-iteration metrics for both baseline and RBA.
    """
    rng = np.random.default_rng(seed)

    bl_drc  = bench["baseline_drc"]
    bl_via  = bench["baseline_via"]
    bl_wl   = bench["baseline_wl"]

    # Baseline: slight stochastic variation across runs
    baseline_runs = []
    for r in range(n_runs):
        noise = rng.normal(1.0, 0.02)
        baseline_runs.append({
            "run": r,
            "drc_count":    int(bl_drc * noise),
            "via_count":    int(bl_via * rng.normal(1.0, 0.01)),
            "wirelength":   float(bl_wl * rng.normal(1.0, 0.005)),
            "unrouted_nets":rng.integers(0, 3),
            "runtime_sec":  float(rng.uniform(120, 280)),
            "method":       "baseline",
        })

    # RBA: per-iteration improvement trajectory across runs
    rba_all_runs = []
    for r in range(n_runs):
        run_seed = seed * 100 + r
        rng2 = np.random.default_rng(run_seed)

        iter_rows = []
        drc  = bl_drc  * rng2.uniform(0.95, 1.05)
        via  = bl_via  * rng2.uniform(0.97, 1.03)
        wl   = bl_wl   * rng2.uniform(0.98, 1.02)

        # Expected final improvement from each component
        ga_drc_benefit  = rng2.uniform(0.08, 0.18)   # net ordering effect
        pso_drc_benefit = rng2.uniform(0.06, 0.14)   # cost tuning effect
        aco_drc_benefit = rng2.uniform(0.05, 0.12)   # rerouting effect

        total_drc_red = 1 - (1-ga_drc_benefit) * (1-pso_drc_benefit) * (1-aco_drc_benefit)
        via_red  = rng2.uniform(0.06, 0.13)
        wl_delta = rng2.uniform(-0.005, 0.025)  # slight WL increase possible

        # Per-iteration decay
        for it in range(n_iters):
            prog = 1 - math.exp(-2.5 * (it+1) / n_iters)

            drc  = bl_drc  * (1 - total_drc_red * prog) * rng2.uniform(0.97, 1.03)
            via  = bl_via  * (1 - via_red * prog * 0.7) * rng2.uniform(0.99, 1.01)
            wl   = bl_wl   * (1 + wl_delta * prog) * rng2.uniform(0.999, 1.001)

            # Simulate PSO weights at this iteration
            w_wire = 1.0 + prog * 0.8 + rng2.normal(0, 0.05)
            w_via  = 4.0 + prog * 1.2 + rng2.normal(0, 0.08)
            w_cong = 2.0 + prog * 1.1 + rng2.normal(0, 0.06)

            iter_rows.append({
                "run":          r,
                "iteration":    it,
                "drc_count":    max(0, int(drc)),
                "via_count":    int(via),
                "wirelength":   float(wl),
                "unrouted_nets":max(0, int(rng2.poisson(0.5 * (1-prog)))),
                "runtime_sec":  float(rng2.uniform(140, 320)),
                "w_wire":       round(w_wire, 3),
                "w_via":        round(w_via, 3),
                "w_cong":       round(w_cong, 3),
                "method":       "rba",
            })

        rba_all_runs.extend(iter_rows)

    # Run sub-algorithm simulations
    ga_history, ga_improvement = simulate_ga(bench["nets"], seed=seed)
    aco_history = simulate_aco(bench["nets"], seed=seed+1)
    pso_history, pso_final_weights = simulate_pso(seed=seed+2)
    abc_history, vias_removed, via_pct = simulate_abc(bl_via, seed=seed+3)

    return {
        "benchmark":         bench["name"],
        "nets":              bench["nets"],
        "cells":             bench["cells"],
        "layers":            bench["layers"],
        "baseline_runs":     baseline_runs,
        "rba_runs":          rba_all_runs,
        "ga_history":        ga_history,
        "ga_improvement_pct":round(ga_improvement, 2),
        "aco_history":       aco_history,
        "pso_history":       pso_history,
        "pso_final_weights": {k: round(v, 3) for k, v in pso_final_weights.items()},
        "abc_history":       abc_history,
        "abc_vias_removed":  vias_removed,
        "abc_via_pct":       round(via_pct, 2),
    }


# ─── Aggregate summary ────────────────────────────────────────────────────────

def compute_summary(result: dict) -> dict:
    """Compute mean/std comparison between baseline and RBA final iteration."""
    bl = result["baseline_runs"]
    rba_final = [r for r in result["rba_runs"]
                 if r["iteration"] == max(r2["iteration"] for r2 in result["rba_runs"])]

    def stat(rows, metric):
        vals = [r[metric] for r in rows]
        return {"mean": float(np.mean(vals)), "std": float(np.std(vals)),
                "min":  float(np.min(vals)),  "max": float(np.max(vals))}

    def improv(bl_stat, rba_stat):
        if bl_stat["mean"] == 0:
            return 0.0
        return (rba_stat["mean"] - bl_stat["mean"]) / bl_stat["mean"] * 100

    bl_drc  = stat(bl, "drc_count");   rba_drc  = stat(rba_final, "drc_count")
    bl_via  = stat(bl, "via_count");   rba_via  = stat(rba_final, "via_count")
    bl_wl   = stat(bl, "wirelength");  rba_wl   = stat(rba_final, "wirelength")
    bl_rt   = stat(bl, "runtime_sec"); rba_rt   = stat(rba_final, "runtime_sec")

    return {
        "benchmark":       result["benchmark"],
        "baseline_drc":    bl_drc,  "rba_drc":   rba_drc,  "drc_improvement_pct":  improv(bl_drc,  rba_drc),
        "baseline_via":    bl_via,  "rba_via":   rba_via,  "via_improvement_pct":  improv(bl_via,  rba_via),
        "baseline_wl":     bl_wl,   "rba_wl":    rba_wl,   "wl_change_pct":        improv(bl_wl,   rba_wl),
        "baseline_rt":     bl_rt,   "rba_rt":    rba_rt,   "runtime_overhead_pct": improv(bl_rt,   rba_rt),
        "abc_vias_removed":result["abc_vias_removed"],
        "abc_via_pct":     result["abc_via_pct"],
        "ga_improvement_pct": result["ga_improvement_pct"],
    }


# ─── Main ─────────────────────────────────────────────────────────────────────

def run_all(output_dir: str = "./results", n_runs: int = 5, n_iters: int = 5,
            verbose: bool = True):
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    all_results   = []
    all_summaries = []

    benchmarks = ISPD18_BENCHMARKS + ISPD19_BENCHMARKS

    for idx, bench in enumerate(benchmarks):
        if verbose:
            print(f"[Sim] {bench['name']} ({idx+1}/{len(benchmarks)}) "
                  f"nets={bench['nets']:,} ...")
        t0 = time.monotonic()
        result = simulate_routing_iterations(bench, n_iters=n_iters,
                                             n_runs=n_runs, seed=idx*7)
        summary = compute_summary(result)

        if verbose:
            drc_imp = summary["drc_improvement_pct"]
            via_imp = summary["via_improvement_pct"]
            print(f"         DRC: {summary['baseline_drc']['mean']:.0f} → "
                  f"{summary['rba_drc']['mean']:.0f} ({drc_imp:+.1f}%)  "
                  f"Via: ({via_imp:+.1f}%)  "
                  f"[{time.monotonic()-t0:.1f}s]\n")

        all_results.append(result)
        all_summaries.append(summary)

    # Save (convert numpy types to native Python for JSON serialization)
    class NumpyEncoder(json.JSONEncoder):
        def default(self, obj):
            if isinstance(obj, (np.integer,)): return int(obj)
            if isinstance(obj, (np.floating,)): return float(obj)
            if isinstance(obj, np.ndarray):     return obj.tolist()
            if isinstance(obj, np.bool_):       return bool(obj)
            return super().default(obj)

    with open(f"{output_dir}/full_results.json", "w") as f:
        json.dump(all_results, f, indent=2, cls=NumpyEncoder)
    with open(f"{output_dir}/summary.json", "w") as f:
        json.dump(all_summaries, f, indent=2, cls=NumpyEncoder)

    if verbose:
        print(f"[Sim] Results saved to {output_dir}/")
        print_summary_table(all_summaries)

    return all_results, all_summaries


def print_summary_table(summaries: list):
    print("\n" + "="*100)
    print(f"{'Benchmark':<20} {'BL DRC':>10} {'RBA DRC':>10} {'ΔDRC%':>8} "
          f"{'BL Via':>12} {'RBA Via':>12} {'ΔVia%':>8} {'ΔWL%':>8}")
    print("-"*100)

    drc_imps, via_imps, wl_imps = [], [], []
    for s in summaries:
        print(f"{s['benchmark']:<20} "
              f"{s['baseline_drc']['mean']:>10.0f} {s['rba_drc']['mean']:>10.0f} "
              f"{s['drc_improvement_pct']:>+8.1f}% "
              f"{s['baseline_via']['mean']:>12.0f} {s['rba_via']['mean']:>12.0f} "
              f"{s['via_improvement_pct']:>+8.1f}% "
              f"{s['wl_change_pct']:>+8.2f}%")
        drc_imps.append(s["drc_improvement_pct"])
        via_imps.append(s["via_improvement_pct"])
        wl_imps.append(s["wl_change_pct"])

    print("-"*100)
    print(f"{'Average':<20} {'':>10} {'':>10} "
          f"{np.mean(drc_imps):>+8.1f}% "
          f"{'':>12} {'':>12} "
          f"{np.mean(via_imps):>+8.1f}% "
          f"{np.mean(wl_imps):>+8.2f}%")
    print("="*100)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="RBA Simulation Engine")
    parser.add_argument("--all-benchmarks", action="store_true")
    parser.add_argument("--output", default="./results")
    parser.add_argument("--runs",   type=int, default=5)
    parser.add_argument("--iters",  type=int, default=5)
    args = parser.parse_args()

    if args.all_benchmarks:
        run_all(args.output, args.runs, args.iters)
    else:
        parser.print_help()