AbstractHypergraph partitioning is used in many problem domainsincluding VLSI design, linear algebra, Boolean satisfiabil-ity, and data mining. Most versions of this problem are NP-complete or NP-hard, so practical hypergraph partitionersgenerate approximate partitioning solutions for all but thesmallest inputs. One way to speed up hypergraph partitionersis to exploit parallelism. However, existing parallel hyper-graph partitioners are not deterministic, which is consideredunacceptable in domains like VLSI design where the samepartitions must be produced every time a given hypergraph ispartitioned.
In this paper, we describe BiPart, the first deterministic, par-allel hypergraph partitioner. Experimental results show thatBiPart outperforms state-of-the-art hypergraph partitionersin runtime and partition quality while generating partitionsdeterministically.
1 IntroductionA hypergraph is a generalization of a graph in which an edgecan connect any number of nodes. Formally, a hypergraphis a tuple (𝑉 , 𝐸) where 𝑉 is the set of nodes and 𝐸 is a setof nonempty subsets of 𝑉 called hyperedges. Graphs are aspecial case of hypergraphs in which each hyperedge connectsexactly two nodes [3].∗ Both authors contributed equally.
Figure 1. Example hypergraph and the correspondingbipartite graph representation
Figure 1a shows a hypergraph with 6 nodes and 4 hyper-edges. The hyperedges are shown as colored shapes aroundnodes. The degree of a hyperedge is the number of nodes itconnects. In the figure, hyperedge h1 connects nodes a, c, andf, and it has a degree of three.
Hypergraphs arise in many application domains. In VLSIdesign, circuits are often modeled as hypergraphs; nodes inthe hypergraph represent the pins of the circuit and hyper-edges represent wires from the output pin of a gate to the inputpins of other gates [6]. In Boolean satisfiability, a Booleanformula can be represented as a hypergraph in which nodesrepresent clauses and hyperedges represent the occurrences ofa given literal in these clauses. Hypergraphs are also used tomodel data-center networks [36], optimize storage shardingin distributed databases [19], and minimize the number oftransactions in data centers with distributed data [38].
PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea Maleki, Agarwal, Burtscher, and Pingali
1.1 Hypergraph partitioningIn many of these applications, it is necessary to partition thehypergraph into a given number of subgraphs. For example,one of the key steps in VLSI design, called placement, as-signs a location on the die to each gate. Good algorithms forplacement must balance competing goals: to avoid hotspotson the chip, it is important to spread out circuit componentsacross the entire die but this may increase interconnect wirelengths, reducing the rate at which the chip can be clocked.This problem is often solved using hypergraph partitioning [6].Hypergraph partitioning is also used to optimize logic synthe-sis [29], sparse-matrix vector multiplication [7], and storagesharding [19].
Formally, the k-way hypergraph partitioning problem is de-fined as follows. Given a hypergraph G = (V, E), the number ofpartitions to be created (𝑘 ≥ 2), and an imbalance parameter(𝜖 ≥ 0), a k-way partition 𝑃 = {𝑉1,𝑉2...,𝑉𝑘 } is said to be bal-anced if it satisfies the constraint |𝑉𝑖 | ≤ (1+𝜖) ( |𝑉 |/𝑘). Givena partition of the nodes, each hyperedge is assigned a penaltyequal to one less than the number of partitions that it spans;intuitively, a hyperedge whose nodes are all in a single parti-tion has zero penalty, and the penalty increases as the numberof partitions spanned by the hyperedge increases. The penaltyfor the partition is defined to be the sum of the penalties of allhyperedges. Formally, 𝑐𝑢𝑡 (𝐺, 𝑃) = ∑
𝑒 (_𝑒 (𝐺, 𝑃) − 1), where_𝑒 (𝐺, 𝑃) is the number of partitions that hyperedge 𝑒 spans.The goal of hypergraph partitioning is to find a balanced parti-tion that has a minimal cut. In some applications, hyperedgeshave weights, in which case the contribution to 𝑐𝑢𝑡 (𝐺, 𝑃)from each hyperedge 𝑒 in the definition above is multipliedby the weight of 𝑒.
Many partitioners produce two partitions (often called bi-partitions), and this step is repeated recursively to obtain therequired number of partitions.
Although graph partitioners have been studied extensivelyin the literature [13, 15, 22, 23], there has been relatively littlework on hypergraph partitioning. In principle, graph partition-ers can be used for hypergraph partitioning by convertinga hypergraph into a graph, which can be accomplished byreplacing each hyperedge with a clique of edges connectingthe same nodes. However, this transformation increases thememory requirements of the partitioner substantially if thereare many large hyperedges and may lead to poor-quality par-titions [6]. Therefore, it is often better to treat hypergraphsseparately from graphs. One way to represent a hypergraph 𝐻
concretely is to use a bipartite graph 𝐺 as shown in Figure 1.In 𝐺 , one set of nodes represents the hyperedges in 𝐻 , theother set of nodes represents the nodes in 𝐻 , and an edge(𝑢, 𝑣) in G is used to represent the fact that, in the hypergraph,the hyperedge represented by 𝑢 contains the node representedby 𝑣 .
An ideal hypergraph partitioner has three properties.
1. The partitioner should be capable of partitioning largehypergraphs with millions of nodes and hyperedges,producing high-quality partitions within a few seconds.
2. In some domains like VLSI circuit design, the parti-tioner must be deterministic; i.e., for a given hyper-graph, it must produce the same partitions every timeit is run even if the number of threads is changed fromrun to run. For example, the manual post-processing inVLSI design after partitioning optimizes the placementof the cells within each partition. Many placement toolscan do efficient placement only for standard cells, andif non-standard cells are used, the placement may needto be optimized manually. Deterministic partitioning isessential to avoid having to redo the placement.
3. Since hypergraph partitioners are based on heuristics,they have parameters whose optimal values may de-pend on the hypergraph to be partitioned. Hypergraphpartitioners should permit design-space exploration ofthese parameters by sophisticated users.
Most variations of graph and hypergraph partitioning areeither NP-complete or NP-hard [1], so heuristic methods areused in practice to find good solutions in reasonable time.Prior work in this area is surveyed in Section 2 [7, 10, 11, 16,21, 22, 25, 35].
In our experience, existing partitioners lack one or moreof the desirable properties listed above. Many high-qualityhypergraph partitioners like HMetis [21], PaToH [7], andKaHyPar [16] are serial programs. For some of the hyper-graphs in our test suite, these partitioners either run out ofmemory or time out after an hour, as described in Section 4.
Parallel hypergraph partitioners like Zoltan [11] and theSocial Hash Partitioner from Facebook [19] can handle allhypergraphs in our test suite, but they are nondeterministic(we have observed that, for a hypergraph with 9 million nodes,the edge-cut in the output of Zoltan can vary by more than70% from run to run when using different numbers of cores).It is important to note that this nondeterminism does not arisefrom incorrect synchronization of parallel reads and writesbut from under-specification in the program; for example, theprogram may make a random selection from a set, and al-though it is correct to choose any element of that set, differentchoices may produce different outputs. Parallel programmingsystems may exploit such don’t-care nondeterminism to im-prove parallel performance [34], but parallel partitioners withdon’t-care nondeterminism will violate the second require-ment listed above.
1.2 BiPartThese limitations led us to design and implement BiPart, aparallel, deterministic hypergraph partitioner that can parti-tion all the hypergraphs in our test suite in just a few seconds.This paper makes the following contributions.
BiPart: A Parallel and Deterministic Multilevel Hypergraph Partitioner PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea
• We describe BiPart, an open-source framework for par-allel, deterministic hypergraph partitioning.• We describe application-level mechanisms that ensure
that partitioning is deterministic even though the run-time exploits don’t-care nondeterminism for perfor-mance.• We describe a novel strategy for parallelizing multiway
partitioning.• We show experimentally that BiPart outperforms exist-
ing hypergraph partitioners in either partition qualityor running time, and usually outperforms them in bothdimensions.
The rest of the paper is organized as follows. Section 2describes background and related work on hypergraph parti-tioning. Section 3 describes BiPart, our deterministic parallelhypergraph partitioner. Section 4 presents and analyzes theexperimental results on a shared-memory NUMA machine.Section 5 concludes the paper.
2 Prior Work on Graph and HypergraphPartitioning
There is a large body of work on graph and hypergraph parti-tioners, so we discuss only the most closely related work inthis section. It is useful to divide partitioners into geometry-based partitioners (Sec. 2.1) and topology-based partitioners(Sec. 2.2). Multilevel partitioning, discussed in Sec. 2.3, addsa different dimension to partitioning. BiPart uses a topology-based multilevel partitioning approach.
2.1 Geometry-based PartitioningIn some domains such as finite elements, the nodes of thegraph are points in a metric space such as Rd, so we cancompute the distance between two nodes. The geometricnotion of proximity of nodes can be used to partition the graphusing techniques like k-nearest-neighbors (KNN) [28]. Asophisticated geometric partitioner was introduced by Miller,Teng, and Vavasis [27]. This partitioner stereographicallyprojects nodes from R𝑑 to a sphere in R𝑑+1. The sphere isbisected by a suitable great circle, creating the partitions, andthe nodes are projected back to R𝑑 to obtain the partitions.
When there is no geometry associated with the nodes ofa graph, embedding techniques can be used to map nodes topoints in R𝑑 in ways that try to preserve proximity of nodesin the graph; geometry-based partitioners can then be used topartition the embedded graph.
One powerful but expensive embedding technique is basedon computing the Fiedler vector of the Laplacian matrix of agraph [13]. The Fiedler vector is the eigenvector correspond-ing to the second smallest eigenvalue of the Laplacian matrix.The Fiedler vector is a real vector (it can be considered an em-bedding of the nodes in R1) and the signs of its entries can beused to determine how to partition the graph. Several spectralpartitioners based on this idea were implemented and studied
in the mid-90’s [35]. They can produce good graph partitionssince they take a global view of the graph, but they are notpractical for large graphs.
Heuristic embedding techniques known as node2vec orDeepWalk are currently receiving a lot of attention in themachine-learning community [14, 32]. These techniques arebased on random walks in the graph to estimate proximityamong nodes, and these estimates are used to compute the em-bedding. Techniques like stochastic gradient descent (SGD)are employed to iteratively improve the embedding.
Unfortunately, all embedding techniques we know of arecomputationally intensive so they cannot be used for largegraphs without geometry if partitioning is to be done quickly.
2.2 Topology-based PartitioningIn contrast to geometry-based partitioners, topology-basedpartitioners work only with the connectivity of nodes in thegraph or hypergraph. These partitioners generally start withsome heuristically chosen partitioning and then apply localrefinements to improve the balance or the edge cut until atermination condition is reached.
Kernighan and Lin invented one of the first practical graphpartitioners. An initial bipartition of the graph is obtainedusing a technique such as a breadth-first traversal of the graph,starting from an arbitrary node and terminating when half thenodes have been touched. Given such a partitioning of thegraph that is well balanced, the algorithm (usually called theKL algorithm) attempts to reduce the cut by swapping pairsof nodes between the partitions until a termination criterionis met [23].
Fiduccia and Mattheyses generalized this algorithm to hy-pergraphs (their algorithm is usually referred to as the FMalgorithm) [12]. It starts by computing the gain values foreach node, where gain refers to the change in the edge cut ifa node were moved to the other partition. The algorithm exe-cutes in rounds; in each round, a subset of nodes are movedfrom their current partition to the other partition. A greedyalgorithm is used to identify this subset: the node with thehighest gain value is selected to be moved, the gain valuesof its neighbors are updated accordingly, and the process isrepeated with the remaining unmoved nodes until all nodesare moved exactly once. At the end of every round, the algo-rithm picks the maximal prefix of these moves that results inthe highest gain and moves the rest of the nodes back to theiroriginal partition. The overall algorithm terminates when nogain is achieved in the current round.
Experimental studies show that the quality of the parti-tions produced by these techniques depends critically on thequality of the initial partition. Intuitively, these algorithmsperform local optimization, so they can improve the qualityof a good initial partition but they cannot find a high qual-ity partition if the initial partition is poor, since this requiresglobal optimization.
PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea Maleki, Agarwal, Burtscher, and Pingali
2.3 Multilevel Graph PartitioningMultilevel partitioning techniques attempt to circumvent thelimitations of the algorithms described above rather than re-place them with an entirely new algorithm. This approachwas first explored for graphs [2, 5, 22] and later extendedto hypergraphs in the HMetis partitioner [21]. Since everygraph is a hypergraph, we use the term hypergraph to includegraphs in the rest of the paper.
Multilevel hypergraph partitioning consists of three phases:coarsening, initial partitioning, and refinement.
• Coarsening: For a given hypergraph 𝐺 𝑓 , a coarsenedhypergraph 𝐺𝑐 is created by merging pairs of nodesin 𝐺 𝑓 . We call 𝐺𝑐 the coarsened hypergraph and 𝐺 𝑓
the fine-grained hypergraph. This process can be ap-plied recursively to the coarsened hypergraph, creatinga chain of hypergraphs in which the first hypergraphis the initial hypergraph and the final hypergraph isa coarsened hypergraph that meets some terminationcriterion (e.g., its size is below some threshold).• Initial partitioning: The coarsest hypergraph is parti-
tioned using any of the techniques discussed in Sec-tions 2.1 and 2.2.• Refinement: For each pair 𝐺𝑐 and 𝐺 𝑓 , the partitioning
of 𝐺𝑐 is projected onto 𝐺 𝑓 and then refined, startingfrom the most coarsened hypergraph and finishing withthe input hypergraph.
Various heuristics have been implemented for these threephases. For example, heavy-edge matching, where a nodetries to merge with the neighbor with which it shares theheaviest weighted edge, is widely used in coarsening [22].Techniques frequently used in refinement include swappingpairs of nodes from different partitions, as in the KL algo-rithm, or moving nodes from one partition to another, as inthe FM algorithm. Most of these heuristics were designed forsequential implementations so they cannot be used directly ina parallel implementation.
2.4 Parallel Hypergraph PartitioningHypergraph partitioners should be parallelized to preventthem from becoming the performance bottleneck in hyper-graph processing. Zoltan [11] and Parkway [37] are parallelhypergraph partitioners based on the multilevel scheme. Hy-perSwap [39] is a distributed algorithm that partitions hyper-edges instead of nodes. The Social Hash partitioner [19] isanother distributed partitioner for balanced k-way hypergraphpartitioning.
One disadvantage of these parallel hypergraph partitionersis that their output is nondeterministic. For example, in thecoarsening phase, it may be desirable to merge a given node𝑉1
with either node 𝑉2 or node 𝑉3. In a parallel implementation,slight variations in the internal timing between executionsmay result in choosing different nodes for merging, producingdifferent partitions of the same input graph. However, many
applications require deterministic partitioning, as discussedin Section 1.
2.5 Ensuring determinismThe problem of ensuring deterministic execution of parallelprograms with don’t-care nondeterminism has been studied atmany abstraction levels. At the systems level, there has been alot of work on ensuring that parallel threads communicate ina deterministic manner [9, 18, 20]. For many programs, thisensures deterministic output if the program is executed on thesame number of threads in every run. However, it does notaddress our requirement that the output of the partitioner mustbe the same even if the number of threads on which it executesis different in different runs. Moreover, these solutions usuallyresult in a substantial slowdown [9, 31].
For nested task-parallel programs, an approach called inter-nal determinism has been proposed to ensure that the programis executed in deterministic steps, thereby ensuring that theoutput is deterministic as well [4]. The Galois system solvesthe determinism problem in its task scheduler [31], whichfinds independent sets of tasks in an implicitly constructedinterference graph. To guarantee a deterministic schedule,the independent set must be selected in a deterministic fash-ion. This is achieved without building an explicit interferencegraph. The neighborhood items of a task are marked with thetask ID, and ownership of neighborhood items with lowerID values are stolen during the marking process. An inde-pendent set is then constructed by selecting the tasks whoseneighborhood locations are all marked with their own IDvalues.
Both these solutions guarantee that the output does notdepend on the number of threads used to execute the pro-gram. However, our experiments showed that these generic,application-agnostic solutions are too heavyweight for use inhypergraph partitioning, so we devised a lightweight application-specific technique for ensuring determinism with substantiallyless overhead as described in Section 3.
3 BiPart: A Deterministic ParallelHypergraph Partitioner
This sections describes BiPart, our deterministic parallel mul-tilevel hypergraph partitioner. BiPart produces a bipartition ofthe hypergraph, and it is used recursively on these partitionsto produce the desired number of partitions.
3.1 CoarseningThe goal of coarsening is to create a series of smaller hyper-graphs until a small enough hypergraph is obtained that canbe partitioned using a simple heuristic. Intuitively, coarseningfinds nodes that should be assigned to the same partition andmerges them to obtain a smaller hypergraph. However, it isimportant to reduce the size of hyperedges as well since this
BiPart: A Parallel and Deterministic Multilevel Hypergraph Partitioner PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea
h1 h3h2
h1 h3h2 h2
Figure 2. Multi-node coarsening: (a) a hypergraph with 3 hyperedges, h1, h2, and h3 (left). (b) multi-node matching matchesnodes within a hypergraph (center). (c) merging matched nodes coarsen hypergraph (right).
1: for all nodes 𝑛𝑜𝑑𝑒 ∈ 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ in parallel do2: 𝑛𝑜𝑑𝑒.𝑝𝑟𝑖𝑜𝑟𝑖𝑡𝑦 ←∞3: 𝑛𝑜𝑑𝑒.𝑟𝑎𝑛𝑑 ←∞4: 𝑛𝑜𝑑𝑒.ℎ𝑒𝑑𝑔𝑒𝑖𝑑 ←∞
/* Assign priorities based on the policy (e.g. low degree hy-peredges) */
5: for all hyperedges ℎ𝑒𝑑𝑔𝑒 ∈ 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ in parallel do6: ℎ𝑒𝑑𝑔𝑒.𝑝𝑟𝑖𝑜𝑟𝑖𝑡𝑦 ← 𝑑𝑒𝑔𝑟𝑒𝑒 (ℎ𝑒𝑑𝑔𝑒)7: ℎ𝑒𝑑𝑔𝑒.𝑟𝑎𝑛𝑑 ← ℎ𝑎𝑠ℎ(ℎ𝑒𝑑𝑔𝑒.𝑖𝑑)8: for 𝑛𝑜𝑑𝑒 ∈ ℎ𝑒𝑑𝑔𝑒 do9: 𝑛𝑜𝑑𝑒.𝑝𝑟𝑖𝑜𝑟𝑖𝑡𝑦 ← 𝑎𝑡𝑜𝑚𝑖𝑐𝑀𝑖𝑛(𝑛𝑜𝑑𝑒.𝑝𝑟𝑖𝑜𝑟𝑖𝑡𝑦,
10: ℎ𝑒𝑑𝑔𝑒.𝑝𝑟𝑖𝑜𝑟𝑖𝑡𝑦)/* Assign a second priority (hash of hedge id) */
11: for all hyperedges ℎ𝑒𝑑𝑔𝑒 ∈ 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ in parallel do12: for node ∈ hedge do13: if ℎ𝑒𝑑𝑔𝑒.𝑝𝑟𝑖𝑜𝑟𝑖𝑡𝑦 == 𝑛𝑜𝑑𝑒.𝑝𝑟𝑖𝑜𝑟𝑖𝑡𝑦 then14: 𝑛𝑜𝑑𝑒.𝑟𝑎𝑛𝑑 ← 𝑎𝑡𝑜𝑚𝑖𝑐𝑀𝑖𝑛(𝑛𝑜𝑑𝑒.𝑟𝑎𝑛𝑑, ℎ𝑒𝑑𝑔𝑒.𝑟𝑎𝑛𝑑)
/* Assign each node to its incident hyperedge with highestpriority */
15: for all hyperedges ℎ𝑒𝑑𝑔𝑒 ∈ 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ in parallel do16: for node ∈ hedge do17: if ℎ𝑒𝑑𝑔𝑒.𝑟𝑎𝑛𝑑 == 𝑛𝑜𝑑𝑒.𝑟𝑎𝑛𝑑 then18: 𝑛𝑜𝑑𝑒.ℎ𝑒𝑑𝑔𝑒𝑖𝑑 ← 𝑎𝑡𝑜𝑚𝑖𝑐𝑀𝑖𝑛(𝑛𝑜𝑑𝑒.ℎ𝑒𝑑𝑔𝑒𝑖𝑑,19: ℎ𝑒𝑑𝑔𝑒.𝑖𝑑)
enables the subsequent refinement phase to be more effec-tive (FM and related algorithms are most effective with smallhyperedges).
Coarsening can be described using the idea of matchingsfrom graph theory [3].
Hyperedge matching: A hyperedge matching of a hyper-graph 𝐻 is an independent set of hyperedges such thatno two of them have a node in common. In Figure 1,{h3, h4} is a hyperedge matching.
Node matching: A node matching of a hypergraph 𝐻 is aset of node pairs (𝑢, 𝑣), where 𝑢 and 𝑣 belong to thesame hyperedge such that no two pairs have a node incommon. In Figure 1, {(a,e), (b,c)} is a node matching.
1: Find a multi-node matching 𝑀 of 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ using Algorithm 1
/* Merge nodes of the finer graph */2: for all hyperedges ℎ𝑒𝑑𝑔𝑒 ∈ 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ in parallel do3: 𝑆: Set of nodes in ℎ𝑒𝑑𝑔𝑒 that are matched4: if |𝑆 | > 1 then5: 𝑁 ←Merge nodes in 𝑆
6: for all 𝑛𝑜𝑑𝑒 ∈ 𝑆 do7: 𝑝𝑎𝑟𝑒𝑛𝑡 (𝑛𝑜𝑑𝑒) ← 𝑁
/* Merge singleton nodes with an already merged node */8: for all hyperedges ℎ𝑒𝑑𝑔𝑒 ∈ 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ in parallel do9: 𝑆: Set of nodes in ℎ𝑒𝑑𝑔𝑒 that are matched
10: if |𝑆 | = 1 and there exist an already merged node 𝑣 ∈ ℎ𝑒𝑑𝑔𝑒then
11: 𝑣 : Merged nodes in hedge with smallest weight12: Merge node 𝑢 in 𝑆 with 𝑣
/* Create hyperedges in the coarsened graph */16: for all hyperedges ℎ𝑒𝑑𝑔𝑒 ∈ 𝑓 𝑖𝑛𝑒𝐺𝑟𝑎𝑝ℎ in parallel do17: 𝑝𝑎𝑟𝑒𝑛𝑡𝑠 ← ∅18: for all 𝑛𝑜𝑑𝑒 ∈ ℎ𝑒𝑑𝑔𝑒 do19: if 𝑝𝑎𝑟𝑒𝑛𝑡 (𝑛𝑜𝑑𝑒) ∉ 𝑝𝑎𝑟𝑒𝑛𝑡𝑠 then20: 𝑁 ← 𝑐𝑜𝑎𝑟𝑠𝑒𝐺𝑟𝑎𝑝ℎ.𝑐𝑟𝑒𝑎𝑡𝑒𝑁𝑜𝑑𝑒 (𝑝𝑎𝑟𝑒𝑛𝑡 (𝑛𝑜𝑑𝑒))21: 𝑝𝑎𝑟𝑒𝑛𝑡𝑠.𝑎𝑑𝑑 (𝑝𝑎𝑟𝑒𝑛𝑡 (𝑛𝑜𝑑𝑒))22: if |𝑝𝑎𝑟𝑒𝑛𝑡𝑠 | > 1 then23: 𝐸 ← 𝑐𝑜𝑎𝑟𝑠𝑒𝐺𝑟𝑎𝑝ℎ.𝑐𝑟𝑒𝑎𝑡𝑒𝐻𝑦𝑝𝑒𝑟𝑒𝑑𝑔𝑒 ()24: 𝑝𝑎𝑟𝑒𝑛𝑡 (ℎ𝑒𝑑𝑔𝑒) ← 𝐸
25: for all 𝑛𝑜𝑑𝑒 ∈ 𝑝𝑎𝑟𝑒𝑛𝑡𝑠 do26: 𝑖𝑛𝑐𝑙𝑢𝑑𝑒𝑁𝑜𝑑𝑒𝐼𝑛𝐸𝑑𝑔𝑒 (𝐸, 𝑛𝑜𝑑𝑒)
Multi-node matching: BiPart uses a modified version ofnode matching called multi-node matching, where in-stead of node pairs we have a partition of the nodesof 𝐻 such that each node set in the partition containsnodes belonging to one hyperedge. In Figure 1, {(a,e),(b,c,d), (f)} is a multi-node matching.
Coarsening can be performed by contracting nodes or hy-peredges. In the node coarsening scheme, a node matching is
PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea Maleki, Agarwal, Burtscher, and Pingali
Table 1. Matching policies for multi-node matching
Policy Policy DescriptionLDH Hyperedges with lower degree have higher priorityHDH Hyperedges with higher degree have higher priorityLWD Lower weight hyperedges have higher priorityHWD Higher weight hyperedges have higher priorityRAND Priority assigned by a deterministic hash of ID value
first computed and the nodes in each node pair in the matchingare then merged together. Hyperedge coarsening computesa hyperedge matching, and all nodes connected by a hyper-edge in this matching are merged to form a single node in thecoarsened hypergraph.
In contrast, BiPart uses multi-node matching, which hasadvantages over both node coarsening and hyperedge coars-ening. A hyperedge disappears from a coarsened graph onlyafter all its member nodes are merged into one node. In nodecoarsening, the number of hyperedges may stay roughly thesame even after merging the nodes in the matching. Similarlyin hyperedge coarsening, the hyperedge matching may havea very small size and may result in only a small reduction inthe size of the hypergraph. The coarsening phase in BiPartconsists of two parts: finding a multi-node matching and thecoarsening algorithm.
3.1.1 Finding a multi-node matching. Algorithm 1 liststhe pseudocode of multi-node matching. BiPart computesa multi-node matching in the following way: First, everyhyperedge is assigned a priority based on a matching policyand a deterministic hash of its ID value (Lines 6 - 7). Thematching policy can be based on the degree of the hyperedge,weight, etc. Table 1 lists the available matching policies forBiPart. Every node is then assigned a piority value, whichis the minimum across all its incident hyperedges (Lines 8-10). In case many hyperedges have identical degrees, everynode is assigned a second priority value (Lines 11-14) toreduce contention. Finally, every node matches itself to oneof its incident hyperedges with the highest priority, e.g., thehyperedge with the lowest degree and with the lowest hashedvalue (in case the hyperedges have the same degree) (Lines 15-19). The nodes that are matched to the same hyperedge arethen grouped together, resulting in a deterministic multi-nodematching.
3.1.2 Coarsening Algorithm. Algorithm 2 lists the pseu-docode of a single phase of the coarsening algorithm used inBiPart. We perform this step repeatedly for at most coarseToiterations. Coarsening consists of two steps. First, BiPartmerges all the nodes that are matched to the same hyperedgeinto a single node in the coarsened graph (Lines 1-7). For op-timization purposes, we ignore the singleton sets and BiPartinstead merges nodes in such sets with a neighbor node thathas been merged in the previous step (Lines 10-15).
Figure 2 illustrates this on a hypergraph with nine nodesand three hyperedges h1, h2, and h3. In the first step, BiPartperforms multi-node matching (priority is with the low degreehyperedges (LDH)), Figure 2 (center). Figure 2 (right) showsthe result of this matching. The nodes in each of the disjointsets in the matching are merged into a single node. Note that,since all nodes of hyperedges h1 and h3 are merged to a singlenode, we can remove those hyperedges and only h2 remainsin the hypergraph.
3.1.3 Ensuring Determinism. Step 1 in the coarsening phase,which finds a multi-node matching of the hypergraph, is apotential source of nondeterminism. The approach presentedin Section 3.1.1 yields a deterministic multi-node matching.This matching is used to coarsen the graph deterministically.
1: 𝑃0 = {}; 𝑃1 = 𝑉𝑥2: n = |𝑉𝑥 |3: Compute move gain values for nodes in 𝑃1 using Algorithm 44: while |𝑃0 | < |𝑃1 | do5: Pick
√𝑛 nodes from 𝑃1 with highest gain values (break ties
using node ID) and move them to 𝑃0 in parallel6: Re-compute move gain values for nodes in 𝑃1 using Algo-
rithm 4
The goal of this step is to obtain a good bipartition of thecoarsest graph. There are many ways to accomplish this butthe key idea in most algorithms is to maintain two sets ofnodes 𝑃0 and 𝑃1 where 𝑃0 and 𝑃1 contain the nodes assignedto partitions 0 and 1, respectively. Iteratively, some nodesfrom 𝑃1 are selected and moved to 𝑃0 (assuming 𝑃0 is smallerthan 𝑃1) until the balance condition is met.
The selection of nodes can be implemented in many ways.A simple approach is to do a breadth-first search (BFS) of thegraph starting from some arbitrary vertex. In this approach,nodes on the BFS frontier are selected at each step for inclu-sion in the partition. The greedy graph-growing partitioningalgorithm (GGGP) used in Metis maintains gain values forevery node 𝑣 in 𝑃1 (i.e., the decrease in the edge cut if 𝑣 ismoved to the growing partition) and it always picks the nodewith the highest gain at each step and updates the gain valuesof the remaining nodes in 𝑃1. However, this GGGP approachis inherently serial.
Instead, BiPart uses a more parallel approach to obtain aninitial partition. The approach used in BiPart is the following.Like GGGP, we maintain gain values for nodes in 𝑃1, butwe pick the top
√𝑛 nodes with the highest gain values in
each step and move them to 𝑃0 (here 𝑛 denotes the numberof nodes in the coarsest graph). We then re-compute the gain
BiPart: A Parallel and Deterministic Multilevel Hypergraph Partitioner PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea
values of all nodes in 𝑃1. This gives us a good parallel algo-rithm for computing the initial partition. Algorithm 3 lists thepseudocode.
Algorithm 4 describes the pseudocode for computing movegain values. It is based on the approach used in the FM algo-rithm [12].
Algorithm 4 Compute Move-Gain ValuesInput: Graph 𝐺 = (𝑉 , 𝐸), 𝑃0 and 𝑃1 are the two partitions
1: Initialize 𝐺𝑎𝑖𝑛(𝑢) to 0 for all 𝑢 ∈ 𝑉 in parallel2: for all hyperedges ℎ𝑒𝑑𝑔𝑒 ∈ 𝐸 in parallel do3: 𝑛0← number of nodes in 𝑃0 ∩ ℎ𝑒𝑑𝑔𝑒4: 𝑛1 ← number of nodes in 𝑃1 ∩ ℎ𝑒𝑑𝑔𝑒5: for 𝑢 ∈ ℎ𝑒𝑑𝑔𝑒 do6: 𝑖 ← partition of 𝑢7: if 𝑛𝑖 == 1 then ⊲ 𝑢 is the only node from 𝑃𝑖 in ℎ𝑒𝑑𝑔𝑒
8: 𝐺𝑎𝑖𝑛(𝑢) ← 𝐺𝑎𝑖𝑛(𝑢) + 19: else if 𝑛𝑖 == |ℎ𝑒𝑑𝑔𝑒 | then ⊲ all nodes are in 𝑃𝑖
10: 𝐺𝑎𝑖𝑛(𝑢) ← 𝐺𝑎𝑖𝑛(𝑢) − 1
3.2.1 Ensuring Determinism. In the initial partitioning phase,nondeterminism may be present in Line 5 of Algorithm 3where we need to pick a node 𝑣 with highest gain value andthere are multiple nodes with the same highest gain. To ensuredeterminism, BiPart again breaks ties using node IDs.
3.3 Refinement PhaseThe third phase of the overall partitioning algorithm is therefinement phase. The goal of this phase is to improve on thebipartition obtained from the initial partitioning. This phaseruns a refinement algorithm on the sequence of graphs ob-tained during the coarsening phase, starting from the coarsestgraph and terminating at the original input graph. The FMrefinement algorithm described in Section 2.2 is inherentlyserial and cannot be used for large graphs as it is, since itneeds to make individual moves for every node in every pass.Our refinement algorithm, in contrast, makes parallel nodemoves, thus speeding up the process. However, this approachmay result in a poor edge cut since it does not choose thebest prefix of moves, unlike the FM algorithm. We addressthis issue by ensuring that we only move nodes with high orpositive gain values.
Another major difference in our refinement algorithm isthat we do not consider the weight of the nodes when makingthese moves. This helps in speeding up the algorithm butmay result in an unbalanced partition. We resolve this pos-sible issue by running a separate balancing algorithm afterthe refinement. Algorithm 5 provides the pseudocode of ourrefinement approach. The input to the algorithm is an integeriter that specifies the number of rounds of refinement to beperformed; a larger number of rounds may improve partitionquality at the cost of extra running time.
1: Initialization: Project bipartition from coarsened graph2: for 𝑖𝑡𝑒𝑟 iterations do3: Compute move gain values for all nodes using Algo 44: 𝐿0 ← nodes in 𝑃0 with gain value ≥ 05: 𝐿1 ← nodes in 𝑃1 with gain value ≥ 06: Sort nodes in 𝐿0 and 𝐿1 with gain value as the key (break
ties using node IDs)7: 𝑙𝑚𝑖𝑛 ← min ( |𝐿0 |, |𝐿1 |)8: Swap 𝑙𝑚𝑖𝑛 nodes with highest gain values between parti-
tions 𝑃0 and 𝑃1 in parallel
9: Check if the balance criterion is satisfied. Otherwise, movehighest gain nodes from the higher weighted partition to theother partition, using a variant of Algorithm 3.
3.3.1 Ensuring Determinism. In the refinement phase, theonly step with potential nondeterminism is Line 6, in whichwe create a sorted ordering of the nodes based on their gainvalues, since there can be multiple nodes with the same gain.BiPart breaks ties between such nodes using their IDs.
3.4 Tuning parametersMultilevel hypergraph partitioning algorithms like BiParthave a number of tuning parameters whose values can af-fect the quality and runtime of the partitioning. For BiPart,the three most important tuning parameters are the following.
The first tuning parameter controls the maximum numberof levels of coarsening to be performed before the initial parti-tioning. Most hypergraph partitioners coarsen the hypergraphuntil the coarsest hypergraph is very small (e.g., PaToH [7]terminates its coarsening phase when the size of the coars-ened hypergraph falls below 100). Although one would expectmore coarsening steps to produce a better partitioning, this isnot always the case. For some hypergraphs, we end up withheavily weighted nodes (the weight is the number of mergednodes represented by that node) and processing such nodesin the refinement phase is expensive since they can causebalance problems. In Section 4, we study the performanceimpact of terminating the coarsening phase at different levels.The default value used in BiPart is 25.
The second tuning parameter controls the iteration countin the refinement phase. To obtain the best solution, we canrun the refinement until convergence (i.e., until the edge cutdoes not change anymore). However, this strategy is veryslow and thus infeasible for large hypergraphs, which are thefocus of this work. BiPart, by default, uses only 2 refinementiterations.
The final tuning parameter is selecting a matching policyfor finding a multi-node matching in a hypergraph. Table 1shows the different matching policies available in BiPart.Some of these policies are based on hyperedge degrees oron the weight of the hyperedge. More policies can be added
PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea Maleki, Agarwal, Burtscher, and Pingali
to the framework by the user. The best choice for the policydepends on the structure of the graph, and different policiescan result in different partitioning quality as well as differentconvergence rates. For the experimental results in Section 4,we used LDH, HDH, or RAND, depending on the input hy-pergraph.
BiPart exposes these tuning parameters to the applicationdeveloper but also provides default values for use by novices.Section 4 studies the effect of changing these parameters.
3.5 Parallel Strategy for Multiway PartitioningMultiway partitioning for obtaining 𝑘 partitions can be per-formed in two ways: direct partitioning and recursive bisec-tion. In direct partitioning, the hypergraph obtained aftercoarsening is divided into 𝑘 partitions and these partitionsare refined during the refinement phase. Recursive bisectionuses a divide-and-conquer approach by recursively creatingbipartitions until the desired number of partitions is obtained.
In this paper, we present a novel nested 𝑘-way approach forobtaining 𝑘 partitions. At each level of the divide-and-conquertree, we apply the three phases of multilevel partitioning to allthe subgraphs at that level. Intuitively, the divide-and-conquertree is processed level-by-level, and each phase of the multi-level partitioning algorithm is applied to all the subgraphs atthe current level. Algorithm 6 presents the pseudocode of ournested 𝑘-way approach.
Algorithm 6 Nested 𝑘-Way AlgorithmInput: 𝑘
1: for 𝑙𝑒𝑣𝑒𝑙 𝑙 = 1 to ⌈log𝑘⌉ iterations do2: Construct subgraphs 𝐺1,𝐺2, . . . ,𝐺𝑖 (where 𝑖 = 2𝑙−1) such
This algorithm allows us to run the parallel loops over theentire edge list of the original hypergraph instead of runningthem over edge lists for each subgraph separately, whichyields a significant reduction of the overall running time. InSection 4.4, we present experimental results for obtaining 𝑘
partitions using this approach.
4 ExperimentsWe implement BiPart in the Galois 6.0 system, compiledwith g++ 8.1 and boost 1.67 [24]. Galois is a library of datastructures and a runtime system that exploits parallelism inirregular graph algorithms expressed in C++ [30, 33].
Table 2 describes the 11 hypergraphs that we use in ourexperiments. The hypergraphs WB, NLPK, Webbase, Sat14,and RM07R are from the SuiteSparse Matrix Collection [8],Xyce and Circuit1 are netlists from Sandia Laboratories [11],Leon is a hypergraph derived from a netlist from the Univer-sity of Utah, and IBM18 is from the ISPD 98 VLSI Circuit
Benchmark Suite. Random-10M and Random-15M are twohypergraphs that we synthetically generated for the experi-ments.
All experiments are done on a machine running CentOS 7with 4 sockets of 14-core Intel Xeon Gold 5120 CPUs at 2.2GHz, and 187 GB of RAM in which there are 65,536 hugepages, each of which has a size of 2 MB.
We benchmarked BiPart against three third-party partition-ers: (i) Zoltan 3.83 (Zoltan is designed to work in a distributedenvironment; for our experiments, we run Zoltan with MPI ina multi-threaded configuration), (ii) KaHyPar (direct k-waypartitioning setting), the state-of-the-art partitioner for high-quality partitioning, and (iii) HYPE, a recent serial, single-level bipartitioner [26]. Zoltan and KaHyPar were describedin Section 2.
The balance ratio for these experiments is 55:45. SinceZoltan is nondeterministic, the runtime and quality we reportis the average of three runs. BiPart numbers are obtainedusing the configuration discussed in Section 3.
4.1 Comparison with Other PartitionersTable 3 compares BiPart results with those obtained by run-ning Zoltan, KaHyPar and HYPE. BiPart is executed on 14threads, and Zoltan is executed on 14 processes, while KaHy-Par, and HYPE are executed on a single thread since they areserial codes.
KaHyPar produces high-quality partitions but it took morethan 1800 seconds to partition large graphs such as Random-10M, Random-15M, webbase, and Sat14. For the hypergraphsthat KaHyPar can partition successfully, BiPart is alwaysfaster but worse in quality. HYPE runs on all inputs but theexecution time and the quality of the partitions are alwaysworse than BiPart.
Zoltan was able to partition all the hypergraphs in our testsuite except for the largest hypergraph, Random-15M. Forthe three largest hypergraphs Random-10M, NLPK and WB,
BiPart: A Parallel and Deterministic Multilevel Hypergraph Partitioner PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea
BiPart is roughly 4X faster than Zoltan while producing par-titions of comparable quality. We also compared our resultswith other hypergraph partitioners, such as PaToH [7] andHMetis [21]. We observed that the parallel execution timeof BiPart is better than HMetis’s and PaToH’s serial time onlarge inputs. Since the source code for these partitioners is notavailable and due to the space constraints, we do not list thoseresults here. We did not compare our results with Parkwaysince it frequently produces segfaults.
Figure 3. Strong scaling of BiPart
4.2 ScalabilityFigure 3 shows the strong scaling performance of BiPart. Forthe largest graphs Random-10M and Random-15M, BiPartscales up to 6X with 14 threads.
Scaling is limited for the smaller hypergraphs like Web-base, Sat14 and Leon since they contain a small number ofhyperedges.
Figure 4 shows the breakdown of the time taken by thethree phases in BiPart on 1 and 14 threads, respectively. Forboth single thread and 14 threads, the coarsening phase takesthe majority of the time for all hypergraphs.
The coarsening and refinement phases of BiPart scale simi-larly.
The end-to-end parallel performance of BiPart can be im-proved by limiting the number of levels for the coarseningphase and by a better implementation of the refinement phase.We also see a significant change in the slopes of all the scal-ing lines when the number of cores is increased from 7 to 8as well as from 14 to 15. On this machine, each socket has7 cores so the change in slope arises from NUMA effects.Improving NUMA locality is another avenue for improvingthe performance of BiPart.
4.3 Design-Space Exploration of Parameter SpaceIn this section, we discuss the effect of important tuning pa-rameters on BiPart. The important parameters we explore
Figure 4. Runtime breakdown for BiPart on 1 thread and 14threads.
are the following: the number of coarsening levels, the num-ber of refinement iterations, and the matching policy. Theseparameters are described in detail in Section 3.4.
One benefit of having a deterministic system is that we canperform a relatively simple design space exploration to under-stand how running time and quality change with parametersettings. In this section, we discuss how the choice of thesesettings affects the edge cut and running time.
Figure 5 shows a sweep of the parameter space for the twohypergraphs WB and Xyce. Points corresponding to differentmatching policies are given different shapes; for example,triangles represent points for the LDH policy. While thereare many points, we are most interested in those that are onthe Pareto frontier. As mentioned in Section 3, the defaultsettings for BiPart is to perform coarsening for at most 25coarsening levels or as much as possible until there is nochange in the size of the coarsened graph and to do twoiterations of refinement per level. The BiPart points for thisdefault setting are shown as large circles and triangles (bluein color), and we see that they both lie close to the Paretofrontier. Zoltan points are shown as black X marks; for WB,the point is far from the Pareto frontier while for Xyce, the
PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea Maleki, Agarwal, Burtscher, and Pingali
Table 3. Performance of hypergraph partitioners (time is measured in seconds)
BiPart (14) Zoltan (14) HYPE (1) KaHyPar (1)Inputs Time Edge cut Time Edge cut Time Edge cut Time Edge cut
point is on the Pareto frontier but takes much more time for asmall improvement in quality.
As for the matching policy for finding a multi-node match-ing in the coarsening phase, there is no single policy thatworks best for all inputs. LDH and HDH usually dominateother policies. LWD, which has been used in HMetis, doesnot perform well and does not generate a point on the Paretofrontier, so it should be deprecated.
Table 4 shows the running time and quality for the defaultsettings, for the settings that give the best quality, and for thesettings that give the best running time. The default settingfor BiPart is to do two iterations of refinement per level and atmost 25 levels of coarsening. For the matching policy, we donot have a fixed matching policy for all graphs but it is a com-bination of RAND, LD, and HDH. For all hypergraphs, thepoint corresponding to the default setting for BiPart either liessomewhere in between the two extreme points on the Paretofrontier or lies near the Pareto frontier. We also observed thatthere is no unique parameter setting that guarantees for allhypergraphs that the corresponding point lies on the Paretofrontier.
4.4 Multiway Partitioning PerformanceFigure 6 shows the scaled execution time of BiPart for multi-way partitioning of the two hypergraphs Xyce and WB. Forboth hypergraphs, the execution times are scaled by the timetaken to create 2 partitions. If 𝑘 is the number of partitions tobe created, the critical path through the computation increasesas 𝑂 (𝑙𝑜𝑔2 (𝑘)). The experimental results shown in Figure 6follow this trend roughly.
Tables 5 and 6 show the performance of BiPart and thecurrent state-of-the-art hypergraph partitioner, KaHyPar, formultiway partitioning of a small graph IBM18 (Table 5) anda large graph WB (Table 6). We do not compare our resultswith Zoltan for 𝑘-way since their result is not deterministic.BiPart is much faster than KaHyPar; for example, KaHyPar
Figure 5. Design space for various tuning parameters for thetwo largest hypergraphs, WB (top) and Xyce (bottom); the
Pareto frontier is shown for both hypergraphs
times out after 30 minutes when creating 4 partitions of WB(9.8M nodes, 6.9M hyperedges), whereas BiPart can create16 partitions of this hypergraph in just 20 seconds. However,when KaHyPar terminates in a reasonable time, it producespartitions with a better edge cut (for IBM18, the edge cut ison average 2.5X better).
We conclude that there is a tradeoff between BiPart andKaHyPar in terms of the total running time and the edge cutquality. As shown in Tables 5 and 6, BiPart may be better
BiPart: A Parallel and Deterministic Multilevel Hypergraph Partitioner PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea
Table 4. Parameter sweep results for BiPart
Recommended Best Edge Cut Best RuntimeGraph Time (sec) EdgeCut Time (sec) EdgeCut Time (sec) EdgeCut
Table 5. Performance of BiPart and KaHyPar for k-waypartitioning of the IBM18 hypergraph (time in seconds)
BiPart (14) KaHyPar (1)k Time Edge cut Time Edge cut2 0.2 2,385 453.9 1,915
4 0.5 5,836 425.0 2,926
8 1.0 11,522 288.0 4,822
16 1.6 19,116 299.5 8,560
Table 6. Performance of BiPart and KaHyPar for k-waypartitioning of the WB hypergraph (time in seconds)
BiPart (14) KaHyPar (1)k Time Edge cut Time Edge cut2 7.9 13,853 581.5 11,457
4 14.7 100,380 > 1,800 −8 17.5 185,079 > 1,800 −
16 20.0 269,144 > 1,800 −
suited than KaHyPar for creating a large number of partitionsof large graphs while maintaining determinism.
5 Conclusion and Future WorkWe describe BiPart, a fully deterministic parallel hypergraphpartitioner, and show that it significantly outperforms KaHy-Par, the state-of-the-art hypergraph partitioner, in runningtime, albeit with lower edge-cut quality, for all inputs in ourtest suite. On some large graphs, which BiPart can process inless than a minute, KaHyPar takes over an hour to performmultiway partitioning.
In future work, we want to explore whether we can clas-sify hypergraphs based on features such as the average nodedegree and the number of connected components to comeup with optimal parameter settings and scheduling policiesfor a given hypergraph. We are also looking into ways to
Figure 6. BiPart execution time for k-way partitioning
improve NUMA locality for better performance. Extendingthis work to distributed-memory machines might be usefulfor very large hypergraphs that do not fit in the memory of asingle machine [17].
AcknowledgmentsWe would like to thank the anonymous reviewers for their in-sightful feedback, Josh Vekhter for his feedback and help withthe figures, Yi-Shan Lu for contributing to the initial paper,and Hochan Lee and Gurbinder Gill for optimizing the Bi-Part code. This material is based upon work supported by theDefense Advanced Research Projects Agency under awardnumber DARPA HR001117S0054 and NSF grants 1618425,1705092, and 1725322. Any opinions, findings, and conclu-sions or recommendations expressed in this material are thoseof the authors and do not necessarily reflect the views of eitherthe Defense Advanced Research Projects Agency or NSF.
References[1] Konstantin Andreev and Harald Räcke. 2004. Balanced Graph Parti-
tioning. In Proceedings of the Sixteenth Annual ACM Symposium onParallelism in Algorithms and Architectures (Barcelona, Spain) (SPAA’04). ACM, New York, NY, USA, 120–124. https://doi.org/10.1145/1007912.1007931
PPoPP ’21, February 27–March 3, 2021, Virtual Event, Republic of Korea Maleki, Agarwal, Burtscher, and Pingali
[2] Stephen Barnard and Horst Simon. 1993. A Fast Multilevel Implemen-tation of Recursive Spectral Bisection for Partitioning UnstructuredProblems. 711–718.
[3] C. Berge. 1973. Graphs and Hypergraphs. Amsterdam. https://books.google.com/books?id=X32GlVfqXjsC
[4] Guy E Blelloch, Jeremy T Fineman, Phillip B Gibbons, and JulianShun. 2012. Internally Deterministic Parallel Algorithms Can be Fast.In Proceedings of the 17th ACM SIGPLAN symposium on Principlesand Practice of Parallel Programming. 181–192.
[5] T N Bui and C Jones. 1993. A Heuristic for Reducing Fill-in in SparseMatrix Factorization. (12 1993).
[6] Andrew E. Caldwell, Andrew B. Kahng, Andrew A. Kennings, andIgor L. Markov. 1999. Hypergraph Partitioning for VLSI CAD: Method-ology for Heuristic Development, Experimentation and Reporting. InProc. ACM/IEEE Design Automation Conf. (DAC 99), ACM. Press,349–354.
[8] Timothy A Davis and Yifan Hu. 2011. The University of Floridasparse matrix collection. ACM Transactions on Mathematical Software(TOMS) 38, 1 (2011), 1.
[9] Joseph Devietti, Jacob Nelson, Tom Bergan, Luis Ceze, and Dan Gross-man. 2011. RCDC: A Relaxed Consistency Deterministic Computer.ACM SIGARCH Computer Architecture News 39, 1 (2011), 67–78.
[10] Karen D. Devine, Erik G. Boman, Robert T. Heaphy, Rob H. Bisseling,and Umit V. Catalyurek. 2006. Parallel Hypergraph Partitioning forScientific Computing. In Proceedings of the 20th International Confer-ence on Parallel and Distributed Processing (Rhodes Island, Greece)(IPDPS’06). IEEE Computer Society, Washington, DC, USA, 124–124.http://dl.acm.org/citation.cfm?id=1898953.1899056
[11] Karen D. Devine, Erik G. Boman, Robert T. Heaphy, Rob H. Bisseling,and Umit V. Catalyurek. 2006. Parallel Hypergraph Partitioning forScientific Computing. IEEE.
[12] C. M. Fiduccia and R. M. Mattheyses. 1982. A Linear-Time Heuristicfor Improving Network Partitions. In 19th Design Automation Confer-ence. 175–181.
[13] M. Fiedler. 1973. Algebraic Connectivity of Graphs. Czech. Math. J.23 (1973), 298–305.
[14] Aditya Grover and Jure Leskovec. 2016. node2vec: Scalable FeatureLearning for Networks. In Proceedings of the 22nd ACM SIGKDDinternational conference on Knowledge discovery and data mining.855–864.
[15] Bruce Hendrickson, Bruce Hendrickson, and Robert Leland. 1995. AMultilevel Algorithm for Partitioning Graphs. In Proceedings of the1995 ACM/IEEE Conference on Supercomputing (San Diego, Califor-nia, USA) (Supercomputing ’95). ACM, New York, NY, USA, Article28. https://doi.org/10.1145/224170.224228
[16] Tobias Heuer, Peter Sanders, and Sebastian Schlag. 2019. NetworkFlow-Based Refinement for Multilevel Hypergraph Partitioning. ACMJ. Exp. Algorithmics 24, 1, Article 2.3 (Sept. 2019), 36 pages. https://doi.org/10.1145/3329872
[17] L. Hoang, R. Dathathri, G. Gill, and K. Pingali. 2019. CuSP: A Cus-tomizable Streaming Edge Partitioner for Distributed Graph Analytics.In 2019 IEEE International Parallel and Distributed Processing Sym-posium (IPDPS). 439–450. https://doi.org/10.1109/IPDPS.2019.00054
[18] Derek R Hower, Polina Dudnik, Mark D Hill, and David A Wood. 2011.Calvin: Deterministic or Not? Free Will to Choose. In 2011 IEEE 17thInternational Symposium on High Performance Computer Architecture.IEEE, 333–334.
[19] Igor Kabiljo, Brian Karrer, Mayank Pundir, Sergey Pupyrev, and AlonShalita. 2017. Social Hash Partitioner: A Scalable Distributed Hyper-graph Partitioner. Proc. VLDB Endow. 10, 11 (Aug. 2017), 1418–1429.https://doi.org/10.14778/3137628.3137650
[20] Tim Kaler, William Hasenplaugh, Tao B Schardl, and Charles E Leiser-son. 2016. Executing Dynamic Data-graph Computations Determin-istically Using Chromatic Scheduling. ACM Transactions on ParallelComputing (TOPC) 3, 1 (2016), 1–31.
[21] George Karypis, Rajat Aggarwal, Vipin Kumar, and Shashi Shekhar.1999. Multilevel Hypergraph Partitioning: Applications in VLSI Do-main. IEEE Trans. Very Large Scale Integr. Syst. 7, 1 (March 1999),69–79.
[22] George Karypis and Vipin Kumar. 1998. A Fast and High QualityMultilevel Scheme for Partitioning Irregular Graphs. SIAM J. Sci.Comput. 20, 1 (Dec. 1998), 359–392.
[23] B. W. Kernighan and S. Lin. 1970. An efficient heuristic procedurefor partitioning graphs. The Bell System Technical Journal 49, 2 (Feb1970), 291–307.
[24] Boost library. [n.d.]. Boost C++ Libraries. https://www.boost.org/users/history/version_1_67_0.html
[25] Sepideh Maleki and Martin Burtscher. 2018. Automatic HierarchicalParallelization of Linear Recurrences. SIGPLAN Not. 53, 2 (March2018), 128–138. https://doi.org/10.1145/3296957.3173168
[26] Christian Mayer, Ruben Mayer, Sukanya Bhowmik, Lukas Epple,and Kurt Rothermel. 2018. HYPE: Massive Hypergraph Partition-ing with Neighborhood Expansion. CoRR abs/1810.11319 (2018).arXiv:1810.11319
[27] Gary L. Miller, Shang-Hua Teng, and Stephen A. Vavasis. 1991. AUnified Geometric Approach to Graph Separators. In Proceedings ofthe 32nd Annual Symposium on Foundations of Computer Science(SFCS ’91). IEEE Computer Society, USA, 538–547. https://doi.org/10.1109/SFCS.1991.185417
[29] W. Lau Neto, M. Austin, S. Temple, L. Amaru, X. Tang, and P.-E.Gaillardon. 2019. LSOracle: A Logic Synthesis Framework Drivenby Artificial Intelligence. In IEEE/ACM International Conference onComputer-Aided Design (ICCAD).
[30] Donald Nguyen, Andrew Lenharth, and Keshav Pingali. 2013. A Light-weight Infrastructure for Graph Analytics. In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles (Farminton,Pennsylvania) (SOSP ’13). ACM, New York, NY, USA, 456–471.
[31] Donald Nguyen, Andrew Lenharth, and Keshav Pingali. 2014. Deter-ministic Galois: On-demand, Portable and Parameterless. In Proceed-ings of the 19th International Conference on Architectural Support forProgramming Languages and Operating Systems (ASPLOS ’14).
[32] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. 2014. Deepwalk:Online Learning of Social Representations. In Proceedings of the 20thACM SIGKDD international conference on Knowledge discovery anddata mining. 701–710.
[33] Keshav Pingali, Donald Nguyen, Milind Kulkarni, Martin Burtscher,Muhammad Amber Hassaan, Rashid Kaleem, Tsung-Hsien Lee, An-drew Lenharth, Roman Manevich, Mario Méndez-Lojo, DimitriosPrountzos, and Xin Sui. 2011. The Tao of Parallelism in Algorithms.In PLDI 2011. 12–25.
[34] Keshav Pingali, Donald Nguyen, Milind Kulkarni, Martin Burtscher,M. Amber Hassaan, Rashid Kaleem, Tsung-Hsien Lee, AndrewLenharth, Roman Manevich, Mario Méndez-Lojo, Dimitrios Prount-zos, and Xin Sui. 2011. The TAO of parallelism in algorithms. InProc. ACM SIGPLAN Conf. Programming Language Design and Im-plementation (San Jose, California, USA) (PLDI ’11). 12–25. https://doi.org/10.1145/1993498.1993501
[35] A. Pothen, H. Simon, and K.-P. Liou. 1990. Partitioning Sparse Matriceswith Eigenvectors of Graphs. SIAM J. Matrix Anal. Appl. 11 (1990),430–452.
[36] G. Qu, Z. Fang, J. Zhang, and S. Zheng. 2015. Switch-Centric DataCenter Network Structures Based on Hypergraphs and CombinatorialBlock Designs. IEEE Transactions on Parallel and Distributed Systems
[37] Aleksandar Trifunovic and William J. Knottenbelt. 2008. ParallelMultilevel Algorithms for Hypergraph Partitioning. J. Parallel Distrib.Comput. 68, 5 (May 2008), 563–581.
[38] F. Xia, A. M. Ahmed, L. T. Yang, and Z. Luo. 2015. Community-Based Event Dissemination with Optimal Load Balancing. IEEE Trans.
[39] Wenyin Yang, Guojun Wang, Li Ma, and Shiyang Wu. 2016. ADistributed Algorithm for Balanced Hypergraph Partitioning. In Ad-vances in Services Computing, Guojun Wang, Yanbo Han, and GregorioMartínez Pérez (Eds.). Springer International Publishing, Cham, 477–490.
