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 VLSI Circuits # interconnections Intra-module: many Inter-module: few 4

5 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: e(u 1,,ud) p(ui) p(uj) w(e) 5

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

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

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

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

10 Kernighan-Lin (KL) Algorithm Cost function: cutsize = e ψ w(e) Ψ: 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 } 10

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

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

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

14 Kernighan-Lin (KL) Algorithm Gain computation External cost (a) = E a = w(eav) for all v B = # external edges (if w(e) = 1) Internal cost (a) = I a = w(eav) for all v A = # internal edges (if w(e) = 1) D-value (a) = D a = E a I a 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 ) A E a = 4 I a = 2 D a = 2 a b E b = 1 I b = 0 D b = 1 B 14

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

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

17 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 xb )} {(I x w(e xa ) + w(e xa ))} 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 17

18 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 = -1 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 ) 18

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

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

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

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

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

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

25 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 3. k 5. Find k maximizing G= i=1 g i 25

26 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. Stop criteria Max. # iterations Max. runtime Δ Cutsize between the two consecutive iterations. 26

27 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 O(n) 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. k 5. Find k maximizing G= i=1 g i 27

28 Kernighan-Lin (KL) Algorithm Complexity of the D-value computation External cost (a) = E a = w(eav) for all v B Internal cost (a) = I a = w(eav) 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 A B 28

29 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((n-i) 2 ) 29

30 Kernighan-Lin (KL) Algorithm Complexity of the D-value 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) 30

31 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. O(1) O(n) 5. Find k maximizing G= i=1 k g i O(n) Loop. # iterations: n O((n-i) 2 ) O(n 3 ) 31

32 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 D b1 D b2 D b3 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. 32

33 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. O(1) O(n) 5. Find k maximizing G= i=1 k g i O(n) Loop. # iterations: n O(n log n) O(n 2 log n) 33

34 Questions Intentionally left blank 34

35 Fiduccia-Mattheyses (FM) Algorithm Handles Hyperedges edge hyperedge Imbalance (unequal partition sizes) Runtime: O(n) 35

36 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. Max cell size r V - s max A r V + s max A + B = V Base cell: The cell selected for movement. The max-gain cell that doesn t violate the balance criterion. 36

37 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 Either the distribution of the net is (0,x), (1,x), (x,0), or (x,1). 37

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

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

40 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 B 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)} 40

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

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

43 Fiduccia-Mattheyses (FM) Algorithm Before move, update the gain of 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 43

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

45 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 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)++; 45

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

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

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

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

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

51 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 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) F(n) = 1 : g(c)--; // c n & T 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) F(n) = 2 : g(c)++; // c n & F 53

54 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)++; 54

55 Fiduccia-Mattheyses (FM) Algorithm Before move, update the gain of 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 55

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

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

58 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 Total complexity: O(n or c) 58

59 Simulated Annealing Borrowed from chemical process 59

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

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

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

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

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

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

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

67 hmetis Three coarsening methods. 67

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

69 hmetis Final results 69

70 hmetis Final results 70