eda
play

EDA Design Automation Prof. Ulf Schlichtmann Abacus: Fast - PowerPoint PPT Presentation

Dec 29, 2023 •529 likes •784 views

Institute for Electronic EDA Design Automation Prof. Ulf Schlichtmann Abacus: Fast Legalization of Standard Cell Circuits with Minimal Movement Peter Spindler, Ulf Schlichtmann and Frank M. Johannes Technische Universitaet Muenchen ISPD,

  1. Institute for Electronic EDA Design Automation Prof. Ulf Schlichtmann Abacus: Fast Legalization of Standard Cell Circuits with Minimal Movement Peter Spindler, Ulf Schlichtmann and Frank M. Johannes Technische Universitaet Muenchen ISPD, April 2008

  2. Outline • Background • State-of-the-Art • Abacus, PlaceRow • Experimental Results • Conclusion Slide 2

  3. Background Standard cell circuits: Millions of cells: inverter , NAND , NOR Physical representation: Rectangles, all have the same height, but different widths Placement: Align cells overlap-free to row structure Legalization Legal placement: ● No overlap ● Cells aligned to rows ● Preserve global placement: minimal cell movement 2. Legal 1. Global Placement Placement Slide 3

  4. State-of-the-Art in Legalization State-of-the-Art: ● Flow based: assign cells to places Domino [Doll et al., TCAD 1994] BonnPlace [Vygen et al., TCAD 2004] ● Two stage: first assign cells to rows, then place the rows [Madden et al., ICCAD 2003, Kahng et al., GLS-VLSI 2004] ● Diffusion based [Alpert et al., DAC 2005] ● Computational Geometry based [Alpert et al., DAC 2007] ● Greedy: legalize one cell at a time: Tetris [Hill, Patent, 2002] Slide 4

  5. Abacus: Overview Abacus : ● Similar to Tetris: sort cells, legalize one cell at a time ● Legalization of one cell: move cell over the rows, place cell to best/nearest row ● Difference to Tetris: PlaceRow : move already legalized cells within one row, minimize total movement ● Because of PlaceRow : lower total movement Slide 5

  6. Step 1: Sorting Sort cells according to x-pos in global placement 6 6 3 3 8 8 1 1 4 4 7 7 2 2 9 9 5 5 x Process order: 1, 2, 3, 4, 5, 6, 7, 8, 9 Slide 6

  7. Legalize Cell 1 Cell 1 to be legalized Insert to row 1 Insert to row 2 Row 1 Insert to row 3 Best row: 2 Row 2 Row 3 Slide 7

  8. Legalize Cell 2 Cell 2 to be legalized Insert to row 1 Insert to row 2 Row 1 PlaceRow 2: Minimize quadratic movement in Cell 1 already x-dir of cells Row 2 legalized to row 2 Insert to row 3 Best row: 3 Row 3 Slide 8

  9. Legalize Cell 3 Cell 3 to be legalized Insert to row 1 Insert to row 2 Row 1 PlaceRow 2: Minimize quadratic movement in Cell 1 already x-dir of cells Row 2 legalized to row 2 Insert to row 3 PlaceRow 3: Minimize Row 3 quadratic movement in x-dir of cells Best row: 1 Cell 2 already legalized to row 3 Slide 9

  10. Legalize Cell 4 Cell 4 to be legalized Insert to row 1 PlaceRow 1 Row 1 Insert to row 2 PlaceRow 2 Row 2 Insert to row 3 PlaceRow 3 Best row: 2 Row 3 Already legalized cell is moved within the row Slide 10

  11. Final Result Global Abacus Tetris: Placement No PlaceRow � higher movement (about 50% more for a large circuit) Slide 11

  12. PlaceRow Input: one row with N cells, x-pos of cells: global placement ( x i ) Output: new (legal) x-pos of cells ( x i ) such that the overlap is removed and the total quadratic movement is minimized w 1 w 2 1 2 3 4 5 6 Input: 1 2 3 4 5 6 Output: x … x 1 x 2 x 3 x 1 x 2 x 3 N ( ) ∑ ′ − ≥ + 2 width min s.t. e x x x x w QP: − − 1 1 i i i i i i = i 1 global x-pos no overlap weight legal x-pos Slide 12

  13. PlaceRow: Dynamic Programming PlaceRow: ● Solve QP by dynamic programming approach: solve sub problems optimally to obtain final solution ● Process cells from left to right Cell 1: 1 first cell � do not move Slide 13

  14. PlaceRow, Cell 2 w 1 Cell 2: 1 2 overlap with previous cell? yes � cluster with previous cell = + x x w Clustering process: 2 1 1 ( ) 2 ⎛ ′ ′ ⎞ + − ( ) e x e x w ( ) ( ) ⎜ ⎟ + − ′ ′ − + − 1 1 2 2 1 2 2 min e e x ⎜ ⎟ min e x x e x x + 1 2 1 1 1 1 2 2 2 ⎝ ⎠ e e 1 2 new e 1 Update x 1 , e 1 , and w 1 : new x 1 ( ) ′ ′ + − e x e x w ′ ← + ← + ← 1 1 2 2 1 w w w x e e e + 1 1 1 2 1 1 2 e e 1 2 ( ) ′ − ′ = 2 � min e x x x x Result: 1 1 1 1 1 Slide 14

  15. PlaceRow, Cell 2 (Cont‘d) Animation: 1 2 1 Result: (2) 1 2 Global: Cluster cell 1 and 2 Move cluster to new global x-pos Slide 15

  16. PlaceRow, Cell 3 w 3 w 1 Cell 3: 3 1 Overlap with previous cell? yes � cluster with previous cell ( ) ′ ′ + − Update x 1 , e 1 , and w 1 : ← + e x e x w w w w ′ ← 1 1 3 3 1 x 1 1 3 + 1 ← + e e e e e 1 3 1 1 3 ( ) ′ ′ = − 2 Move cell 1: � min x x e x x 1 1 1 1 1 3 11 Result: (3) 1 3 Prev: Slide 16

  17. PlaceRow, Cell 4 Cell 4: 4 1 Overlap with previous cell? no � no clustering, no movement Slide 17

  18. PlaceRow, Cell 5 Cell 5: 5 1 4 Overlap with previous cell? yes � cluster with previous cell 4 ( ) ′ ′ + − ← + e x e x w Update x 4 , e 4 , and w 4 : ′ e e e ← 4 4 5 5 4 x 4 4 5 + 4 ← + e e w w w 4 5 4 4 5 ( ) ′ − Move cell 4: 2 ′ = min e x x � x x 4 4 4 4 4 5 1 4 4 (5) Overlap with previous cell? yes � cluster with previous cell 1 4 1 1 Result: (4) (5) 5 1 4 Prev: Slide 18

  19. PlaceRow, Cell 6 Cell 6: 6 1 Overlap with previous cell? no � no clustering, no movement Last cell � done, PlaceRow finished Slide 19

  20. PlaceRow: Summary PlaceRow: ● Called several times for legalizing one cell ● Places cells aligned to one row: minimize quadratic movement � quadratic program (QP) ● Solves QP by dynamic programming: ● Process cells from left to right ● If cell overlaps with previous cell: clustering � movement � further checks with left cells ● Clustering: update width, weight, and global x-pos of cell constant execution time ● Linear worst-case complexity: O(N) N: number of cells in the row At most N-1 clustering operations for N cells Slide 20

  21. Complexity 2 Worst-case for a complete circuit with N cells: ( ) O N Average-case (experimental results): Θ 1 . 2 ( N ) Slide 21

  22. Movement Experimental results of one circuit: Abacus (this work) Abacus: more cells are moved less Tetris Tetris: more cells are moved farther � Lower movement with Abacus Slide 22

  23. Results IBM-Place 2.0 benchmark suite: ● Routability-driven placement ● Global placement: Kraftwerk (with routability optimization) ● Legalization: preserve global placement, minimal movement Results of Abacus (normalized to Tetris): Avg. movement -32% (negative: better Routed wirelength -1.2% positive: worse) Total CPU time place. +7% 0.500 0.600 0.700 0.800 0.900 1.000 1.100 Slide 23

  24. Conclusion Abacus: ● Greedy legalization approach, legalizes one cell at a time, similar to Tetris ● Already legalized cells are moved within the row: PlaceRow ● PlaceRow: minimize total quadratic movement, dynamic programming, linear worst-case complexity ● Results: lower movement than Tetris � better results in routability-driven placement Slide 24

  25. The End Thanks for the attention! Questions? Slide 25

Recommend

More recommend