Upload
jeslyn
View
42
Download
0
Embed Size (px)
DESCRIPTION
Multi-Threaded Collision Aware Global Routing. Bounded Length Maze Routing. Contributions. Optimal Bounded Length Maze Routing Heuristic Bounded Length Maze Routing Parallel Multi-Threaded Collision Aware Strategy for Multi-core Platforms. Bounded Length vs Bounded Box. Bounded Length. - PowerPoint PPT Presentation
Citation preview
© 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