Loading in 2 Seconds...

Optimization of Linear Placements for Wirelength Minimization with Free Sites

Loading in 2 Seconds...

- 100 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about ' Optimization of Linear Placements for Wirelength Minimization with Free Sites' - ciara-white

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

### Optimization of Linear Placements for Wirelength Minimization with Free Sites

A. B. Kahng, P. Tucker, A. Zelikovsky

(UCLA & UCSD)

Supported by grants fromCadence Design Systems, Inc.

http://vlsicad.cs.ucla.edu

Outline

- Single-Row Problem
- Cell Cost Function
- Exact Algorithms for Single-Row Problem
- Dynamic Programming Algorithm
- Prefix Algorithm
- Clumping Algorithm
- Swapping Heuristic for Cell Ordering
- Experimental Results
- Conclusions and Future Directions

Single-Row Problem

- Given
- single cell row with nmovable cells C[i] with fixed left-to-right order (but variable positions) and integer lattice of k sites (k > n)
- m signal nets N [j]containing fixed cells from other rows
- Find
- non-overlapping placement of n movable cells at k sites minimizing the total bounding-box half-perimeter of all m nets.

Net with Movable and Fixed Cells

fixed cells

fl(N)

net N

fr(N)

single row with

movable cells

ml(N)

mr(N)

span (N)

fixed_span (N)

minimize

Cell Cost Function

- Cell cost function of C[i] = sum over all nets N of contributions of C[i] to span(N) - fixed_span(N)
- Given position x of cell C[i], cell cost function =

cost[i](x) = max{mr(N) - fr(N),0}

C[i] = rightmost movable on net N

+ max{fl(N) - ml(N),0}

C[i] = leftmost movable on net N

- Total # linear pieces 2 #pins = 2 #nets = 2m

fl(2)

fl(3)

fr(3)

fr(2)

fl(4)

fr(4)

minimum segment (point)

Properties of Cell Cost Function- Cost function of multi-pin cell is piecewise-linear and convex

- If each cell is placed in its minimum segment,

total bounding box half-perimeter is minimized

Exact Algorithms for Single-Row Problem

- Dynamic Programming Algorithm
- based on pre-computed cell cost functions
- Prefix Algorithm
- based on piecewise-linearity of cell cost function
- Clumping Algorithm
- based on convexity of cell cost function

Dynamic Programming Algorithm

- Optimum constrained prefix placementP[i,j] of C[1], ..., C[i] subject to C[i] being left of site s[j]
- P[i,j] is selected from P[i,j-1] and

P[i-1,j-w[i-1]]extended by C[i] at s[j]

w[i-1] = width of C[i-1]

- Cost of prefix placement increased by cost[i](s[j])
- Runtime = (i-range) (j-range)

= n (k - w[i])

O(n2)

Dynamic Programming Algorithm

P[i,j] has either:

C[i] exactly at s[j] (extend P[i-1,j-w[i-1]])

C[i-1]

C[i]

s[j]

s[j-w[i-1]]

orC[i] to left of s[j] (use already-computed P[i,j-1])

C[i]

s[j-1]

Prefix Algorithm

- Prefix cost functionpcost[i](x) = optimal placement cost of first i cells subject to C[i] being left of x
- pcost[i](x) is piecewise-linear decreasing
- Each linear segment is tuple = [a,b, min,max]
- Computing pcost[i] from pcost[i-1] and cost[i]

merging sorted tuple sequences of sizes

j<ipin[j] and pin[i] (pin[i] = #pins on C[i])

- Runtime = O(m2)
- Note: error in proceedings (missing +cost[i] term)

Clumping Algorithm

- For each cell C[i], find
- list of coordinates where cost[i] changes slope
- C[i]’s minimum segment
- To each cell in order, apply PLACE(C[i])
- Output positions of cells
- ProcedurePLACE(C[i])

if C[i-1] and C[i] cannot be both in their minimum segments

thenCOLLAPSE(C[i-1],C[i]) and PLACE(C[i-1])

else place C[i] at leftmost optimal available position

Clumping Algorithm

- Procedure COLLAPSE(C[i-1],C[i])
- shift positions from the list of C[i] by width(C[i-1])
- merge the list for C[i] with the list for C[i-1]
- find minimum segment for merged list
- width(C[i-1]) = width(C[i-1]) + width(C[i])
- delete cell C[i]
- Using red-black trees for representation of cell lists, achieve runtime = O(m log m), m = # nets

Clumping Algorithm

directions to minimum segments of individual cells

clumped

cell

clumped cell

optimal positions for cells

Swapping Heuristic for Cell Ordering

- Cell-Ordering Problem = the Single-Row Problem where the left-to-right order of cells is not fixed
- Swapping Heuristic

Repeatedly iterate down the row until no pairs swap:

- for every adjacent pair of cells that overlap or change order when placed at respective min points, swap their order if placement cost improves

Conclusions

- First optimal algorithms for single-row cell placement with free sites, fixed order of cells, and fixed positions of cells in all other rows
- New iterative algorithm to improve the cell ordering within a given row
- Iterative row-based placement algorithm that applies single-row cell placement to each row in turn, with optional cell ordering improvement in the given row
- Average of 6.5% improvement in total wirelength

Extensions

- Incorporate cell flipping into DP solution
- Linear programming formulation for Cell Ordering Problem
- Extend exact DP solution to k rows simultaneously
- Incorporate routability into objective function

Download Presentation

Connecting to Server..