A Network Flow Approach for Hierarchical Tree Partitioning

Transcription

1 A Network Flow Approach for Hierarchical Tree Partitioning Ming-Ter Kuo Aptix Corporation San Jose, CA Chung-Kuan Cheng University of California, San Diego La Jolla, CA ABSTRACT Network flow approaches have been used for partitioning with success in the past. However, most of them can not deal with size constraints directly in partitioning. Instead, they incorporate the size constraints implicitly in the objective function. This paper presents a new network flow approach for partitioning circuits into tree hierarchies. We formulate a linear program for the hierarchical tree partitioning problem by spreading metrics proposed in [3][4]. The size constraints in partitioning can be formulated directly as linear constraints. Motivated by the duality between the linear programs for partitioning and network flow problems, we devise a heuristic algorithm based on network flow and spreading metric computations. xperimental results demonstrate that the new algorithm can generate better solutions for MCNC benchmarks. 1. INTRODUCTION Netlist partitioning problems have been studied intensively in the past. They are mostly formalized as problems on graphs or hypergraphs. Due to different applications, there are various (hyper-) graph partitioning problem formulations with their own objectives and constraints. Regarding the partition structure, basically there are two-way partitioning and multiway partitioning. The standard objective is to minimize the number of cut edges between the partition blocks or the number of I/O pins consumed on all blocks. Typical constraints are lower and upper bounds on the area and the pin count of the blocks. In generalizing the partition structure from two-way and multiway to a tree structure, Vijayan [16] proposed a min-cost tree partitioning which maps a hypergraph H onto the vertices of a tree T, and the cost function to be minimized is the cost to globally route the hyperedges of H on the edges of T. In [9], Kuo et al. introduced a hierarchical tree partitioning (HTP) which partitions a netlist into a tree hierarchy subject to a size constraint on partition blocks at each level of the hierarchy. The problem arises when a design is implemented in a hardware hierarchy. The objective of partitioning is to minimize the total weighted I/O pin cost at all levels of hierarchy. Practically, there are many hierarchies into which we can partition a circuit. The problem is how to find a hierarchy and a partition so that the interconnection cost is minimized. In this paper, we focus on devising algorithms for the HTP problem. Netlist partitioning problems like two-way partitioning and multiway partitioning are NP-hard problems. However, many algorithms that find a reasonably good partition have been developed. As the two-way and multiway partitioning problems, HTP is Design Automation Conference Copyright 1997 by the Association for Computing Machinery, Inc. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from Publications Dept, ACM Inc., fax +1 (212) , or permissions@acm.org /97/0006/$3.50 DAC 97-06/97 Anaheim, CA, USA also NP-hard, even when the tree structure is fixed [9]. To develop heuristic algorithms for it, we can apply some of the approaches used for two-way partitioning and multiway partitioning. However, we need to consider the distinct hierarchy and cost function in HTP. In [9], an iterative improvement algorithm based on the Fiduccia-Mattheyses method was proposed to improve an existing initial partition with a fixed tree hierarchy. The initial partition can be generated either randomly or by a constructive algorithm. In the original HTP problem, the structure of the partition is a flexible tree hierarchy. Thus, random generation of an initial partition with the partitioning structure unknown is not a feasible method. Most constructive methods such as placement-based method or spectral method are also developed for partitioning with a fixed structure, e.g., a K-way partition. Therefore, they are difficult to apply for solving the HTP problem. Another constructive method often used in partitioning is the network flow method. The network flow method exploits the duality between network flow problems and graph partitioning problems in linear programming. This close relationship was first established by the max-flow min-cut theory [5]. The duality was later extended to uniform multicommodity flows [6][13], and recently has been used for finding sparest cuts [12] or minimum ratio cuts [1][10][17]. These theoretical foundations suggest that graph edges which are more saturated in a flow computation are more likely to form a cut that disconnects clusters of nodes with high density. In other words, network flow computations can uncover the hierarchical structures of circuits. However, the previous approaches incorporate the size constraints in partitioning into the objective function to find minimum sparest cuts or ratio cuts. For partitioning problems such as the HTP problem that have explicit size constraints, we need a new network flow approach to solve them. In this paper, we propose a constructive algorithm for HTP based on a new network flow approach. First, we derive a linear programming formulation for the HTP problem by spreading metrics (length functions on the graph edges) proposed by ven et al. for graph partitioning [3][4]. Informally, a spreading metric is an assignment of fractional lengths on graph edges so that heavy subgraphs (subgraphs with large total node size) will have a large enough radius, i.e. the subgraphs are spread apart in the associated metric space. Using spreading metrics, the size constraints in HTP can be formulated directly as linear constraints. The duality between network flows and graph partitioning suggests that a spreading metric can be computed approximately by flow computation heuristics such as the stochastic shortest path approach proposed in [10] and [17]. After the flow computation, we apply Prim s minimum spanning tree algorithm [14] to identify the cuts and construct a partition hierarchically from the spreading metric. The rest of the paper is organized as follows. In Section 2, we review the definition of the HTP problem in [9] and formulate it in

2 level 3 level 2 level 1 level 0 Figure 1: A rooted tree hierarchy for partitioning. linear programing by spreading metrics. In Section 3, we will present the network flow based algorithm which consists of two parts: computation of the spreading metric and construction of the hierarchical tree partition. Analysis of the algorithm complexity will also be given in this section. In Section 4, we will show the experimental results of our algorithm on MCNC benchmarks. The paper will be concluded with a summary in Section PROBLM FORMULATIONS 2.1. Hierarchical Tree Partitioning Problem Let hypergraph H = (V, ) represent a netlist, where V ( V = n) is the set of nodes and ( = m) is the set of nets. ach node v in V has size s(v); each hyperedge e in is a subset of V with cardinality e 2 and has capacity c(e). For a set of nodes V, V V, the total size of nodes in V is denoted by s(v ) ( sv' ( ) = sv ()). s V' In hierarchical tree partitioning, nodes in V are assigned to partition blocks at each level of hierarchy. The partition hierarchy can be represented by a rooted tree where tree vertices denote the partition blocks and all leaves are at level 0 (See Figure 1 for example). We refer a partition in a tree hierarchy as a hierarchical tree partition and use P = (T, {V q } q T ) to denote it, where T is the tree hierarchy and V q is the set of nodes assigned to a tree vertex q. With the partition hierarchy, a node assigned to a leaf q in T is also assigned to q s ancestors. For partitioning constraints, each vertex q at level l has a upper bound K l on the number of its branches (except that leaves have no branches) and a upper bound C l on the total size of the nodes that are assigned to it, i.e. sv ( q ) C l. Therefore, each tree vertex at level l (l 1) with its children represents a multiway partition with at most K l parts and each part has size limit C l-1. The objective of partitioning is to minimize interconnection cost. In hierarchical tree partitioning, cost at each level l has a weighting factor w l. Let span(e, l) denote the number of blocks at level l that require I/O pins off the block to connect net e. Then, span(e, l) is defined to be 0 if all nodes in e are assigned to the same vertex at level l, and f if they are assigned to f (f 2) different vertices. The total interconnection cost of each net e at all levels, denoted by cost(e), is defined as cost() e = w l span( e, l)ce () (1) 0 l L 1 where level L is the highest level (level of the root) in the partition hierarchy. The Hierarchical Tree Partitioning (HTP) Problem. Given a hypergraph H = (V, ), upper bounds on the number of branches K l and total node size C l, and cost weighting factor w l at level l, find a partition P = (T, {V q } q Œ T ) with respect to K l, C l, and w l such that cost() e is minimized Linear Program Formulations by Spreading Metrics In [4], ven et al. studied a multiway graph partitioining called the ρ-separator problem, which partition a graph G = (V, ) into connected subgraphs such that the total node size of each subgraph is at most ρ sv ( ). They presented an approximation algorithm with an O(log n) error bound. The algorithm is based on a linear program formulation using length functions on edges called spreading metrics first proposed in [3]. In this paper, we generalize the linear program formulation to solve the HTP problem. For formulation, we consider the HTP problem on graphs, i.e. all edges connect two nodes. We also ignore the upper bound on the number of branches K l for each tree vertex since we can induce a multiway partition with at most K l parts from a ρ-separator [4]. From the linear program formulation, we can devise a heuristic algorithm based on network flow computations which can be easily extended for the general HTP problem on hypergraphs. Given a graph G = (V, ), size upper bound C l and cost weighting factor w l at level l (l 0) in the tree hierarchy, consider the problem to find a hierarchical tree partition P with size limits C l. We can derive a spreading metric {d(e)} from a partition P by setting de () = cost() e ce () for each. Then, the total interconnection cost of P, cost() e, will be equal to. For example, Figure 2 shows a hierarchical tree partition and its corresponding spreading metric. Suppose we want to partition a netlist into a tree hierarchy with the size upper bounds C 0 = 4, C 1 = 8 and cost weighting factors w 0 = 1, w 1 = 2 as shown in Figure 2(a). A graph of 16 nodes with unit sizes and 30 edges with unit capacities can be optimally partitioned into this tree hierarchy as shown in Figure 2(b). ach group of 4 nodes circled by solid lines denotes a partition block (leaf) at level 0; each group of 8 nodes circled by dashed lines denotes a partition block (vertex) at level 1. ach edge e that are cut only at level 0 (e.g. (a, b)) will have an interconnection cost of 2 by the definition cost() e = w l span( e, l)ce () in quation (1) since 0 l 1 span(e, 0) = 2 and span(e, 1) = 0. The cost of each edge e cut at level 1 (e.g. (c, d)) will be 6 since span( e, 0) = span( e, 1) = 2. In this example, if we set de () = cost() e ce () = cost() e, each cut edge e will have a spreading metric d(e) greater than 0 as labeled in Figure 2(b). All unlabeled edges have de () = 0. To formulate the HTP problem as a linear program using spreading metrics, we need to consider the size upper bounds C l. Let dist(v, u) denote the length of a shortest path from node v to node u in the graph with respect to the spreading metric { de ( )}. We have the following linear program formulation: P1: min (2) s.t. S V, v S, dist( v, () gss ( ( )) (3) u S where gx () = 2 ( x C i )w i if C l < x C l+1 for some l 0 0 i l and gx () = 0if x C 0, d(e) 0 (4) Objective (2) is equivalent to minimizing the total interconnection cost cost() e. Constraint (3) states that every set of nodes S should also have a weighted distance sum proportional to

3 level l C l w l b c a (a) 6 (b) Figure 2: A hierarchical tree partition and its corresponding spreading metric. (a) The tree hierarchy with the size upper bounds C l and cost weighting factors w l for partitioning. (b) A graph of 16 nodes and 30 edges with unit edge capacities is parti- its total node size. The reason is that a partition satisfying constraints on the size upper bounds C l will have some edges in each S, s(s) > C 0, with nontrivial d(e). For S with s(s) C 0, the constraint in (3) is trivial since dist(v, u) 0 for all v, u S and g(s(s)) 0. Constraint (4) requires each d(e) to be a positive real number. Therefore, a spreading metric (i.e. a feasible solution to (P1)) can be seen as a fractional hierarchical tree partition. Conversely, it means that every hierarchical tree partition can induce a feasible integral solution to (P1). Moreover, the cost of the integral solution equals to the interconnection cost of the partition. Lemma 1: Given a hierarchical tree partition P of a graph G =(V,) with respect to the size upper bounds C l and cost weighting factors w l, { de () = cost() e ce ()} is a feasible integral solution to (P1). (See [8] for the proof.) Since { de () = cost() e ce ()} is a feasible integral solution to (P1) and cost() e =, we can obtain a e lower bound on the interconnection cost of a HTP problem from the linear program formulation. Lemma 2: Given a graph G = (V, ), size upper bound C l and cost weighting factors w l at level l (l 0) in the tree hierarchy, the cost of a hierarchical tree partition has a lower bound where { de ( )} is an optimal solution to the e linear program (P1). Lemma 1 and Lemma 2 show that the linear program (P1) provides a natural formulation of the HTP problem. Thus, the optimal fractional solution to (P1), i.e. the spreading metric with minimum, gives us basis to construct a hierarchical tree partition. d Algorithm 1 Input: Hypergraph H= (V, ); parameters C l, K l, and w l for the tree hierarchy; number of iterations N Output: Hierarchical tree partition P = (T, {V q } q T ) 1. Repeat 1.1 to 1.2 for N times 1.1 Find a spreading metric { de ( )} for linear program (P1) by flow injection; 1.2 Construct a partition P from d(e) by techniques of finding minimum spanning trees; 2. Output the best partition P in the N iterations; Figure 3: Algorithm for hierarchical tree partitioning. 3. A CONSTRUCTIV ALGORITHM BY NTWORK FLOWS Based on the linear program formulation, we propose a constructive algorithm (Algorithm 1) to solve the HTP problem as shown in Figure 3. First, in Step 1.1, we compute a fractional spreading metric { de ( )} which is an approximate solution to the linear program (P1) by a flow injection approach. From the spreading metric, we construct a hierarchical tree partition in Step 1.2 by growing the partition blocks using techniques of finding minimum spanning trees. Since both steps use some random processes, they can be iterated to find a best solution. Section 3.1 and Section 3.2 will describe Steps 1.1 and 1.2 respectively in detail. Complexity of the algorithm will be analyzed in Section A Stochastic Flow Injection Approach for Computing Spreading Metrics To solve the linear program (P1), we need to find spreading metrics that satisfy Constraint (3): S V, v S, dist( v, () gss ( ( )). u S Although there are exponential many combinations of S and v in (3), we can reduce the number of constraints to O(n 2 ) by following Claim 4 in ven et al s paper [4]. Let Sv (, denote a tree rooted at v that connects the k closest nodes to v by shortest paths with respect to the edge length { de ( )} and ssv ( (, ) denote the total size of the k nodes. We call Sv (, is a shortest path tree for v with k nodes. The following constraint is equivalent to Constraint (3) of (P1): v V, 1 k n, dist( v, () gssv ( ( (, )) (5) u Constraint (5) denotes O(n 2 ) constraints which is only a subset of constraints in (3). However, it is not difficult to show that for each S with k nodes and a node v in S, dist( v, () gssv ( ( (, )) implies dist( v, () gss ( ( )) since u S dist( v, () and u S dist( v, () u ssv ( (, ) = ss ( ) = k for unit node sizes. For non-unit node sizes, we need to modify the definition of k closest node to v ordered by a weighted distance ( dist( v, u) 1)su () instead of dist( v, u) [4]. From above, any solution { de ( )} that satisfies Constraint (5) will also satisfy Constraint (3), and vice versa. After reducing the number of constraints in the linear program, we can further rewrite the constraints to derive a dual program. Let δ( Sv (,, e) denote the total node size of the subtree of Sv (,

4 Algorithm 2 Input: Hypergraph H= (V, ); parameters C l and w l for the tree hierarchy Output: Spreading metric { de ( )} e 1. Initialize the flow f(e) of each edge e to ε and edge length α ε d(e) to exp ; V = V; ce () 2. Repeat Repeat to for each v in V in a random order Set S as the tree that contains only v, S(v,1), and k = 1; Run Dijkstra s shortest path algorithm to construct S = S(v, for k = 2, 3, by iteratively adding a new closest node u from v and the shortest connecting edge of u to S until Constraint (5) for S is violated or k = n; If Constraint (5) is not violated for all S(v,, 1 k n, V = V - {v}; continue the next iteration in Increase f(e) by for each edge e in S; α fe () Update d(e) to exp for each edge e in ce () S; Until V = ; 3. Output the spreading metric { de ( )} e ; Figure 4: Algorithm for computing a spreading metric. that are disconnected from v by removing edge e. It is easy to see that dist( v, () = de ()δsv ( (,, e). (6) u Thus, Constraint (5) can be rewritten as v V, 1 k n, de ()δsv ( (,, e) gssv ( ( (, )). (7) By assigning a dual variable f(s(v, ) for each v V and 1 k n in (7) as the flow on each tree S(v,, we can derive a dual program of (P1) which formulates a maximum flow problem. Motivated by the duality between the linear programs, we proposed a heuristic algorithm based on a stochastic flow injection method to compute a spreading metric for (P1). Similar approaches have been used in solving minimum ratio cut problems in [10] and [17]. Both of their approaches try to solve a multicommodity flow problem by iteratively adding or rerouting flows on the shortest paths between randomly selected pairs of nodes. Derived from the linear programs for the HTP problem, our approach is to select a node v and add flows to a shortest path tree Sv (, from v that violates Constraint (5). (A similar approach has also been applied by Rao [15] for a graph bifurcation problem [11, page 230].) Figure 4 presents the proposed heuristic (Algorithm 2) for computing a spreading metric. ach edge is associated with d(e) as its length and f(e) as the total amount of flows on all the shortest path trees Sv (, to which e belongs. Initially, every edge has a very small amount of flows, ε, so that its length will be close (but not equal) to 0. Let V be the set of nodes v such that the constraint in (5) for some Sv (, may not be satisfied. For each node in V, Step 2.1 finds a shortest path tree and adds flows to it if necessary as follows. In Steps to 2.1.3, the shortest path trees, Sv (, for k = 1, 2,, from a node v are constructed by running Dijkstra s shortest path algorithm [2] to find the first Sv (, that violates Constraint (5). If one is found, we add units of flows to all edges in the tree (Step 2.1.4) and update their lengths by setting d(e) as exp( α fe () ce ()) 1 to penalize the congested edges (Step 2.1.5). ( and α are constant parameters in the algorithm.) As d(e) increases for some edges in each iteration, more constraints in (5) are satisfied. By repeating Step 2.1, eventually all constraints are satisfied ( V = ) and a spreading metric { de ( )} for the HTP is generated Constructing Partitions by Techniques of Finding Minimum Spanning Trees In this section, we describe the algorithm that constructs a hierarchical tree partition from a spreading metric. The algorithm follows a general top-down approach used in graph partitioning. Given a hypergraph H = (V, ) and a spreading metric { de ( )}, Algorithm 3 in Figure 5 constructs a hierarchical tree partition P recursively from the top level to the bottom level. First, a tree T with a single vertex is created as the base hierarchy. The top level l of the tree is decided by the size of the nodes in H. At level l, the size lower and upper bounds (LB and UB) calculated from C l and K l are set for a partition block. xcept at the bottom level, Step 4 is executed to construct the partitions and the subtrees at the next level as follows. Procedure find_cut is called repeatedly in Step 4.1 to separate a subset of nodes V within the prescribed size bounds from the current graph. We then run Algorithm 3 on the subgraph induced by V to construct a hierarchical tree partition P recursively (Step 4.3). The tree hierarchy T of P is then combined with the current hierarchy T as T s subtree at the root (Step 4.4). We use T + (r T ) to denote the resulting tree hierarchy of this operation. The main step in Algorithm 3 is Procedure find_cut which takes a spreading metric { de ( )} for the edges in a hypergraph H = (V, ) and finds a subset of nodes with its size in the range of [LB..UB] to be cut off from H. In the linear program formulation, we define edges within partition blocks at the bottom level will have d(e) = 0. For edges that cross blocks at a higher level, they will also have a larger d(e) if the spreading metric is a good approximation. Therefore, we use a greedy approach in Procedure find_cut to find a subset of nodes V where nodes in V are close to each other and the cut size between V and the remaining nodes is small. The greedy algorithm follows Prim s minimum spanning tree algorithm [14] and proceeds as follows. Starting from a random node v and V = {v}, we repeatedly finds a node u with minimum distance to V defined by d(e) and adds u to V until the size s(v ) has reached the upper bound UB (Step 2). For each V encountered in the procedure, the cut between V and V - V, denoted by cut(v, V - V ), is computed (Step 2.3). At the end, find_cut outputs the set V with its size in [LB..UB] and cut(v, V - V ) is minimum Computational Complexity of the Algorithm Our algorithm, Algorithm 1, for the HTP problem has two major steps: computing a spreading metric (Algorithm 2) and constructing a partition (Algorithm 3). We now analyze the time complexities of these two steps and the time complexity of the algorithm.

5 Algorithm 3 Input: Hypergraph H = (V, ); parameters C l and K l for the tree hierarchy; spreading metric { de ( )} Output: Hierarchical tree partition P = (T, {V q } q T ) 1. Create a tree T with root r as the only vertex and V r = V; P = {T, {V r }}; 2. If sv ( ) C 0 then l = 0 sv ( ) else l = the integer that C l 1 < sv ( ) C l ; LB = ; K l UB = C l 1 ; 3. If l == 0 then goto 5; 4. While V do 4.1 to 4.4: 4.1 V = find_cut(h, { de ( )}, LB, UB); 4.2 Cut off a subgraph H = (V, ) from H; 4.3 Run Algorithm 3 with H = (V, ), parameters C l, K l and spreading metric { de ( )} ' to find a partition P = (T, {V q } q T ); 4.4 P = (T + (r T ), {V q } q T {V q } q T ); T = T + (r T ); 5. Output partition P; Procedure find_cut Input: Hypergraph H = (V, ); spreading metric {d(e)} ; size bounds LB and UB Output: Set of nodes V (V V) to be separated from other nodes in V 1. Choose an arbitrary node v in V; V = {v}; 2. While s(v ) < UB do 2.1 to 2.3: 2.1 u = the closest node to V in V - V ; 2.2 V = V {u}; 2.3 Record V and the number of cut edges, cut(v, V - V ) between V and V - V ; 3. Output the recorded V with minimum cut(v, V - V ) for LB s( V ) UB ; Figure 5: Algorithm for constructing a hierarchical tree partition from a spreading metric. Let n be the number of nodes, m be the number of nets, and p be total number of pins in a circuit. Assume that the capacity c(e) of a net is bounded by b c and the length d(e) of a net defined by a partition is bounded by b d. Algorithm 2 repeatedly runs Dijkstra s shortest path algorithm to find a tree S(v, and add flows on its edges. Since d(e) is updated as exp( α fe () ce ()) 1 in Algorithm 2, the flow of a net is bounded by Ob ( c log b d ). Thus, Steps to are executed at most Ob ( c log b d m ) times. Since Dijkstra s algorithm requires O( ( n + p) log n) time for each iteration, the complexity of Algorithm 2 for computing a spreading metric is O( ( b c log b d ) mn ( + p) log n). Algorithm 3 for constructing a hierarchical tree partition from a spreading metric is a recursive algorithm. The main step in each recursion is to call find_cut which requires O( ( n + p) log n) time by running Prim s algorithm. Assume that the numbers of branches K l are constants bounded by b k. Then we have recurrence relation Tn () = b k Tn ( b k ) + b k O( ( n + p) log n) for the time complexity T(n) of Algorithm 3. Therefore, the time complexity of Algorithm 3 is O( ( n + p) log n). As the complexity of Algorithm 2 dominates that of Algorithm 3, the complexity of Algorithm 1 is O( ( b c log b d ) mn ( + p) log n). 4. XPRIMNTS We implemented the network flow based algorithm (Algorithm 1) for the HTP problem proposed in this paper and tested it on ISCAS85 benchmarks from MCNC. The experimental results are compared with those of two other recursive partitioning algorithms, GFM and RFM, from [9]. The GFM algorithm uses a bottom-up approach by constructing a hierarchical tree partition from a multiway partition at the bottom level. On the other hand, the RFM algorithm is a top-down recursive partitioning algorithm which follows the same general approach as Algorithm 3 for constructing a hierarchical tree partition. The difference between RFM and our network flow based algorithm is in procedure find_cut: RFM calls a min-cut algorithm directly on hypergraph H = (V, ) to find a subset set V with minimum cut(v, V - V ) while our new algorithm takes a spreading metric as the length function of edges and applies Prim s minimum spanning tree algorithm to find V. Note that all three algorithms construct the partition recursively. However, both GFM and RFM try to optimize the partition at one level for each recursion, without considering the global cost in HTP. Thus, the partitioning results at the following levels may be sacrificed. In the network flow based algorithm, a spreading metric is computed first to consider the global cost formulated in the linear programs. Then, the partition at each level is generated according to the spreading metric. Hopefully, the drawbacks of GRM and RFM can be prevented to get better results. Table 1 lists the numbers of nodes, nets and pins in the ISCAS85 test cases. In all experiments, we set the parameters K l and C l in a way that the target tree hierarchy will be a full binary tree with height 4 for all test cases as in [9]. All the programs were run on a Sun Sparc20 and the runtimes reported in the tables were measured in seconds. Table 2 shows the experimental results and the comparisons for the benchmarks. The column labeled FLOW lists the costs of the results from the network flow based algorithm while the results in columns GFM and RFM are quoted from [9]. From Table 2, we see that FLOW outperforms GFM and RFM in most cases, especially with significant improvements for circuits c2670 and c7552. However, the result for c6288 by FLOW was worse than those by TABL 1 TH SIZS OF TH ISCAS85 TST CASS circuit #nodes #nets #pins c c c c c

6 TABL 2 PARTITIONING RSULTS OF THR ALGORITHMS GFM and RFM. Thus, further study and refinement on the algorithm is definitely required. In [9], a Fiduccia-Mattheyses (FM) based iterative improvement is proposed for HTP. Using the results from the three algorithm in Table 2 as the initial partitions, we run the FM based algorithm for further improvements and denote the combined algorithms as GFM+, RFM+ and FLOW+. Table 3 lists the costs and of the final partitions and the improvements by FM. As in Table 2, the results for GFM+ and RFM+ are quoted from [9]. From Table 3, we can see that the FM algorithm definitely improves the initial solutions from the three constructive algorithms. Combined with FM, FLOW+ still beats GFM+ and RFM+ for c2670 and c7552 but the cost differences have decreased. 5. CONCLUSIONS GFM RFM FLOW circuit cost cost cost CPU (s) c c c c c TABL 3 PARTITIONING RSULTS OF THR ALGORITHMS COMBIND WITH ITRATIV IMPROVMNT ALGORITHMS GFM+ RFM+ FLOW+ circuit cost improv. cost improv. cost improv. c % % % c % % % c % % % c % % % c % % % We presented an algorithm for the hierarchical tree partitioning problem based on a new network flow approach. First, we formulated the problem as a linear program by spreading metrics. From the primal and dual programs, we devised a heuristic to compute a spreading metric approximately and use the spreading metric to construct a hierarchical tree partition. Preliminary experimental results demonstrated that our new algorithm can generate better results for some MCNC benchmarks. Since the complexity of the algorithm is dominated by the spreading metric computation, we may improve the results from constructing multiple partitions for the same spreading metric without a significant increase on the run time. In constructing the partition, more sophisticated algorithms, such as the one in a recent paper by Karger [7], may also be applied to find a minimum cut from a minimum spanning tree ACKNOWLDGMNT We would like to thank Dr. Satish Rao for insightful discussions on spreading metrics and graph partitioning problems. This work was done while the first author was with University of California at San Diego, and was supported in part by grants from the NSF project MIP and the California MICRO Program. RFRNCS [1] C.-K. Cheng and T. C. Hu, Maximum concurrent flows and minimum cuts, Algorithmica, Vol. 8, 1992, pp [2]. W. Dijkstra, A note on two problems in connexion with graphs, Numerische Mathematik, Vol. 1, 1959, pp [3] G. ven, J. Naor, S. Rao, and B. Schieber, Divide-and-conquer approximation algorithms via spreading metrics, Proc. 36th Annual Symposium of Foundations on Computer Science, Oct. 1995, pp [4] G. ven, J. Naor, S. Rao, and B. Schieber, Fast approximate graph partitioning algorithms, submitted to Symposium of Discrete Algorithms, [5] L. R. Ford and D. R. Fulkerson, Maximal flow through a network, Canadian Journal of Mathematics, Vol. 8, No. 3, [6] M. Iri, On an extension of the maximum flow minimum cut theorem to multicommodity flows, Journal of the Operations Research Society of Japan, Vol. 5, No. 4, 1967, pp [7] D. R.Karger, Minimum cuts in near-linear time, Proc. 28th ACM Symposium on Theory of Computing, 1996, pp [8] M.-T. Kuo, Circuit partitioning in hierarchical design, Technical Report CS96-509, University of California, San Diego, CA, [9] M.-T. Kuo, L.-T. Liu, and C.-K. Cheng, Network partitioning into tree hierarchies, Design Automation Conference, 1996, pp [10] K. Lang and S. Rao, Finding near-optimal cuts: An empirical evaluation, ACM-SIAM Symposium on Discrete Algorithms, 1993, pp [11] T. Lengauer, Combinatorial Algorithms for Integrated Circuit Layout, New York, Wiley, [12] D. W. Matula and F. Shahrokhi, The maximum concurrent flow problem and sparest cuts, Technical Report, Southern Methodist University, [13] K. Onaga, A multi-commodity theorem, Transactions of the Institute of lectronics and Communication ngineers of Japan, Vol. 53-A, No. 7, 1970, pp [14] R. C. Prim, Shortest connection networks and some generalizations, Bell System Technical Journal, Vol. 36, 1959, pp [15] S. Rao, Personal Communications, May [16] G. Vijayan, Generalization of min-cut partitioning to tree structures and its applications, I Trans. on Computers, Vol 40, No. 3, 1991, pp [17] C.-W. Yeh, C.-K. Cheng, and T.-T Y. Lin, Circuit clustering using a stochastic flow injection method, I Trans. on Computer-Aided Design of Integrated Circuits and Systems, Vol. 14, No. 2, 1995, pp