Multi-Level Refinement Algorithm of Weighted Hypergraph Partitioning Problem

3.1 The Coarsening Phase

In the coarsening phase, an input weighted hypergraph H0G(V0,E0h) is successively coarsened. The creation of coarse hypergraph Hi + 1G from the hypergraph of the previous level HiG, consists of matching pairs of vertices of HiG(Vi, Eih) that are connected by an hyperedge, thus, obtaining a new hypergraph Hi + 1G. By repeating the coarsening process, a hypergraph with fewer vertices is generated in each level until finally a coarsest hypergraph is built. The coarsening phase produces a sequence of hyper-graphs H1G, …, HkG, …, HlG, whose vertices are satisfied with |V₁| >…>|V_k|>…|V_l|. The coarsening must stop when the number of vertices becomes less than a given threshold.

3.2 The Initial Partitioning Phase

In the initial partitioning phase, the move-based approaches [4, 8], geometric representations [18], combinatorial formulations [3], spectral method [9], cellular automata approaches [11] are applied to obtain the initial partition P_l of the coarsest weighted hypergraph HlG. The initial partition P_l is satisfied with the approximate same sum of the vertex weights of two subsets and the minimum of the sum of the hyperedge weights, which contain vertices in different subsets, respectively. According to the minimum of the hyper-edges and vertices of the coarsest weighted hypergraph, the quality of partitioning on the coarsest weighted hypergraph is better than the quality of partitioning on the original weighted hypergraph in the same computing time.

3.3 The Uncoarsening and Refinement Phase

In the uncoarsening and refinement phase, the initial partitioning P_l of the coarsest weighted hypergraph HlG(Vl, Elh) is projected to the finer weighted hypergraph Hl − 1G(Vl − 1, El − 1h), whose partition is P_l–1. By repeating the uncoarsening process, the partitioning P_k of finer hypergraph HkG(Vk, Ekh) is projected from the partitioning P_k+1 of the coarser hypergraph Hk + 1G(Vk + 1, Ek + 1h) until the partitioning P₀ of the original hypergraph H0G(V0, E0h) is projected. At the same time, the refinement algorithm selects two subsets of vertices VkA(VkA ⊂ Vk1) and VkB(VkB ⊂ Vk2) from the partitioning Pk(Vk1, Vk2), such that the cut of the refined partitioning P′k((Vk1 − VkA) ∪ VkB, (Vk2 − VkB) ∪ VkA) is smaller than the cut of the partitioning P_k.

4.1 The Framework of the Multi-Level Method based on the Discrete Particle Swarm Optimization

Algorithm 1 illustrates the framework of multi-level method based on the discrete particle swarm optimization. It is the difference between algorithm 1 and section 3 that are the initial partitioning phase and the uncoarsening and refinement phase. (1) In the initial partitioning phase, we should initially input parameters for the first call of the MDPSOR algorithm, which includes the initial partitioning P_l of the coarsest weighted hypergraph HlG(Vl, Elh) at line 8, the initial position vector Xli→ of each particle at line 10, the best position vector Qli→ of each particle at line 11, the random velocity vector Yli→ of each particle at line 12. (2) In the uncoarsening and refinement phase, we can get the approximate global optimal partitioning Qkδ→ of particle swarm by running MDPSOR algorithm on the k level finer weighted hypergraph HkG(Vk, Ekh) at line 15. With the refinement of the uncoarsening phase, we should project successively the i^th particle’s velocity vector Yki→, position vector Xki→ and best position vector Qki→ at the k level back to Y(k − 1)i→,X(k − 1)i→, and Q(k − 1)i→ of the next level finer hypergraph for the next call of the MDPSOR algorithm at lines 18–20 separately. We also should project successively the approximate global optimal partitioning Qkδ→ of the particle swarm at the k level back to Q(k − 1)δ→ of the next level finer hypergraph at line 22. Finally, we can get the partitioning P₀ of the original hypergraph H0G(V0, E0h), the approximate global optimal partitioning Q0δ→ of the particle swarm, by running MDPSOR algorithm on original weighted hypergraph H0G(V0, E0h) at line 25.

4.2 The Multi-Level Discrete Particle Swarm Optimization Refinement Algorithm

Algorithm 2 presents the pseudo-code of the multi-level discrete particle swarm optimization refinement algorithm. The main structure of the MDPSOR algorithm consists of a nested loop. The first outer loop at line 2–22 detects the stopping condition whether the MDPSOR algorithm is run for a fixed number of iterations δ, and its loop control variable of the first outer loop is t. The loop control variable of the second level loop at line 3–20 is i, whose number of iterations is the size of the particle swarm N. The loop control variable of the third inner loop at lines 5–17 is d, whose number of iterations is the dimension of particle |V_k|.

In the third inner loop, we calculate the d^th vertex’s gain of the i^th particle based on the fast calculation of vertex gain method described in section 5.2. If the gain is greater than zero, we should move the d^th vertex to the other side of the partitioning at line 8. Otherwise, we should execute the velocity update equation and the position update equation at lines 10–15. First, we should update the d^th vertex’s velocity yidt + 1 of the i^th particle based on the velocity update equation at line 10. Second, it is necessary to impose a maximum value y_max on velocity yidt + 1. If the yidt + 1 exceeded this threshold, it will be set equal to y_max at line 11. Third, we should update the d^th vertex’s position xidt + 1 of the i^th particle based on the position update equation at line 12. If the d^th vertex’s position xidt + 1 of the i^th particle has changed, we also should move the d^th vertex of the i^th particle to the other side of the partitioning at lines 13–15.

Each particle ’s positionX→ki also needs to update by moving probabilistically vertices and maybe violates the balancing constraintβ. Therefore, we choose repetitively the highest-gain vertex to move from the larger side and satisfy the balance constraint of X→ki by using the EE-FM algorithm [7] and the fast calculation of partitioning cut method described at section 5.3 at line 18. It may be possible to improve the quality of X→ki by using the local heuristic algorithm until the local optimum is reached. If the position vector Xki→ of the i^th particle is better than the best position vector Qki→ of the i^th particle in the second level loop, we should update the best position vector Qki→ to the position vector Xki→ at line 19. If the best position vector Qki→ of the i^th particle is better than the global optimal position vector Qkδ→ of particle swarm in the first outer loop, we should update the global optimal position vector Qkδ→ to the best position vector Qki→ at line 21.

5.1 The Improved Compressed Storage Format of Weighted Hypergraph

The data physical structure, as the physical storage of data logical structure, is data mapping storage in memory according to the requirement of response speed, processing time, modification time, storage space, and processing amount per unit time [14]. It is different that the time complexity and space complexity of the partitioning algorithm are based on the different data physical structure of the weighted hypergraph [10]. Therefore, we adopt the Improved Compressed Storage Format (ICSF). Figure 2 illustrates an example of weighted hypergraph and its improved compressed storage format. It is the main characteristic of ICSF that linked list has not been used for storage of hypergraph. Therefore, it can effectively avoid retrieving adjacency and complex maintenance. It also can effectively reduce the storage space and is easy to maintain.

Figure 2:

An Example of Weighted Hypergraph and its Improved Compressed Storage Format.

In the ICSF, the adjacency structure of a hypergraph with n vertices and m hyper-edges is represented using two arrays xadj and adjncy. The xadj array is of size n+1, whereas the adjncy array is of size 2m. Assuming that vertex numbering starts from 0 (C style), then the adjacency list of vertex i is stored in array adjncy starting at index xadj[i] and ending at (but not including) index xadj[i+1] (i.e. adjncy[xadj[i]] through and including adjncy[xadj[i+1]-1]). That is, for each vertex i, its adjacency list is stored in consecutive locations in the array adjncy, and the array xadj is used to point to where it begins and where it ends.

In the ICSF, the other two arrays are used to describe hyper-edges in the hypergraph. The first array, eptr, is of size m+1, and it is used to index the second array eind that stores the actual hyper-edges. Each hyperedge is stored as a sequence of the vertices that it spans, in consecutive locations in eind. Specifically, the j^th hyperedge is stored starting at location eind[eptr[j]] up to (but not including) eind[eptr[j+1]] (i.e. eind[eptr[j]] through and including eind[eptr[j+1]]-1]). The weights of the vertices (if any) are stored in an additional array called vwgts, whose size is n. The weights of the hyper-edges (if any) are stored in an additional array called hewgts, whose size is m. Specifically, the weight of the i^th vertex is stored at vwgts[i], the weight of the j^th hyperedge is stored at hewgts[j].

Figure 2B illustrates the CSR format of the seven-vertex and eight-hyperedge hypergraph shown in Figure 2A. For example, the 6^th vertex’s weight is stored at vwgts[6]=7, has f and h adjacency hyper-edges, whose corresponding weights are 4 and 1 and corresponding adjacency vertices are 7, 3 and 4.

5.2 The Fast Calculation of Vertex Gain

The time complexity analysis of the multi-level discrete particle swarm optimization refinement algorithm indicates that the operation of the highest frequency is the calculation of vertex gain. That is to say, the calculation of vertex gain dictates the time complexity of the whole MDPSOR algorithm.

According to the definition of vertex gain based on definition 5, the simple calculation of vertex gain includes the following steps:

• Initialize the value of gain as zero.

• Read the adjacency hyper-edges list from the adjncy[xadj[i]] to adjncy[xadj[i+1]-1], according to the starting index xadj[i] and ending index xadj[i+1] of the vertex adjacency hyper-edges.

• Read the weight of the adjacency hyper-edges list from the hewgts[adjncy[xadj[i]]] to hewgts[adjncy [xadj[i+1]-1]].

• Read the vertex information of the j^th adjacency hyper-edge list from the eind[eptr[j]] to eind[eptr[j+1]]-1].

• Calculate the gain of vertex according to the status of current vertex and all vertices of each adjacency hyperedge.

  1. If vertices of the adjacency hyperedge are located at the same partitioning, then the value of gain minus the weight of the adjacency hyperedge.

  2. If vertices of the adjacency hyperedge, which the current vertex are excepted, are located at the same partitioning, then the value of gain plus the weight of the adjacency hyperedge.

It is not too difficult to find that the simple calculation of vertex gain should traverse all vertices of all adjacency hyper-edges. In order to reduce the time complexity of vertex gain calculation, we introduce the two-dimensional auxiliary array EDG[2][m] for the fast calculation of vertex gain, which stores the vertices number of each hyperedge at V¹ and V² partitioning. The fast calculation of vertex gain includes the following steps:

• Initialize:

  1. At line 4 of the pseudo-code of MDPSOR algorithm, the two-dimensional auxiliary array EDG[2][m] is initial to put zero.

  2. Read the vertex information of the each hyperedge from the eind[eptr[j]] to eind[eptr[j+1]]-1], Calculate the vertices number of each hyperedge at V¹ and V² based on the initial partitioning.

• Update:

  1. At line 8 or 14 of the pseudo-code of MDPSOR algorithm, move the d^th vertex to the other side (assume the original side is from, the new side is to).

  2. Traverse all adjacency hyper-edges eId of current vertex, the value of EDG[from][eId] minus 1 and the value of EDG[to][eId] plus 1.

• Calculate:

  1. At line 6 of the pseudo-code of MDPSOR algorithm, fast calculate the d^th vertex’s gain. Traverse all adjacency hyper-edges eId of current vertex, read the weight of the adjacency hyper-edges list from the hewgts[adjncy[xadj[i]]] to hewgts[adjncy [xadj[i+1]-1]].

     1. If EDG[from][eId] is equal to 1, the value of gain plus the weight of the eId^th hyperedge.

     2. If EDG[to][eId] is equal to 0, the value of gain minus the weight of the eId^th hyperedge.

5.3 The Fast Calculation of Partitioning Cut

The basic idea of partitioning cut calculation should traverse each hyperedge and determine whether each hyperedge is crossing-partitioning hyperedge based on the status of all vertices of current hyperedge. If the current hyperedge is crossing-partitioning hyperedge, the cut of partitioning is plus the weight of current hyperedge. However, the simple calculation of partitioning cut must traverse each vertex of the current hyperedge and determine the crossing-partitioning hyperedge whether all vertices of current hyperedge occupy at the V¹ and V² partitioning.

In order to reduce the time complexity of partitioning cut calculation and avoiding to traverse all vertices of each hyperedge, we proposed the judgment method of crossing-partitioning hyperedge based on the fast partitioning cut calculation. If the condition (EDG[from][eId]≧1) and (EDG[to]eId]≧1) are met, the current hyperedge is crossing-partitioning hyperedge, which satisfied with the vertices number of each hyperedge at the V¹ and V² partitioning is greater than or equal to 1.

5.4 The Time Complexity Analysis of Algorithm

Suppose the vertices number of the weighted hypergraph partitioning problem is n, the hyper-edge number is m, the maximum of adjacency hyperedge of any vertex is x (x<m), the maximum of vertices of any hyperedge is y (y<n), the scale of swarm is N, the maximum cycles is δ.

The main structure of the MDPSOR algorithm consists of a three-level nested loop. The cycle index of the first outer loop is δ, the cycle index of the second level loop is N×δ, the cycle index of the third inner loop is n×N×δ. The time complexity of the MDPSOR algorithm includes six parts:

• Initialization of the two-dimensional auxiliary array EDG[2][m] of the second level loop:

  1. Traverse all vertices of each hyperedge and Calculate the vertices number of each hyperedge at the V¹ and V² partitioning.

  2. The time complexity is Θ (N×δ×m×y).

• Calculation of the d^thvertex’s gain of the i^thparticle of the third inner loop:

  1. Traverse all adjacency hyper-edges of current vertex and Fast Calculate the gain of current vertex.

  2. The time complexity is Θ (n×N×δ×x).

• Update of each particle’s velocity and position of the third inner loop:

  1. Calculate the velocity update equation and the position update equation of each particle.

  2. The time complexity is Θ (n×N×δ×2).

• Execution of the EE-FM algorithm of the second level loop:

  1. In general, the EE-FM algorithm only refines the 1% vertices required by the FM algorithm. Moreover, the quality of the partitioning produced by the EE-FM algorithm are, in general, only slightly worse (if any) than those produced by the FM algorithm.

  2. The time complexity of the EE-FM algorithm can often be ignored in comparison to particle swarm optimization algorithm.

• Update of each particle’s best position of the second level loop:

  1. Calculate the cut of each particle’s best position based on the fast calculation of partitioning cut.

  2. The time complexity is Θ (N×δ×m).

• Update of the global optimal position of the first outer loop:

  1. If the best position vector Qki→ of the i^th particle is better than the global optimal position vector Qkδ→ of the particle swarm, we should update the global optimal position vector Qkδ→ to the best position vector Qki→.

  2. The time complexity is Θ (δ×1).

Regardless of the impact of the lower rank factors, the whole time complexity of the MDPSOR algorithm can be reduced as Θ (N×δ×m×y+n×N×δ×x).

5.5 The Space Complexity Analysis of Algorithm

Suppose the vertices number of the weighted hypergraph partitioning problem is n, the hyper-edges number is m, the sum of vertices number of each hyperedge is z, the scale of swarm is N.

The space complexity of the MDPSOR algorithm includes five parts:

• the particle swarm:

  1. The velocity vector, the position vector, and the best position vector of each particle

  2. The space complexity is Ω (3×n×N).

• the global array adjncy and eind:

  1. The size of adjncy and eind array is z

  2. The space complexity is Ω (2×z).

• the global array hewgts and eptr:

  1. The size of hewgts and eptr array is m

  2. The space complexity is Ω (2×m).

• the global array vwgts and xadj:

  1. The size of vwgts and xadj array is n

  2. The space complexity is Ω (2×n).

• the two-dimensional auxiliary array EDG:

  1. The size of two-dimensional auxiliary array EDG[2][m] is 2×m

  2. The space complexity is Ω (2×m).

Therefore, the whole space complexity of the MDPSOR algorithm is Ω (3×n×N+4×m+2×n+2×z).

6.1 ISPD98 Benchmark

In [1], Professor Alpert of IBM Austin Research Laboratory introduced the ISPD98 benchmark suite, which consists of 18 circuits and used for the researchers of academic and industrial to compare and validate electronic design automation algorithms. In our experiments, we use 18 weighted graphs and weighted hyper-graphs converted from the ISPD98 benchmark suite based on the pseudo-code of algorithm for converting ISPD98 netlist into weighted graphs [12] and weighted hyper-graphs [11] separately, which also converts the circuit netlist partitioning into the weighted graphs and weighted hyper-graphs partitioning. Table 1 presents the characteristics of 18 weighted graphs and weighted hyper-graphs of ISPD98 benchmark. The characteristics of 18 weighted graphs are ranging from 12752 to 210613 vertices and from 109183 to 2235716edges. The characteristics of 18 weighted hyper-graphs are ranging from 12752 to 210613 vertices and from 14111 to 201920hyper-edges.

We implement the MDPSOR algorithm in ANSI C and integrate with the leading edge partitioner UMpack. In the evaluation of our algorithm, we must make sure that the results produced by our algorithm can be easily compared against those produced by the Metis and hMetis tools, which are state-of-the-art tools of multi-level method. We use the same balance constraint b and random seed in every comparison. The quality of bipartitioning (nparts=2) is evaluated by looking at two different quality measures, which are the minimum cut (MinCut) and the average cut (AveCut). To ensure the statistical significance of our experimental results, two measures are obtained in twenty (Nruns=20) runs whose random seed is different to each other. For all experiments, we use a 49–51 bipartitioning balance constraint by setting b to 0.02.

In the scheme choices of three phases offered by the multi-level method, we use the RM [6] and SHEM [6] combination strategy during the coarsening phase, the GGGP [7] algorithm during the initial partitioning phase that consistently finds smaller edge-cuts than other algorithms, the weighted graphs refinement algorithm based on the FM algorithm (Metis-FM-Graph), the weighted hyper-graphs refinement algorithm based on the FM algorithm (hMetis-FM-HyperGraph), and the weighted hyper-graphs refinement algorithm based on the MDPSOR algorithm (UMpack-MDPSOR-HyperGraph) during the refinement phase. These measures are sufficient to guarantee that our experimental evaluations are not biased in any way. Furthermore, we adopt the experimentally determined optimal set of parameter values for the MDPSOR algorithm, the scale of swarmN is 40, the maximum cyclesδ is 40, the inertia weightα is 1, the cognitive parameterϕ₁ is 0.5, the social parameterϕ₂ is 0.5.

Table 2 presents the min-cut bipartitioning results allowing up to 2% deviation from the exact bisection, which the Metis-FM-Graph algorithm result comes from paper [9] and the hMetis-FM-HyperGraph algorithm result comes from paper [10]. The comparison and analysis indicate that:

• The cut of Metis-FM-Graph algorithm is greater than the cut of hMetis-FM-HyperGraph algorithm and UMpack-MDPSOR-HyperGraph algorithm. Compared with the weighted graphs, the weighted hyper-graphs provide more precise mathematical model for the circuit partitioning whose wire can connect with more than two circuits. That is to say, each hyperedge can connect with more than two vertices.

• The cut of UMpack-MDPSOR-HyperGraph algorithm is superior to the cut of hMetis-FM-HyperGraph algorithm. According to “the global optimal partitioning of the coarsest weighted hypergraph might be the local optimal partitioning of the original weighted hypergraph” and “the global optimal partitioning of the coarser weighted hypergraph might be the local optimal partitioning of the finer weighted hypergraph,” the UMpack-MDPSOR-HyperGraph algorithm can improve the search capability of the refinement algorithm.