An efficient parallel algorithm for the efficient domination problem on distance-hereditary graphs

In this paper, we sketch characteristics of those problems which can be systematically solved on decomposable graphs. Trees, series-parallel graphs, outerplanar graphs, and bandwidth-k graphs all belong to decomposable graphs. Let T d (|V|,|E|) and P d (|V|,|E|) denote the time complexity and processor complexity required to construct a parse tree representation T G for a decomposable G=(V,E) on a PRAM model M d . We define a general problem-solving paradigm to solve a wide class of subgraph optimization problems on decomposable graphs in O(T d (|V|,|E|)+log |V(T G )|) time using O(P d (|V|,|E|)+|V(T G )|/log |V(T G )|) processors on M d . By using our paradigm, we show the following parallel complexities: (a) The maximum independent set problem on trees can be solved in O(log |V|) time using O(|V|/log |V|) processors on an EREW PRAM. (b) The maximum matching problem on series-parallel graphs can be solved in O(log |E|) time using O(|E|/log |E|) processors on an EREW PRAM. (c) The efficient domination problem on series-parallel graphs can be solved in O(log |E|) time using O(|E|/log |E|) processors on an EREW PRAM.

The Hamiltonian problem on distance-hereditary graphs

In this paper, we first present an O(|V| + |E|)-time sequential algorithm to solve the Hamiltonian problem on a distance-hereditary graph G = (V, E). This algorithm is faster than the previous best result which takes O(|V|2) time. Let Td(|V|, |E|) and Pd(|V|, |E|) denote the parallel time and processor complexities, respectively, required to construct a decomposition tree of a distance-hereditary graph on a PRAM model Md. We also show that this problem can be solved in O(Td(|V|, |E|) + log |V|) time using O(Pd(|V|, |E|) + (|V| + |E|)/ log |V|) processors on Md. Moreover, if G is represented by its decomposition tree form, the problem can be solved optimally in O(log |V|) time using O((|V| + |E|)/ log |V|) processors on an EREW PRAM.

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.

Over the years many interesting and efficient parallel algorithms have been developed to solve a wide variety of problems, but not much attention has been paid to studying the inherent parallelism in sequential algorithms---i.e., understanding the depth of their dependence structure, and how shallow dependence structures might beused to develop efficient parallel implementations. In this talk I will describe recent work on analyzing the dependence depth of iterative sequential algorithms---ones that loop over a collection of elements. Many of these algorithms have deep dependence chains in the worst case, but shallow chains (polylog w.h.p.) if the elements are randomly ordered. Examples include many fundamental algorithms: the Knuth shuffle for random permutations, sorting by insertion into a binary search tree, greedy maximal independent set (MIS), greedy maximal matching, greedy graph-coloring, counting cycles in a permutation, incremental k-dimensional linear programming, and incremental 2d Delaunay triangulation. An advantage of the approach is that it can lead to very simple and efficient parallel algorithms. Our MIS algorithm, for example can be coded in a dozen or so lines, and is significantly faster than Luby's algorithm on modern multicore machines. Also the approach encourages snapping the view that sequential and parallel algorithms are distinct, and instead thinking of algorithms, in general, as collections of instructions with dependences among them.

By restricting weight functions to satisfy the quadrangle inequality or the inverse quadrangle inequality, significant progress has been made in developing efficient sequential algorithms for the least-weight subsequence problem [10], [9], [12], [16]. However, not much is known on the improvement of the naive parallel algorithm for the problem, which is fast but demands too many processors (i.e., it takesO(log2 n) time on a CREW PRAM with n3/logn processors). In this paper we show that if the weight function satisfies the inverse quadrangle inequality, the problem can be solved on a CREW PRAM in O(log2 n log logn) time withn/log logn processors, or in O(log2 n) time withn logn processors. Notice that the processor-time complexity of our algorithm is much closer to the almost linear-time complexity of the best-known sequential algorithm [12].

Efficient parallel factorization and solution of structured and unstructured linear systems

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.

Linear rank-width is a linearized variation of rank-width, and it is deeply\nrelated to matroid path-width. In this paper, we show that the linear\nrank-width of every $n$-vertex distance-hereditary graph, equivalently a graph\nof rank-width at most $1$, can be computed in time $\\mathcal{O}(n^2\\cdot \\log_2\nn)$, and a linear layout witnessing the linear rank-width can be computed with\nthe same time complexity. As a corollary, we show that the path-width of every\n$n$-element matroid of branch-width at most $2$ can be computed in time\n$\\mathcal{O}(n^2\\cdot \\log_2 n)$, provided that the matroid is given by an\nindependent set oracle.\n To establish this result, we present a characterization of the linear\nrank-width of distance-hereditary graphs in terms of their canonical split\ndecompositions. This characterization is similar to the known characterization\nof the path-width of forests given by Ellis, Sudborough, and Turner [The vertex\nseparation and search number of a graph. Inf. Comput., 113(1):50--79, 1994].\nHowever, different from forests, it is non-trivial to relate substructures of\nthe canonical split decomposition of a graph with some substructures of the\ngiven graph. We introduce a notion of `limbs' of canonical split\ndecompositions, which correspond to certain vertex-minors of the original\ngraph, for the right characterization.\n

Efficient parallel recognition algorithms of cographs and distance hereditary graphs

We provide efficient parallel algorithms for the minimum separation, offset range, and optimal offset problems for single-layer channel routing. We consider all the variations of these problems that have linear-time sequential solutions rather than limiting attention to the “river-routing” context, where single-sided connections are disallowed. For the minimum separation problem, we obtain O(lg N) time on a CREW PRAM or O(lg N/lg lg N) time on a CRCW PRAM, both with optimal work (processor-time product) of O(N), where N is the number of terminals. For the offset range problem, we obtain the same time and processor bounds as long as only one side of the channel contains single-sided nets. For the optimal offset problem with single-sided nets on one side of the channel, we obtain time O(lg N lg lg N) on a CREW PRAM or O(lg N) time on a CRCW PRAM with O(N lg lg N) work. Not only does this improve on previous results for river routing, but we can obtain an even better time of O((lg lg N)2) on the CRCW PRAM in the river routing context.KeywordsParallel AlgorithmMinimum SeparationChannel BoundaryConvex CornerEfficient Parallel AlgorithmThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Labelling the lines of a planar line drawing of a 3-D object in a way that reflects the geometric properties of the object is a much studied problem in computer vision and considered to be an important step towards understanding the object from its 2-D drawing. Combinatorially, the labellability problem is a restricted version of the Constraint Satisfaction Problem and has been shown to be NP-complete even for images of polyhedral scenes. In this paper, we examine scenes that consist of a set of objects each obtained by rotating a polygon around an arbitrary axis. The objects are allowed to arbitrarily intersect or overlay. We show that for these scenes, there is a sequential linear-time labelling algorithm. Moreover, we show that the algorithm has a fast parallel version that executes in O(log4 n) time on a EREW PRAM with O(n 3/log2 n) processors. The algorithm not only answers the decision problem of labellability, but also produces a legal labelling, if there is one. This parallel algorithm should be contrasted with the techniques of dealing with special cases of the constraint satisfaction problem. These techniques employ an effective, but inherently sequential, relaxation procedure in order to restrict the domains of the variables.

The efficient parallel algorithms proposed for many fundamental problems, such as list ranking, computing preorder numberings on trees and integer sorting, are very sensitive to processor failures. The requirements of efficiency (commonly formalized using {\em Parallel-time x Processors} as a cost measure) has led to the design of highly tuned PRAM algorithms which, given the additional constraint of simple processor failures, unfortunately become inefficient or even incorrect. We propose a new notion of {\em robustness} that combines efficiency with fault tolerance. For the common case of fail-stop errors, we develop a general and easy-to-implement technique to make robust many efficient parallel algorithms, e.g., algorithms for all the problems listed above. More specifically,{\em for any dynamic pattern of fail-stop errors on} a CRCW PRAM {\em with at least one surviving processor}, our method increases the original algorithm''s cost by at most a {\em polylog} multiplicative factor. We also show that at least a {\em log/loglog} multiplicative overhead will be incurred for certain patterns of failures by any algorithm that implements robust solutions to the problems listed.

Laminar structure of ptolemaic graphs with applications

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.