Cost-optimal Parallel Algorithm 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.

Efficient algorithms for two generalized 2-median problems and the group median problem on trees

The p -median problem on a tree T is to find a set S of p vertices on T that minimizes the sum of distances from T ’s vertices to S . In this paper, we study two generalizations of the 2-median problem, which are obtained by imposing constraints on the two vertices selected as a 2-median: one is to limit their distance while the other is to limit their eccentricity. Previously, both the best upper bounds of these two generalizations were O ( n 2 ) [A. Tamir, D. Perez-Brito, J.A. Moreno-Perez, A polynomial algorithm for the p -centdian problem on a tree, Networks 32 (1998) 255–262; B.-F. Wang, S.-C. Ku, K.-H. Shi, Cost-optimal parallel algorithms for the tree bisector problem and applications, IEEE Transactions on Parallel and Distributed Systems 12 (9) (2001) 888–898]. In this paper, we solve both in O ( n log n ) time. We also study cases when linear time algorithms exist for the two generalizations. For example, we solve both in linear time when edge lengths and vertex weights are all polynomially bounded integers. Furthermore, we consider the relaxation of the two generalized problems by allowing 2-medians on any position of edges, instead of just on vertices, and we give O ( n log n ) -time algorithms for them. A problem, named the tree marker problem, arises several times in our approaches to the two generalized 2-median problems, and we give an O ( n log n ) -time algorithm for this problem. We also use this algorithm to speedup an algorithm of Gupta and Punnen [S.K. Gupta, A.P. Punnen, Group center and group median of a tree, European Journal of Operational Research 65 (1993) 400–406] for the group median problem, improving the running time from O ( k n ) to O ( n + k log n ) , where k is the number of groups in the input.

Parallel Generation of t-Ary Trees in A-order

We present a cost-optimal and adaptive parallel algorithm for generating t-ary trees in A-order. The generation is based on an encoding using integer sequences (z-sequences) due to Zaks [(1980), Lexicographic generation of ordered tree. Theor. Comput. Sci., 10, 63–82]. Our algorithm is the first introduced parallel generation algorithm, which generates t-ary trees in A-order in the literature. The used computational model is CREW SM SIMD multi-processors. This algorithm is designed based on a novel sequential generation algorithm that is also discussed. Ranking and unranking algorithms for z-sequences are also presented.

Parallel generation of í-ary trees with ballot-sequences

We present an adaptive and cost-optimal parallel algorithm for generating t-ary trees represented by extended Ballot-sequences. This algorithm is a parallel version of a sequential generation algorithm that we discuss it first. Our parallel algorithm generates t-ary trees in B-order and can be executed on an EREW SM SIMD model.

A Cost Optimal Parallel Algorithm for Patience Sorting

In this paper, we consider a parallel algorithm for the patience sorting. The problem is not known to be in the class NC or P-complete. We propose two algorithms for the patience sorting of n distinct integers. The first algorithm runs in [Formula: see text] time using p processors on the EREW PRAM, where m is the number of decreasing subsequences in a solution of the patience sorting. The second algorithm runs in [Formula: see text] time using p processors on the EREW PRAM. If [Formula: see text] is satisfied, the second algorithm becomes cost optimal.

ARITHMETIC CODING IN PARALLEL

We present an EREW PRAM cost optimal parallel algorithm for arithmetic coding computation. We solve the problem in [Formula: see text] time using n/log n processors. Each part of the algorithm as well as a well-known parallel prefix computation forming a basis of the algorithm are clarified on simple examples.

Cost-optimal Gaussian Elimination Algorithm on RCC-FULL

This paper presents a cost-optimal parallel algorithm to find the solution of n simultaneous linear equations on RCC-FULL λ(N, L) network. The algorithm is designed following the strategy of the sequential Gaussian Elimination algorithm. The algorithm utilizes strength of the RCC-FULL network which helps to reduce the time complexity and has the time complexity of O(n) with O(n 2) processors.

Optimal parallelization of a recursive algorithm for triangular matrix inversion on MIMD computers

This paper studies the parallelization of a recursive algorithm for triangular matrix inversion (TMI), using the “divide and conquer” paradigm. For a (large scale) matrix of size n=m2 k (m,k⩾1) and p=2 q (⩽n/2) available processors, we first construct an adequate 2-phases task segmentation and inducing a balanced layered task graph. Then, we design a greedy scheduling leading to a cost optimal parallel algorithm, i.e. whose efficiency is equal to 1 for large n. The practical interest of the contribution is proven through an experimental study of two versions of the original algorithm on an IBM SP1 distributed memory multiprocessor.

Cost-optimal parallel algorithms for the tree bisector and related problems

An edge is a bisector of a simple path if it contains the middle point of the path. Let T=(V,E) be a tree. Given a source vertex s /spl isin/ V, the single-source tree bisector problem is to find, for every vertex /spl upsi/ /spl isin/ V, a bisector of the simple path from s to /spl upsi/. The all-pairs tree bisector problem is to find for, every pair of vertices u, /spl upsi/ /spl isin/ V, a bisector of the simple path from u to /spl upsi/. In this paper, it is first shown that solving the single-source tree bisector problem of a weighted tree has a time lower bound /spl Omega/(n log n) in the sequential case. Then, efficient parallel algorithms are proposed on the EREW PRAM for the single-source and all-pairs tree bisector problems. Two O(log n) time single-source algorithms are proposed. One uses O(n) work and is for unweighted trees. The other uses O(n log n) work and is for weighted trees. Previous algorithms for the single-source problem could achieve the same time O(log n) and the same optimal work, O(n) for unweighted trees and O(n log n) for weighted trees, on the CRCW PRAM. The contribution of our single-source algorithms is the improvement from CRCW to EREW. One all-pairs parallel algorithm is proposed. It requires O(log n) time using O(n/sup 2/) work. All the proposed algorithms are cost-optimal. Efficient tree bisector algorithms have practical applications to several location problems on trees. Using the proposed algorithms, efficient parallel solutions for those problems are also presented.

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.

A cost optimal parallel algorithm for weighted distance transforms

The distance transform and the nearest feature transform are useful operations in image processing. These transforms are based on various kinds of distance functions because the distance functions have different efficiency or usefulness. In this paper, we consider these transforms based on the weighted distance, which is a generalization of many distances, such as city block, chessboard and chamfer distances. This paper presents a parallel algorithm for these transforms of an n× n binary image. The algorithm runs in O ( log n) time using n 2/ log n processors on the EREW PRAM and in O ( log log n) time using n 2/ log log n processors on the common CRCW PRAM. The algorithm also runs in O( n 2/ p 2+ n) time on a p× p mesh and in O (n 2/p 2+(n log p)/p) time on a p 2 processor hypercube (for 1⩽ p⩽ n). From these complexities, the algorithm is cost optimal on all models. Also we obtained an Ω( log n) lower bound for the transform on the CREW PRAM. This implies that the algorithm is time optimal on the EREW PRAM.

Parallel Algorithms for Listing Well-Formed Parentheses Strings

We present two cost-optimal parallel algorithms generating the set of all well-formed parentheses strings of length 2n with constant delay for each generated string. In our first algorithm we generate in lexicographic order well-formed parentheses strings represented by bitstrings, and in the second one we use the representation by weight sequences. In both cases the computational model is based on an architecture CREW PRAM, where each processor performs the same algorithm simultaneously on a different set of data. Different processors can access the shared memory at the same time to read different data in the same or different memory locations, but no two processors are allowed to write into the same memory location simultaneously. These results complete a recent parallel generating algorithm for well-formed parentheses strings in a linear array of processors model, due to Akl and Stojmenović.

O(log logN) Time Algorithms for Hamiltonian Suffix and Min-Max-Pair Heap Operations on the Hypercube

This paper deals with a fast implementation of a heap data structure on a hypercube-connected, synchronous, distributed-memory multicomputer. In particular, we present a communication-efficient mapping of a min-max-pair heap on the hypercube architecture in which the load on each processor's local memory is balanced and propose cost-optimal parallel algorithms which requireO((logN)/p+ logp) time to perform single insertion, deletemin, and deletemax operations on a min-max-pair heap of sizeN, wherepis the number of processors. Our implementation is based on an embedding of complete binary trees in the hypercube and an efficient parallel solution to a special kind of suffix computation, that we call theHamiltonian suffix, along a Hamiltonian path in the hypercube. The binary tree underlying the heap data structure is, however, not altered by the mapping process.

Optimal parallel multiselection on EREW PRAM

Multiselection requires to select r elements at specified ranks in a given set of n elements, r ≤ n. This paper proposes a paradigm for parallel multiselection to achieve the optimal cost. Following this paradigm and employing a cost-optimal algorithm for single-element selection, a cost-optimal parallel algorithm for multiselection is presented. Our algorithm runs in O( n ϵ log r) time on an EREW PRAM with n 1− ϵ processors for any 0 < ϵ < 1. In the special case when ϵ = log( log n log ∗ n) log n , our algorithm requires O( log n log ∗ n log r) time and O( n log r) cost.

A Cost-Optimal Pipeline Algorithm for Permutation Generation in Lexicographic Order

In this paper we solve the open problem of designing a cost-optimal parallel algorithm for generating permutations ofMelements out of the set {0, 1, …,N− 1}, in lexicographic order. Our algorithm runs on the simplest model of parallel computation, i.e., a linear array of sizeM, where each processor PE(i) needs only a constant number of words of length logN, and is responsible for producing with constant delay, theith components in the successive permutations. This algorithm runs in timeO(N!/(N−M)!) on an array of sizeMand is therefore cost-optimal when the time needed to output the permutations is taken into account. Moreover, by doubling the number of cells, it is possible to implement this algorithm on a unidirectional linear array.

OPTIMAL PARALLEL MATCHING ON BIPARTITE PERMUTATION GRAPHS

We present a cost-optimal parallel algorithm for the maximum matching problem on bipartite permutation graphs on an EREW PRAM. Previously, Chen and Yesha have dealt with this problem. Their solution relies on Dekel and Sahni's matching algorithm for convex bipartite graphs, which runs in O(log2 n) time using O(n) processors. Given a permutation diagram, our algorithm runs in O(log n) time by using O(n/log n) processors. Our method starts with an easily understood greedy algorithm. We define a nontrivial binary operation which is associative and equivalent to the greedy algorithm. Thus parallel prefix can be applied to the problem.

GENERATING n-ARY REFLECTED GRAY CODES ON A LINEAR ARRAY OF PROCESSORS

We present a cost-optimal parallel algorithm for generating n-ary reflected Gray codes, i.e. variations of m elements out of {0, 1,…, n–1} in a Gray code order. It uses a linear array of m processors, each having constant size memory and each being responsible for producing one part of a given variation. The algorithm is simple and uses a weaker model of computation than a recently published algorithm. In addition, it can be made adaptive (i.e. to run on a linear array with an arbitrary number of processors) and can be generalized to produce variations out of an arbitrary set of elements.

Time- and Cost-Optimal Parallel Algorithms for the Dominance and Visibility Graphs

The compaction step of integrated circuit design motivates associating several kinds of graphs with a collection of non-overlapping rectangles in the plane. These graphs are intended to capture various visibility relations amongst the rectangles in the collection. The contribution of this paper is to propose time- and cost-optimal algorithms to construct two such graphs, namely, the dominance graph (DG, for short) and the visibility graph (VG, for short). Specifically, we show that with a collection of n non-overlapping rectangles as input, both these structures can be constructed in θ(log n) time using n processors in the CREW model.

EFFICIENT ALGORITHMS FOR THE EUCLIDEAN DISTANCE TRANSFORM

The Euclidean Distance Transform is an important computational tool for the processing of binary images, with applications in many areas such as computer vision, pattern recognition and robotics. We investigate the properties of this transform and describe an O(n2) time optimal sequential algorithm. A deterministic EREW-PRAM parallel algorithm which runs in O( log n) time using O(n2) processors and O(n2) space is also derived. Further, a cost optimal randomized parallel algorithm which runs within the same time bounds with high probability, is given.

Cost-optimal parallel algorithms for constructing B-trees

In this paper two cost-optimal parallel algorithms are presented for constructing a B-tree for a sorted list of N keys. These two parallel algorithms are designed on the shared-memory SIMD computer: one, based on the EREW model, uses N loglog N processors and requires O( loglog N) time; the other, based on the CREW model, uses N processors and requires O(1) time.