Reproduction is permitted for noncommercial purposes.

Finite Element Method (FEM) is a well known technique extensively studied for spatial and temporal modeling of environmental processes, weather prediction computations, and intelligent signal processing for wireless sensors. The need for huge computational power arising in such applications to simulate physical phenomenon correctly mandates the use of massively parallel computers to distribute the workload evenly. In this study, a novel heuristic algorithm called

Finite Element Methods (FEM) and repeated solutions of linear systems of equations for different right-hand side vectors in the form of

The issue of distributing the overall workload evenly amongst a set of processors has been widely studied [

In this paper, a novel heuristic algorithm called

Given an undirected graph

There has been tremendous research on graph partitioning in the literature. Liu and Ashcraft [

There exist some other algorithms which have relied on the underlying characteristics of the problem domain. One such algorithm that arises in applications where the graph is planar was studied by Lipton and Tarjan [

It is emphasized in [

Kernighan-Lin algorithm as an edge separator minimizing bisection algorithm can be seen to find its niche in refining results obtained via a versatility of algorithms and frameworks proposed in the literature. This observation coupled with the fact that constructing vertex separators from edge separators is not always effective forms the primary sources behind the motivation for LGB algorithm devised in this study. LGB is, hence, developed to obtain vertex separators directly, and yet, has the same characteristics as does Kernighan-Lin (KLB) algorithm so that it is readily applicable to domains where KLB is currently being used. The objective stated may as well hint to the idea behind LGB. If KLB could be somehow modified without imposing any constraints on the way it operates in such a way that it would be possible to treat the nodes as if they were edges, LGB would find its uses in graph partitioning through vertex separators both as a better replacement for KLB when used in the refinement phase and as a standalone heuristic algorithm which may be coupled with other combinatorial techniques to produce more powerful schemes to better suit the needs of different domains.

Line Graph Bisection algorithm has been inspired from the well-known Kernighan-Lin [^{2} log

Let us assume that we have a graph of which all the nodes are numbered and all the edges are labeled distinctly. In this case its line graph is the graph obtained by replacing each edge with a corresponding single node and each node with some number of edges proportional to the degree of the respective node. An example graph

As can be seen from

Terminal nodes in the original graph, on the other hand, with a degree of one will be edges in the line graph represented with one of their end points as a non-existent artificial node. It should also be noted that

_{1}_{2}_{1}_{2}_{1}_{2}

It can easily be derived from Theorem 4.3 that there exists no degree one vertex in a line graph with the exception of artificial nodes. This fact is presented in Lemma 4.4.

Having introduced the terminology, the KLB algorithm whose understanding is crucial to the development of the proposed (LGB) algorithm can be described now.

The Kernighan-Lin algorithm [^{2}

In order to partition a graph into two clusters such that the total weight of the edges in the cut, i.e., between the two partitions, will be minimized, and the sum of the node weights in each of the two partitions will only differ by a tolerance factor, the graph is initially partitioned into two randomly chosen sub-graphs. Then, by a number of moves originating from the partition with more total weight to balance the load implicitly, the cut size (the sum of the weights of edges from one partition to the other partition) is tried to be made smaller. To perform such a task, the node to be selected in each move should be the one which has the maximum gain. The gain of a node in the KLB algorithm is defined as the total weight of edges by which the cut size would increase or decrease if this node were to be moved to the other partition. Each node in a given configuration has some internal and external edges (i.e., some link to those vertices in the same partition, and others to those in the other partition, respectively). The gain of a node _{i}_{(i, j)}_{i}_{j}_{i}_{j}_{i}_{old}_{(i, j)}_{old}_{(i, j)}_{(i, j)}_{i}_{j}

The process continues until all the nodes are locked. To prevent the procedure from getting stuck at a local maximum, the sequence of moves that gives the maximum total decrease in the cut size is chosen afterwards. This, in turn, means that some intermediary individual moves that may even worsen the cut size are allowed. All the nodes are unlocked at the end of the iteration, and the sequence of moves minimizing the cut size is actually performed this time, thus resulting in a new configuration, and the algorithm is restarted with this new initial configuration. The overall procedure may be repeated so long as either the cut size decreases or the load balance is improved.

In the next section, how the proposed algorithm, LGB, has evolved will be explained, and it will be presented in detail.

The trick which makes the LGB algorithm possible is to convert the original graph

The LGB algorithm is, in essence, a modified version of KLB in that both the characteristics of the line graph such as the existence of edges, now, that needs to be treated as one and the requirements imposed by the original problem such as the necessity to keep track of the loads of the respective partitions in terms of the weights of the edges rather than nodes are neatly taken into account so as to efficiently compute small edge separators. Assuming that such small edge separators can feasibly be found in the line graph through an algorithm which is going to be described in full detail shortly, it is trivial to derive the corresponding nodal partition induced in the original graph which corresponds exactly to the minimum cut partition obtained by LGB in the line graph.

An example graph

In light of the previous discussion, the overall procedure for partitioning a graph via vertex separators may be formulated as listed in

For computing vertex separators as outlined in _{1}_{2}_{1}_{2}

The individual steps of Procedure 4.1 for computing vertex separators given in

An algorithm to convert a given graph

_{G}_{L(G)}_{L(G)}_{G}^{T}C_{G}

Lemma 4.6 given below is used to show the time complexity of the line graph conversion algorithm used.

_{i}

^{2})

_{i}^{2})

The LGB algorithm used in step (2) of Procedure 4.1 to find small vertex separators for partitioning a graph is listed in

The input to the Algorithm 4.2 listed in

Each slot of the array as shown in _{i}_{i}_{1}_{2}_{[1]}n_{[2]}n_{[1]}s_{[2]}s_{[1]}n_{[2]}n_{[1]}o_{[2]}o_{[1]}n_{[2]}n_{i}_{i}_{(i,j)}, l_{(i,j)})_{(i,j)}_{(i,j)}

Upon getting the input, LGB obtains an initial partition _{1}_{2}_{[1]}o_{[2]}o_{[1]}s_{[2]}s_{1}_{2}_{1}_{2}_{1}_{2}

A doubly linked list data structure, _{v}] [_{v}_{v}_{1}_{2}_{ν}_{ν}_{ν}_{i}_{i}

Initial gains are calculated for all nodes in _{L(G)}_{[1]}n_{[2]}n

Each set of edges naturally connects to some adjacent nodes that are either in the same partition called

The Algorithm 4.3 for calculating the initial gain of a node is given in

_{1}_{2}_{3}_{1}_{2}_{3}_{1}_{2}

The term _{[k]}n

After recording the previous load balance difference at step 9.4, the inner loop that performs a sequence of moves from the source partition to the destination partition which has less weight until all the nodes are marked as locked is executed at steps 9.5 through 9.6. For each prospective move found, respective weights of the partitions are updated at step 9.5.3.2 of Algorithm 4.2 as detailed by Algorithm 4.4 shown in

Having recorded the move together with its sequence number, gain and the new load difference value between the partitions at step 9.5.3.3, it is time for updating the gains affected by this move at step 9.5.3.4. Fortunately, the nodes whose gains need to be updated are only those adjacent to the node just moved. Additionally, the updates are local in that the distinct labels in the cut need not be searched for updates to be done accurately.

This property is exploited for minimizing the number of cases to perform fast updates and minimizes the storage required.

As can be seen from _{L(G)}

The inner loop is exited to step 9.7 when all the nodes are marked as locked where a sequence number maximizing the expression _{move[1]}_{move[k]}

It can easily be seen that a single pass of LGB algorithm takes _{1}_{2}

In this section, some test cases are provided to compare LGB to methods that use KLB either indirectly to obtain vertex separators from edge separators or modify KLB based on some combinatorial techniques such as bipartite graph matching. As Hendrickson and Rothberg [

In

Another algorithm which finds alternating level structures by augmenting paths is described by Liu [

Other cases, however, may be plotted where bipartite graph matching cannot escape from local minima as depicted in

However, it should be noted that combinatorial techniques such as bipartite graph matching and LGB can very well be used together in combination without any sacrifice. It is actually the nature of NP-Hard problems that urges a constant search in need of newer heuristics with a potential of domination when used in combination with others. The LGB algorithm is orthogonal in that respect, and hence, can be coupled with any method developed within the context of vertex separators.

A separator

In this section, the LGB algorithm presented is applied recursively to obtain ^{dmax} subgraphs which can be later assigned to a set of processors numbered from ^{dmax} -

The algorithm, _{max}^{th}^{th}

^{p}^{p}

For assigning the separators, a similar strategy is followed. Each separator is assigned the processor which is either one of the two processors involved while this separator emerges and the one that has not been already assigned a separator before. To speed up the procedure, separator 1 is assigned the processor number 0, and the processor number 1 is never used while assigning separators to the processors. This algorithm, presented in

Procedures

In this study, a novel heuristic which performs fast was developed, and it has been shown to be superior to the method of obtaining vertex separators indirectly from edge separators. When coupled with appropriate combinatorial methods such as bipartite graph matching, it is conjectured to be the best viable heuristic that can be used in the refinement phase of multilevel nodal graph partitioning schemes. Although it is generally conjectured that problems on vertex separators are harder than the corresponding problems on edge separators [

Some difficult issues remain to be explored such as the optimality bounds for the separator size to be investigated, and modification and testing of LGB in different problem domains. Another area of future research is the investigation of the intrinsic characteristics of line graphs which would lead to the development of more efficient heuristic algorithms. A thorough experimental evaluation of the algorithm with respect to different types of randomly generated graphs is considered to be of great value in that respect. Another further improvement on LGB may be to apply a look-ahead type of bin search so that insertion to the bins may also take into account another criterion so as to favor nodes with more number of edges labeled the same. This is expected to help enhance the elasticity of the moves such that more number of nodes (due to connectivity) will have the capability to move freely.

The author would like to thank anonymous referees for their careful reading.

A graph and its corresponding line graph.

An example initial partition for KLB algorithm.

An example move by KLB.

Moves performed by KLB.

Original graph

Example line graph

Computing vertex separators.

LGB Algorithm.

Record structure for nodes in

Bin data structures.

Visualizing the edges emanating from a node in

Initial gain calculations.

Updating partition weights.

Update of gain values when in different partitions.

Update of gain values when in the same partition.

Algorithm for updating the gains of adjacent nodes after a move.

A graph for comparing KLB and LGB.

A configuration where bipartite graph matching gets stuck at a local minimum.

Recursive LGB.

Mapping partitions to processors.

Algorithm to map separators.

Procedures used in mapping separators.