UFO Trees: Practical and Provably-Efficient Parallel Batch-Dynamic Trees

TL;DR

This paper tackles maintaining dynamic forests under edge updates while supporting rich queries, a problem where traditional link-cut trees lack parallel batch capabilities. It introduces UFO trees, a parallel batch-dynamic tree structure based on unbounded fan-out contraction that achieves work-efficient updates and poly-log depth, while providing extensive query support akin to RC/topology trees. The authors prove diameter-related performance advantages, develop batch-update algorithms for both topology and UFO trees, and demonstrate through extensive experiments that UFO trees offer superior practical performance and scalable memory usage, even approaching billion-scale inputs. Overall, UFO trees offer a robust, scalable building block for dynamic graph algorithms in practice, with strong theoretical guarantees and broad applicability.

Abstract

The dynamic trees problem is to maintain a tree under edge updates while supporting queries like connectivity queries or path queries. Despite the first data structure for this fundamental problem -- the link-cut tree -- being invented 40 years ago, our experiments reveal that they are still the fastest sequential data structure for the problem. However, link-cut trees cannot support parallel batch-dynamic updates and have limitations on the kinds of queries they support. In this paper, we design a new parallel batch-dynamic trees data structure called UFO trees that simultaneously supports a wide range of query functionality, supports work-efficient parallel batch-dynamic updates, and is competitive with link-cut trees when run sequentially. We prove that a key reason for the strong practical performance of both link-cut trees and UFO trees is that they can perform updates and queries in sub-logarithmic time for low-diameter trees. We perform an experimental study of our optimized C++ implementations of UFO trees with ten other dynamic tree implementations, several of which are new, in a broad benchmark of both synthetic and real-world trees of varying diameter and size. Our results show that, in both sequential and parallel settings, UFO trees are the fastest dynamic tree data structure that supports a wide range of queries. Our new implementation of UFO trees has low space usage and easily scales to billion-size inputs, making it a promising building block for implementing more complex dynamic graph algorithms in practice.

Figures (15)

• Figure 1: An example of an input tree (left) and a topology tree for it (right). The rightmost chain of nodes forms because the only neighbor of that cluster repeatedly merges with a different cluster.
• Figure 2: An example of an update to a topology tree. In (a), we show the input tree, with the deleted edge $(h,i)$ in red. In (b), we show the original topology tree with the ancestor clusters of $h$ and $i$ highlighted in red. In (c), we show the topology tree after the initial delete ancestors step with the root clusters highlighted in blue. In (d), we show the topology tree after the reclustering process with the newly created clusters highlighted in green. In this example, a root cluster ($i$'s parent) merges with a non-root cluster ($k$'s parent) to maintain a maximal matching. The ancestors of $k$'s grandparent are deleted.
• Figure 3: An example of an input tree (left) and a UFO tree for it (right). The high degree vertices $c$, $f$, and $k$ merge with all of their respective degree $1$ neighbors in the first round.
• Figure 4: An example of an update to a UFO tree. Subfigure (a) shows the input tree, with the deleted edge $(c,f)$ in red. In (b), we show the original UFO tree with the ancestor clusters of $c$ and $f$ highlighted in red. In (c), we show the UFO tree after the initial ancestor removal step with the root clusters highlighted in blue. In this example, the parents of $c$ and $f$ were not deleted because they were high fanout, but all other ancestors were. In (d), we show the UFO tree after the reclustering process with the newly created clusters highlighted in green.
• Figure 5: The results of our sequential dynamic tree data structure update speed experiments. The top row shows results on a variety of synthetic trees with $n=10^7$. The bottom row shows results on breadth-first search forests and random incremental spanning forests of our real-world graph datasets. We report the total time for inserting all edges and then deleting all edges, both in a random order.

Theorems & Definitions (49)

• Theorem 3.1
• Theorem 3.2
• Theorem 3.3
• Theorem 4.1
• Theorem 4.2
• Theorem 4.3
• Theorem 4.4
• Theorem 5.1
• Theorem 5.2
• Theorem B.1