A Linear-Time Heuristic for Improving Network Partitions

Transcription

1 A Linear-Time Heuristic for Improving Network Partitions ECE 556 Project Report Josh Brauer Introduction The Fiduccia-Matteyses min-cut heuristic provides an efficient solution to the problem of separating a network of vertices into 2 separate partitions in an effort to minimize the number of nets which contain nodes in each partition. The heuristic is designed to specifically handle large and complex networks which contain multi-terminal and also weighted cells. The worst case computation time of this heuristic increases linearly with the overall size of the network. Additionally, in practice in can be seen that the number of iterations that is typically required for the cutest to converge to the minimum value is typically very small. The key factor in obtaining this linear-time behavior is due to the fact that the algorithm moves one node at a time between partitions in an attempt to reduce the current cut-set by the maximum possible value. We must also note that at times, the maximum cut-set reduction will be negative; however, at this point we proceed with the algorithm as this allows the opportunity escape from a local minima, should we currently be in one. Upon the movement of a node, appropriate nodes connected to the moved cell are updated to represent the move. The use of simple, yet efficient data structures allows us the ability to avoid redundant searching for best cell to be moved, and similarly also prevents an excess and unnecessary updates to the neighbor cells that need to be updated. Thus the data structures themselves, assist in adding to the already efficient nature of the algorithm. The heuristic also contains a balance constraint which allows the user to retain control over the size of the created partitions. Algorithm The FM algorithm centers around 2 simple data structures which represent the network by relating both cells to nets and nets to cells. Example data structures are show below: Page 1 of 10

2 Before describing the FM heuristic in its entirety, we first shall discuss a few common, yet potentially unfamiliar terms followed the basic sub routines used by the FM heuristic Cut-Set Refers to the set of all the nets in the network which cross the boundary between the two defined partitions. In other words, the cut-set is equal to the set of nets, which are connected to at least one node in each of the two defined partitions. Gain Every cell posses its own gain value. The gain value refers to the number of nets by which the current cut-set would reduce if the specified node were to be moved from the partition it is currently in to the other partition. Base Cell The base cell is the cell which has been selected to be moved to the other partition. Free Cell All the remaining cells in the network which are marked as unlocked and also not being evaluated as the base cell. Critical Net A critical net is defined as any net which contains a cell, which if moved, will change its cut-state. From Block (F) The From Block of a base cell x is defined as the set of cells connected to x by a specified net n, which live in the partition that the base cell x would be moving from. To Block (T) The To Block of a base cell x is defined as the set of cells connected to x by a specified net n, which live in the partition that the base cell x would be moving to. We now can take a look a few specific sub functions that are used within the FM algorithm. These functions are presented separately from the algorithm itself in order to provide the reader with additional clarity when traversing the steps of the heuristic. Balance Constraint R* V - S max <= A <= R* V + S max Where: R = Balance factor between 0 and 1 (typically ~ 0.5) V = A + B = total size of both partitions S max = Weight of the largest cell in the network Page 2 of 10

3 This formula is the controlling factor in maintaining a balance set of partitions. From this we can a validity range for partition A which we can check against each time we wish to move a cell across partitions. Note that only cells that contain the maximum gain AND also do not violate the balance constraint can be chosen as the base cell. Initial Network Data Input /* net-list input routine */ FOR each net n = 1 N DO FOR each (cell, pin) pair (i,j) on net n DO /* maintain set property */ IF net n is not at the front of the net-list for cell i THEN Insert cell i into the cell-list of net n and insert net n into the net-list of cell i END FOR END FOR This pseudo code, as presented in the reference paper, fills the previously mentioned data structures with the initial set-up of our network. The code operates by simply utilizing nested for loops to traverse all the data in the input network, we then routinely insert the current net/cell data into our arrays. Initial Gain Calculation FOR each cell i in the network DO g(i) 0; F from blocks of cell i; T To blocks of cell i FOR each net n on cell i DO IF F(n) = 1 THEN g(i) = g(i) +1; IF T(n) = 0 THEN g(i) = g(i) 1; This sub routine simply processes each node in the network and analyses its From Block and its To Block as described previously. This code operates by simply traversing each node in the network and assigning it s From and To Blocks as described earlier. Then we iteratively check each net on our current cell if the From Block size = 1 then we are the only connected node in our partition, and thus the net must already cross the boundary, thus by moving to the other partition we will reduce the cut-set by one, thus we increment the current cells gain. Similarly, if there exists no nodes in the To Block, then we are only Page 3 of 10

4 connected to a cell in our current partition by this net. Thus by moving across the boundary we will add an extra net to the cutest, thus we reduce the gain by one. Updating Cell Gains This algorithm as stated in the Circuit Partition Lecture Notes displays the routine to following when updating the neighbor cells which are connected to the base cell via a critical net. The routine simply analyses the From and To Blocks on each net with respect to the base cell. Then for each net n on the base cell we check if there are no nodes in the To Block and if so we increment the gain on all of the other free cells on n because since we are moving the current cell to the other partition we would increment the cut-set, thus after that move if we to move one of the free cells, it would undo this addition to the cut-set thus incrementing its own gain. Else we check if T(n) = 1, we decrement the gain of the only T cell since after moving our current cell, if we were to move the T cell it would cause this net between itself and the current base cell to be added to the cut-set. We then update the From and To Blocks to reflect the move by decrementing F of the cell that it lost and incrementing T of the cell that it gained. We can now use the exact opposite reasoning as stated above to describe the procedure of the check the From Block after the base cell move has been completed. At this point we have covered enough background information, terms and routines to be able to accurately analyze the FM algorithm in its entirety. As we will see upon examining the full FM heuristic, the simple terms and routines described earlier make up the majority of the FM algorithm itself. The rest of the heuristic simply forms the process by which the other routines are used. Page 4 of 10

5 A pseudo code representation of the algorithm is as follows: 1. Gather input data and store into the relevant structures. 2. Compute gains of all cells 3. i = 1, Select base cell ci that has (i) max. gain, (ii) satisfies balance criterion. If tie, Then use size criterion or internal connections. If no base cell, then EXIT; 4. Lock c i ; update gains of cells of affected critical nets 5. If free cell is not-empty, Then i = i+1; select next base cell and go to step Select best sequence of moves c1, c2,, ck; (1 k i) such that G(k) = is maximum. If tie, then choose subset that achieves a superior performance. If G 0, Then EXIT 7. Make all i moves permanent; Free all cells; Goto step 1. The first step of the algorithm simply involves getting the input data and storing it into the array as mentioned earlier. The next step, we initialize the gains of all the cells on the network using the straightforward method above. In the third step, we choose a base cell from the current set of free cells. This base cell must have the maximum possible gain while also ensuring that the balance constraint remains in tact. If the balance constraint will not hold, we look for the cell with the next best gain which satisfies the balance constraint. If we cannot find a base cell within these conditions we exit the program and offer our current solution. In the fourth step, we have found our base cell, and we now must lock it in place, and proceed to update the gains of all the other free cells using the above mentioned technique. At step five we check the list of free cells and if more free cells still exist, we go back to step three and repeat this process until there are no free cells left, at which time we proceed to step six. As of step six we have completed a pass through the network and we have accumulated a sequence of gains that result from each of the moves we have evaluated. The goal here is to choose the best sub-sequence of moves (i.e. The highest partial sum of gains that can be obtained by selecting the first k moves.). If the maximum partial sum of the gains turns out to be less than or equal to zero, we exit the program and return our most recent solution as our final solution, otherwise we proceed to step seven. At step seven we are ready to begin the next iterative pass through our newly updated network. We proceed to make all i moves permanent. We then re-mark all cells as free cells, and finally we return to step one, in order to run the next pass on our new partition set. Page 5 of 10

6 Program Structure My implementation of the Fiduccia-Mattheyses Heuristic will be in C++ and will follow the same general algorithms that were presented above, along with very similar data structures. Input Data The program 2 specific input files which describe the network at hand. The first input file lists each of the individual nets and also which exact cells are connected to the appropriate net. This file will also provide the program with the total number of nodes and the total number nets in the system on the first two lines of the input file respectively. The second input file is simply a list of all the cell numbers and also specifies an integer value for the weight of the cell. The format of the input files is shown below: Input File 1 Format: Example: [number of cells] [number of nets] [1] [connected cell 1]..[connected cell x] ~ [N] [connected cell 1]..[connected cell y] Input File 2 Format: Example: [1] [node 1 weight] ~ [C] [node C weight] Page 6 of 10

7 Data Structures The main data structures of the application will be stored as arrays of structures. The 2 appropriate structures are as follows: struct net { int id; vector<node*>* nodes; } struct node { int id; int gain; bool locked; vector<net*>* nets; } These two simple structures handle the majority of information that is needed to efficiently process the FM algorithm. We note that there is a small amount of redundancy between each net containing a list of nodes and each node also containing a list of nets, however this data is crucial to the effective linear runtime of the algorithm, thus the small amount of data overhead can be disregarded. Process The execution of the program will for the most part follow exactly as the FM algorithm above is presented. A simple step-by-step flow is as follows: --Initial set up 1. Obtains input data from files 2. Sets up appropriate data structures 3. Fills the data structures with the relevant data 4. Creates 2 initial partitions which satisfy the balance constraint -- Begins F-M algorithm 5. Calculates and stores the initial gains of all the cells based on partitions. 6. Calls the getmax() function which returns the cell with the maximum gain that satisfies the balance constraint, else returns -1. On a return of -1 we exit the program, presenting our most recent solution. 7. Marks the returned cell as locked. Stores the temporary move and gain information. Page 7 of 10

8 8. Calls the updategains() function to process the neighbor nodes of the base cell. 9. Check to see if there are any remaining free cells, if so we call our getmax() function again and we repeat the process that was described above in step Since no remaining free cells we process the sequence of data that was stored in step 7 and find the maximum partial sum of the move gains. If we find that this partial sum is less that or equal to zero the program will exit and present the most recent solution. 11. Since we have a positive partial sum gain at this stage, we now make all the previously stored temporary moves permanent and mark all of the cells in the network as unlocked. 12. We the repeat the loop starting back at step 5. Results At the time of this writing my C++ implementation is not fully functional and thus not producing accurate results. The reasons for this will be discussed later on in the discussion session of this paper. In light of this, I will now present to you the author s results and give a brief analysis as I would expect my results to be somewhere in the general vicinity of the results except for the running time which I suspect would be somewhat higher based upon the faster speeds of present computer systems. Author s Results: Cells Nets Pins Passes Time Chip Chip Chip Chip The author states that the four sample chips above have an average of 267 cells, 245 nets, and 2650 pins. It is also worth noting that at the time this test was run, the algorithm was able to execute about 900 moves per cpu-second which of course by today s standards is incredibly slow. Thus by looking at how fast this algorithm performed back then as compared to how fast computers run these days, the actual run time of this algorithm is very small. It is also interesting to note the amazingly small number of passes that is actually required for the algorithm to converge to a final and effective solution. Page 8 of 10

9 Discussion As mentioned earlier in the report I have been unable up to implement the tool at full functionality at the time of this writing. This has been attributed mainly to the fact that this course has been my first significant development experience using the C/C++ language. Combined with the intense programming required, this proved to be a very difficult hill to climb. The majority of issues that I encountered were related to memory management of the more complex data structures. Due to the complexity of these structures I found it rather difficult to manually handle all of the data allocation for these objects as this is something I have never had to do before. Initially for this project, I had completed the program structure outline that is shown above before actually implementing any code. The data structures seemed to be relatively straight-forward, as did the overall FM algorithm so I did not foresee any significant errors arising. Upon implementation however, I had several issues dealing with large amounts of input data and setting up the data structures to hold the information. I spent extensive time attempting to do additional research to verify that my memory allocation techniques were correct and I did find some useful information. Unfortunately I got to a point in which the program would generate and invalid memory reference ( Segmentation Fault ) on a vast majority of the runs. The part that I was not able to understand is that the Fault error would not reproduce every time. At some points the program would execute all the way through, however, some of the information in the data structures seemed to corrupt. I spent a great deal of time attempting to pinpoint the exact location of this problem to no avail. At this point I decided to basically restart the implementation of the project using very basic structures and basic features and then once that is complete, I intended on adding in the full feature set of the F-M algorithm. In this second implementation I simply brought in a much simpler and more familiar data structure set from a previous implementation of the KL algorithm that I had worked. This set did not account for multi-terminal nets or weighted vertices; however I figured that once I had the base program working correctly, these additions would not be too difficult to add in. Up to this point I have had much more luck with this current implementation. I am able to successfully obtain all of the input data and access/modify it all as necessary. Upon the completion of the input data I began to work on the basic components of the FM algorithm, namely, generating an initial partition that satisfies the balance constraint, calculating the initial gains for each of the cells, and also developing the getmax() method that is described earlier in the paper. This method is able to supply the user with the cell that has the maximum gain and also will not violate the balance constraint that we have in place. Similarly it will tell you if there are no more possible base cells that can be chosen It was at this point that I simply ran out of time in the development process. I spent so much time attempting to debug my first implementation that I just did not have enough time to fully complete my second implementation even though everything up to this point seems to be working just fine using the simpler data structures. At this point if I were able to completely rework the project I believe I would continue on the same path that I am going right now. Things are making much more Page 9 of 10

10 sense now and additionally, as I stated above, the functionality up to this point in my second implementation is working well. References C. M. Fiduccia and R. M. Matteyses. A linear time heuristic for improving network partitions. In 19 th Design Automaton Conference, pages , 1982 Yu Hen Hu. University of Wisconsin - ECE 556 Course Lecture Notes, Circuit Partition Fiduccia Mattheyses Heuristics. Page 10 of 10