- 71 Views
- Uploaded on
- Presentation posted in: General

Optimization of Linear Placements for Wirelength Minimization with Free Sites

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

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

- 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

fixed cells

movable cells

C1

C2

C3

C4

C5

C6

C7

fixed cells

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

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

fr(1)

fl(2)

fl(3)

fr(3)

fr(2)

fl(4)

fr(4)

minimum segment (point)

- 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

- 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

- 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)

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 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)

cost

pcost[i-1]

cost[i]

pcost[i]

x

- 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

- 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

directions to minimum segments of individual cells

clumped

cell

clumped cell

optimal positions for cells

- 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

- 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

- 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