Partitioning Outline –What is Partitioning –Partitioning Example –Partitioning Theory –Partitioning Algorithms Goal –Understand partitioning problem –Understand partitioning algorithms

What is Partitioning Divide a design into smaller pieces –based on a set of constraints Constraints –amount of design in a partition –number of nets to/from partition –number of partitions allowed –balance between partition sizes –weight nets crossing partition boundaries Applications –divide large design into multiple packages –place circuit components on a chip or board

Partitioning Example Constraints –12 transistors per package –7 pins per package –few packages as possible –nets of equal weight Bounds –30 xistors => >=3 packages –21 terminals => <=3 packages xistors 7 pins 12 xistors 5 pins 6 xistors 4 pins xistors 7 pins 10 xistors 6 pins 8 xistors 5 pins etc.

Partitioning Theory Partitioning Set Formulation –V a set of nodes (components) –each node r having area a(r) –X a set of nodes (terminals) external to V –S = (S 1, S 2,..., S N ) a set of subsets of V U X »S i correspond to nets –partition V into disjoint subsets V 1, V 2,..., V k such that »area of nodes in V i <= A i »number of sets in S which have nodes external and internal to V i is <= T i, (pin count) Other formulations –graphs - weighted nets, edges –connection matrix - eigenvectors

Partitioning Algorithms Direct –seed each module, grow based on constraints Group Migration –randomly place components, then move between partitions Metric Allocation –goodness metric for each component pair, partition to minimize metric Simulated Annealing –shuffle components among partitions to minimize cost function, permit uphill moves to get around local minima

Direct Partitioning place a component r from V into each partition V i –pick relatively independent components for each remaining component r in V { for each V i with area of nodes <= A i and number of sets in S which have nodes external and internal to V i <= T i, compute cost of placing r in V i place r in lowest-cost V i } Complexity –O(V*k) –assumes placement cost computation is O(1) Issues –sensitive to initial seeding –sensitive to component examination order –gets stuck in local minimum

Direct Partitioning Example A B C D E F G A BC D E F G D A D A E D A E B E B A BC D E C G, F

Group Migration 1. Partition nodes into groups A and B 2. For every a in A, and every b in B { compute change in terminal counts D a and D b that occur if a and b are swapped.} –set queue to empty and i = Select from all pairs (a, b) the pair (a i, b i ) that gives most reduction in total terminal count when swapped. –add to queue –save the improvement in terminal count as g i 4. Remove a i from A and b i from B, recalculate D a and D b. –if A and B not empty, i++, go to Find k such that G = sum of g 1 to g k is a minimum. –swap a 1,...a k and b 1,...b k. –if G 0, go to 2, else stop.

Group Migration Example A B C D E F G A BC D E F G Initial Partition, Cutset = 6 (A,E) 0 -3 (A,F) -1 0 (A,G) -1 0 (D,E) (D,F) (D,G) (B,E) (B,F) 0 0 (B,G) 0 0 (C,E) (C,F) 0 0 (C,G) 0 0 Queue 1: (D,E) -5 2: (A,F) +1 (-1,+3)... Minimum G=-5 at k=1 Swap D and E Next iteration: all pairs positive k=0, quit D a D b A B CF G Final Partition, Cutset = 1 removed (D,E)

Group Migration Complexity –O(n 2 ) per iteration in worst case for n nodes »steps 2, 3 –converges in only a few iterations –newer versions are O(nlogn) Application to partitioning –use bisection –divide into two partitions, then split those partitions, etc. –partition area is ignored, partitions remain balanced »subdivide until partition area is small enough –algorithm also called min-cut since it minimizes terminals

Fiduccia-Mattheyses Algorithm Approach –move one cell at a time between partitions A and B »less restrictive than pair moves »no longer need to maintain partition size balance –use special data structures to minimize cell gain updates –only move cells once per pass Complexity –prove constant number of updates per cell per pass –runtime per pass = O(P) - P pins/terminals »vs. O(n 2 ) for group migration –small (3-5) number of passes to converge –estimate total time is O(PlogP) »more pins than nets »usually more pins than cells

Definitions n i - number of cells on net i s i - size (area) of cell i s max - largest cell = max(s i ) S - total size of cells = sum(s i ) p i - number of pins on cell i p max - most pins on a cell = max(p i ) P - total number of pins = sum(p i ) C - total number of cells N - total number of nets r - fraction of cell area in partition A CELL - C-entry array, entry is linked list of nets on cell NET - N-entry array, entry is linked list of cells on net

Cell Gain –g i - reduction in cutset by moving cell i –label each cell with its gain –-p i <= g i <= p i –-p max <= g i <= p max Gain Data Structure –BUCKET array of cell gains »one per partition –O(1) access to cells of a given gain –MAXGAIN tracks cells of max gain –remove cell once it has moved »cells move once per pass »gain does not matter after that MAX GAIN 12C Cell # +p max -p max BUCKET CELL

Critical Nets Minimize cell gain updates –if all cells are updated on each move - O(C 2 ) algorithm –only cells that share a net with a moved cell must be updated »but big net implies many moves and many updates –only cells on critical nets must be updated Critical nets –moving a cell would change cutstate »cutstate - whether net is cut or not »critical only if net has 0 or 1 cells in A or B A=0, B=3 critical A=1, B=2 critical A=2, B=2 not critical

Partition Balance Control size balance between partitions –otherwise all cells move to one partition –cutset = 0 Balance criterion –rS - s max <= |A| <= rS + s max –permits some “wiggle room” for cells to move no yes

Algorithm Initially place cells randomly into A and B Compute cell gains Algorithm for each pass –for all cells in A and B of maximum gain whose move would not cause imbalance »choose one with best balance result - the base cell »if none qualify, quit pass –move to opposite partition and lock (remove from BUCKET) »unlocked cells are free cells –update cell gains and MAXGAIN pointer Repeat passes until no moves occur –unlock all cells at beginning of pass

Update Cell Gains F = “from” partition of base cell T = “to” partition of base cell FT(n) = # free T cells of net n FF(n) = # free F cells of net n LT(n) = # locked T cells of net n LF(n) = # locked F cells of net n for each net n on base cell do if LT(n) == 0 if FT(n) == 0 UpdateGains(NET(n)) else if FT(n) == 1 UpdateGains(NET(n)) FF(n)-- LT(n)++ if LF(n) == 0 if FF(n) == 0 UpdateGains(NET(n)) else if FF(n) == 1 UpdateGains(NET(n))

Example +3+1 abcd Initial partition cutset = 3 s i = 1, r = 0.5, 1 <= |A| <= 3 +1L abcd - b, c are highest-gain candidates - choose b, move and lock - recompute gains for a and b - a, c are highest-gain candidates - choose c, move and lock - recompute gains for a, d -3LL+1 abcd Final partition cutset = 1 - no candidates qualify - quit pass - second pass - no candidates qualify - quit abcd

Properties of Algorithm Fast –O(PlogP) –constant factors are small »arrays, pointer access Space Efficient –5 words/net overhead –4 words/cell overhead –small constant overhead Suboptimal –gets stuck in local minima –any one move has negative gain –need multiple moves for positive gain Example –moving a or b results in -3 or -4 gain –moving both a and b results in +1 gain a b