120 lines
4.2 KiB
Python
120 lines
4.2 KiB
Python
import time
|
|
|
|
from shapely.geometry import box
|
|
|
|
from inire import (
|
|
NetSpec,
|
|
Port,
|
|
RoutingProblem,
|
|
RoutingResult,
|
|
)
|
|
from inire.router._stack import build_routing_stack
|
|
from inire.utils.visualization import plot_expanded_nodes, plot_routing_results
|
|
|
|
|
|
def main() -> None:
|
|
print("Running Example 07: Fan-Out (10 Nets, 50um Radius)...")
|
|
|
|
bounds = (0, 0, 1000, 1000)
|
|
obstacles = [
|
|
box(450, 0, 550, 400),
|
|
box(450, 600, 550, 1000),
|
|
]
|
|
|
|
num_nets = 10
|
|
start_x = 50
|
|
start_y_base = 500 - (num_nets * 10.0) / 2.0
|
|
end_x = 950
|
|
end_y_base = 100
|
|
end_y_pitch = 800.0 / (num_nets - 1)
|
|
|
|
netlist: dict[str, tuple[Port, Port]] = {}
|
|
for index in range(num_nets):
|
|
start_y = int(round(start_y_base + index * 10.0))
|
|
end_y = int(round(end_y_base + index * end_y_pitch))
|
|
netlist[f"net_{index:02d}"] = (Port(start_x, start_y, 0), Port(end_x, end_y, 0))
|
|
|
|
problem = RoutingProblem(
|
|
bounds=bounds,
|
|
nets=tuple(NetSpec(net_id, start, target, width=2.0) for net_id, (start, target) in netlist.items()),
|
|
static_obstacles=tuple(obstacles),
|
|
clearance=6.0,
|
|
)
|
|
from inire import CongestionOptions, DiagnosticsOptions, ObjectiveWeights, RoutingOptions, SearchOptions
|
|
|
|
options = RoutingOptions(
|
|
search=SearchOptions(
|
|
node_limit=2_000_000,
|
|
bend_radii=(50.0,),
|
|
sbend_radii=(50.0,),
|
|
greedy_h_weight=1.5,
|
|
bend_clip_margin=10.0,
|
|
),
|
|
objective=ObjectiveWeights(
|
|
unit_length_cost=0.1,
|
|
bend_penalty=100.0,
|
|
sbend_penalty=400.0,
|
|
),
|
|
congestion=CongestionOptions(
|
|
max_iterations=15,
|
|
base_penalty=100.0,
|
|
multiplier=1.4,
|
|
net_order="shortest",
|
|
shuffle_nets=True,
|
|
seed=42,
|
|
),
|
|
diagnostics=DiagnosticsOptions(capture_expanded=True),
|
|
)
|
|
stack = build_routing_stack(problem, options)
|
|
evaluator = stack.evaluator
|
|
finder = stack.finder
|
|
metrics = finder.metrics
|
|
|
|
iteration_stats: list[dict[str, int]] = []
|
|
|
|
def iteration_callback(iteration: int, current_results: dict[str, RoutingResult]) -> None:
|
|
successes = sum(1 for result in current_results.values() if result.is_valid)
|
|
total_collisions = sum(result.collisions for result in current_results.values())
|
|
total_nodes = metrics.nodes_expanded
|
|
print(f" Iteration {iteration} finished. Successes: {successes}/{len(netlist)}, Collisions: {total_collisions}")
|
|
new_greedy = max(1.1, 1.5 - ((iteration + 1) / 10.0) * 0.4)
|
|
evaluator.greedy_h_weight = new_greedy
|
|
print(f" Adaptive Greedy Weight for Next Iteration: {new_greedy:.3f}")
|
|
iteration_stats.append(
|
|
{
|
|
"Iteration": iteration,
|
|
"Success": successes,
|
|
"Congestion": total_collisions,
|
|
"Nodes": total_nodes,
|
|
}
|
|
)
|
|
metrics.reset_per_route()
|
|
|
|
print(f"Routing {len(netlist)} nets through 200um bottleneck...")
|
|
start_time = time.perf_counter()
|
|
results = finder.route_all(iteration_callback=iteration_callback)
|
|
end_time = time.perf_counter()
|
|
|
|
print(f"Routing took {end_time - start_time:.4f}s")
|
|
print("\n--- Iteration Summary ---")
|
|
print(f"{'Iter':<5} | {'Success':<8} | {'Congest':<8} | {'Nodes':<10}")
|
|
print("-" * 43)
|
|
for stats in iteration_stats:
|
|
print(f"{stats['Iteration']:<5} | {stats['Success']:<8} | {stats['Congestion']:<8} | {stats['Nodes']:<10}")
|
|
|
|
success_count = sum(1 for result in results.values() if result.is_valid)
|
|
print(f"\nFinal: Routed {success_count}/{len(netlist)} nets successfully.")
|
|
for net_id, result in results.items():
|
|
if not result.is_valid:
|
|
print(f" FAILED: {net_id}, collisions={result.collisions}")
|
|
else:
|
|
print(f" {net_id}: SUCCESS")
|
|
|
|
fig, ax = plot_routing_results(results, list(obstacles), bounds, netlist=netlist)
|
|
plot_expanded_nodes(list(finder.accumulated_expanded_nodes), ax=ax)
|
|
fig.savefig("examples/07_large_scale_routing.png")
|
|
print("Saved plot to examples/07_large_scale_routing.png")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|