Multi-Threaded Collision Aware Global Routing

1. Multi-Threaded Collision Aware Global Routing Bounded Length Maze Routing

2. Contributions • Optimal Bounded Length Maze Routing • Heuristic Bounded Length Maze Routing • Parallel Multi-Threaded Collision Aware Strategy for Multi-core Platforms

3. Bounded Length vs Bounded Box Bounded Length Bounded Box Algo : While(!viol) { viol = Route(net, BB); if(!viol) { increase BB; } } Start with the MBB • Algo : • While(!viol) { • viol = Route(net, BL); • if(!viol) { • increase BL; • } • } Start with Manhattan distance

4. Maze Routing Dijkstra Algorithm (G, E, s, t) • curr_node = s; • Parent[u] = NULL; // parent of all nodes is null initially • Q : Fibonacci heap with no nodes initially; //might have multiple copies of a node • cost[s] = 0; • cost[u] = infinity for all nodes except s • While(curr_node != t) { • for (each neighbour u of curr_node) { • if (cost[curr_node] + w(curr_node, u) < cost[u]) { • parent[u] = curr_node; • cost[u] = cost[curr_node] + w (curr_node, u); • insert_to_Q(u); • } • } • curr_node = Extract_min(Q); //extracts the min cost node from Q • } Complexity : O(|E| + |V|log|V|)

5. PROPOSED ROUTER FLOW DIAGRAM MST Decomposition Congestion Graph G = Route(net, viol) While(!viol) { NCRRoute(net, BL); if(!viol) { BL = Relax(BL) } } Post Refinement Layer Assignment NCR Route : Negotiation Based Congestion Rip up & Route

6. Optimal Bounded Length Maze Routing • Idea : Discard a path Pi(s,v) if, wl(Pi) + Manh(v,t) > BL • Comparison to Traditional Routing: • Prunes all paths with BL violations,thereby making the search space smaller • Keep more than one path unlike Traditional routing.

7. OPTIMAL BLMR Cont’d • What happens if keep the paths with lower cost. In this figure, cost(P1) = 80, cost(P2) = 90 wl(P1) = 11, wl(P2) = 5 BL = 16 If we keep only P1 (lower cost), then it does not have enough slack to detour the congested graph around t. Thus, keep both P1 & P2. However, if cost(Pi) < cost(Pj) and wl(Pi) < wl(Pj), then Pj is inferior to Pj, can discard Pj.

8. Heuristic BLMR Problemwith Optimal BLMR • May have any number of paths that meet the criteria. Thus, slower Solution • Need a Heuristic to select a single path. • Examine each path if it has the required wire-length • Select the lowest cost path with enough slack. • If no candidate path have enough slack, select shortest path.

9. Heuristic BLMR cont. Heuristic: ewk(v,t) =Manh(v, t) × (Lk-1(s, t) / Manh(s, t))--1 Condition : wl(Pi )+ewk (v, t) ≤BL ---------------------------------2 ewk (v,t) : estimated wire length from v to t in kth iteration Lk-1(s, t) : actual routed wirelength from s to t in k-1th iteration Pi(s,v) : Path from s to v wl(Pi ) : wirelength of Path Pi Manh(v, t) : Manhattan distance from v to t Manh(s, t) : Manhattan distance from s to t The heuristic keeps on getting better with each iteration : • Overestimated wl from v to t in kth iteration : Path might be discarded by equation 2, thus in (k+1)th iteration, it gets better. • Under-estimated wl from v to t in kth iteration, actual wl (LK) corrects it in the next iteration

10. Bounded Length Relaxation • With each iteration of rip-up & re-route, • Overflow decreases • Wire-length increases For the nets to be routed in the next iteration, BL is relaxed BLnk=Manh(s n, t n)×(arctan(k − α )+β) α, β are user defined (use 9,2.5 for this paper)

11. Task-Based Concurrency Parallelism • Rip & Re-route still takes 99.6% of total routing time on one of the difficult benchmarks (ISPD2007) Task Based vs Partition Based Concurrency • Load might not be shared evenly between the threads because of differing congestions in different parts of the grid graph.

12. Partition vs TCS TASK BASED CONCURRENCY & CHALLANGES • Each entry in Task Q is a 2 pin routing task • All threads pull one task out of Q Issues • Same routing resource can be used by two threads unaware of each other. • No Common Routing Resources (search restricted by partition)

13. Challenges Cont’d

14. Maze Routing & Collisions Maze routing happens in two phases : • Wave Propagation : explore every possible move. • Back-Tracing : Identify new routing path based on the paths explored. When will it be clear that collision occurred ? • Not clear at Wave propagation • Not clear at BackTracing • Clear after BackTracing – both the threads have used the resource.

15. Collision Aware RR Observations : • Nets closer are the most likely candidates for collisions. • About 41% of overflow nets in RR are due to collisions. • An overflow net has few overflow edges • It reuses most of its edges(80% of edges re-used)

16. Using Observations in Collision Aware RR • Thread T2 : marks the edges previously used by the net • Thread T1 : see the increased cost of the common edges

17. ALGORITHMS Collision Aware RR Collision Aware BLMR Algorithm Collision-aware BLMR Input: grid graphG, netN, bounded-lengthBL mark_grid_edge( path(N) ,G); ripup(path(N) ,G); collision_aware_wave_propagation(N, G, BL); newPath←back_tracing(N, G); unmark_grid_edge(path(N) ,G); path(N)←newPath; end • Algorithm Collision-aware Rip-up and Reroute • Input: grid graphG • TaskQueueTQ; • while ( G has overflows) • update(TQ) // insert overflow net to TQ; • //parallel by each thread • while (TQ is not empty); • N ←extract_a_task(TQ); • BLkn←relax_bounded_length(N); • collision_aware_BLMR(G, N,BLkn ); • end while end

18. Evaluation

19. Evaluation cont.

20. Summary BLMR • Bounded length Maze Routing • Optimal BLMR : paths based on slack left to reach the target • Heuristic BLMR : select a single path based on heuristic • The heuristic gets better with each iteration of rip-up & reroute Task Based Concurrency • Better for load sharing compared to partition based concurrancy • Collision may occur due to same resource used by more than one thread • Collision Aware RR : avoid overflow due to race conditions.

21. THANK YOU