Parallel Batch-Dynamic Graph Connectivity

TL;DR

This paper introduces the first parallel batch-dynamic graph connectivity algorithm that is work-efficient and faster for large batch sizes, improving upon sequential algorithms in terms of parallel efficiency and scalability.

Contribution

It presents a novel parallel batch-dynamic connectivity algorithm with provable work efficiency and improved performance for large batch updates, filling a gap in parallel graph algorithms.

Findings

Achieves $O( ext{log} n ext{log}(1 + n / ext{Δ}))$ expected work per update

Answers batch connectivity queries in $O(k ext{log}(1 + n/k))$ expected work

Provides $O( ext{log} n)$ depth with high probability

Abstract

In this paper, we study batch parallel algorithms for the dynamic connectivity problem, a fundamental problem that has received considerable attention in the sequential setting. The most well known sequential algorithm for dynamic connectivity is the elegant level-set algorithm of Holm, de Lichtenberg and Thorup (HDT), which achieves $O(\log^2 n)$ amortized time per edge insertion or deletion, and $O(\log n / \log\log n)$ time per query. We design a parallel batch-dynamic connectivity algorithm that is work-efficient with respect to the HDT algorithm for small batch sizes, and is asymptotically faster when the average batch size is sufficiently large. Given a sequence of batched updates, where $\Delta$ is the average batch size of all deletions, our algorithm achieves $O(\log n \log(1 + n / \Delta))$ expected amortized work per edge insertion and deletion and $O(\log^3 n)$ depth w.h.p. Our algorithm answers a batch of $k$ connectivity queries in $O(k \log(1 + n/k))$ expected work and $O(\log n)$ depth w.h.p. To the best of our knowledge, our algorithm is the first parallel batch-dynamic algorithm for connectivity.

Equations

$$\sum _{i=1}^c{k}_i\lg \left(1+\frac{n_i}{k_i}\right)\le k\lg \left(1+\frac{n}{k}\right).$$

$$\sum _{w=0}^r{2}^w\lg \left(1+\frac{n}{2^w}\right)=O\left(2^r\lg \left(1+\frac{n}{2^r}\right)\right).$$

$$O\left(k\lg n\lg \left(1+\frac{n}{k}\right)\right),$$

$$O\left(l\lg \left(1+\frac{n}{l}\right)\right),$$

$$\sum _{w=0}^q{2}^w\lg n=O(2^q\lg n)$$

$$O\left(p_c\lg \left(1+\frac{n_c}{p_c}\right)\right)$$

$$O\left(p_c\lg \left(1+\frac{n_c}{p_c}\right)\right).$$

$$O\left(2^r\lg \left(1+\frac{n_c}{2^r}\right)\right),$$

$$\sum _{r=1}^{R-1}O\left(2^r\lg \left(1+\frac{n_c}{2^r}\right)\right)$$

$$O\left(2^R\lg \left(1+\frac{n_c}{2^R}\right)\right),$$

$$O\left(2^R\lg \left(1+\frac{n_c}{2^R}\right)\right)=O\left(p_c\lg \left(1+\frac{n_c}{p_c}\right)\right).$$

$$O\left(k\lg \left(1+\frac{n}{k}\right)+p\lg \left(1+\frac{n}{p}\right)\right)$$

$$O\left(p_c\lg \left(1+\frac{n_c}{p_c}\right)\right)$$

$$O\left(t\lg \left(1+\frac{n}{t}\right)+\sum _{c\in C}{p}_c\lg \left(1+\frac{n_c}{p_c}\right)\right).$$

$$O\left(p\lg \left(1+\frac{2n}{p}\right)\right)=O\left(p\lg \left(1+\frac{n}{p}\right)\right)$$

$$O\left(k\lg \left(1+\frac{n}{k}\right)+p\lg \left(1+\frac{n}{p}\right)\right)$$

$$O\left(\lg n\lg \left(1+\frac{n}{\Delta }\right)\right)$$

$$O\left(k\lg n\lg \left(1+\frac{n}{\Delta }\right)\right),$$

$$\begin{array}{r}O\left(\sum _{\text{batch }b}\sum _{\text{level }i}{k}_b\lg \left(1+\frac{n}{k_b}\right)+p_{b,i}\lg \left(1+\frac{n}{p_{b,i}}\right)\right).\end{array}$$

$$K=\sum _{\text{batch }b}{k}_b$$

$$O\left(\sum _{\text{batch }b}\sum _{\text{level }i}{k}_b\lg \left(1+\frac{n}{k_b}\right)\right)=O\left(K\lg n\lg \left(1+\frac{n\cdot d}{K}\right)\right),$$

$$O\left(K\lg n\lg \left(1+\frac{n}{\Delta }\right)\right),$$

$$O\left(k\lg n\lg \left(1+\frac{n}{\Delta }\right)\right)$$

$$P=\sum _{\text{batch }b}\sum _{\text{level }i}{p}_{b,i}$$

$$\sum _{\text{batch }b}\sum _{\text{level }i}{p}_{b,i}\lg \left(1+\frac{n}{p_{b,i}}\right)=O\left(P\lg \left(1+\frac{nd\lg n}{P}\right)\right).$$

$$P\le m\lg n,$$

$$O\left(m\lg n\lg \left(1+\frac{nd\lg n}{m\lg n}\right)\right)=O\left(m\lg n\lg \left(1+\frac{nd}{m}\right)\right)$$

$$O\left(m\lg n\lg \left(1+\frac{nK}{m\Delta }\right)\right)$$

$$\begin{array}{r}O\left(m\lg n\lg \left(1+\frac{n}{\Delta }\right)\right).\end{array}$$

Full text

We design a parallel batch-dynamic connectivity algorithm that is work-efficient with respect to the HDT algorithm for small batch sizes, and is asymptotically faster when the average batch size is sufficiently large. Given a sequence of batched updates, where $\Delta{}$ is the average batch size of all deletions, our algorithm achieves $O(\mathop{\textnormal{lg}}n\mathop{\textnormal{lg}}(1+n/\Delta{}))$ expected amortized work per edge insertion and deletion and $O(\mathop{\textnormal{lg}}^{3}n)$ depth w.h.p. Our algorithm answers a batch of $k$ connectivity queries in $O(k\mathop{\textnormal{lg}}(1+n/k))$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. To the best of our knowledge, our algorithm is the first parallel batch-dynamic algorithm for connectivity.

1 Introduction

Computing the connected components of a graph is a fundamental problem that has been studied in many different models of computation [62, 56, 53, 32, 5, 7]. The connectivity problem takes as input an undirected graph $G$ and requires an assignment of labels to vertices such that two vertices have the same label if and only if they are in the same connected component. The dynamic version of the problem requires maintaining a data structure over an $n$ vertex undirected graph that supports insertions and deletions of edges, and queries of whether two vertices are in the same connected component. Despite the large body of work on the dynamic connectivity problem over the past two decades [28, 21, 32, 63, 64, 29, 69, 37, 39, 33, 44, 70], little is known about batch-dynamic connectivity algorithms that process batches of queries and updates, either sequentially or in parallel.

Traditional dynamic algorithms were motivated by applications where data undergos small changes that can be adequately handled by updates of single elements. Today, however, applications operate on increasingly large datasets that undergo rapid changes over time: for example, millions of individuals can simultaneously interact with a web site, make phone calls, send emails and so on. In the context of these applications, traditional dynamic algorithms require serializing the changes made and processing them one at a time, missing an opportunity to exploit the parallelism afforded by processing batches of changes.

Motivated by such applications, there has been recent interest in developing theoretically efficient parallel batch-dynamic algorithms [2, 59, 1, 65]. In the batch-dynamic setting, instead of applying one update or query at a time, a whole batch is applied. A batch could be of size $\lg{n}$, $\sqrt{n}$, or $n/\lg n$ for example. There are two advantages of applying operations in batches.

1. 1-.

Batching operations allows for more parallelism. 2. 2-.

Batching operations can reduce the cost of each update.

In this paper we are interested in both these advantages. We use the term parallel batch-dynamic to mean algorithms that process batches of operations instead of single ones, and for which the algorithm itself is parallel. The underlying parallel model used in this paper is a formalization of the widely used shared-memory work-depth model [10, 16, 13, 8].

Understanding the connectivity structure of graphs is of significant practical interest, for example, due to its use as a primitive for clustering the vertices of a graph [54]. Due to the importance of connectivity there are several implementations of parallel batch-dynamic connectivity algorithms [42, 34, 68, 35, 55, 67]. In the worst case, however, these algorithms may recompute the connected components of the entire graph even for very small batches. Since this requires $O(m+n)$ work, it makes the worst-case performance of the algorithms no better than running a static parallel algorithm. On the theoretical side, existing batch-dynamic efficient connectivity algorithms have only been designed for restricted settings, e.g., in the incremental setting when all updates are edge insertions [59], or when the underlying graph is a forest [52, 1, 65]. Therefore, two important questions are:

1. 1-.

Is there a batch-dynamic connectivity algorithm that is asymptotically faster than existing dynamic connectivity algorithms for large enough batches of insertions, deletions and queries? 2. 2-.

Can the batch-dynamic connectivity algorithm be parallelized to achieve low worst-case depth?

In this paper we give an algorithm that answers both of these questions affirmatively. To simplify our exposition and present the main ideas, we first give a less efficient version of the algorithm that runs in $O(\mathop{\textnormal{lg}}^{4}n)$ depth w.h.p.222 We say that an algorithm has $O(f(n))$ cost with high probability (w.h.p.) if it has $O(k\cdot f(n))$ cost with probability at least $1-1/n^{k}$, $k\geq 1$. and performs $O(\mathop{\textnormal{lg}}^{2}n)$ expected amortized work per update, making it work-efficient with respect to the sequential algorithm of Holm, de Lichtenberg, and Thorup. Next, we describe the improved algorithm which runs in $O(\mathop{\textnormal{lg}}^{3}n)$ depth w.h.p. and achieves an improved work bound that is asymptotically faster than the HDT algorithm for sufficiently large batch sizes. We note that our depth bounds hold even when processing the updates one a time, ignoring batching. Our improved work bounds are derived by a novel analysis of the work performed by the algorithm over all batches of deletions. Our contribution is summarized by the following theorem:

Theorem 1.1**.**

There is a parallel batch-dynamic data structure which, given batches of edge insertions, deletions, and connectivity queries processes all updates in $O\left(\mathop{\textnormal{lg}}n\mathop{\textnormal{lg}}\left(1+\frac{n}{\Delta{}}\right)\right)$ expected amortized work per edge insertion or deletion where $\Delta{}$ is the average batch size of a deletion operation. The cost of connectivity queries is $O(k\mathop{\textnormal{lg}}(1+n/k))$ work and $O(\mathop{\textnormal{lg}}n)$ depth for a batch of $k$ queries. The depth to process a batch of edge insertions and deletions is $O(\mathop{\textnormal{lg}}n)$ and $O(\mathop{\textnormal{lg}}^{3}n)$ respectively.

1.1 Technical Overview

The starting point of our algorithm is the classic Holm, de Lichtenberg and Thorup (HDT) dynamic connectivity algorithm [32]333We provide full details of the HDT algorithm in Section 2.2.. Like nearly all existing dynamic connectivity algorithms, the HDT algorithm maintains a spanning forest certifying the connectivity of the graph. The algorithm maintains a set of $\mathop{\textnormal{lg}}n$ nested forests under two carefully designed invariants. The forests are represented using the Euler tour tree (ET-tree) data structure [43, 28].

The main challenge in a dynamic connectivity algorithm is to efficiently find a replacement edge, or a non-tree edge going between the two disconnected components after deleting a tree edge. The key idea of the HDT algorithm is to organize the spanning-forest of the graph into $\mathop{\textnormal{lg}}n$ levels of trees. The top-most level of the structure stores a spanning forest of the entire graph, and each level contains all tree-edges stored in levels below it. The algorithm ensures that the largest size of a component at level $i$ is $2^{i}$. Using these invariants, the algorithm is able to cleverly search the tree edges so that each non-tree edge is examined at most $\mathop{\textnormal{lg}}n$ times as a candidate replacement edge. The main idea is to store each non-tree edge at a single level (initially the top-most level), and push the edge to a lower level each time it is unsuccessfully considered as a replacement edge. Since there are $\mathop{\textnormal{lg}}n$ levels, and the cost of discovering, processing, and removing an edge from each level using ET-tree operations is $O(\mathop{\textnormal{lg}}n)$, the amortized cost of the HDT algorithm is $O(\mathop{\textnormal{lg}}^{2}n)$ per edge operation. We now discuss the main challenges and sequential bottlenecks that arise in the HDT algorithm that a parallel batch-dynamic algorithm must address.

Efficiently searching for replacements. A challenge, and sequential bottleneck in the HDT algorithm is the fact that it processes each non-tree edge one at a time—a property which is crucial for achieving good amortized bounds. Aside from hindering parallelism, processing the edges one at a time eliminates any potential for improved batch bounds, since finding the representative of the endpoints of an edge costs $O(\mathop{\textnormal{lg}}n)$ time per query. Therefore, to obtain an efficient batch or parallel algorithm we must examine batches of multiple non-tree edges at a time, while also ensuring that we do not perform extra work that cannot be charged to level-decreases on an edge. Our approach is to use a doubling technique, where we examine sets of non-tree edges with geometrically increasing sizes.

Handling Batches of Deletions. Another challenge is that processing a batch of deletions can shatter a component into multiple disconnected pieces. Since the HDT algorithm deletes at most a single tree edge per deletion operation, it handles exactly two disconnected pieces per level. In contrast, since we delete batches of edges in our batch-dynamic algorithm, we may have many disconnected pieces at a given level, and must search for replacement edges reconnecting these pieces. Our algorithm searches for a replacement edge from each piece that is small enough to be pushed down to the next lower level.

Each round of both of our algorithms can be viewed as calling an oracle which returns a set of replacement edges incident on the disconnected pieces that we are trying to reconnect. Unlike in the HDT algorithm which terminates once it finds any replacement edge, the edges returned by the oracle may not fully restore the connectivity of the original component. In particular, the replacement edges that we find may contain multiple edges going between the same pieces (like in Borůvka’s algorithm) or may contain cycles, which must be dealt with since each level of the data structure represents a forest. Our approach to handling these issues is to run a static spanning forest algorithm on the replacement edges found in this round, and insert only the spanning forest edges into the ET-tree at the current level.

Both of our algorithms alternate between a first phase which calls the oracle to find a set of replacement edges, and a second phase which determines a set of replacement edges that can be committed as tree edges. The difference is that our first (simpler) algorithm (Section 3) requires $O(\mathop{\textnormal{lg}}^{2}n)$ oracle queries per level, whereas the second algorithm (Section 4) only requires $O(\mathop{\textnormal{lg}}n)$ oracle queries due to a more careful doubling technique.

Dynamic trees supporting batching. Another obstacle to improving on the bounds of the HDT algorithm is that the classic ET-tree data structure performs links and cuts one at a time. To achieve good batch bounds for forest operations, we use a recently developed solution to the batch-parallel forest connectivity problem by Tseng et al. [65]. Their data structure, which we refer to as a batch-parallel ET-tree processes a set of $k$ links, cuts, or connectivity queries in $O(k\mathop{\textnormal{lg}}(1+n/k))$ work and $O(\mathop{\textnormal{lg}}n)$ depth. We extend the data structure to supports operations such as fetching the first $l$ non-tree edges in the tree efficiently.

2 Preliminaries

Model. In this paper we analyze our algorithms in the work-depth model using fork-join style parallelism. Specifically, we use a particular work-depth model called the Threaded Random Access Machine ($\mathsf{TRAM}$), which is closely related to the $\mathsf{PRAM}$ but more closely models current machines and programming paradigms that are asynchronous and support dynamic forking. The model can work-efficiently cross-simulate a $\mathsf{CRCW}\ \mathsf{PRAM}$, equipped with the same atomic instructions, and is therefore essentially equivalent to the classic $\mathsf{CRCW}\ \mathsf{PRAM}$ model. We formally define the model and provide more details about the simulations in Appendix A, and refer the interested reader to [11] for full details.

Our algorithms are designed using nested fork-join parallelism in which a procedure can fork off another procedure call to run in parallel and then wait for forked calls to complete with a join synchronization [10]. Our efficiency bounds are stated in terms of work and depth, where work is the total number of vertices in the thread DAG and where depth (span) is the length of the longest path in the DAG [10].

Parallel Primitives. The following parallel procedures are used throughout the paper. A semisort takes an input array of elements, where each element has an associated key and reorders the elements so that elements with equal keys are contiguous, but elements with different keys are not necessarily ordered. The purpose is to collect equal keys together, rather than sort them. Semisorting a sequence of length $n$ can be performed in $O(n)$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. assuming access to a uniformly random hash function mapping keys to integers in the range $[1,n^{O(1)}]$ [51, 25].

A parallel dictionary data structure supports batch insertion, batch deletion, and batch lookups of elements from some universe with hashing. Gil et al. describe a parallel dictionary that uses linear space and achieves $O(k)$ work and $O(\mathop{\textnormal{lg}}^{*}k)$ depth w.h.p. for a batch of $k$ operations [24].

The pack operation takes an $n$-length sequence $A$ and an $n$-length sequence $B$ of booleans as input. The output is a sequence $A^{\prime}$ of all the elements $a\in A$ such that the corresponding entry in $B$ is $\mathit{true}$. The elements of $A^{\prime}$ appear in the same order that they appear in $A$. Packing can be easily implemented in $O(n)$ work and $O(\mathop{\textnormal{lg}}n)$ depth [36].

Useful Lemmas. The following lemmas are useful for analyzing the work bounds of our parallel algorithms. We provide proofs in Appendix D.

Lemma 2.1**.**

Let $n_{1},n_{2},...,n_{c}$ and $k_{1},k_{2},...,k_{c}$ be sequences of non-negative integers such that $\sum k_{i}=k$, and $\sum n_{i}=n$. Then

[TABLE]

Lemma 2.2**.**

For any non-negative integers $n$ and $r$,

[TABLE]

Lemma 2.3**.**

For any $n\geq 1$, the function $x\mathop{\textnormal{lg}}\left(1+\frac{n}{x}\right)$ is strictly increasing with respect to $x$ for $x\geq 1$.

2.1 Batch-Dynamic Trees

The batch-dynamic trees problem is to represent a forest as it undergoes batches of links, cuts, and connectivity queries. A link operation inserts an edge connecting two trees in the forest. A cut deletes an edge from the forest, breaking one tree into two trees. A connectivity query returns whether two vertices are connected by a path (in the same tree) in the forest. The interface is formally defined as follows:

Batch-Dynamic Trees Interface.

• •

$\textsc{BatchLink}(\{(u_{1},v_{1}),\ldots,(u_{k},v_{k})\})$ takes a sequence of edges and adds them to the graph $G$. The input edges must not create a cycle in $G$.

• •

$\textsc{BatchCut}(\{(u_{1},v_{1}),\ldots,(u_{k},v_{k})\})$ takes a sequence of edges and removes them from the graph $G$.

• •

$\textsc{BatchConnected}(\{(u_{1},v_{1}),\ldots,(u_{k},v_{k})\})$ takes a sequence of tuples representing queries. The output is a sequence where the $i$-th entry returns whether vertices $u_{i}$ and $v_{i}$ are connected by a path in $G$.

• •

$\textsc{BatchFindRepr}(\{(x_{1},\ldots,x_{k}\})$ takes a sequence of pointers to tree elements. The output is a sequence where the $i$-th entry is the representative (repr) of the tree in which $x_{i}$ lives. The representative is defined so that $\emph{repr}(u)=\emph{repr}(v)$ if and only if $u$ and $v$ are in the same tree. Note that representatives are invalidated after the tree is modified.

Batch-Parallel Euler Tour Trees. In this paper we make use of a recently developed, parallel solution to the batch-dynamic trees problem, called a batch-parallel Euler tour tree (batch-parallel ET-trees) [65]. The data structure represents each ET-tree sequence using a concurrent skip-list, and reduces bulk link, cut, and query operations to bulk operations on the concurrent skip-list. Tseng et al. [65] prove the following theorem on the efficiency of the batch-parallel ET-tree:

Theorem 2.1**.**

A batch of $k$ links, $k$ cuts, $k$ connectivity queries, or $k$ representative queries over an $n$-vertex forest can be processed in $O(k\mathop{\textnormal{lg}}(1+n/k))$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth with high probability.

The trees also support augmentation with an associative and commutative function $f:D^{2}\to D$ with values from $D$ assigned to vertices and edges of the forest. The goal is to compute $f$ over subtrees of the represented forest. The interface can be easily extended with the following batch-parallel primitives for updating and querying augmented values.

Appendix C contains information about additional tree operations that are needed to efficiently implement our algorithms.

2.2 The sequential (HDT) algorithm

Our parallel algorithm is based on the sequential algorithm of Holm, De Lichtenberg, and Thorup [32], which we refer to as the HDT algorithm. The HDT algorithm assigns to each edge in the graph, an integer level from $1$ to $\mathop{\textnormal{lg}}n$. The levels correspond to sequence of subgraphs $G_{1}\subset G_{2}\subset...\subset G_{\mathop{\textnormal{lg}}n}=G$, such that $G_{i}$ contains all edges with level at most $i$. The algorithm also maintains a spanning forest $F_{i}$ of each $G_{i}$ such that $F_{1}\subset F_{2}\subset...\subset F_{\mathop{\textnormal{lg}}n}$. Each forest is maintained using a set of augmented ET-trees which we describe shortly. Throughout the algorithm, the following invariants are maintained.

Invariant 1**.**

$\forall i=1...\mathop{\textnormal{lg}}n$, the connected components of $G_{i}$ have size at most $2^{i}$.

Invariant 2**.**

$F_{\mathop{\textnormal{lg}}n}$* is a minimum spanning forest where the weight of each edge is its level. *

Connectivity Queries. To perform a connectivity query in $G$, it suffices to query $F_{\mathop{\textnormal{lg}}n}$, which takes $O(\mathop{\textnormal{lg}}n)$ time by querying for the root of each Euler tour tree and returning whether the roots are equal. We note that in [32], a query time of $O\left(\mathop{\textnormal{lg}}n/\mathop{\textnormal{lg}}\mathop{\textnormal{lg}}n\right)$ is achieved by storing the Euler tour of $F_{\mathop{\textnormal{lg}}n}$ in a B-tree with branching factor $\mathop{\textnormal{lg}}n$.

Inserting an Edge. An edge insertion is handled by assigning the edge to level $\mathop{\textnormal{lg}}n$. If the edge connects two currently disconnected components, then it is added to $F_{\mathop{\textnormal{lg}}n}$.

Deleting an Edge. Deletion is the most interesting part of the algorithm. If the deleted edge is not in the spanning forest $F_{\mathop{\textnormal{lg}}n}$, the algorithm removes the edge and does nothing to $F_{\mathop{\textnormal{lg}}n}$ as the connectivity structure of the graph is unchanged. Otherwise, the component containing the edge is split into two. The goal is to find a replacement edge, that is, an edge crossing the split component.

If the deleted edge had level $i$, then the smaller of the two resulting components is searched starting at level $i$ in order to locate a replacement edge. Before searching this component, all tree edges whose level is equal to $i$ have their level decremented by one. As the smaller of the split components at level $i$ has size $\leq 2^{i-1}$, pushing the entire component to level $i-1$ does not violate Invariant 1. Next, the non-tree edges at level $i$ are considered one at a time as possible replacement edges. Each time the algorithm examines an edge that is not a replacement edge, it decreases the level of the edge by one. If no replacement is found, it moves up to the next level and repeats. Note that because the algorithm first pushes all tree edges to level $i-1$, any subsequent non-tree edges that may be pushed from level $i$ to level $i-1$ will not violate Invariant 2.

Implementation and Cost. To efficiently search for replacement edges, the ET-trees are augmented with two additional pieces of information. The first augmentation is to maintain the number of non-tree edges whose level equals the level of the tree. The second augmentation maintains the number of tree-edges whose level is equal to the level of the tree.

Using these augmentations, each successive non-tree edge (or tree edge) whose level is equal to the level of the tree can be found in $O(\mathop{\textnormal{lg}}n)$ time. Furthermore, checking whether the edge is a replacement edge can be done in $O(\mathop{\textnormal{lg}}n)$ time. Lastly, the cost of pushing an edge that is not a replacement edge to the lower level is $O(\mathop{\textnormal{lg}}n)$, since it corresponds to inserting the edge into an adjacency structure and updating the augmented values. Since each edge can be processed at most once per level, paying a cost of $O(\mathop{\textnormal{lg}}n)$, and there are $\mathop{\textnormal{lg}}n$ levels, the overall amortized cost per edge is $O(\mathop{\textnormal{lg}}^{2}n)$.

3 A Parallel Algorithm

In this section, we give a simple parallel batch-dynamic connectivity algorithm based on the HDT algorithm. The underlying invariants maintained by our parallel algorithm are identical to the sequential HDT algorithm: we maintain $\mathop{\textnormal{lg}}n$ levels of spanning forests subject to Invariants 1 and 2. The main challenge, and where our algorithm departs from the HDT algorithm is in how we search for replacement edges in parallel, and how we search multiple components in parallel. We show by a charging argument that this parallel algorithm is work-efficient with respect to the HDT algorithm—it performs $O(\mathop{\textnormal{lg}}^{2}n)$ amortized work per edge insertion or deletion. Furthermore, we show that the depth of this algorithm is $O(\mathop{\textnormal{lg}}^{4}n)$. Although these bounds are subsumed by the improved parallel algorithm we describe in Section 4, the parallel algorithm in this section is useful to illustrate the main ideas in this paper.

Data Structures. Each spanning forest, $F_{i}$, is represented using a set of batch-parallel ET-trees [65]. We represent the edges of the graph in a parallel dictionary $E_{D}$ for convenience (see Section 2). We also store an adjacency array, $A_{i}[u]$, at each level $i$, and for each vertex $u$ to store the tree and non-tree edges incident on $u$ with level $i$. Note that tree and non-tree edges are stored separately so that they can be accessed separately. The adjacency arrays support batch insertion and deletion of edges, as well as the ability to fetch a batch of edges of a desired size. These operations have the following cost bounds.

Lemma 3.1**.**

InsertEdges*, DeleteEdges, and FetchEdges can be implemented in $O(1)$ amortized work per edge and in $O(\mathop{\textnormal{lg}}n)$ depth.*

See Appendix B for proofs and full details on the adjacency data structure.

3.1 Connectivity Queries

As in the sequential algorithm, a connectivity query can be answered by simply performing a query on $F_{\mathop{\textnormal{lg}}n}$. Algorithm 1 gives pseudocode for the batch connectivity algorithm. The bound we achieve follows from the batch bounds on batch-parallel ET-trees.

Theorem 3.1**.**

A batch of $k$ connectivity queries can be processed in $O\left(k\mathop{\textnormal{lg}}\left(1+\frac{n}{k}\right)\right)$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p.

Proof.

Follows from Theorem 2.1. ∎

3.2 Inserting Batches of Edges

To perform a batch insertion, we first determine a set of edges in the batch that increase the connectivity of the graph. To do so, we treat each current connected component of the graph as a vertex, and build a spanning forest of the edges being inserted over this contracted graph. The edges in the resulting spanning forest are then inserted into the topmost level in parallel.

Algorithm 2 gives pseudocode for the batch insertion algorithm. We assume that the edges given as input in $U$ are not present in the graph. Each vertex $u$ that receives an updated edge inserts its edges into $A_{\mathop{\textnormal{lg}}n}[u]$ (Line 3). This step can be implemented by first running a semisort to collect all edges incident on $u$.

The last step is to insert edges that increase the connectivity of the graph as tree edges (Lines 4–8). The algorithm starts by computing the representatives for each edge (Line 4). The output is an array of edges, $R$, which maps each original $(u,v)$ edge in $U$ to $(\textsc{FindRepr}(u),\textsc{FindRepr}(v))$ (note that these calls can be batched using BatchFindRepr). Next, it computes a spanning forest over the tree edges (Line 5). Finally, the algorithm promotes the corresponding edges in $U$ to tree edges. This is done by updating the appropriate adjacency lists and inserting them into $F_{\mathop{\textnormal{lg}}n}$ (Lines 7–8).

Theorem 3.2**.**

A batch of $k$ edge insertions can be processed in $O\left(k\mathop{\textnormal{lg}}\left(1+\frac{n}{k}\right)\right)$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p.

Proof.

Lines 2–3 cost $O(k)$ work and $O(\mathop{\textnormal{lg}}k)$ depth w.h.p. using our bounds for updating $A$ (see Lemma 3.1). The find representative queries (Line 4) can be implemented using a BatchFindRepr call, which costs $O\left(k\mathop{\textnormal{lg}}\left(1+\frac{n}{k}\right)\right)$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. by Theorem 2.1. Computing a spanning forest (Line 5) can be done in $O(k)$ expected work and $O(\mathop{\textnormal{lg}}k)$ depth w.h.p. using Gazit’s connectivity algorithm [23]. Finally, updating the adjacency lists and inserting the spanning forest edges into $F_{\mathop{\textnormal{lg}}n}$ costs $O\left(k\mathop{\textnormal{lg}}\left(1+\frac{n}{k}\right)\right)$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. (Lines 7–8). ∎

3.3 Deleting Batches of Edges

As in the sequential HDT algorithm, searching for replacement edges after deleting a batch of tree edges is the most interesting part of our parallel algorithm. A natural idea for parallelizing the HDT algorithm is to simply scan all non-tree edges incident on each disconnected component in parallel. Although this approach has low depth per level, it may examine a huge number of candidate edges, but only push down a few non-replacement edges. In general, it is unable to amortize the work performed checking all canidates edges at a level to the edges that experience level decreases. To amortize the work properly while also searching the edges in parallel we must perform a more careful exploration of the non-tree edges. Our approach is to use a doubling technique, in which we geometrically increase the number of non-tree edges explored as long as we have not yet found a replacement edge. We show that using the doubling technique, the work performed (and number of non-tree edges explored) is dominated by the work of the last phase, when we either find a replacement edge, or run out of non-tree edges. Our amortized work-bounds follow by a per-edge charging argument, as in the analysis of the HDT algorithm.

The Deletion Algorithm. Algorithm 3 shows the pseudocode for our parallel batch deletion algorithm. As with the batch insertion algorithm, we assume that each edge is present in $U$ in both directions. Given a batch of $k$ edge deletions, the algorithm first deletes the given edges from their respective adjacency lists in parallel (Line 2). It then filters out the tree edges (Line 3) and deletes each tree edge $e$ from $F_{i}\ldots,F_{\mathop{\textnormal{lg}}n}$, where $i$ is the level of $e$ (Line 4). Next, it computes $C$, a set of components (representatives) from the deleted tree edges (Line 5). For each deleted tree edge, $e$, the algorithm includes the representatives of both endpoints in the forest at $l(e)$, which must be in different components as $e$ is a deleted tree edge. Finally, the algorithm loops over the levels, starting at the lowest level where a tree edge was deleted (Line 7), and calls ParallelLevelSearch at each level. Each call to ParallelLevelSearch takes $i$, the level to search, $C$, the current set of disconnected components, and $S$, an initially empty set of replacement edges that the algorithm discovers over the course of the searches (Line 8)

Searching a Level in Parallel. The bulk of the work done by the deletion algorithm is performed by Algorithm 4, which implements a subroutine that searches the disconnected components at a given level of the data structure in parallel. The input to ParallelLevelSearch is an integer $i$, the level to search, a set of representatives of the disconnected components, $L$, and the set of replacement spanning forest edges that were found in levels lower than $i$, $S$. The output of ParallelLevelSearch is the set of components that are still disconnected after considering the non-tree edges at this level, and the set of replacement spanning forest edges found so far.

ParallelLevelSearch starts by inserting the new spanning forest edges in $S$ into $F_{i}$ (Line 12). Next, it computes $C$ and $D$, which are the components that are active and inactive at this level, respectively (Lines 13–14). The main loop of the algorithm (Lines 15–27) operates in a number of rounds. Each round first pushes down all tree edges at level $i$ of every active component. It then finds a single replacement edge incident to each active component, searching the active components in parallel, pushing any non-replacement edge to level $i-1$. It then promotes a maximal acyclic subset of the replacement edges found in this round to tree edges, and proceeds to the next round. The rounds terminate once all components at this level are deactivated by either becoming too large to search at this level, or because the algorithm finished examining all non-tree edges incident to the component at this level.

The main loop (Lines 15–27) works as follows. The algorithm first pushes any level $i$ tree edges in an active component down to level $i-1$. The active components in $C$ have size at most $2^{i-1}$, meaning that any tree edges they have at level $i$ can be pushed to level $i-1$ (Line 16) without violating Invariant 1. Next, the algorithm searches each active component for a replacement edge in parallel by calling the ComponentSearch procedure in parallel over all components (Line 17). This procedure either returns an empty set if there are no replacement edges incident to the component, or a set containing a single replacement edge. Next, the algorithm maps the replacement edge endpoints to their current component’s representatives by calling FindRepr on each endpoint (Line 18). It then computes a spanning forest over these replacement edges (Line 19) and maps the edges included in the spanning forest back to their original endpoints ids (Line 20). Observe that the edges in $T$ constitute a maximal acyclic subset of replacement edges of $R$ in $F_{i}$. The algorithm therefore promotes the edges in $T$ to tree edges (Lines 21– 22). Note that the new tree edges are not immediately inserted into all higher level spanning trees. Instead, the edges are buffered by adding them to $S$ (Line 23) so that they will be inserted when the higher level is reached in the search. Finally, the algorithm updates the set of components by computing their representatives on the updated $F_{i}$ (Line 24), and filtering out any components which have no remaining non-tree edges, or become larger than $2^{i-1}$ (i.e., become unsearchable at this level) into $D$ (Lines 30–27).

We now describe the ComponentSearch procedure (Lines 1–10). The search consists of a number of phases, where the $i$’th phase searches the first $2^{i}$ non-tree edges, or all of the non-tree edges if $2^{i}$ is larger than the number of non-tree edges in $c$. The search terminates either once a replacement edge incident to $c$ is found (Line 7), or once the algorithm unsuccessfuly examines all non-tree edges incident to $c$ (Line 3). Initially $w$, the search size, is set to $1$ (Line 4). On each phase, the algorithm retrieves the first $w$ many non-tree edges, $E_{c}$ (Line 5). It pushes all non-tree edges that are not replacements to level $i-1$ (Line 6). It then checks whether any of the edges in $E_{c}$ are a replacement edge, and if so, returns one of the replacement edges in $E_{c}$ (Line 8). Note that checking whether an edge is a replacement edge is done using BatchFindRepr. Otherwise, if no replacement edge was found it doubles $w$ (Line 9) and continues.

Cost Bounds. We now prove that our parallel algorithm has low depth, and is work-efficient with respect to the sequential HDT algorithm. For simplicity, we assume that we start with no edges in a graph on $n$ vertices.

Theorem 3.3**.**

A batch of $k$ edge deletions can be processed in $O(\mathop{\textnormal{lg}}^{4}n)$ depth w.h.p.

Proof.

The algorithm doubles the number of edges searched in each phase. Therefore, after $\mathop{\textnormal{lg}}m=O(\mathop{\textnormal{lg}}n)$ phases, all non-tree edges incident on the component will be searched.

In every round, each active component is either deactivated, or has a replacement edge found. In the worst case, the edges found for each active component pair the components off, leaving us with half as many active components in the subsequent round. As we lose a constant fraction of the active components per round, the algorithm takes $O(\mathop{\textnormal{lg}}n)$ rounds.

A given level can therefore perform at most $O(\mathop{\textnormal{lg}}^{2}n)$ phases. Each phase consists of fetching, examining, and pushing down non-tree edges, and hence can be implemented in $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. by Lemma 3.2, Theorem 2.1, and Lemma 3.3. Therefore, the overall depth for a given level is $O(\mathop{\textnormal{lg}}^{3}n)$ w.h.p. As all $\mathop{\textnormal{lg}}n$ levels will be processed in the worst case, the overall depth of the algorithm is $O(\mathop{\textnormal{lg}}^{4}n)$ w.h.p. ∎

We now analyze the work performed by the algorithm. We begin by stating the following lemmas on the efficiency of the augmented ET-tree operations.

Lemma 3.2**.**

Given some vertex, $v$ in a batch-parallel ET-tree, we can fetch the first $l$ tree (or non-tree) edges referenced by the augmented values in the tree in $O\left(l\mathop{\textnormal{lg}}\left(1+\frac{n_{c}}{l}\right)\right)$ work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. where $n_{c}$ is the number of vertices in the ET-tree at the current level. Furthermore, removing the edges can be done in the same bounds.

Lemma 3.3**.**

Decreasing the level of $l$ tree (or non-tree) edges in a batch-parallel ET-tree can be performed in $O\left(l\mathop{\textnormal{lg}}\left(1+\frac{n_{c}}{l}\right)\right)$ expected work and $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. where $n_{c}$ is the number of nodes in the ET-tree at the current level.

The proofs of these lemmas are provided in Appendix C. We now have the tool to analyze the work performed by batch deletion.

Lemma 3.4**.**

The work performed by BatchDeletion excluding the calls to ParallelLevelSearch is

[TABLE]

in expectation.

Proof.

The edge deletions performed by Line 2 cost $O(k)$ work by Lemma 3.1. Filtering the tree edges (Line 3) can be done in $O(k)$ work. Deleting the tree edges costs at most $O\left(k\mathop{\textnormal{lg}}\left(1+{n}/{k}\right)\right)$ work by Lemma 2.3 (Line 4).

Line 5 perform a FindRepr call for each endpoint of each deleted tree edge. These calls can be implemented as a single BatchFindRepr call which costs $O\left(k\mathop{\textnormal{lg}}\left(1+{n}/{k}\right)\right)$ work in expectation by Theorem 2.1. Since in the worst case each tree edge must be deleted from $\mathop{\textnormal{lg}}n$ levels, the overall cost of this step is $O\left(k\mathop{\textnormal{lg}}n\mathop{\textnormal{lg}}\left(1+{n}/{k}\right)\right)$ in expectation. Summing up the costs for each level proves the lemma. ∎

Theorem 3.4**.**

The expected amortized cost per edge insertion or deletion is $O(\mathop{\textnormal{lg}}^{2}n)$.

Proof.

Algorithm 3 takes as input a batch of $k$ edge deletions. By Lemma 3.4, the expected work performed by BatchDeletion excluding the calls to ParallelLevelSearch is

[TABLE]

which is at most $O(k\mathop{\textnormal{lg}}^{2}n)$ in expectation. We now consider the cost of the calls to ParallelLevelSearch. Specifically, we show that the work performed during the calls to ParallelLevelSearch can either be charged to level decreases on edges, or is at most $O(k\mathop{\textnormal{lg}}n)$ per call in expectation. Since the total number of calls to ParallelLevelSearch is at most $\mathop{\textnormal{lg}}n$, the bounds follow.

First, observe that the number of spanning forest edges we discover, $|S|$, is at most $k$, since at most $k$ tree edges were deleted initially. Therefore, the batch insertion on Line 12 costs $O(k\mathop{\textnormal{lg}}n)$ in expectation by Theorem 2.1. Similarly, $L$, the number of components that are supplied to ParallelLevelSearch, is at most $k$. Therefore, the cost of filtering the components in $L$ based on their size, and checking whether their representative exists in $F_{i}$ is at most $O(k\mathop{\textnormal{lg}}n)$ in expectation (Lines 13–14).

To fetch, examine, and push down $l$ tree or non-tree edges costs

[TABLE]

work in expectation, by Lemma 3.2, Theorem 2.1, and Lemma 3.3. Note that this is at most $O(\mathop{\textnormal{lg}}n)$ per edge. In particular, the cost of retrieving and pushing the tree edges of active components to level $i-1$ (Line 6) is therefore at most $O(\mathop{\textnormal{lg}}n)$ per edge in expectation, which we charge to the corresponding level decreases.

We now show that all work done while searching for replacement edges (Lines 15–27) can be charged to level decreases. Consider an active component, $c$ in some round. Suppose the algorithm performs $q>0$ phases before either the component is exhausted (all incident non-tree edges have been checked), or a replacement edge is found. First consider the case where it finds a replacement edge. If $q=1$, only a single edge was inspected, so then we charge the $\mathop{\textnormal{lg}}n$ work for the round to the edge, which will become a tree edge. Otherwise, it performs $q-1$ phases which do not produce any replacement edge.

Since phase $w$ inspects $2^{w}$ edges, it costs $O(2^{w}\mathop{\textnormal{lg}}n)$ work. The total work over all $q$ phases is therefore

[TABLE]

in expectation. However, since no replacement was found during the first $q-1$ phases, there are at least $2^{q-1}=O(2^{q})$ edges that will be pushed down, so we can charge $O(\mathop{\textnormal{lg}}n)$ work to each such edge to pay for this. In the other case, $q$ phases run without finding a replacement edge. In this case, all edges inspected are pushed down, and hence each assumes a cost of $O(\mathop{\textnormal{lg}}n)$ in expectation.

Now, we argue that the work done while processing the replacement edges is $O(k\mathop{\textnormal{lg}}n)$ in expectation over all rounds. Since $k$ edges were deleted, the algorithm discovers at most $k$ replacement edges. We charge the work in these steps to the replacement edges that we find. Let $k^{\prime}$ be the number of replacement edges that we find. Filtering the edges, and computing a spanning forest all costs $O(k^{\prime})$ work. Promoting the edges to tree edges (inserting them into $F_{i}$ and updating the adjacency lists) costs $O(k^{\prime}\mathop{\textnormal{lg}}n)$ work in expectation. Finally, updating the components costs $O(k^{\prime}\mathop{\textnormal{lg}}n)$ work in expectation, which we can charge to either the component, if it is removed from $C$ in this round, or to the replacement edge that it finds, which is promoted to a tree edge. Since the algorithm can find at most $k$ replacement edges, the cost per level is $O(k\mathop{\textnormal{lg}}n)$ in expectation for these steps as necessary.

In total, on each level the algorithm performs $O(k\mathop{\textnormal{lg}}n)$ expected work that is not charged to a level decrease. Summing over $\mathop{\textnormal{lg}}n$ levels, this yields an amortized cost of $O(\mathop{\textnormal{lg}}^{2}n)$ expected work per edge deletion. Finally, since the level of an edge can decrease at most $\mathop{\textnormal{lg}}n$ times, and an edge is charged $O(\mathop{\textnormal{lg}}n)$ expected work each time its level is decreased, the expected amortized cost per edge insertion is $O(\mathop{\textnormal{lg}}^{2}n)$.

∎

4 An Improved Algorithm

In this section we design an improved version of the parallel algorithm that performs less work than the algorithm from Section 3. Furthermore, the improved algorithm runs in $O(\mathop{\textnormal{lg}}^{3}n)$ depth w.h.p., improving on Algorithm 4 which runs in $O(\mathop{\textnormal{lg}}^{4}n)$ depth w.h.p.

4.1 The Interleaved Deletion Algorithm

Overview. Algorithm 5 is based on interleaving the phases of doubling that search for replacement edges with the spanning forest computation performed on the replacement edges. Recall that in Algorithm 4, the number of edges examined in each round is reset, and the doubling algorithm must therefore start with an initial search size of $1$ on the next round. Because the doubling resets from round to round, the number of phases per round can be $O(\mathop{\textnormal{lg}}n)$ in the worst case, making the total number of phases per level $O(\mathop{\textnormal{lg}}^{2}n)$. Instead, the interleaved algorithm avoids resetting the search size by maintaining a single, geometrically increasing search size over all rounds of the search.

The second important difference in Algorithm 5 compared with Algorithm 4 is that it defers inserting tree edges found on this level until the end of the search. Instead, it continues to search for replacement edges from the initial components until the component is deactivated. This property is important to show that the work done for a component across all rounds is dominated by the cost of the last round, since the number of vertices in the component is fixed, but the number of non-tree edges examined doubles in each round. For the same reason, it also defers inserting the pushed edges onto level $i-1$. We crucially use this property to obtain improved batch work bounds (Section 4.3).

Another difference in the modified algorithm is that if a component is still active after adding the replacement edges found in this round (i.e., the component on level $i$ still has size at most $2^{i-1}$), then all of the edges found in this round can be pushed to level $i-1$ without violating Invariant 1. Notice now that when pushing down edges, both the tree and non-tree edges that are found in this round are pushed. Pushing down all edges ensures that the algorithm performs enough level decreases to which to charge the work performed during the next round. The component deactivates either once it runs out of incident non-tree edges, or when it becomes too large. Since the algorithm defers adding the new tree edges found until the end of the level, it also maintains an auxiliary data structure that dynamically tracks the size of the resulting components as new edges are found.

The Deletion Algorithm. We briefly describe the main differences between InterleavedLevelSearch, the new level search procedure, and ParallelLevelSearch. The algorithm consists of a number of rounds (Lines 21–33). We use $r$ to track the round numbers, and we use $E_{P}$ to store the set of both tree and non-tree edges that will be pushed to level $i-1$ at the end of the search at this level (Line 19). $T$ stores the set of tree edges that have been selected, which will be added to the spanning forest at the end of the level. Lastly, we use $M$ to maintain a dynamic mapping from all the components in $L$ to a unique representative for their contracted supercomponent (initially itself), and the size of the contracted supercomponent.

In round $r$, the algorithm first retrieves the first $2^{r}$ (or fewer) edges of each the active components in parallel, and finds replacement edges. All replacement edges are added to the set $R$ (line 23).

The algorithm then computes a spanning forest over the edges in $R$, and computes $T_{r}$, which are the original replacement edges in $R$ that were selected as spanning forest edges (lines 25–27). The spanning forest computation returns, in addition to the tree edges, a mapping from the vertices in $R^{\prime}$ to their connectivity label (line 25), which can be used on line 28 to efficiently update the representatives of all affected components and the sizes of the supercomponents.

The next step maps over the components in parallel again, calling PushEdges on each active component, and checks whether the edges searched in this round can be (lazily) pushed to level $i-1$ (Line 29).444 Note that the set of edges retrieved by PushEdges in Line 9 is assumed to be the same as the one in Line 4. This assumption is satisfied by using our FetchEdges primitive on a batch-parallel ET-tree, and can be satisfied in general by associating the edges retrieved in ComponentSearch to be used in PushEdges.

If a component is still active (its new size is small enough to still be searched, and the component still has some non-tree edges remaining) (line 10), all of the searched edges are removed from the adjacency lists at level $i$ (line 11) and are added to the set of edges that will be pushed to level $i-1$ at the end of the level (Lines 12 and 29). Note that this set of edges contains both replacement tree edges we discovered, and non-tree edges. The tree-edges can be pushed down to level $i-1$ because the component with the tree edges added has size $\leq 2^{i-1}$.

The end of the round (lines 30–33) handles updating the set of components and incrementing the round number, as in Algorithm 4.

Finally, once all components are inactive, the tree edges found at this level that are not contained in $E_{p}$ are promoted (the tree edges added to $E_{p}$ have their level decreased to $i-1$) and inserted into $F_{i}$ (Lines 34–35), and all edges added to $E_{P}$ in Line 29 are pushed down to level $i-1$ (Line 36). Note that any tree-edges found in this set are promoted in level $i-1$ and added to $F_{i-1}$. The procedure returns the set of components and all replacement edges found at this level and levels below it (Line 37).

4.2 Cost Bounds

We start by showing that the depth of Algorithm 5 is $O(\mathop{\textnormal{lg}}^{3}n)$.

Lemma 4.1**.**

The number of rounds performed by Algorithm 5 is $O(\mathop{\textnormal{lg}}n)$ and the depth of each round is $O(\mathop{\textnormal{lg}}n)$ w.h.p.. The depth of the InterleavedLevelSearch is therefore $O(\mathop{\textnormal{lg}}^{2}n)$ w.h.p..

Proof.

Each round of the algorithm increases the search size of a component by a factor of $2$. Therefore, after $O(\mathop{\textnormal{lg}}n)$ rounds, every non-tree edge incident on a component will be considered and the algorithm will terminate.

To argue the depth bound, we consider the main steps performed during a round. Fetching, examining and removing the edges from level $i$ takes $O(\mathop{\textnormal{lg}}n)$ depth w.h.p. by Lemma 3.2, Theorem 2.1, and Lemma 3.3. Computing a spanning forest on the replacement edges and filtering the components (at most $k$ replacement edges, or components) can be done in $O(\mathop{\textnormal{lg}}k)$ depth. The depth per round is therefore $O(\mathop{\textnormal{lg}}n)$ w.h.p. and the depth of InterleavedLevelSearch is $O(\mathop{\textnormal{lg}}^{2}n)$ w.h.p. ∎

Combining Lemma 4.1 with the fact that there are $\mathop{\textnormal{lg}}n$ levels gives the following theorem.

Theorem 4.1**.**

A batch of $k$ edge deletions can be processed in $O(\mathop{\textnormal{lg}}^{3}n)$ depth w.h.p.

We now consider the work performed by the algorithm. We start with a lemma showing that the search-size for a component increases geometrically until the round where the component is deactivated.

Lemma 4.2**.**

Consider a component, $c$, that is active at the end of round $r-1$. If $c$ is not removed from $C$, then it examines $\geq 2^{r-1}$ edges that are pushed down to level $i-1$ at the end of the search.

Proof.

We prove the contrapositive. Suppose that $<2^{r-1}$ edges are pushed down in total by $c$ in the last round. Then, we will show that $c$ cannot be active in the next round (i.e., it is removed from $C$ in round $r-1$).

Notice that $c$ must be active at the start of round $r-1$. Consider the check on Line 10, which checks whether $w\leq 2^{r-1}$ and $w<w_{\max}$ on this round. Suppose for the same of contradiction that both conditions are true. Then, by the fact that $w<w_{\max}$, it must be the case that $w=2^{r-1}$ by Line 8. If the condition is true, then on Line 11 the algorithm adds $2^{r-1}$ edges to be pushed to level $i-1$, contradicting our assumption that $<2^{r-1}$ edges are pushed.

Therefore the check on Line 10 must be false, giving that either $w>2^{i-1}$, or $w=w_{\max}$. This means that $c$ will be marked as inactive on Line 30, and then become deactivated on line 32. Therefore, if $<2^{r-1}$ edges are pushed down by $c$ in round $r-1$, $c$ is deactivated at the end of the round, concluding the proof.

∎

Lemma 4.3**.**

Consider the work done by some component $c$ over the course of InterleavedLevelSearch at a given level. Let $R$ be the total number rounds that $c$ is active. Then, $c$ pushes down $p_{c}=2^{R}-1$ edges in total. Furthermore, the total cost of searching for and pushing down replacement edges performed by $c$ is

[TABLE]

in expectation, where $n_{c}$ is the number of vertices in $c$.

Proof.

By Lemma 4.2, for each round $r<R$, $c$ adds $2^{r}$ edges to be pushed down. Summing over all rounds shows that the total number of edges added to be pushed down is $2^{R}-1$. The cost of pushing down these edges at the end of the search at this level is exactly

[TABLE]

by Lemma 3.3, since the size of the tree that is affected is $n_{c}$.

We now consider the cost of fetching and examining the edges over all rounds. The cost of fetching and examining $2^{r}$ edges is

[TABLE]

in expectation by Theorem 2.1 and Lemma 3.2. Summing over all rounds $r<R$, the work is

[TABLE]

in expectation to fetch and examine edges in the first $R-1$ rounds, which is equal to

[TABLE]

by Lemma 2.2. Since on round $R$, the algorithm searches at most $2^{R}$ edges, the total cost of searching for replacement edges over all rounds is at most

[TABLE]

∎

Lemma 4.4**.**

The cost of InterleavedLevelSearch is at most

[TABLE]

in expectation where $p$ is the total number of edges pushed down.

Proof.

First consider lines 2–5. Since we are deleting a batch of $k$ edges, we can find at most $k$ replacement edges to reconnect these components. Therefore line 2 performs $O\left(k\mathop{\textnormal{lg}}\left(1+\frac{n}{k}\right)\right)$ expected work by Theorem 2.1. Pushing $t$ spanning tree edges to the next level (line 5) can be done in $O\left(t\mathop{\textnormal{lg}}\left(\frac{n}{t}+1\right)\right))$ expected work by Lemmas 3.2, 3.3, and 2.1, and Theorem 2.1. Hence in total, lines 2–5 perform at most $O\left(k\mathop{\textnormal{lg}}\left(1+\frac{n}{k}\right)+t\mathop{\textnormal{lg}}\left(1+\frac{n}{t}\right)\right)$ work in expectation.

Now, consider the cost of the steps which scan or update the components that are active in each round. On the first round, this cost is $O(k)$. In every subsequent round, $r$, by Lemma 4.2 each currently active component must have added $2^{r-1}$ edges to be pushed down on the previous round. Therefore, we can charge the $O(1)$ work per component performed in this round to these edge pushes.

Next, we analyze the work done while searching for and pushing replacement edges. Consider some component $c\in C$ that is searched on this level. By Lemma 4.3, the cost of searching for and pushing down the replacement edges incident on this component is

[TABLE]

in expectation, where $n_{c}$ is the number of vertices in $c$ and $p_{c}$ is the total number of edges pushed down by $c$.

The total work done over all components to search for replacement edges and push down both the original tree edges, and the edges in each round is therefore

[TABLE]

in expectation. Since $\sum n_{c}=n$, by Lemma 2.1 this costs

[TABLE]

work in expectation, where $p=t+\sum p_{c}$ is the total number of edges pushed, including tree and non-tree edges. Therefore, the total cost is

[TABLE]

in expectation. ∎

Theorem 4.2**.**

The expected amortized cost per edge insertion or deletion is $O(\mathop{\textnormal{lg}}^{2}n)$.

Proof.

The proof follows from the same argument as Theorem 3.4, by using Lemma 4.4. ∎

4.3 A Better Work Bound

We now show that by a more careful analysis, we can obtain a tighter bound on the amount of work performed by the interleaved algorithm. In particular, we show in this section that the algorithm performs

[TABLE]

amortized work per edge in expectation, where $\Delta{}$ is the average batch size of all batches of deletions. Therefore, if we process batches of deletions of size $\Omega(n/\textnormal{polylog}(n))$ on average, our algorithm performs $O(\mathop{\textnormal{lg}}n\mathop{\textnormal{lg}}\mathop{\textnormal{lg}}n)$ expected amortized work per edge, rather than $O(\mathop{\textnormal{lg}}^{2}n)$. Furthermore, if we have batches of size $\Omega(n)$, the cost is just $O(\mathop{\textnormal{lg}}n)$ per edge.

At a high level, our proof formalizes the intuition that in the worst case, all edges are pushed down at every level, and that performing fewer deletion operations results in larger batches of pushes which take advantage of work bounds of the ET-tree. Our proof crucially relies on the fact that although the deletion algorithm at a level can perform $O(\mathop{\textnormal{lg}}n)$ ET-tree operations per component, since the batch sizes are geometrically increasing, these operations have the cost of a single ET-tree operation per component. Furthermore, Lemma 4.4 shows that the costs per component can be combined so that the total cost is equivalent to the cost of a single ET-tree operation on all the vertices. Therefore, the number of deletion operations can be exactly related to the effective number of ET-tree operations at a level. We relate the number of deletions to the average batch size, which lets us obtain a single unified bound for both insertions and deletions.

Theorem 4.3**.**

Using the interleaved deletion algorithm, the amortized work performed by BatchDeletion and BatchInsertion on a batch of $k$ edges is

[TABLE]

in expectation where $\Delta{}$ is the average batch size of all batch deletions.

Proof.

Batch insertions perform only $O\left(k\mathop{\textnormal{lg}}\left(1+\frac{n}{k}\right)\right)$ work by Theorem 3.2, so we focus on the cost of deletion since it dominates. Consider the total amount of work performed by all batch deletion operations at any given point in the lifetime of the data structure. We will denote by $k_{b}$, the size of batch $b$, and by $p_{b,i}$, the number of edges pushed down on level $i$ during batch $b$. Combining Lemmas 3.4, and 4.4, the total work is bounded above by

[TABLE]

We begin by analyzing the first term, which is paid for by the deletion algorithm. Let

[TABLE]

denote the total number of deleted edges. Applying Lemma 2.1, and using the fact that there are $\mathop{\textnormal{lg}}n$ levels, we have

[TABLE]

where $d$ is the number of batches of deletions. Since $K/d=\Delta{}$, this is equal to

[TABLE]

work in expectation. Each batch can therefore be charged a cost of $\mathop{\textnormal{lg}}n\mathop{\textnormal{lg}}\left(1+n/\Delta{}\right)$ per edge, and hence the amortized cost of batch deletion is

[TABLE]

in expectation.

The remainder of the cost, which comes entirely from searching for replacement edges, is charged to the insertions. Consider this cost and let

[TABLE]

denote the total such number of edge pushes. Since the total number of terms in the double sum is $d\mathop{\textnormal{lg}}n$, Lemma 2.1 allows us to bound the total work of all pushes by

[TABLE]

in expectation. Since every edge can only be pushed down once per level, we have

[TABLE]

where $m$ is the total number of edges ever inserted. Therefore by Lemma 2.3, the total work is at most

[TABLE]

in expectation. Since $d=K/\Delta{}$, this is equal to

[TABLE]

in expectation. Since each edge can be deleted only once, we have $K\leq m$, and hence we obtain that the total work to push all tree edges down is at most

[TABLE]

in expectation. We can therefore charge $O\left(\mathop{\textnormal{lg}}n\mathop{\textnormal{lg}}(1+n/\Delta{})\right)$ per edge to each batch insertion. Since this dominates the cost of the insertion algorithm itself, the amortized cost of batch insertion is therefore

[TABLE]

in expectation as desired, concluding the proof. ∎

5 Related Work

Parallel Dynamic Algorithms. There are only a few results on parallel dynamic algorithms. Earlier results [22, 19] are not work-efficient with respect to the fastest sequential dynamic algorithms, do not support batch updates, and perform polynomial work per update. Some more recent results such as parallel dynamic depth-first search [40] and minimum spanning forest [41] process updates one at a time, and are therefore not batch-dynamic algorithms. Work efficient parallel batch-dynamic algorithms include those for the well-spaced point sets problem [2] and those for the dynamic trees problem [52, 1, 65].

Parallel Connectivity. Parallel algorithms for connectivity have a long history [31, 56, 66, 9, 50, 47, 18, 38], and there are many existing algorithms that solve the problem work-efficiently and in low-depth [23, 17, 26, 27, 46, 48, 58], some of which are also practical [58, 20]. However, there is no obvious way to adapt existing parallel connectivity algorithms to the dynamic setting, particularly for batch updates.

Parallel Dictionaries and Trees. There are many results on parallel dictionaries and trees supporting batch updates [24, 14, 15, 57, 12, 6, 60]. The dictionary data structures in the literature culminated in dictionaries supporting batch insertions, deletions and lookups in linear work and $O(\mathop{\textnormal{lg}}^{*}n)$ depth w.h.p. [24]. Early work on batch insertions into trees focused on optimizing the depth, but was not work-efficient. Paul et al. design batch search, insertion and deletion algorithms for 2-3 trees on the EREW PRAM [45]. These results were later extended to B-trees by Higham et al. [30]. The algorithms of both Paul et al. and Higham et al. perform $O(m\mathop{\textnormal{lg}}n)$ work for $m$ tree operations.

Recent work on parallel tree data structures has focused on how to parallelize batch operations for various balancing schemes in binary search trees [12], and also how to improve the depth of these operations [6]. There is also some very recent work on extending these tree data structures to support range and segment queries [60] as well as practical implementations of parallel trees supporting batch insertions, deletions and lookups [61].

Other Related Work. There is also recent work on parallel working-set structures that supports batching by Agrawal et al. [4]. Earlier work by Agrawal et al. [3] introduces the idea of implicit batching which uses scheduler support to convert dynamically multithreaded programs using an abstract data type to programs that perform batch accesses to an underlying parallel data structure.

6 Discussion

In this paper, we present a novel batch-dynamic algorithm for the connectivity problem. Our algorithm is always work-efficient with respect to the Holm, de Lichtenberg and Thorup dynamic connectivity algorithm, and is asymptotically faster than their algorithm when the average batch size is sufficiently large. A parallel implementation of our algorithm achieves $O(\mathop{\textnormal{lg}}^{3}n)$ depth w.h.p., and is, to the best of our knowledge, the first parallel algorithm for the dynamic connectivity problem performing $O(T\mathop{\text{polylog}}(n))$ total expected work, where $T$ is the total number of edge operations.

There are several natural questions to address in future work. First, can the depth of our algorithm be improved to $O(\mathop{\textnormal{lg}}^{2}n)$ without increasing the work? Investigating lower bounds in the batch setting would also be very interesting—are there non-trivial lower-bounds for batch-dynamic connectivity? Lastly, in this paper we show expected amortized bounds. One approach to strengthen these bounds is to show that our tree operations hold w.h.p. and argue that our amortized bounds hold w.h.p. Another is to design a deterministic batch-dynamic forest connectivity data structure with the same asymptotic complexity as the batch-parallel ET-tree, which would make the randomized bounds in this paper deterministic.

Two additional questions are whether we can extend our results to give parallel work-efficient batch-dynamic MST, 2-edge connectivity and biconnectivity algorithms. MST seems solvable using the techniques presented in this paper, although our dynamic tree structure would need to be extended with additional primitives. Existing sequential 2-edge connectivity and biconnectivity algorithms require a dynamic tree data structure supporting path queries which are not supported by ET-trees. However, RC-trees [1] can be extended to support path queries, which makes them a possible candidate for this line of work. Finally, it seems likely that ideas from our work can be extended to give a parallel batch-dynamic Monte-Carlo connectivity algorithm based on the Kapron-King-Mountjoy algorithm [37].

Acknowledgments

We thank Tom Tseng and Goran Zuzic for helpful discussions. This work was supported in part by NSF grants CCF-1408940, CCF-1533858, and CCF-1629444.

Appendix A Model

The Multi-Threaded Random-Access Machine ($\mathsf{TRAM}$) consists of a set of threads that share an unbounded memory. Each thread is essentially a Random Access Machine—it runs a program stored in memory, has a constant number of registers, and uses standard RAM instructions (including an end to finish the computation). The only difference between the $\mathsf{TRAM}$ and a RAM is the fork instruction that takes a positive integer $k$ and forks $k$ new child threads. Each child thread receives a unique identifier in the range $[1,\ldots,k]$ in its first register and otherwise has the same state as the parent, which has a [math] in that register. All children start by running the next instruction. When a thread performs a fork, it is suspended until all the children terminate (execute an end instruction). A computation starts with a single root thread and finishes when that root thread terminates. This model supports what is often referred to as nested parallelism. Note that if root thread never forks, it is a standard sequential program.

We note that we can simulate an $\mathsf{TRAM}$ algorithm on the CRCW PRAM equipped with the same operations with an additional $O(\mathop{\textnormal{lg}}^{*}n)$ factor in the depth due to load-balancing. Furthermore, a PRAM algorithm using $P$ processors and $T$ time can be simulated in our model with $PT$ work and $T$ depth. We equip the model with a compare-and-swap operation (see Section 2) in this paper.

Lastly, we define the cost-bounds for this model. A computation can be viewed as a series-parallel DAG in which each instruction is a vertex, sequential instructions are composed in series, and the forked subthreads are composed in parallel. The work of a computation is the number of vertices and the depth (span) is the length of the longest path in the DAG. We refer the interested reader to [11] for more details about the model.

Appendix B Data Structures

In this section we describe a simple adjacency-list like data structure that efficiently supports insertion and deletion of arbitrary edges, and quickly fetching a batch of $l$ edges. This is the data structure that we use to store adjacency lists of vertices at each level. Note that we actually store two adjacency lists, one for tree edges, and one for non-tree edges. The adjacency list data structure supports the following operations:

• •

$\textsc{InsertEdges}(\{e_{1},\ldots,e_{l}\})$: Insert a batch of edges adjacent to this vertex.

• •

$\textsc{DeleteEdges}(\{e_{1},\ldots,e_{l}\})$: Delete a batch of edges adjacent to this vertex.

• •

$\textsc{FetchEdges}(l)$: Return a set of $l$ arbitrary edges adjacent to this vertex.

We now show how to implement a data structure that gives us the following bounds:

See 3.1

Proof.

For a given vertex, the data structure stores a list of pointers to each adjacent edge in a resizable array. Each edge correspondingly stores its positions in the adjacency arrays of its two endpoints. Since each vertex can have at most $O(n)$ edges adjacent to it, the adjacency arrays are of size at most $O(n)$.

Insertions are easily handled by inserting the batch onto the end of the array, and resizing if necessary. This costs $O(1)$ amortized work per edge and $O(\mathop{\textnormal{lg}}n)$ depth. To fetch $l$ elements, we simply return the first $l$ elements of the array, which takes $O(1)$ work per edge and $O(\mathop{\textnormal{lg}}n)$ depth.

Finally, to delete a batch of $l$ edges, the algorithm first determines which of the edges to be deleted are contained within the final $l$ elements of the array. It then compacts the final $l$ elements of the array, removing those edges. Compaction costs $O(l)$ work and $O(\mathop{\textnormal{lg}}n)$ depth. The algorithm then considers the remaining $l^{\prime}$ edges to be deleted, and in parallel, swaps these elements with the final $l^{\prime}$ elements of the array. The final $l^{\prime}$ elements in the array can then be safely removed. Note that any operation that moves an element in the array also updates the corresponding position value stored in the edge. Swapping and deleting can be implemented in $O(l^{\prime})$ work and $(\mathop{\textnormal{lg}}n)$ depth, and hence all operations cost $O(1)$ amortized work per edge and $O(\mathop{\textnormal{lg}}n)$ depth. ∎

Appendix C Additional Tree Operations

Retrieving and Pushing Down Edges. The batch-parallel ET-trees used in this paper augment each node in the tree with two values indicating the number of tree and non-tree edges whose level is equal to the level of the forest currently stored in that subtree. The augmentation is necessary for efficiently fetching the tree edges that need to be pushed down before searching the data structure, and for fetching a subset of non-tree edges in a tree.

We extend the batch-dynamic trees interface described earlier with operations which enable efficiently retrieving, removing and pushing down batches of tree or non-tree edges.

These primitives are all similar and can be implemented as follows. We first describe the primitives which fetch and remove a set of $l$ tree (or non-tree) edges. The algorithm starts by finding a set of vertices containing $l$ edges. To do this we perform a binary search on the skip-list in order to find the first node that has augmented value greater than $l$. The idea is to sequentially walk at the highest level, summing the augmented values of nodes we encounter and marking them, until the first node that we hit whose augmented value makes the counter larger than $l$, or we return to $v$. In the former case, we descend a level using this node’s downwards pointer, and repeat, until we reach a level 0 node. We also keep a counter, $ctr$, indicating the number of tree (non-tree) edges to take from the rightmost marked node at level 0. Otherwise, all nodes at the topmost level are marked. The last step of the algorithm is to find all descendants of marked nodes that have a non-zero number of tree (non-tree) edges, and return all tree (non-tree) edges incident on them. The only exception is the rightmost marked node, from which we only take $ctr$ many tree (non-tree) edges

Insertions are handled by first inserting the edges into the adjacency list data structure. We then update the augmented values in the ET-tree using the primitive from Tseng et al. [65].

We now argue that these implementations achieves good work and depth bounds.

See 3.2

Proof.

Standard proofs about skip-lists shows that the number of nodes traversed in the binary search is $O(\mathop{\textnormal{lg}}n)$ w.h.p. [49, 65]. We can fetch $l$ edges from each vertex’s adjacency list data structure in $O(l)$ amortized work and $O(\mathop{\textnormal{lg}}n)$ depth by Lemma 3.1. The total work is therefore $O\left(l\mathop{\textnormal{lg}}\left(1+\frac{n_{c}}{l}\right)\right)$ in expectation, and the depth is $O(\mathop{\textnormal{lg}}n)$ w.h.p. since the depth of the adjacency list access is an additive increase of $O(\mathop{\textnormal{lg}}n)$. Observe that removing the edges can be done in the same bounds since updating the augmented values after deleting the edges costs $O\left(l\mathop{\textnormal{lg}}\left(1+\frac{n_{c}}{l}\right)\right)$ expected work. ∎

See 3.3

Proof.

The proof is identical to the proof of Lemma 3.2. The only difference is that the augmented values of the nodes that receive an edge must be updated after insertion which costs at most $O\left(l\mathop{\textnormal{lg}}\left(1+\frac{n_{c}}{l}\right)\right)$ in expectation. Note that since the forest on the lower level is a subgraph of the tree at the current level, it has size at most $n_{c}$, proving the bounds. ∎

Appendix D Additional Proofs

We now state and give proofs for some of the technical lemmas used in our proofs of the improved batch bounds.

See 2.1

Proof.

We proceed by induction on $c$. When $c=1$, the quantities are equal. For $c>1$, we can write

[TABLE]

Then, using the concavity of the logarithm function, we have

[TABLE]

which concludes the proof. ∎

See 2.2

Proof.

First, write

[TABLE]

Now substitute this into the sum to obtain

[TABLE]

We evaluate the remaining sum by writing

[TABLE]

and then use the fact that

[TABLE]

to conclude that

[TABLE]

as desired. ∎

See 2.3

Proof.

The derivative of the function with respect to $x$ is

[TABLE]

We must show that this quantity is strictly positive for all $x\geq 1$. First, we use a well-known inequality that states

[TABLE]

for $a\geq 1$ and $y\in[0,1]$. Using $a=2$ and $y=n/(n+x)$, we obtain

[TABLE]

Since $n\geq 1$ and $x\geq 1$, we have

[TABLE]

and hence by transitivity,

[TABLE]

Taking logarithms on both sides yields

[TABLE]

which implies the desired result. ∎