EREW PRAM Model Research Articles

A cost-optimal parallel algorithm for the 0–1 knapsack problem and its performance on multicore CPU and GPU implementations

A parallel algorithm COPA is proposed for the 0-1 knapsack problem.There are no memory conflicts for the proposed algorithm.The proposed algorithm has better scalability.The proposed algorithm can achieve good results on general GPU. The 0-1 knapsack problem has been extensively studied in the past years due to its immediate applications in industry and financial management, such as cargo loading, stock cutting, and budget control. Many algorithms have been proposed to solve this problem, most of which are heuristic, as the problem is well-known to be NP-hard. Only a few optimal algorithms have been designed to solve this problem but with high time complexity. This paper proposes the cost-optimal parallel algorithm (COPA) on an EREW PRAM model with shared memory to solve this problem. COPA is scalable and yields optimal solutions consuming less computational time. Furthermore, this paper implements COPA on two scenarios - multicore CPU based architectures using Open MP and GPU based configurations using CUDA. A series of experiments are conducted to examine the performance of COPA under two different test platforms. The experimental results show that COPA could reduce a significant amount of execution time. Our approach achieves the speedups of up to 10.26 on multicore CPU implementations and 17.53 on GPU implementations when the sequential dynamic programming algorithm for KP01 is considered as a baseline. Importantly, GPU implementations outstand themselves in the experimental results.

AN EFFICIENT NC ALGORITHM FOR APPROXIMATE MAXIMUM WEIGHT MATCHING

We present an alternative implementation of the (1 – ϵ) factor NC approximation algorithm for the maximum weight matching by Hougardy et al. [1]. Our implementation, on the EREW PRAM model of computation, achieves an [Formula: see text] factor improvement on both the execution time and the number of processors.

Optimal Algorithms for Finding a Trunk on a Tree Network and its Applications

Given an edge-weighted tree T, a trunk is a path P in T which minimizes the sum of the distances of all vertices in T from P plus the weight of path P. In this paper, we give efficient algorithms for finding a trunk of T. The first algorithm is a sequential algorithm which runs in O(n) time, where n is the number of vertices in T. The second algorithm is a parallel algorithm which runs in O(log n) time using O(n/log n) processors on the EREW PRAM model. We present an application of trunk on mobile ad hoc networks for efficient multicasting.

Optimal parallel selection

We present an optimal parallel selection algorithm on the EREW PRAM. This algorithm runs in O (log n ) time with n /log n processors. This complexity matches the known lower bound for parallel selection on the EREW PRAM model. We therefore close this problem which has been open for more than a decade.

Fast and scalable computations of 2D image moments

Image moments are used in image analysis for object modelling and matching. The moment computation of a two-dimensional (2D) image involves a significant amount of multiplication and addition in a direct method. In this paper, we use the suffix sum functions to compute the gray-level image moments instead of using a direct method. This new method can reduce drastically the number of multiplications required. We first derive the mathematical relationships between moment computations and suffix sums. Based on the derived mathematical relationships, four new parallel algorithms for computing image moments are derived on various computational models. By integrating the advantages of both optical transmission and electronic computation, the 2D image moments can be computed in constant time on a 2D array with reconfigurable optical buses. The performance comparison shows that the proposed method is fast and efficient. In addition, three scalable and cost optimal algorithms are derived on the AROB, the hypercube computer and the EREW PRAM model.

On coding labeled trees

We consider the problem of coding labeled trees by means of strings of node labels. Different codes have been introduced in the literature by Prüfer, Neville, and Deo and Micikevičius. For all of them, we show that both coding and decoding can be reduced to integer (radix) sorting, closing several open problems within a unified framework that can be applied both in a sequential and in a parallel setting. Our sequential coding and decoding schemes require optimal O ( n ) time when applied to n -node trees, yielding the first linear time decoding algorithm for a code presented by Neville. These schemes can be parallelized on the EREW PRAM model, so as to work in O ( log n ) time with cost O ( n ) , O ( n log n ) , or O ( n log n ) , depending on the code and on the operation: in all cases, they either match or improve the performances of the best ad hoc approaches known so far.

Linear work suffix array construction

Suffix trees and suffix arrays are widely used and largely interchangeable index structures on strings and sequences. Practitioners prefer suffix arrays due to their simplicity and space efficiency while theoreticians use suffix trees due to linear-time construction algorithms and more explicit structure. We narrow this gap between theory and practice with a simple linear-time construction algorithm for suffix arrays. The simplicity is demonstrated with a C++ implementation of 50 effective lines of code. The algorithm is called DC3, which stems from the central underlying concept of difference cover . This view leads to a generalized algorithm, DC, that allows a space-efficient implementation and, moreover, supports the choice of a space--time tradeoff. For any v ∈ [1, √n ], it runs in O( vn ) time using O( n / √v ) space in addition to the input string and the suffix array. We also present variants of the algorithm for several parallel and hierarchical memory models of computation. The algorithms for BSP and EREW-PRAM models are asymptotically faster than all previous suffix tree or array construction algorithms.

An optimal parallel solution for the path cover problem on [formula omitted]-sparse graphs

Nakano et al. [A time-optimal solution for the path cover problem on cographs, Theoret. Comput. Science 290 (2003) 1541–1556] presented a time- and work-optimal algorithm for finding the smallest number of vertex-disjoint paths that cover the vertices of a cograph and left open the problem of applying their technique into other classes of graphs. Motivated by this issue we generalize their technique and apply it to the class of P 4 -sparse graphs, which forms a proper superclass of cographs. We show that the path cover problem on P 4 -sparse graphs can also be optimally solved. More precisely, given a P 4 -sparse graph G on n vertices and its modular decomposition tree, we describe an optimal parallel algorithm which returns a minimum path cover of G in O ( log n ) time using O ( n / log n ) processors on the EREW PRAM model. Our results generalize previous results and extend the family of perfect graphs admitting optimal solutions for the path cover problem.

Formula omitted] query time algorithm for all pairs shortest distances on permutation graphs

We present an algorithm for the all pairs shortest distance problem on permutation graphs. Given a permutation model for the graph on n vertices, after O ( n ) preprocessing the algorithm will deliver answers to distance queries in O ( 1 ) time. In the EREW PRAM model, preprocessing can be accomplished in O ( log n ) time with O ( n ) work. Where the distance between query vertices is k, a path can be delivered in O ( k ) time. The method is based on reduction to bipartite permutation graphs, a further reduction to unit interval graphs, and a coordinatization of unit interval graphs.

Efficient parallel recognition of cographs

In this paper, we establish structural properties for the class of complement reducible graphs or cographs, which enable us to describe efficient parallel algorithms for recognizing cographs and for constructing the cotree of a graph if it is a cograph; if the input graph is not a cograph, both algorithms return an induced P 4 . For a graph on n vertices and m edges, both our cograph recognition and cotree construction algorithms run in O ( log 2 n ) time and require O ( ( n + m ) / log n ) processors on the EREW PRAM model of computation. Our algorithms are motivated by the work of Dahlhaus (Discrete Appl. Math. 57 (1995) 29–44) and take advantage of the optimal O ( log n ) -time computation of the co-connected components of a general graph (Theory Comput. Systems 37 (2004) 527–546) and of an optimal O ( log n ) -time parallel algorithm for computing the connected components of a cograph, which we present. Our results improve upon the previously known linear-processor parallel algorithms for the problems (Discrete Appl. Math. 57 (1995) 29–44; J. Algorithms 15 (1993) 284–313): we achieve a better time-processor product using a weaker model of computation and we provide a certificate (an induced P 4 ) whenever our algorithms decide that the input graphs are not cographs.

An optimal parallel algorithm for solving all-pairs shortest paths problem on circular-arc graphs

The shortest-paths problem is a fundamental problem in graph theory and finds diverse applications in various fields. This is why shortest path algorithms have been designed more thoroughly than any other algorithm in graph theory. A large number of optimization problems are mathematically equivalent to the problem of finding shortest paths in a graph. The shortest-path between a pair of vertices is defined as the path with shortest length between the pair of vertices. The shortest path from one vertex to another often gives the best way to route a message between the vertices. This paper presents anO(n2) time sequential algorithm and anO(n2/p+logn) time parallel algorithm on EREW PRAM model for solving all pairs shortest paths problem on circular-arc graphs, wherep andn represent respectively the number of processors and the number of vertices of the circular-arc graph.

An optimal parallel algorithm for c-vertex-ranking of trees

For a positive integer c, a c-vertex-ranking of a graph G = ( V , E ) is a labeling of the vertices of G with integers such that, for any label i, deletion of all vertices with labels > i leaves connected components, each having at most c vertices with label i. The c-vertex-ranking problem is to find a c-vertex-ranking of a given graph using the minimum number of ranks. In this paper we give an optimal parallel algorithm for solving the c-vertex-ranking problem on trees in O ( log 2 n ) time using linear number of operations on the EREW PRAM model.

Parallel Algorithms for Recognizing P5-free and ${\bar P}_5$-free Weakly Chordal Graphs

We prove algorithmic characterizations of weakly chordal graphs, which lead to efficient parallel algorithms for recognizing P5-free and [Formula: see text]-free weakly chordal graphs. For an input graph on n vertices and m edges, our algorithms run in O( log 2n) time and require O(m2/ log n) processors on the EREW PRAM model of computation. The proposed recognition algorithms efficiently detect P5 s and [Formula: see text] in weakly chordal graphs in O( log n) time with O(m2/ log n) processors on the EREW PRAM. Additionally, we show how the algorithms can be augmented to provide a certificate for the existence of a P5 (or a [Formula: see text]) in case the input graph is not P5-free (respectively, [Formula: see text]-free) weakly chordal.

An Optimal Parallel Co-Connectivity Algorithm

In this paper we consider the problem of computing the connected components of the complement of a given graph. We describe a simple sequential algorithm for this problem, which works on the input graph and not on its complement, and which for a graph on n vertices and m edges runs in optimal O(n+m) time. Moreover, unlike previous linear co-connectivity algorithms, this algorithm admits efficient parallelization, leading to an optimal O(log n)-time and O((n+m)log n)-processor algorithm on the EREW PRAM model of computation. It is worth noting that, for the related problem of computing the connected components of a graph, no optimal deterministic parallel algorithm is currently available. The co-connectivity algorithms find applications in a number of problems. In fact, we also include a parallel recognition algorithm for weakly triangulated graphs, which takes advantage of the parallel co-connectivity algorithm and achieves an O(log2 n) time complexity using O((n+m2) log n) processors on the EREW PRAM model of computation.

Optimal Sequential and Parallel Algorithms to Compute All Cut Vertices on Trapezoid Graphs

In this paper, a sequential algorithm is presented to find all cut-vertices on trapezoid graphs. To every trapezoid graph G there is a corresponding trapezoid representation. If all the 4n corner points of n trapezoids, in a trapezoid representation of a trapezoid graph G with n vertices, are given, then the proposed sequential algorithm runs in O(n) time. Parallel implementation of this algorithm can be done in O(log n) time using O(n/ log n) processors on an EREW PRAM model.

Optimal Sequential And Parallel Algorithms To Compute A Steiner Tree On Permutation Graphs

This paper presents an optimal sequential and an optimal parallel algorithm to compute a minimum cardinality Steiner set and a Steiner tree. The sequential algorithm takes O ( n ) time and parallel algorithm takes O (log n ) time and O ( n /log n ) processors on an EREW PRAM model.

Parallel computation of the euclidean distance transform on a three-dimensional image array

In a two- or three-dimensional image array, the computation of Euclidean distance transform (EDT) is an important task. With the increasing application of 3D voxel images, it is useful to consider the distance transform of a 3D digital image array. Because the EDT computation is a global operation, it is prohibitively time consuming when performing the EDT for image processing. In order to provide the efficient transform computations, parallelism is employed. We first derive several important geometry relations and properties among parallel planes. We then, develop a parallel algorithm for the three-dimensional Euclidean distance transform (3D-EDT) on the EREW PRAM computation model. The time complexity of our parallel algorithm is O(log/sup 2/ N) for an N/spl times/N/spl times/N image array and this is currently the best known result. A generalized parallel algorithm for the 3D-EDT is also proposed. We implement the proposed algorithms sequentially, the performance of which exceeds the existing algorithms (proposed by Yamada, 1984). Finally, we develop the corresponding parallel programs on both the emulated EREW PRAM model computer and the IBM SP2 to verify the speed-up properties of the proposed algorithms.

ON COST-OPTIMAL MERGE OF TWO INTRANSITIVE SORTED SEQUENCES

The problem of merging two intransitive sorted sequences (that is, to generate a sorted total order without the transitive property) is considered. A cost-optimal parallel merging algorithm is proposed under the EREW PRAM model. This algorithm has a run time of O( log 2 n) using O(n/ log 2 n) processors. The cost-optimal merge in the strong sense is still an open problem.

ON FINDING A HAMILTONIAN PATH IN A TOURNAMENT USING SEMI-HEAP

The problem of sorting an intransitive total ordered set, a generalization of regular sorting, is considered. This generalized sorting is based on the fact that there exists a special linear ordering (also called a generalized sorted sequence) for any intransitive total ordered set, or equivalently, the existence of a Hamiltonian path in a tournament. A new data structure called semi-heap is proposed to construct an optimal Θ(n log n) sorting algorithm. We also provide a cost-optimal parallel algorithm using semi-heap. The run time of this algorithm is Θ(n) with Θ( log n) processors under the EREW PRAM model. The use of a Hamiltonian path (generalized sorting sequence) as an approximation of a ranking system in a tournament is also discussed.

Parallel Algorithms for Partitioning Sorted Sets and Related Problems

We consider the following partition problem: Given a set S of n elements that is organized as k sorted subsets of size n/k each and given a parameter h with 1/k ≤ h ≤ n/k , partition S into g = O(n/(hk)) subsets D 1 , D 2 , . . . , D g of size Θ(hk) each, such that, for any two indices i and j with 1 ≤ i < j ≤ g , no element in D i is bigger than any element in D j . Note that with various combinations of the values of parameters h and k , several fundamental problems, such as merging, sorting, and finding an approximate median, can be formulated as or be reduced to this partition problem. The partition problem also finds many applications in solving problems of parallel computing and computational geometry. In this paper we present efficient parallel algorithms for solving the partition problem and a number of its applications. Our parallel partition algorithm runs in O( log n) time using $$ O\left(\frac{\min\{(n/h)*\max\{\log h,1\}, n*\max\{\log(1/h),1\}\}}{\log n}\right) $$ processors in the EREW PRAM model. The complexity bounds of our parallel partition algorithm on the respective special cases match those of the optimal EREW PRAM algorithms for merging, sorting, and finding an approximate median. Using our parallel partition algorithm, we are also able to obtain better complexity bounds (even possibly on a weaker parallel model) than the previously best known parallel algorithms for several important problems, including parallel multiselection, parallel multiranking, and parallel sorting of k sorted subsets.