© 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 G

3. 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 BLMR

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