[Paper Review] Parallel Range, Segment and Rectangle Queries with Augmented Maps

Yihan Sun, Guy E. Blelloch|arXiv (Cornell University)|Mar 23, 2018

Computational Geometry and Mesh Generation4 citations

TL;DR

This paper presents a simple, theoretically efficient, and highly parallelizable framework for 2D range, segment, and rectangle queries using augmented maps. By modeling problems as two-level augmented maps with either multi-level trees or sweepline-based prefix structures, the authors achieve work-efficient construction (O(n log n)) and polylogarithmic parallel depth, with query times nearly linear in output size. Their implementations outperform CGAL and Boost libraries by up to 1400× in query speed and achieve 68× parallel speedup on 72-core systems.

ABSTRACT

The range, segment and rectangle query problems are fundamental problems in computational geometry, and have extensive applications in many domains. Despite the significant theoretical work on these problems, efficient implementations can be complicated. We know of very few practical implementations of the algorithms in parallel, and most implementations do not have tight theoretical bounds. We focus on simple and efficient parallel algorithms and implementations for these queries, which have tight worst-case bound in theory and good parallel performance in practice. We propose to use a simple framework (the augmented map) to model the problem. Based on the augmented map interface, we develop both multi-level tree structures and sweepline algorithms supporting range, segment and rectangle queries in two dimensions. For the sweepline algorithms, we propose a parallel paradigm and show corresponding cost bounds. All of our data structures are work-efficient to build in theory and achieve a low parallel depth. The query time is almost linear to the output size. We have implemented all the data structures described in the paper using a parallel augmented map library. Based on the library each data structure only requires about 100 lines of C++ code. We test their performance on large data sets (up to $10^8$ elements) and a machine with 72-cores (144 hyperthreads). The parallel construction achieves 32-68x speedup. Speedup numbers on queries are up to 126-fold. Our sequential implementation outperforms the CGAL library by at least 2x in both construction and queries. Our sequential implementation can be slightly slower than the R-tree in the Boost library in some cases (0.6-2.5x), but has significantly better query performance (1.6-1400x) than Boost.

Motivation & Objective

• To develop theoretically efficient and practical parallel algorithms for 2D range, segment, and rectangle queries with tight theoretical bounds.
• To simplify implementation of complex geometric data structures using a unified augmented map abstraction.
• To achieve high parallel performance with low overhead, enabling fast construction and query processing on large-scale datasets.
• To outperform existing libraries like CGAL and Boost in both sequential and parallel performance while maintaining theoretical guarantees.

Proposed method

• Modeling range, segment, and rectangle queries as two-level augmented map structures: an outer map with augmented values and an inner map implemented via augmented trees.
• Using the parallel augmented map (PAM) library as a foundation, enabling polylogarithmic parallel depth and optimal sequential work for construction.
• Introducing prefix structures as an alternative to augmented trees for the outer map, enabling efficient sweepline algorithms with O(n^ε) depth under certain conditions.
• Designing parallel paradigms for constructing prefix structures, with theoretical cost bounds when input functions satisfy specific properties.
• Implementing all data structures using only ~100 lines of C++ code per structure on top of the PAM library, ensuring engineering simplicity.
• Leveraging the augmented map abstraction to support list-all, counting, and weighted sum queries uniformly across all problem types.

Experimental results

Research questions

• RQ1 Can a unified augmented map abstraction simplify the implementation of complex geometric data structures while maintaining theoretical efficiency?
• RQ2 How do multi-level tree-based and sweepline-based algorithms compare in terms of construction and query performance under parallel execution?
• RQ3 To what extent can the augmented map framework achieve both theoretical guarantees and practical high performance on large-scale geometric queries?
• RQ4 How does the performance of the proposed implementations compare to established libraries like CGAL and Boost in both sequential and parallel settings?
• RQ5 What is the impact of output size on query performance, and how do theoretical bounds translate to real-world scalability?

Key findings

• The parallel construction of the data structures achieves up to 68× speedup on a 72-core system with 144 hyperthreads, demonstrating strong scalability.
• Query performance achieves up to 126× speedup in parallel, with the best-performing implementations (e.g., RecSwp) being up to 1400× faster than Boost R-tree on small query windows.
• Sequential implementations outperform CGAL by at least 2× in both construction and query time, and are competitive with or faster than Boost R-tree in most cases.
• Sweepline-based algorithms (e.g., RecSwp, SegSwp) show superior performance on small-window queries and counting queries due to better theoretical bounds, while two-level trees excel on large-window queries due to better data locality.
• The implementation of each data structure requires only about 100 lines of C++ code on top of the PAM library, highlighting the framework’s simplicity and maintainability.
• Theoretical bounds are within a log n factor of optimal in work, and all constructions are work-efficient (O(n log n)) with polylogarithmic parallel depth for tree-based structures and O(n^ε) for sweepline algorithms.