26,323 research outputs found
Implicit Decomposition for Write-Efficient Connectivity Algorithms
The future of main memory appears to lie in the direction of new technologies
that provide strong capacity-to-performance ratios, but have write operations
that are much more expensive than reads in terms of latency, bandwidth, and
energy. Motivated by this trend, we propose sequential and parallel algorithms
to solve graph connectivity problems using significantly fewer writes than
conventional algorithms. Our primary algorithmic tool is the construction of an
-sized "implicit decomposition" of a bounded-degree graph on
nodes, which combined with read-only access to enables fast answers to
connectivity and biconnectivity queries on . The construction breaks the
linear-write "barrier", resulting in costs that are asymptotically lower than
conventional algorithms while adding only a modest cost to querying time. For
general non-sparse graphs on edges, we also provide the first writes
and operations parallel algorithms for connectivity and biconnectivity.
These algorithms provide insight into how applications can efficiently process
computations on large graphs in systems with read-write asymmetry
Connected component identification and cluster update on GPU
Cluster identification tasks occur in a multitude of contexts in physics and
engineering such as, for instance, cluster algorithms for simulating spin
models, percolation simulations, segmentation problems in image processing, or
network analysis. While it has been shown that graphics processing units (GPUs)
can result in speedups of two to three orders of magnitude as compared to
serial codes on CPUs for the case of local and thus naturally parallelized
problems such as single-spin flip update simulations of spin models, the
situation is considerably more complicated for the non-local problem of cluster
or connected component identification. I discuss the suitability of different
approaches of parallelization of cluster labeling and cluster update algorithms
for calculations on GPU and compare to the performance of serial
implementations.Comment: 15 pages, 14 figures, one table, submitted to PR
How to Extract the Geometry and Topology from Very Large 3D Segmentations
Segmentation is often an essential intermediate step in image analysis. A
volume segmentation characterizes the underlying volume image in terms of
geometric information--segments, faces between segments, curves in which
several faces meet--as well as a topology on these objects. Existing algorithms
encode this information in designated data structures, but require that these
data structures fit entirely in Random Access Memory (RAM). Today, 3D images
with several billion voxels are acquired, e.g. in structural neurobiology.
Since these large volumes can no longer be processed with existing methods, we
present a new algorithm which performs geometry and topology extraction with a
runtime linear in the number of voxels and log-linear in the number of faces
and curves. The parallelizable algorithm proceeds in a block-wise fashion and
constructs a consistent representation of the entire volume image on the hard
drive, making the structure of very large volume segmentations accessible to
image analysis. The parallelized C++ source code, free command line tools and
MATLAB mex files are avilable from
http://hci.iwr.uni-heidelberg.de/software.phpComment: C++ source code, free command line tools and MATLAB mex files are
avilable from http://hci.iwr.uni-heidelberg.de/software.ph
OBDD-Based Representation of Interval Graphs
A graph can be described by the characteristic function of the
edge set which maps a pair of binary encoded nodes to 1 iff the nodes
are adjacent. Using \emph{Ordered Binary Decision Diagrams} (OBDDs) to store
can lead to a (hopefully) compact representation. Given the OBDD as an
input, symbolic/implicit OBDD-based graph algorithms can solve optimization
problems by mainly using functional operations, e.g. quantification or binary
synthesis. While the OBDD representation size can not be small in general, it
can be provable small for special graph classes and then also lead to fast
algorithms. In this paper, we show that the OBDD size of unit interval graphs
is and the OBDD size of interval graphs is $O(\
| V \ | \log \ | V \ |)\Omega(\ | V \ | \log
\ | V \ |)O(\log \ | V \ |)O(\log^2 \ | V \ |)$ operations and
evaluate the algorithms empirically.Comment: 29 pages, accepted for 39th International Workshop on Graph-Theoretic
Concepts 201
An Algorithmic Framework for Labeling Road Maps
Given an unlabeled road map, we consider, from an algorithmic perspective,
the cartographic problem to place non-overlapping road labels embedded in their
roads. We first decompose the road network into logically coherent road
sections, e.g., parts of roads between two junctions. Based on this
decomposition, we present and implement a new and versatile framework for
placing labels in road maps such that the number of labeled road sections is
maximized. In an experimental evaluation with road maps of 11 major cities we
show that our proposed labeling algorithm is both fast in practice and that it
reaches near-optimal solution quality, where optimal solutions are obtained by
mixed-integer linear programming. In comparison to the standard OpenStreetMap
renderer Mapnik, our algorithm labels 31% more road sections in average.Comment: extended version of a paper to appear at GIScience 201
Fast Computation of Small Cuts via Cycle Space Sampling
We describe a new sampling-based method to determine cuts in an undirected
graph. For a graph (V, E), its cycle space is the family of all subsets of E
that have even degree at each vertex. We prove that with high probability,
sampling the cycle space identifies the cuts of a graph. This leads to simple
new linear-time sequential algorithms for finding all cut edges and cut pairs
(a set of 2 edges that form a cut) of a graph.
In the model of distributed computing in a graph G=(V, E) with O(log V)-bit
messages, our approach yields faster algorithms for several problems. The
diameter of G is denoted by Diam, and the maximum degree by Delta. We obtain
simple O(Diam)-time distributed algorithms to find all cut edges,
2-edge-connected components, and cut pairs, matching or improving upon previous
time bounds. Under natural conditions these new algorithms are universally
optimal --- i.e. a Omega(Diam)-time lower bound holds on every graph. We obtain
a O(Diam+Delta/log V)-time distributed algorithm for finding cut vertices; this
is faster than the best previous algorithm when Delta, Diam = O(sqrt(V)). A
simple extension of our work yields the first distributed algorithm with
sub-linear time for 3-edge-connected components. The basic distributed
algorithms are Monte Carlo, but they can be made Las Vegas without increasing
the asymptotic complexity.
In the model of parallel computing on the EREW PRAM our approach yields a
simple algorithm with optimal time complexity O(log V) for finding cut pairs
and 3-edge-connected components.Comment: Previous version appeared in Proc. 35th ICALP, pages 145--160, 200
- …