Multi-Threaded Collision Aware Global Routing

  • View

  • Download

Embed Size (px)


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

Text of Multi-Threaded Collision Aware Global Routing

Multi-Threaded Collision Aware Global Routing

Multi-Threaded Collision Aware Global RoutingBounded Length Maze Routing

KLMHLienigContributionsOptimal Bounded Length Maze Routing Heuristic Bounded Length Maze Routing

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

KLMHLienigBounded Length vs Bounded BoxBounded LengthAlgo : While(!viol) { viol = Route(net, BL); if(!viol) { increase BL; } }Start with Manhattan distanceBounded BoxAlgo :While(!viol) { viol = Route(net, BB); if(!viol) { increase BB; } }Start with the MBB

KLMHLienigMaze RoutingDijkstra Algorithm (G, E, s, t)curr_node = s;Parent[u] = NULL; // parent of all nodes is null initiallyQ : Fibonacci heap with no nodes initially; //might have multiple copies of a nodecost[s] = 0;cost[u] = infinity for all nodes except sWhile(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|)


PROPOSED ROUTERFLOW DIAGRAMMST DecompositionCongestion 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

KLMHLienigOptimal Bounded Length Maze RoutingIdea : 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 smallerKeep more than one path unlike Traditional routing.

KLMHLienigOPTIMAL BLMR ContdWhat happens if keep the paths with lower cost.In this figure, cost(P1) = 80, cost(P2) = 90wl(P1) = 11, wl(P2) = 5BL = 16

If we keep only P1 (lower cost), then it does not have enough slack to detourthe 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.

KLMHLienigHeuristic BLMRProblem 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.

KLMHLienigHeuristic BLMR cont.Heuristic :ewk (v,t) = Manh(v, t) (Lk-1(s, t) / Manh(s, t))--1Condition :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 iterationPi(s,v) : Path from s to vwl(Pi ) : wirelength of Path PiManh(v, t) : Manhattan distance from v to tManh(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

KLMHLienigBounded Length RelaxationWith each iteration of rip-up & re-route,Overflow decreasesWire-length increases

For the nets to be routed in thenext iteration, BL is relaxed

BLnk = Manh (s n , t n ) (arctan(k ) + ), are user defined (use 9,2.5 for this paper)

KLMHLienigTask-Based ConcurrencyParallelism Rip & Re-route still takes 99.6% of total routing time on one of the difficult benchmarks (ISPD2007)

Task Based vs Partition Based ConcurrencyLoad might not be shared evenly between the threads because of differing congestions in different parts of the grid graph.

KLMHLienigPartition vs TCSTASK 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)

KLMHLienigChallenges Contd

KLMHLienigMaze Routing & CollisionsMaze 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 BackTracingClear after BackTracing both the threads have used the resource.

KLMHLienigCollision Aware RRObservations :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 edgesIt reuses most of its edges (80% of edges re-used)

KLMHLienigUsing Observations in Collision Aware RRThread T2 : marks the edges previously used by the netThread T1 : see the increased cost of the common edges

KLMHLienigALGORITHMSCollision Aware RRAlgorithm Collision-aware Rip-up and RerouteInput: grid graph GTaskQueue TQ; 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

Collision Aware BLMRAlgorithm Collision-aware BLMRInput: grid graph G, net N, bounded-length BLmark_grid_edge( path(N) ,G); ripup(path(N) ,G); collision_aware_wave_propagation(N, G, BL); newPathback_tracing(N, G); unmark_grid_edge(path(N) ,G); path(N)newPath; end


KLMHLienigEvaluation cont.

KLMHLienigSummaryBLMRBounded length Maze RoutingOptimal BLMR : paths based on slack left to reach the target Heuristic BLMR : select a single path based on heuristicThe heuristic gets better with each iteration of rip-up & reroute

Task Based ConcurrencyBetter for load sharing compared to partition based concurrancyCollision may occur due to same resource used by more than one threadCollision Aware RR : avoid overflow due to race conditions.