823 research outputs found
An implementation of range trees with fractional cascading in C++
Range trees are multidimensional binary trees which are used to perform
d-dimensional orthogonal range searching. In this technical report we study the
implementation issues of range trees with fractional cascading, named layered
range trees. We also document our implementation of range trees with fractional
cascading in C++ using STL and generic programming techniques.Comment: Technical repor
Efficient Authenticated Data Structures for Graph Connectivity and Geometric Search Problems
Authenticated data structures provide cryptographic proofs that their answers
are as accurate as the author intended, even if the data structure is being
controlled by a remote untrusted host. We present efficient techniques for
authenticating data structures that represent graphs and collections of
geometric objects. We introduce the path hash accumulator, a new primitive
based on cryptographic hashing for efficiently authenticating various
properties of structured data represented as paths, including any decomposable
query over sequences of elements. We show how to employ our primitive to
authenticate queries about properties of paths in graphs and search queries on
multi-catalogs. This allows the design of new, efficient authenticated data
structures for fundamental problems on networks, such as path and connectivity
queries over graphs, and complex queries on two-dimensional geometric objects,
such as intersection and containment queries.Comment: Full version of related paper appearing in CT-RSA 200
GPU LSM: A Dynamic Dictionary Data Structure for the GPU
We develop a dynamic dictionary data structure for the GPU, supporting fast
insertions and deletions, based on the Log Structured Merge tree (LSM). Our
implementation on an NVIDIA K40c GPU has an average update (insertion or
deletion) rate of 225 M elements/s, 13.5x faster than merging items into a
sorted array. The GPU LSM supports the retrieval operations of lookup, count,
and range query operations with an average rate of 75 M, 32 M and 23 M
queries/s respectively. The trade-off for the dynamic updates is that the
sorted array is almost twice as fast on retrievals. We believe that our GPU LSM
is the first dynamic general-purpose dictionary data structure for the GPU.Comment: 11 pages, accepted to appear on the Proceedings of IEEE International
Parallel and Distributed Processing Symposium (IPDPS'18
Odds-On Trees
Let R^d -> A be a query problem over R^d for which there exists a data
structure S that can compute P(q) in O(log n) time for any query point q in
R^d. Let D be a probability measure over R^d representing a distribution of
queries. We describe a data structure called the odds-on tree, of size
O(n^\epsilon) that can be used as a filter that quickly computes P(q) for some
query values q in R^d and relies on S for the remaining queries. With an
odds-on tree, the expected query time for a point drawn according to D is
O(H*+1), where H* is a lower-bound on the expected cost of any linear decision
tree that solves P.
Odds-on trees have a number of applications, including distribution-sensitive
data structures for point location in 2-d, point-in-polytope testing in d
dimensions, ray shooting in simple polygons, ray shooting in polytopes,
nearest-neighbour queries in R^d, point-location in arrangements of hyperplanes
in R^d, and many other geometric searching problems that can be solved in the
linear-decision tree model. A standard lifting technique extends these results
to algebraic decision trees of constant degree. A slightly different version of
odds-on trees yields similar results for orthogonal searching problems that can
be solved in the comparison tree model.Comment: 19 pages, 0 figure
LSM-based Storage Techniques: A Survey
Recently, the Log-Structured Merge-tree (LSM-tree) has been widely adopted
for use in the storage layer of modern NoSQL systems. Because of this, there
have been a large number of research efforts, from both the database community
and the operating systems community, that try to improve various aspects of
LSM-trees. In this paper, we provide a survey of recent research efforts on
LSM-trees so that readers can learn the state-of-the-art in LSM-based storage
techniques. We provide a general taxonomy to classify the literature of
LSM-trees, survey the efforts in detail, and discuss their strengths and
trade-offs. We further survey several representative LSM-based open-source
NoSQL systems and discuss some potential future research directions resulting
from the survey.Comment: This is a pre-print of an article published in VLDB Journal. The
final authenticated version is available online at:
https://doi.org/10.1007/s00778-019-00555-
Biased Range Trees
A data structure, called a biased range tree, is presented that preprocesses
a set S of n points in R^2 and a query distribution D for 2-sided orthogonal
range counting queries. The expected query time for this data structure, when
queries are drawn according to D, matches, to within a constant factor, that of
the optimal decision tree for S and D. The memory and preprocessing
requirements of the data structure are O(n log n)
An Optimal Algorithm for Range Search on Multidimensional Points
This paper proposes an efficient and novel method to address range search on
multidimensional points in time, where is the number of points
reported in space. This is accomplished by introducing a new data
structure, called BITS d-tree. This structure also supports fast updation
that takes time for insertion and time for deletion.
The earlier best known algorithm for this problem is time in
the pointer machine model
Hidden surface removal for rectangles
AbstractA simple but important special case of the hidden surface removal problem is one in which the scene consists of n rectangles with sides parallel to the x- and y-axes, with viewpoint at z=∞ (that is, an orthographic projection). This special case has application to overlapping windows in computer displays. An algorithm with running time O(n log n + k log n) is given for static scenes, where k is the number of line segments in the output. Algorithms are given for a dynamic setting (that is, rectangles may be inserted and deleted) that take time O(log2n log log n + k log2 n) per insert or delete, where k is now the number of visible line segments that change (appear or disappear). Algorithms for point location in the visible scene are also given
Discrepancy-Sensitive Dynamic Fractional Cascading, Dominated Maxima Searching, and 2-d Nearest Neighbors in Any Minkowski Metric
This paper studies a discrepancy-sensitive approach to dynamic fractional
cascading. We provide an efficient data structure for dominated maxima
searching in a dynamic set of points in the plane, which in turn leads to an
efficient dynamic data structure that can answer queries for nearest neighbors
using any Minkowski metric. We provide an efficient data structure for
dominated maxima searching in a dynamic set of points in the plane, which in
turn leads to an efficient dynamic data structure that can answer queries for
nearest neighbors using any Minkowski metric.Comment: Expanded version of a paper that appeared in WADS 200
Stratified B-trees and versioning dictionaries
A classic versioned data structure in storage and computer science is the
copy-on-write (CoW) B-tree -- it underlies many of today's file systems and
databases, including WAFL, ZFS, Btrfs and more. Unfortunately, it doesn't
inherit the B-tree's optimality properties; it has poor space utilization,
cannot offer fast updates, and relies on random IO to scale. Yet, nothing
better has been developed since. We describe the `stratified B-tree', which
beats all known semi-external memory versioned B-trees, including the CoW
B-tree. In particular, it is the first versioned dictionary to achieve optimal
tradeoffs between space, query and update performance
- …