Planarity testing in parallel

The authors provide optimal parallel solutions to several fundamental link distance problems set in trapezoided rectilinear polygons. All parallel algorithms are deterministic, run in logarithmic time, have an optimal time-processor product and are designed to run on EREW PRAM. The authors develop techniques (e.g. rectilinear window partition) for solving link distance problems in parallel which are expected to find applications in the design of other parallel computational geometry algorithms. They employ these parallel techniques for example to compute the link diameter, link center, and central diagonal of a rectilinear polygon. Their results also imply an optimal linear-time sequential algorithm for constructing a data structure to support rectilinear link distance queries between points.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Parallel recognition algorithms for chordal_planar graphs and planar [formula omitted]-trees

The process of merging two arbitrary partitions of a given finite set 𝒰 of n elements is known as coarsest refinement. In the COARSEST REFINEMENT PROBLEM we are given two arbitrary partitions 𝒳, 𝒴 of the set 𝒰 such that 𝒳 = {𝒳1, 𝒳2, ..., 𝒳 x} and 𝒴 = {𝒴1, 𝒴2, ..., 𝒴 y}, and determine a new partition 𝒵 = {𝒵1, 𝒵2, ..., 𝒵 z} such that each is a common non-empty subset of some 𝒳 a ∈ 𝒳 and some 𝒴 b ∈ 𝒴 and |𝒵| is as small as possible. This article describes a resource-efficient parallel algorithm to solve this problem. More specifically, we show that a coarsest refinement can be computed in O( t( n) + log n) parallel time using max{nlogn,p(n)} processors, where t( n) denotes the running time of a parallel stable sorting algorithm that uses p( n) processors on an EREW PRAM. This result depends on t( n) and p( n). We give a table that shows the best known time and processor complexities for a parallel stable sorting algorithm. If the parallel stable sorting algorithms by Ajtai et al., Cole, and Leighton are used, the coarsest refinement can be computed in O(log n) parallel time using n processors on an EREW PRAM. On the other hand, if the parallel stable sorting algorithm by Bahig et al. is used, the coarsest refinement can be computed in O(lognlog(nlogn)) parallel time using nlogn processors on an EREW PRAM. In addition, we show that on, a RAM machine, our parallel algorithm runs as asymptotically efficient as the fastest known sequential algorithm.

We consider parallel algorithms working in sequential global time, for example, circuits or parallel random access machines (PRAMs). Parallel abstract state machines (parallel ASMs) are such parallel algorithms, and the parallel ASM thesis asserts that every parallel algorithm is behaviorally equivalent to a parallel ASM. In an earlier article, we axiomatized parallel algorithms, proved the ASM thesis, and proved that every parallel ASM satisfies the axioms. It turned out that we were too timid in formulating the axioms; they did not allow a parallel algorithm to create components on the fly. This restriction did not hinder us from proving that the usual parallel models, like circuits or PRAMs or even alternating Turing machines, satisfy the postulates. But it resulted in an error in our attempt to prove that parallel ASMs always satisfy the postulates. To correct the error, we liberalize our axioms and allow on-the-fly creation of new parallel components. We believe that the improved axioms accurately express what parallel algorithms ought to be. We prove the parallel thesis for the new, corrected notion of parallel algorithms, and we check that parallel ASMs satisfy the new axioms.

The fastest deterministic algorithms for connected components take logarithmic time and perform superlinear work on a Parallel Random Access Machine (PRAM). These algorithms maintain a spanning forest by merging and compressing trees, which requires pointer-chasing operations that increase memory access latency and are limited to shared-memory systems. Many of these PRAM algorithms are also very complicated to implement. Another popular method is “leader-contraction” where the challenge is to select a constant fraction of leaders that are adjacent to a constant fraction of non-leaders with high probability, but this can require adding more edges than were in the original graph. Instead we investigate label propagation because it is deterministic, easy to implement, and does not rely on pointer-chasing. Label propagation exchanges representative labels within a component using simple graph traversal, but it is inherently difficult to complete in a sublinear number of steps. We are able to overcome the problems with label propagation for graph connectivity. We introduce a surprisingly simple framework for deterministic, undirected graph connectivity using label propagation that is easily adaptable to many computational models. It achieves logarithmic convergence independently of the number of processors and without increasing the edge count. We employ a novel method of propagating directed edges in alternating direction while performing minimum reduction on vertex labels. We present new algorithms in PRAM, Stream, and MapReduce. Given a simple, undirected graph [Formula: see text] with [Formula: see text] vertices, [Formula: see text] edges, our approach takes O(m) work each step, but we can only prove logarithmic convergence on a path graph. It was conjectured by Liu and Tarjan (2019) to take [Formula: see text] steps or possibly [Formula: see text] steps. Our experiments on a range of difficult graphs also suggest logarithmic convergence. We leave the proof of convergence as an open problem.

Sorting strings and constructing digital search trees in parallel

In this paper, the problem of A-order of binary tree is studied with the PRAM(Parallel Random Access Machine) model of parallel computation and a parallel algorithm for A-order of binary tree is proposed. The process of the parallel algorithm is proceed with detailed description and verified analysis with an application instance. The parallel algorithm of A-order of binary tree provides using and reference for applying it to binary tree traverse sequence and solving the parallelism problem of application program.

A parallel algorithm to find k, 2/spl les/k/spl les/n/sup n-2/, spanning trees from a connected, weighted and undirected graph C(V, E, W) in the order of increasing weight is presented. It runs in O(T(n)+klogn) time with O(n/sup 2//log n) processors on a CREW PRAM, where n=|V|, m=|E| and T(n), O(log n)/spl les/T(n)/spl les/O(log/sup 2/ n), is the time of the fastest parallel algorithms to find a minimum spanning tree of G on a CREW PRAM with no more than O(n/sup 2//log n) processors. Since T(n)=O(log/sup 2/ n) for the time being, this result shows that to find k minimum spanning trees can be done in the same time bound as to find just one when k/spl les/O(log n) on a CREW PRAM.

While sliding window (LZ1) compression can be parallelized efficiently, the LZ2 compression method seems hardly parallelizable since some related heuristics are known to be P-complete. In spite of such negative result, there are parallel decoders which run in O(log/sup 2/ n) time with O(n/log n) processors on the PRAM EREW where n is the length of the output string, as for LZ1 decompression. We show a faster parallel decoding algorithm which runs on the PRAM EREW in O(log n) time with O(n) processors for text compressed by a standard implementation of the LZ2 algorithm (next character heuristic). We observe that LZ1 parallel decoders also can have such speed up. Moreover, we address a different implementation of LZ2 compression called identity heuristic. In this case, decoding on the PRAM EREW takes O(log n log log n) time with O(n/log n) processors with the realistic assumption that the length of the dictionary elements is logarithmic.

On Efficient Parallel Algorithms for Solving Set Recurrence Equations

We describe a new technique for contracting planar graphs which generalizes the tree contraction technique introduced by Miller and Reif. Our algorithm contracts a given planar graph in O(log n) rounds to one with a constant number of vertices. We use this technique to give an efficient NC solution to the following problem. It is known that a planar graph with n≥ 3 vertices has a straight-line embedding on an n−2 by n−2 grid. We show that such an embedding is computable in O(log2n log*n) time using O(n) processors on a CREW PRAM.

The authors propose a novel framework for designing efficient parallel algorithms on series parallel graphs. Recently, a novel approach for recognizing series parallel graphs was presented by D. Eppstein. Eppstein explored characterizations of the ear decomposition of series parallel graphs, which can be identified efficiently, in parallel. The authors extend Eppstein's results and show in a unified manner how to solve problems on series parallel graphs efficiently, in parallel, by finding a special ear decomposition of the graph. They demonstrate the utility of their novel framework by presenting O(log n) concurrent read exclusive write (CREW) parallel random access machine (PRAM) algorithms for the construction of a depth-first spanning tree, st-numbering, and a breadth-first spanning tree on series parallel graphs. >

Summary form only given. The parallel complexity of LZ compression and decompression has been studied. Parallel algorithms have been designed for LZ1 compression and decompression. LZ2 compression is hardly parallelizable, since it is P-complete. A nearly work-optimal parallel decoding algorithm was shown which run on the PRAM EREW in O(log n) time with O(n/(log n)/sup 1/2 /) processors for text compressed with LZ1 and LZ2 methods. Pseudo work-optimal PRAM EREW decoders for finite window compression and LZ2 compression requiring logarithmic time with O(dn) work are presented. Finally, the PRAM EREW decoders requiring logarithmic time and O(n/log n) processors were observed that are possible with the non-conservative assumption. The algorithms employed the Euler tour technique and parallel integer sorting.

Algorithms for finding and updating minimum-depth spanning trees in parallel

The ability of the strongest parallel random access machine model WRAM is investigated. In this model different processors may simultaneously try to write into the same cell of the common memory. It has been shown that a parallel RAM without this option (PRAM), even with arbitrarily many processors, can almost never achieve sublogarithmic time. On the contrary, every function with a small domain like binary values in case of Boolean functions can be computed by a WRAM in constant time. The machine makes fast table look-ups using its simultaneous write ability. The main result of this paper implies that in general this is the “only way” to perform such fast computations and that a domain of small size is necessary. Otherwise simultaneous writes do not give an advantage. Functions with large domains for which any change of one of the n arguments also changes the result are considered, and a logarithmic lower time bound for WRAMs is proved. This bound can be achieved by machines that do not perform simultaneous writes. A simple example of such a function is the sum of n natural numbers.