EE582 Physical Design Automation of VLSI Circuits and Systems

Transcription

1 EE582 Prof. Dae Hyun Kim School of Electrical Engineering and Computer Science Washington State University Partitioning

2 What We Will Study Partitioning Practical examples Problem definition Deterministic algorithms Kernighan-Lin (KL) Fiduccia-Mattheyses (FM) h-metis Stochastic algorithms Simulated-annealing 2

3 Example Source: 3

4 Example ASIC Placement Source: Nam, Modern Circuit Placement 4

5 VLSI Circuits # interconnections Intra-module: many Inter-module: few Source: David, A Stochastic Wire-Length Distribution for Gigascale Integration (GSI) Part I: Derivation and Validation, TCAD 98 5

6 Problem Definition Given A set of cells: T = {c 1, c 2,, c n }. W =n. A set of edges (netlist): R = {e 1, e 2,, e m }. R =m. Cell size: s(c i ) Edge weight: w(e j ) # partitions: k (k-way partitioning). P = {P 1,, P k } Minimum partition size: b s(p i ) Balancing factor: max(s(p i )) min(s(p j )) B Graph representation: edges / hyper-edges Find k partitions P = {P 1,, P k } Minimize Cut size: ww(ee) ee(uu 1,,uuuu) pp(uuuu) pp(uuuu) 6

7 Problem Definition A set of cells T = {c 1, c 2,, c n }. W =n c 1 e 1 c 5 e 5 e c 3 3 c e 2 2 c 4 c 6 e 4 e 6 c 7 c 8 7

8 Problem Definition A set of edges (netlist, connectivity) R = {e 1, e 2,, e m }. R =m c 1 e 1 c 5 e 5 e c 3 3 c e 2 2 c 4 c 6 e 4 e 6 c 7 c 8 8

9 k-way Partitioning k=2, P i =4 c 1 c 5 c 1 c 5 c 7 c 7 c 3 c 3 c 2 c 6 c 8 c 2 c 6 c 8 c 4 c 4 P 1 = {c 1, c 2, c 3, c 4 } P 1 = {c 1, c 2, c 3, c 5 } P 2 = {c 5, c 6, c 7, c 8 } P 2 = {c 4, c 6, c 7, c 8 } Cut size = 3 Cut size = 3 9

10 Kernighan-Lin (KL) Algorithm Problem definition Given A set of vertices (cell list): V = {c 1, c 2,, c 2n }. T =2n. A set of two-pin edges (netlist): E = {e 1, e 2,, e m }. E =m. Weight of each edge: w(e j ) Vertex size: s(c i ) = 1 Constraints # partitions: 2 (two-way partitioning). P = {A, B} Balanced partitioning: A = B = n Minimize Cutsize 10

11 Kernighan-Lin (KL) Algorithm Cost function: cutsize = ww(ee) ee ψψ Ψ: cut set = {e 2, e 4, e 5 } Cutsize = w(e 2 ) + w(e 4 ) + w(e 5 ) c 1 e 1 e 2 e 3 c 4 c 2 c 5 e 4 c 3 e 5 c 6 A={c 1, c 2, c 3 } B={c 4, c 5, c 6 } 11

12 Kernighan-Lin (KL) Algorithm Algorithm Find an initial solution Improve the solution No Best? No Yes Keep the best one. No more improvement? Yes End 12

13 Kernighan-Lin (KL) Algorithm Iterative improvement A B A* B* X Y Y X Current Optimal How can we find X and Y? 13

14 Kernighan-Lin (KL) Algorithm Iterative improvement Find a pair of vertices such that swapping the two vertices reduces the cutsize. c a c b c b c a Cutsize = 4 Cutsize = 3 14

15 Kernighan-Lin (KL) Algorithm Gain computation For each cell a External cost = E a = ww(eeeeee) for all v B = ww(external edges) Internal cost = I a = ww(eeeeee) for all v A = ww(internal edges) D-value (a) = D a = E a I a For each pair (a, b) Gain = g ab = D a + D b 2w(e ab ) g ab = {(E a w(e ab )) I a }+ {(E b w(e ab )) I b } = D a + D b 2w(e ab ) E a = 4 I a = 2 D a = 2 a b E b = 1 I b = 0 D b = 1 A B 15

16 Kernighan-Lin (KL) Algorithm Find a best-gain pair among all the gate pairs c 1 c 2 c 5 c 3 c 6 c 4 E a I a D a c c c c c c g 12 = = -2 g 13 = = 0 g 14 = = +2 g 52 = = -1 g 53 = = -1 g 54 = = -1 g 62 = = -1 g 63 = = -1 g 64 = = -1 A B g ab = D a + D b 2w(e ab ) Cutsize = 3 16

17 Kernighan-Lin (KL) Algorithm Swap and Lock After swapping, we lock the swapped cells. The locked cells will not be moved further. c 4 c 2 E a I a D a c c 5 c 6 A c 3 c 1 B c c c c c Cutsize = 1 17

18 Kernighan-Lin (KL) Algorithm Update of the D-value Update the D-value of the cells affected by the move. D x = E x I x = {E x w(e xb ) + w(e xa )} {I x + w(e xb ) w(e xa )} = (E x I x ) + 2w(e xa ) 2w(e xb ) = D x + 2w(e xa ) 2w(e xb ) D y = (E y I y ) + 2w(e yb ) 2w(e ya ) = D y + 2w(e yb ) 2w(e ya ) x c a y c b 18

19 Kernighan-Lin (KL) Algorithm Update c 1 c 2 c 5 c 3 c 6 c 4 A B D a D a c 1 1 c = -1 c c 4 1 c = -2 c = -2 D x = D x + 2*w(e xa ) 2*w(e xb ) D y = D y + 2*w(e yb ) 2*w(e ya ) 19

20 Kernighan-Lin (KL) Algorithm Gain computation and pair selection c 4 c 2 D a c 5 c 3 c 1 c 2-1 c 3-1 g 52 = = -3 g 53 = = -3 g 62 = = -3 g 63 = = -3 c 6 c 1 c 4 c 5-2 c 6-2 A B g ab = D a + D b 2w(e ab ) Cutsize = 1 20

21 Kernighan-Lin (KL) Algorithm Swap and update c 4 c 2 D a D a c 5 c 6 A c 3 c 1 B c 1 c = +1 c 3-1 c 4 c = 0 c 6-2 Cutsize = 1 D x = D x + 2*w(e xa ) 2*w(e xb ) D y = D y + 2*w(e yb ) 2*w(e ya ) 21

22 Kernighan-Lin (KL) Algorithm Swap and update c 4 c 2 D a c 1 c 2 +1 c 5 c 6 c 3 c 3 c 1 c 4 c 5 0 A B c 6 Cutsize = 4 D x = D x + 2*w(e xa ) 2*w(e xb ) D y = D y + 2*w(e yb ) 2*w(e ya ) 22

23 Kernighan-Lin (KL) Algorithm Gain computation c 4 c 2 D a c 1 c 2 +1 g 52 = = +1 c 5 c 6 c 3 c 3 c 1 c 4 c 5 0 A B c 6 g ab = D a + D b 2w(e ab ) Cutsize = 4 23

24 Kernighan-Lin (KL) Algorithm Swap c 4 c 5 c 2 c 6 c 3 c1 A B Cutsize = 3 24

25 Kernighan-Lin (KL) Algorithm Cutsize Initial: 3 g 1 = +2 After 1 st swap: 1 g 2 = -3 After 2 nd swap: 4 g 3 = +1 After 3 rd swap: 3 c 4 c 2 c 5 c 3 c 6 c 1 A B Cutsize = 1 25

26 Kernighan-Lin (KL) Algorithm Algorithm (a single iteration) 1. V = {c 1, c 2,, c 2n } {A, B}: initial partition 2. Compute D v for all v V queue = {}, i = 1, A =A, B =B 3. Compute gain and choose the best-gain pair (a i, b i ). queue += (a i, b i ), A = A -{a i }, B =B -{b i } 4. If A and B are empty, go to step 5. Otherwise, update D for A and B and go to step Find k maximizing G= gg ii kk ii=1 26

27 Kernighan-Lin (KL) Algorithm Algorithm (overall) 1. Run a single iteration. 2. Get the best partitioning result in the iteration. 3. Unlock all the cells. 4. Re-start the iteration. Use the best partitioning result for the initial partitioning of the next iteration. Stop criteria Max. # iterations Max. runtime Δ Cutsize between the two consecutive iterations. Target cutsize 27

28 Kernighan-Lin (KL) Algorithm Complexity analysis 1. V = {c 1, c 2,, c 2n } {A, B}: initial partition 2. Compute D v for all v V queue = {}, i = 1, A =A, B =B 3. Compute gain and choose the best-gain pair (a i, b i ). queue += (a i, b i ), A = A -{a i }, B =B -{b i } 4. If A and B are empty, go to step 5. Otherwise, update D for A and B and go to step Find k maximizing G= gg ii kk ii=1 28

29 Kernighan-Lin (KL) Algorithm Complexity of the D-value computation External cost (a) = E a = ww(ee aaaa ) for all v B Internal cost (a) = I a = ww(ee aaaa ) for all v A D-value (a) = D a = E a I a For each cell (node) a For each net connected to cell a Compute E a and I a Practically O(n) E a = 4 I a = 2 D a = 2 a b E b = 1 I b = 0 D b = 1 n: # nodes A B 29

30 Kernighan-Lin (KL) Algorithm Complexity of the gain computation g ab = D a + D b 2w(e ab ) For each pair (a, b) g ab = D a + D b 2w(e ab ) Complexity: O((2n 2i + 2) 2 ) 30

31 Kernighan-Lin (KL) Algorithm Complexity of the D-value update for swapping a and b D x = D x + 2w(e xa ) 2w(e xb ) D y = D y + 2w(e yb ) 2w(e ya ) For a (and b) For each cell x connected to cell a (and b) Update D x and D y Practically O(1) 31

32 Kernighan-Lin (KL) Algorithm Complexity analysis 1. V = {c 1, c 2,, c 2n } {A, B}: initial partition 2. Compute D v for all v V queue = {}, i = 1, A =A, B =B 3. Compute gain and choose the best-gain pair (a i, b i ). queue += (a i, b i ), A = A -{a i }, B =B -{b i } 4. If A and B are empty, go to step 5. Otherwise, update D for A and B and go to step 3. kk 5. Find k maximizing G= ii=1 gg ii Overall: O(n 3 ) O(n) O(1) Loop. # iterations: n O((2n-2i+2) 2 ) 32

33 Kernighan-Lin (KL) Algorithm Reduce the runtime The most expensive step: gain computation (O(n 2 )) Compute the gain of each pair: g ab = D a + D b 2w(e ab ) How to expedite the process Sort the cells in the decreasing order of the D-value D a1 D a2 D a3 in partition A D b1 D b2 D b3 in partition B Keep the max. gain (g max ) found until now. When computing the gain of (D al, D bm ) If D al + D bm < g max, we don t need to compute the gain for all the pairs (D ak, D bp ) s.t. k>l and p>m. Practically, it takes O(1). Complexity: O(n*logn) for sorting. 33

34 Kernighan-Lin (KL) Algorithm Complexity analysis 1. V = {c 1, c 2,, c 2n } {A, B}: initial partition 2. Compute D v for all v V queue = {}, i = 1, A =A, B =B 3. Compute gain and choose the best-gain pair (a i, b i ). queue += (a i, b i ), A = A -{a i }, B =B -{b i } 4. If A and B are empty, go to step 5. Otherwise, update D for A and B and go to step 3. kk 5. Find k maximizing G= ii=1 gg ii O(n) Overall: O(n 2 log n) O(1) Loop. # iterations: n O(n log n) 34

35 Questions Can the KL algorithm handle hyperedges? unbalanced partitions? fixed cells (e.g., cell k should be in partition A)? 35

36 Questions Intentionally left blank 36

37 Fiduccia-Mattheyses (FM) Algorithm Handles Hyperedges edge hyperedge Imbalance (unequal partition sizes) Runtime: O(n) Idea Move a cell instead of swapping two cells. 37

38 Fiduccia-Mattheyses (FM) Algorithm Algorithm Find an initial solution Improve the solution No Best? No Yes Keep the best one. No more improvement? Yes End 38

39 Fiduccia-Mattheyses (FM) Algorithm Definitions Cutstate(net) uncut: the net has all the cells in a single partition. cut: the net has cells in both the two partitions. Gain of cell: # nets by which the cutsize will decrease if the cell were to be moved. Balance criterion: To avoid having all cells migrate to one block. r V - s max A r V + s max A + B = V Max cell size Base cell: The cell selected for movement. The max-gain cell that doesn t violate the balance criterion. 39

40 Fiduccia-Mattheyses (FM) Algorithm Definitions (continued) Distribution (net): (A(n), B(n)) A(n): # cells connected to n in A B(n): # cells connected to n in B Critical net A net is critical if it has a cell that if moved will change its cutstate. cut to uncut uncut to cut The distribution of the net is (0,x), (1,x), (x,0), or (x,1). Distribution (n1) = (1, 1) Distribution (n2) = (0, 1) Distribution (n3) = (0, 2) Distribution (n4) = (2, 1) Distribution (n5) = (1, 1) Distribution (n6) = (2, 0) 40

41 Fiduccia-Mattheyses (FM) Algorithm Critical net Moving a cell connected to the net changes the cutstate of the net. A B A B A B A B 41

42 Fiduccia-Mattheyses (FM) Algorithm Algorithm 1. Gain computation Compute the gain of each cell move 2. Select a base cell (a max-gain cell) 3. Move and lock the base cell and update gain. 42

43 Fiduccia-Mattheyses (FM) Algorithm Gain computation F(c): From_block (either A or B) T(c): To_block (either B or A) gain = g(c) = FS(c) TE(c) A FS(c): P s.t. P = {n c n and dis(n) = (F(c), T(c)) = (1, x)} TE(c): P s.t. P = {n c n and dis(n) = (F(c), T(c)) = (x, 0)} B 43

44 Fiduccia-Mattheyses (FM) Algorithm Gain computation c 1 m A c 3 c 2 q k p c 4 c 5 c 6 j B gain = g(c) = FS(c) TE(c) FS(c): # nets whose dis. = (F(c), T(c)) = (1, x)} TE(c): # nets whose dis. = (F(c), T(c)) = (x, 0)} For each net n connected to c if F(n) = 1, g(c)++; if T(n) = 0, g(c)--; Distribution of the nets (A, B) m: (3, 0) q: (2, 1) k: (1, 1) p: (1, 1) j: (0, 2) Gain g(c 1 ) = 0 1 = -1 g(c 2 ) = 2 1 = +1 g(c 3 ) = 0 1 = -1 g(c 4 ) = 1 1 = 0 g(c 5 ) = 1 1 = 0 g(c 6 ) = 1 0 = +1 44

45 Fiduccia-Mattheyses (FM) Algorithm Select a base (best-gain) cell. Balance factor: 0.4 S: 1 Size: 3 c 1 m S: 4 c 3 c 2 S: 2 q k p c 4 j c 5 c 6 S: 3 S: 5 Gain g(c 1 ) = 0 1 = -1 g(c 2 ) = 2 1 = +1 g(c 3 ) = 0 1 = -1 g(c 4 ) = 1 1 = 0 g(c 5 ) = 1 1 = 0 g(c 6 ) = 1 0 = +1 A B S(A) = 9, S(B) = 9 Area criterion: [0.4*18-5, 0.4*18+5] = [2.2, 12.2] 45

46 Fiduccia-Mattheyses (FM) Algorithm Before move, update the gain of all the other cells. S: 1 Size: 3 c 1 m S: 4 c 3 q k c 4 c 5 j S: 3 c 2 S: 2 p c 6 S: 5 A B 46

47 Fiduccia-Mattheyses (FM) Algorithm Original code for gain update F: From_block of the base cell T: To_block of the base cell For each net n connected to the base cell If T(n) = 0 gain(c)++; // for c n Else if T(n) = 1 gain(c)--; // for c n & T F(n)--; T(n)++; If F(n) = 0 gain(c)--; // for c n Else if F(n) = 1 gain(c)++; // for c n & F 47

48 Fiduccia-Mattheyses (FM) Algorithm Gain update (reformulated) F: From_block of the base cell T: To_block of the base cell For each net n connected to the base cell If T(n) = 0 gain(c)++; // for c n Else if T(n) = 1 gain(c)--; // for c n & T If F(n) = 1 gain(c)--; // for c n Else if F(n) = 2 gain(c)++; // for c n & F F(n)--; T(n)++; 48

49 Fiduccia-Mattheyses (FM) Algorithm Gain update base cell Case 1) T(n) = 0 g: -1 g: +1 g: -1 g: -1 g: 0 g: 0 F T F T F T F T 49

50 Fiduccia-Mattheyses (FM) Algorithm Gain update base cell Case 2) T(n) = 1 g: +1 g: -1 g: 0 g: +1 g: +1 g: 0 F T F T F T F T g: 0 g: 0 g: +1 g: 0 g: 0 g: 0 F T F T 50

51 Fiduccia-Mattheyses (FM) Algorithm Instead of enumerating all the cases, we consider the following combinations. F(n) = 1 T(n) = 0 (3) (2) (4) (5) F(n) = 2 T(n) = 1 (7) (8) (1) (6) F(n) 3 T(n) 2 (9) Δg(c) in F Δg(c) in T F(n) T(n) (1) (2) (3) (4) (5) (6) (7) (8) (9) 51

52 Fiduccia-Mattheyses (FM) Algorithm Conversion from the table to a source code. Δg(c) in F Δg(c) in T F(n) T(n) (1) (2) (3) (4) (5) (6) (7) (8) (9) 52

53 Fiduccia-Mattheyses (FM) Algorithm Conversion from the table to a source code. Δg(c) in F Δg(c) in T F(n) T(n) (1) (2) (3) (4) (5) (6) (7) (8) (9) T(n) = 0 : g(c)++; // c n & F 53

54 Fiduccia-Mattheyses (FM) Algorithm Conversion from the table to a source code. Δg(c) in F Δg(c) in T F(n) T(n) (1) (2) (3) (4) (5) (6) (7) (8) (9) T(n) = 1 : g(c)--; // c n & T 54

55 Fiduccia-Mattheyses (FM) Algorithm Conversion from the table to a source code. Δg(c) in F Δg(c) in T F(n) T(n) (1) (2) (3) (4) (5) (6) (7) (8) (9) F(n) = 1 : g(c)--; // c n & T 55

56 Fiduccia-Mattheyses (FM) Algorithm Conversion from the table to a source code. Δg(c) in F Δg(c) in T F(n) T(n) (1) (2) (3) (4) (5) (6) (7) (8) (9) F(n) = 2 : g(c)++; // c n & F 56

57 Fiduccia-Mattheyses (FM) Algorithm Gain update F: From_block of the base cell T: To_block of the base cell For each net n connected to the base cell If T(n) = 0 gain(c)++; // for c n If T(n) = 1 gain(c)--; // for c n If F(n) = 1 gain(c)--; // for c n If F(n) = 2 gain(c)++; // for c n F(n)--; T(n)++; 57

58 Fiduccia-Mattheyses (FM) Algorithm Before move, update the gain of all the other cells. Δg(c) in F Δg(c) in T F(n) T(n) S: 1 (2) Size: 3 c 1 m S: 4 c 3 q k c 4 c 5 j S: 3 (3) (4) (5) (6) c 2 (7) S: 2 p c 6 S: 5 (8) A Gain (before move) g(c 1 ) = 0 1 = -1 g(c 2 ) = 2 1 = +1 g(c 3 ) = 0 1 = -1 g(c 4 ) = 1 1 = 0 g(c 5 ) = 1 1 = 0 g(c 6 ) = 1 0 = +1 B Gain (after move) g(c 1 ) = = 0 g(c 3 ) = = +1 g(c 4 ) = 0 1 = -1 g(c 5 ) = 0 2 = -2 g(c 6 ) = 1 2 = -1 58

59 Fiduccia-Mattheyses (FM) Algorithm Move and lock the base cell. S: 1 Size: 3 c 1 m S: 4 c 3 q c 2 p c 4 c 5 j k S: 2 S: 3 Gain (after move) g(c 1 ) = = 0 g(c 3 ) = = +1 g(c 4 ) = 0 1 = -1 g(c 5 ) = 0 2 = -2 g(c 6 ) = 1 2 = -1 c 6 S: 5 A B 59

60 Fiduccia-Mattheyses (FM) Algorithm Choose the next base cell (except the locked cells). Update the gain of the other cells. Move and lock the base cell. Repeat this process. Find the best move sequence. 60

61 Fiduccia-Mattheyses (FM) Algorithm Complexity analysis 1. Gain computation Compute the gain of each cell move For each net n connected to c if F(n) = 1, g(c)++; if T(n) = 0, g(c)--; Practically O(# cells or # nets) 2. Select a base cell O(1) 3. Move and lock the base cell and update gain. Practically O(1) # iterations: # cells Overall: O(n or c) 61

62 Simulated Annealing Borrowed from chemical process 62

63 Simulated Annealing Algorithm T = T 0 (initial temperature) S = S 0 (initial solution) Time = 0 repeat Call Metropolis (S, T, M); Time = Time + M; T = α T; // α: cooling rate (α < 1) M = β M; until (Time maxtime); 63

64 Simulated Annealing Algorithm Metropolis (S, T, M) // M: # iterations repeat NewS = neighbor(s); // get a new solution by perturbation Δh = cost(news) cost(s); If ((Δh < 0) or (random < e -Δh/T )) S = NewS; // accept the new solution M = M 1; until (M==0) 64

65 Simulated Annealing Cost function for partition (A, B) Imbalance(A, B) = Size(A) Size(B) Cutsize(A, B) = Σw n for n ϵ ψ Cost = W c Cutsize(A, B) + W s Imbalance(A, B) W c and W s : weighting factors Neighbor(S) Solution perturbation Example: move a free cell. 65

66 hmetis Clustering-based partitioning Coarsening (grouping) by clustering Uncoarsening and refinement for cut-size minimization 66

67 hmetis Coarsening c 5 c 5 c 3 c 6 c 4 c 7 c 3 c 6 c 4 ' c 7 c 1 c 8 c 8 c 2 67

68 hmetis Coarsening Reduces the problem size Make sub-problems smaller and easier. Better runtime Higher probability for optimality Finds circuit hierarchy 68

69 hmetis Algorithm 1. Coarsening 2. Initial solution generation - Run partitioning for the top-level clusters. 3. Uncoarsening and refinement - Flatten clusters at each level (uncoarsening). - Apply partitioning algorithms to refine the solution. 69

70 hmetis Three coarsening methods. 70

71 hmetis Re-clustering (V- and v-cycles) Different clustering gives different cutsizes. 71

72 hmetis Final results 72

73 hmetis Final results 73