arXiv subjects

Daniel Anderson

Publications and source records attributed to Daniel Anderson.

14 recordsLinked to original sources

arXiv2025

Parallel batch queries on dynamic trees: algorithms and experiments

Dynamic tree data structures maintain a forest while supporting insertion and deletion of edges and a broad set of queries in $O(\log n)$ time per operation. Such data structures are at the core of many modern algorithms. Recent work has extended dynamic trees so as to support batches of updates or queries so as to run in parallel, and these batch parallel dynamic trees are now used in several parallel algorithms. In this work we describe improvements to batch parallel dynamic trees, describe an implementation that incorporates these improvements, and experiments using it. The improvements includes generalizing prior work on RC (rake compress) trees to work with arbitrary degree while still supporting a rich set of queries, and describing how to support batch subtree queries, path queries, LCA queries, and nearest-marked-vertex queries in $O(k + k \log (1 + n/k))$ work and polylogarithmic span. Our implementation is the first general implementation of batch dynamic trees (supporting arbitrary degree and general queries). Our experiments include measuring the time to create the trees, varying batch sizes for updates and queries, and using the tree to implement incremental batch-parallel minimum spanning trees. To run the experiments we develop a forest generator that is parameterized to create distributions of trees of differing characteristics (e.g., degree, depth, and relative tree sizes). Our experiments show good speedup and that the algorithm performance is robust across forest characteristics.

cs.DS↗

arXiv2025

Big Atomics

In this paper, we give theoretically and practically efficient implementations of Big Atomics, i.e., $k$-word linearizable registers that support the load, store, and compare-and-swap (CAS) operations. While modern hardware supports $k = 1$ and sometimes $k = 2$ (e.g., double-width compare-and-swap in x86), our implementations support arbitrary $k$. Big Atomics are useful in many applications, including atomic manipulation of tuples, version lists, and implementing load-linked/store-conditional (LL/SC). We design fast, lock-free implementations of big atomics based on a novel fast-path-slow-path approach we develop. We then use them to develop an efficient concurrent hash table, as evidence of their utility. We experimentally validate the approach by comparing a variety of implementations of big atomics under a variety of workloads (thread counts, load/store ratios, contention, oversubscription, and number of atomics). The experiments compare two of our lock-free variants with C++ std::atomic, a lock-based version, a version using sequence locks, and an indirect version. The results show that our approach is close to the fastest under all conditions and far outperforms others under oversubscription. We also compare our big atomics based concurrent hash table to a variety of other state-of-the-art hash tables that support arbitrary length keys and values, including implementations from Intel's TBB, Facebook's Folly, libcuckoo, and a recent release from Boost. The results show that our approach of using big atomics in the design of hash tables is a promising direction.

cs.DC↗

arXiv2023

Deterministic and Work-Efficient Parallel Batch-Dynamic Trees in Low Span

Dynamic trees are a well-studied and fundamental building block of dynamic graph algorithms dating back to the seminal work of Sleator and Tarjan [STOC'81, (1981), pp. 114-122]. The problem is to maintain a tree subject to online edge insertions and deletions while answering queries about the tree, such as the heaviest weight on a path, etc. In the parallel batch-dynamic setting, the goal is to process batches of edge updates work efficiently in low ($\text{polylog}\ n$) span. Two work-efficient algorithms are known, batch-parallel Euler Tour Trees by Tseng et al. [ALENEX'19, (2019), pp. 92-106] and parallel Rake-Compress (RC) Trees by Acar et al. [ESA'20, (2020), pp. 2:1-2:23]. Both however are randomized and work efficient in expectation. Several downstream results that use these data structures (and indeed to the best of our knowledge, all known work-efficient parallel batch-dynamic graph algorithms) are therefore also randomized. In this work, we give the first deterministic work-efficient solution to the problem. Our algorithm maintains a dynamic parallel tree contraction subject to batches of $k$ edge updates deterministically in worst-case $O(k \log(1 + n/k))$ work and $O(\log n \log^{(c)} k)$ span for any constant $c$. This allows us to implement parallel batch-dynamic RC-Trees with worst-case $O(k \log(1 + n/k))$ work updates and queries deterministically. Our techniques that we use to obtain the given span bound can also be applied to the state-of-the-art randomized variant of the algorithm to improve its span from $O(\log n \log^* n)$ to $O(\log n)$.

cs.DS↗

arXiv2022

Neural Font Rendering

Recent advances in deep learning techniques and applications have revolutionized artistic creation and manipulation in many domains (text, images, music); however, fonts have not yet been integrated with deep learning architectures in a manner that supports their multi-scale nature. In this work we aim to bridge this gap, proposing a network architecture capable of rasterizing glyphs in multiple sizes, potentially paving the way for easy and accessible creation and manipulation of fonts.

cs.CV↗

arXiv2022

Turning Manual Concurrent Memory Reclamation into Automatic Reference Counting

Safe memory reclamation (SMR) schemes are an essential tool for lock-free data structures and concurrent programming. However, manual SMR schemes are notoriously difficult to apply correctly, and automatic schemes, such as reference counting, have been argued for over a decade to be too slow for practical purposes. A recent wave of work has disproved this long-held notion and shown that reference counting can be as scalable as hazard pointers, one of the most common manual techniques. Despite these tremendous improvements, there remains a gap of up to 2x or more in performance between these schemes and faster manual techniques such as epoch-based reclamation (EBR). In this work, we first advance these ideas and show that in many cases, automatic reference counting can in fact be as fast as the fastest manual SMR techniques. We generalize our previous Concurrent Deferred Reference Counting (CDRC) algorithm to obtain a method for converting any standard manual SMR technique into an automatic reference counting technique with a similar performance profile. Our second contribution is extending this framework to support weak pointers, which are reference-counted pointers that automatically break pointer cycles by not contributing to the reference count, thus addressing a common weakness in reference-counted garbage collection. Our experiments with a C++-library implementation show that our automatic techniques perform in line with their manual counterparts, and that our weak pointer implementation outperforms the best known atomic weak pointer library by up to an order of magnitude on high thread counts. All together, we show that the ease of use of automatic memory management can be achieved without significant cost to practical performance or general applicability.

cs.DC↗

arXiv2021

Triplet Fusion Upconversion Nanocapsules for Volumetric 3D Printing

Two-photon photopolymerization delivers prints without support structures and minimizes layering artifacts in a broad range of materials. This volumetric printing approach scans a focused light source throughout the entire volume of a resin vat and takes advantage of the quadratic power dependence of two photon absorption to produce photopolymerization exclusively at the focal point. While this approach has advantages, the widespread adoption of two photon photopolymerization is hindered by the need for expensive ultrafast lasers and extremely slow print speeds. Here we present an analogous quadratic process, triplet-triplet-annihilation-driven 3D printing, that enables volumetric printing at a focal point driven by <4 milliwatt-power continuous wave excitation. To induce photopolymerization deep within a vat, the key advance is the nanoencapsulation of photon upconversion solution within a silica shell decorated with solubilizing polymer ligands. This scalable self-assembly approach allows for scatter-free nanocapsule dispersal in a variety of organic media without leaking the capsule contents. We further introduce an excitonic strategy to systematically control the upconversion threshold to support either monovoxel or parallelized printing schemes, printing at power densities multiple orders of magnitude lower than power densities required for two-photon-based 3D printing. The application of upconversion nanocapsules to volumetric 3D printing provides access to the benefits of volumetric printing without the current cost, power, and speed drawbacks. The materials demonstrated here open opportunities for other triplet fusion upconversion-controlled applications.

physics.app-ph↗

arXiv2021

Efficient Parallel Self-Adjusting Computation

Self-adjusting computation is an approach for automatically producing dynamic algorithms from static ones. The approach works by tracking control and data dependencies, and propagating changes through the dependencies when making an update. Extensively studied in the sequential setting, some results on parallel self-adjusting computation exist, but are either only applicable to limited classes of computations, such as map-reduce, or are ad-hoc systems with no theoretical analysis of their performance. In this paper, we present the first system for parallel self-adjusting computation that applies to a wide class of nested parallel algorithms and provides theoretical bounds on the work and span of the resulting dynamic algorithms. As with bounds in the sequential setting, our bounds relate a "distance" measure between computations on different inputs to the cost of propagating an update. However, here we also consider parallelism in the propagation cost. The main innovation in the paper is in using Series-Parallel trees (SP trees) to track sequential and parallel control dependencies to allow propagation of changes to be applied safely in parallel. We show both theoretically and through experiments that our system allows algorithms to produce updated results over large datasets significantly faster than from-scratch execution. We demonstrate our system with several example applications, including algorithms for dynamic sequences and dynamic trees. In all cases studied, we show that parallel self-adjusting computation can provide a significant benefit in both work savings and parallel time.

cs.DC↗

arXiv2021

Parallel Minimum Cuts in $O(m \log^2(n))$ Work and Low Depth

We present a randomized $O(m \log^2 n)$ work, $O(\text{polylog } n)$ depth parallel algorithm for minimum cut. This algorithm matches the work bounds of a recent sequential algorithm by Gawrychowski, Mozes, and Weimann [ICALP'20], and improves on the previously best parallel algorithm by Geissmann and Gianinazzi [SPAA'18], which performs $O(m \log^4 n)$ work in $O(\text{polylog } n)$ depth. Our algorithm makes use of three components that might be of independent interest. Firstly, we design a parallel data structure that efficiently supports batched mixed queries and updates on trees. It generalizes and improves the work bounds of a previous data structure of Geissmann and Gianinazzi and is work efficient with respect to the best sequential algorithm. Secondly, we design a parallel algorithm for approximate minimum cut that improves on previous results by Karger and Motwani. We use this algorithm to give a work-efficient procedure to produce a tree packing, as in Karger's sequential algorithm for minimum cuts. Lastly, we design an efficient parallel algorithm for solving the minimum $2$-respecting cut problem.

cs.DS↗

arXiv2020

Work-efficient Batch-incremental Minimum Spanning Trees with Applications to the Sliding Window Model

Algorithms for dynamically maintaining minimum spanning trees (MSTs) have received much attention in both the parallel and sequential settings. While previous work has given optimal algorithms for dense graphs, all existing parallel batch-dynamic algorithms perform polynomial work per update in the worst case for sparse graphs. In this paper, we present the first work-efficient parallel batch-dynamic algorithm for incremental MST, which can insert $\ell$ edges in $O(\ell \log(1+n/\ell))$ work in expectation and $O(\text{polylog}(n))$ span w.h.p. The key ingredient of our algorithm is an algorithm for constructing a compressed path tree of an edge-weighted tree, which is a smaller tree that contains all pairwise heaviest edges between a given set of marked vertices. Using our batch-incremental MST algorithm, we demonstrate a range of applications that become efficiently solvable in parallel in the sliding-window model, such as graph connectivity, approximate MSTs, testing bipartiteness, $k$-certificates, cycle-freeness, and maintaining sparsifiers.

cs.DS↗

arXiv2020

Parallel Batch-dynamic Trees via Change Propagation

The dynamic trees problem is to maintain a forest subject to edge insertions and deletions while facilitating queries such as connectivity, path weights, and subtree weights. Dynamic trees are a fundamental building block of a large number of graph algorithms. Although traditionally studied in the single-update setting, dynamic algorithms capable of supporting batches of updates are increasingly relevant today due to the emergence of rapidly evolving dynamic datasets. Since processing updates on a single processor is often unrealistic for large batches of updates, designing parallel batch-dynamic algorithms that achieve provably low span is important for many applications. In this work, we design the first work-efficient parallel batch-dynamic algorithm for dynamic trees that is capable of supporting both path queries and subtree queries, as well as a variety of non-local queries. To achieve this, we propose a framework for algorithmically dynamizing static round-synchronous algorithms that allows us to obtain parallel batch-dynamic algorithms with good bounds on their work and span. In our framework, the algorithm designer can apply the technique to any suitably defined static algorithm. We then obtain theoretical guarantees for algorithms in our framework by defining the notion of a computation distance between two executions of the underlying algorithm. Our dynamic trees algorithm is obtained by applying our dynamization framework to the parallel tree contraction algorithm of Miller and Reif, and then performing a novel analysis of the computation distance of this algorithm under batch updates. We show that $k$ updates can be performed in $O(k \log(1+n/k))$ work in expectation, which matches an existing algorithm of Tseng et al. while providing support for a substantially larger number of queries and applications.

cs.DS↗

arXiv2019

Further Results on an Abstract Model for Branching and its Application to Mixed-Integer Programming

A key ingredient in branch and bound (B&B) solvers for mixed-integer programming (MIP) is the selection of branching variables since poor or arbitrary selection can affect the size of the resulting search trees by orders of magnitude. A recent article by Le Bodic and Nemhauser [Mathematical Programming, (2017)] investigated variable selection rules by developing a theoretical model of B&B trees from which they developed some new, effective scoring functions for MIP solvers. In their work, Le Bodic and Nemhauser left several open theoretical problems, solutions to which could guide the future design of variable selection rules. In this article, we first solve many of these open theoretical problems. We then implement an improved version of the model-based branching rules in SCIP 6.0, a state-of-the-art academic MIP solver, in which we observe an 11% geometric average time and node reduction on instances of the MIPLIB 2017 Benchmark Set that require large B&B trees.

math.OC↗

arXiv2019

Parallel Batch-Dynamic Graph Connectivity

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.

cs.DS↗

arXiv2017

An arbitrary order scheme on generic meshes for miscible displacements in porous media

We design, analyse and implement an arbitrary order scheme applicable to generic meshes for a coupled elliptic-parabolic PDE system describing miscible displacement in porous media. The discretisation is based on several adaptations of the Hybrid-High-Order (HHO) method due to Di Pietro et al. [Computational Methods in Applied Mathematics, 14(4), (2014)]. The equation governing the pressure is discretised using an adaptation of the HHO method for variable diffusion, while the discrete concentration equation is based on the HHO method for advection-diffusion-reaction problems combined with numerically stable flux reconstructions for the advective velocity that we have derived using the results of Cockburn et al. [ESAIM: Mathematical Modelling and Numerical Analysis, 50(3), (2016)]. We perform some rigorous analysis of the method to demonstrate its $L^2$ stability under the irregular data often presented by reservoir engineering problems and present several numerical tests to demonstrate the quality of the results that are produced by the proposed scheme.

cs.CE↗

arXiv2017

A High-Performance Algorithm for Identifying Frequent Items in Data Streams

Estimating frequencies of items over data streams is a common building block in streaming data measurement and analysis. Misra and Gries introduced their seminal algorithm for the problem in 1982, and the problem has since been revisited many times due its practicality and applicability. We describe a highly optimized version of Misra and Gries' algorithm that is suitable for deployment in industrial settings. Our code is made public via an open source library called DataSketches that is already used by several companies and production systems. Our algorithm improves on two theoretical and practical aspects of prior work. First, it handles weighted updates in amortized constant time, a common requirement in practice. Second, it uses a simple and fast method for merging summaries that asymptotically improves on prior work even for unweighted streams. We describe experiments confirming that our algorithms are more efficient than prior proposals.

cs.DS↗