© KLMH Lienig Multi-Threaded Collision Aware Global Routing Bounded Length Maze Routing.
-
Upload
chastity-pitts -
Category
Documents
-
view
223 -
download
0
Transcript of © KLMH Lienig 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
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
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.