© K

LMH

Lien

ig

Multi-Threaded Collision Aware Global Routing

Bounded Length Maze Routing

© K

LMH

Lien

ig

Contributions

· Optimal Bounded Length Maze Routing · Heuristic Bounded Length Maze Routing

· Parallel Multi-Threaded Collision Aware Strategy for Multi-core Platforms

© K

LMH

Lien

ig

Bounded Length vs Bounded Box

Bounded Length· Algo :

1. While(!viol) {

2. viol = Route(net, BL);

3. if(!viol) {

4. increase BL;

5. }

6. }

Start with Manhattan distance

Bounded Box· Algo :

1. While(!viol) {

2. viol = Route(net, BB);

3. if(!viol) {

4. increase BB;

5. }

6. }

Start with the MBB

© K

LMH

Lien

ig

Maze Routing

Dijkstra Algorithm (G, E, s, t)1. curr_node = s;

2. Parent[u] = NULL; // parent of all nodes is null initially

3. Q : Fibonacci heap with no nodes initially; //might have multiple copies of a node

4. cost[s] = 0;

5. cost[u] = infinity for all nodes except s

6. While(curr_node != t) {

7. for (each neighbour u of curr_node) {

8. if (cost[curr_node] + w(curr_node, u) < cost[u]) {

9. parent[u] = curr_node;

10. cost[u] = cost[curr_node] + w (curr_node, u);

11. insert_to_Q(u);

12. }

13. }

14. curr_node = Extract_min(Q); //extracts the min cost node from Q

15. }

Complexity : O(|E| + |V|log|V|)

© K

LMH

Lien

ig

PROPOSED ROUTER

FLOW DIAGRAM

1. MST Decomposition

2. Congestion Graph G = Route(net, viol)

3. While(!viol) {

4. NCRRoute(net, BL);

5. if(!viol) {

6. BL = Relax(BL)

7. }

8. }

9. Post Refinement

10. Layer Assignment

NCR Route : Negotiation Based Congestion Rip up & Route

© K

LMH

Lien

ig

Optimal Bounded Length Maze Routing

· Idea : Discard a path Pi(s,v) if,

wl(Pi) + Manh(v,t) > BL

· Comparison to Traditional Routing:

1. Prunes all paths with BL violations,thereby making the search space smaller

2. Keep more than one path unlike Traditional routing.

© K

LMH

Lien

ig

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.

© K

LMH

Lien

ig

Heuristic BLMR

Problem with 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.

© K

LMH

Lien

ig

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 ---------------------------------2ewk (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 :

1. 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.

2. Under-estimated wl from v to t in kth iteration, actual wl (LK) corrects it in the next iteration

© K

LMH

Lien

ig

Bounded Length Relaxation

· With each iteration of rip-up &

re-route,

1. Overflow decreases

2. 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)

© K

LMH

Lien

ig

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.

© K

LMH

Lien

ig

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)

© K

LMH

Lien

ig

Challenges Cont’d

© K

LMH

Lien

ig

Maze Routing & Collisions

Maze routing happens in two phases : 1. Wave Propagation : explore every possible move.

2. 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.

© K

LMH

Lien

ig

Collision Aware RR

Observations :

1. Nets closer are the most likely candidates for collisions.

2. About 41% of overflow nets in RR are due to collisions.

3. An overflow net has few overflow edges

4. It reuses most of its edges (80% of edges re-used)

© K

LMH

Lien

ig

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

© K

LMH

Lien

ig

ALGORITHMS

Collision Aware RR1. Algorithm Collision-aware Rip-up and

Reroute

2. Input: grid graph G3. TaskQueue TQ;

4. while ( G has overflows)

5. update(TQ) // insert overflow net to TQ;

6. //parallel by each thread

7. while (TQ is not empty);

8. N ←extract_a_task(TQ);

9. BLkn ←relax_bounded_length(N);

10. collision_aware_BLMR(G, N, BLkn );

11. end while

end

Collision Aware BLMR1. Algorithm Collision-aware BLMR

2. Input: grid graph G, net N, bounded-length BL

3. mark_grid_edge( path(N) ,G);

4. ripup(path(N) ,G);

5. collision_aware_wave_propagation(N, G, BL);

6. newPath←back_tracing(N, G);

7. unmark_grid_edge(path(N) ,G);

8. path(N)←newPath;

end

© K

LMH

Lien

ig

Evaluation

© K

LMH

Lien

ig

Evaluation cont.

© K

LMH

Lien

ig

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.

© K

LMH

Lien

ig

THANK YOU