EREW Research Articles

Near Optimal Parallel Algorithms for Dynamic DFS in Undirected Graphs

Depth first search (DFS) tree is a fundamental data structure for solving various graph problems. The classical algorithm [54] for building a DFS tree requires O ( m + n ) time for a given undirected graph G having n vertices and m edges. Recently, Baswana et al. [5] presented a simple algorithm for updating the DFS tree of an undirected graph after an edge/vertex update in Õ( n ) 1 time. However, their algorithm is strictly sequential. We present an algorithm achieving similar bounds that can be easily adopted to the parallel environment. In the parallel environment, a DFS tree can be computed from scratch in expected Õ(1) time [2] on an EREW PRAM, whereas the best deterministic algorithm takes Õ(√ n ) time [2, 27] on a CRCW PRAM. Our algorithm can be used to develop optimal time (to poly log n factors) deterministic parallel algorithms for maintaining fully dynamic DFS and fault tolerant DFS of an undirected graph. (1) Parallel Fully Dynamic DFS : Given an arbitrary online sequence of vertex or edge updates, we can maintain a DFS tree of an undirected graph in Õ(1) time per update using m processors on an EREW PRAM. (2) Parallel Fault tolerant DFS : An undirected graph can be preprocessed to build a data structure of size O ( m ), such that for any set of k updates (where k is constant) in the graph, a DFS tree of the updated graph can be computed in Õ(1) time using n processors on an EREW PRAM. For constant k , this is also work optimal (to poly log n factors). Moreover, our fully dynamic DFS algorithm provides, in a seamless manner, nearly optimal (to poly log n factors) algorithms for maintaining a DFS tree in the semi-streaming environment and a restricted distributed model. These are the first parallel, semi-streaming, and distributed algorithms for maintaining a DFS tree in the dynamic setting.

A Work Efficient Parallel Algorithm for Exact Euclidean Distance Transform.

A fully-parallelized work-time optimal algorithm is presented for computing the exact Euclidean Distance Transform (EDT) of a 2D binary image with the size of n×n . Unlike existing PRAM (Parallel Random Access Machine) and other algorithms, this algorithm is suitable for implementation on modern SIMD (Single Instruction Multiple Data) architectures such as GPUs. As a fundamental operation of 2D EDT, 1D EDT is efficiently parallelized first. Specifically, the GPU algorithm for the 1D EDT, which uses CUDA (Compute Unified Device Architecture) binary functions, such as ballot(), ffs(), clz(), and shfl(), runs in O(log32n) time and performs O(n) work. Using the 1D EDT as a fundamental operation, the fully-parallelized work-time optimal 2D EDT algorithm is designed. This algorithm consists of three steps. Step 1 of the algorithm runs in O(log32n) time and performs O(N) ( N = n2 ) of total work on GPU. Step 2 performs O(N) of total work and has an expected time complexity of O(logn) on GPU. Step 3 runs in O(log32n) time and performs O(N) of total work on GPU. As far as we know, this algorithm is the first fully-parallelized and realized work-time optimal algorithm for GPUs. The experimental results show that this algorithm outperforms the prior state-of-the-art GPU algorithms.

Parallelism in divide-and-conquer non-dominated sorting: a theoretical study considering the PRAM-CREW model

Non-dominated sorting is a crucial component of Pareto-based multi- and many-objective evolutionary algorithms. As the number of objectives increases, the execution time of a multi-objective evolutionary algorithm increases, too. Since multi-objective evolutionary algorithms normally have a low data dependency, research-ers have increasingly adopted parallel programming techniques to reduce their execution time. Evidently, it is also desirable to parallelize non-dominated sorting. There are some recent proposals which focus on the parallelization of non-dominated sorting, with a particular emphasis on a very well-known approach called fast non-dominated sorting. In this paper, however, we explore the scope of parallelism in an approach called divide-and-conquer based non-dominated sorting (DCNS), which we recently introduced. This paper explores the parallelism from a theoretical point of view. The parallelization of the DCNS approach has been explored considering the PRAM-CREW (Parallel Random Access Machine, Concurrent Read Exclusive Write) model. The analysis of parallel algorithms is usually carried out under the assumption that an unbounded number of processors are available. So, in our analysis, we have also considered the same assumption. The time and space complexities of the parallel version of the DCNS approach is obtained in different scenarios. The time complexity of the parallel version of the DCNS approach in different scenarios is proved to be $$\mathcal {O}(\log M + N)$$ . We have also obtained the maximum number of processors which can be required by the parallel version of the DCNS approach. The comparison of the parallel version of the DCNS approach with respect to some other approaches is also performed.

Two parallel algorithms for finding all minimal maximum subsequences

A minimal maximum subsequence is a minimal subsequence with maximum cumulative sum. We present two parallel algorithms that find all successive minimal maximum subsequences: one on the parallel random-access model in logarithmic time with linear work, and the other with overlapping domain decomposition on cluster systems. We confirm the efficacy and efficiency of the latter algorithm for random sequences via: (1) an application of random-walk theory that derives an approximate probabilistic length upper bound for overlapping subsequences — thus facilitating concurrent/independent computations of all minimal maximum subsequences in hosting processors, and (2) an empirical study with normally-distributed random sequences.

An Efficient Algorithm for the 1D Total Visibility-Index Problem and Its Parallelization

Let T be a terrain and P be a set of points on its surface. An important problem in Geographic Information Science (GIS) is computing the visibility index of a point p on P , that is, the number of points in P that are visible from p . The total visibility-index problem asks for the visibility index of every point in P . We present the first subquadratic-time algorithm to solve the one-dimensional total-visibility-index problem. Our algorithm uses a geometric dualization technique to reduce the problem to a set of instances of the red--blue line segment intersection counting problem, allowing us to find the total visibility-index in O ( n log 2 n ) time. We implement a naive O ( n 2 ) approach and four variations of our algorithm: one that uses an existing red--blue line segment intersection counting algorithm and three new approaches that leverage features specific to our problem. Two of our implementations allow for parallel execution, requiring O (log 2 n ) time and O ( n log 2 n ) work in the CREW PRAM model. We present experimental results for both serial and parallel implementations on synthetic and real-world datasets using two hardware platforms. Results show that all variants of our algorithm outperform the naive approach by several orders of magnitude. Furthermore, we show that our special-case red--blue line segment intersection counting implementations out-perform the existing general-case solution by up to a factor 10. Our fastest parallel implementation is able to process a terrain of more than 100 million vertices in under 3 minutes, achieving up to 85% parallel efficiency using 16 cores.

Parallelization of Ant System for GPU under the PRAM Model

We study the parallelized ant system algorithm solving the traveling salesman problem on n cities. First, following the series of recent results for the graphics processing unit, we show that they translate to the PRAM (parallel random access machine) model. In addition, we develop a novel pheromone matrix update method under the PRAM CREW (concurrent-read exclusive-write) model and translate it to the graphics processing unit without atomic instructions. As a consequence, we give new asymptotic bounds for the parallel ant system, resulting in step complexities O(n łg łg n) on CRCW (concurrent-read concurrent-write) and O(n łg n) on CREW variants of PRAM using n2 processors in both cases. Finally, we present an experimental comparison with the currently known pheromone matrix update methods on the graphics processing unit and obtain encouraging results.

An Optimal Parallel Algorithm for Constructing a Spanning Tree on Proper Circle Trapezoid Graphs

Given a simple graph G with n vertices and m edges, the spanning tree problem is to find a spanning tree for a given graph G. This problem has many applications, such as electric power systems, computer network design and circuit analysis. For a simple graph, the spanning tree problem can be solved in O(log n) time with O(m+n) processors on the CRCW PRAM. In general, it is known that more efficient parallel algorithms can be developed by restricting classes of graphs. In this paper, we shall propose a parallel algorithm which runs O(log n) time with O(n/log n) processors on the EREW PRAM for constructing on proper circle trapezoid graphs.

Parallel Algorithms and Concentration Bounds for the Lovász Local Lemma via Witness DAGs

The Lovász Local Lemma (LLL) is a cornerstone principle in the probabilistic method of combinatorics, and a seminal algorithm of Moser and Tardos (2010) provides an efficient randomized algorithm to implement it. This can be parallelized to give an algorithm that uses polynomially many processors and runs in O (log 3 n ) time on an EREW PRAM, stemming from O (log n ) adaptive computations of a maximal independent set (MIS). Chung et al. (2014) developed faster local and parallel algorithms, potentially running in time O (log 2 n ), but these algorithms require more stringent conditions than the LLL. We give a new parallel algorithm that works under essentially the same conditions as the original algorithm of Moser and Tardos but uses only a single MIS computation, thus running in O (log 2 n ) time on an EREW PRAM. This can be derandomized to give an NC algorithm running in time O (log 2 n ) as well, speeding up a previous NC LLL algorithm of Chandrasekaran et al. (2013). We also provide improved and tighter bounds on the runtimes of the sequential and parallel resampling-based algorithms originally developed by Moser and Tardos. These apply to any problem instance in which the tighter Shearer LLL criterion is satisfied.

A fast optimal parallel algorithm for a short addition chain

Given a natural number e, an addition chain for e is a finite sequence of numbers having the following properties: (1) the first number is one, (2) every element is the sum of two earlier elements, and (3) the given number occurs at the end of the sequence. We introduce a fast optimal algorithm to generate a chain of short length for the number e of n-bits. The algorithm is based on the right–left binary strategy and barrel shifter circuit. The algorithm uses $$O((\frac{n}{\log {n}})^2)$$ processors and runs in $$O((\log {n})^2)$$ time under exclusive read exclusive write parallel random access machine.

Algorithms for testing occurrences of length 4 patterns in permutations

In this paper linear time sequential and optimal parallel algorithms for testing pattern involvement for all length 4 permutations are described. This is an improvement as the previous best sequential algorithms, for most of these pattern require $$O(n\log n)$$ time. Our parallel algorithms can be implemented in $$O(\log n)$$ time with $$n/\log n$$ processors on the CREW PRAM model, or alternatively in $$O(\log \log \log n)$$ time with $$n/\log \log \log n$$ processors on a CRCW PRAM PRAM model. Parallel algorithm can also be implemented in constant time with $$n\log ^3 n$$ processors on a CRCW PRAM model. The previous best parallel algorithms were available for only some of these patterns and took $$O(\log n)$$ time with n processors on the CREW PRAM model.

A Parallel Algorithm for the Spanning Forest Problem on Proper Circle Graphs

Given a simple graph G with n vertices, m edges and k connected components. The spanning forest problem is to find a spanning tree for each connected component of G. This problem has applications to the electrical power demand problem, computer network design, circuit analysis, etc. In this paper, we present an time parallel algorithm with processors for constructing a spanning forest on proper circle graph G on EREW PRAM.

On Computing Maximal Independent Sets of Hypergraphs in Parallel

Whether or not the problem of finding maximal independent sets (MIS) in hypergraphs is in (R)NC is one of the fundamental problems in the theory of parallel computing. Essentially, the challenge is to design (randomized) algorithms in which the number of processors used is polynomial and the (expected) runtime is polylogarithmic in the size of the input. Unlike the well-understood case of MIS in graphs, for the hypergraph problem, our knowledge is quite limited despite considerable work. It is known that the problem is in RNC when the edges of the hypergraph have constant size. For general hypergraphs with n vertices and m edges, the fastest previously known algorithm works in time O (√ n ) with poly( m,n ) processors. In this article, we give an EREW PRAM randomized algorithm that works in time n o (1) with O ( n + mlog n ) processors on general hypergraphs satisfying m ≤ n o (1) log log n /log log log n . We also give an EREW PRAM deterministic algorithm that runs in time n ϵ on a graph with m ≤ n 1/δ edges, for any constants δ, ϵ; the number of processors is polynomial in m, n for a fixed choice of δ, ϵ. Our algorithms are based on a sampling idea that reduces the dimension of the hypergraph and employs the algorithm for constant dimension hypergraphs as a subroutine.

Simpler Sequential and Parallel Biconnectivity Augmentation in Trees

For a connected graph, a vertex separator is a set of vertices whose removal creates at least two components and a minimum vertex separator is a vertex separator of least cardinality. The vertex connectivity refers to the size of a minimum vertex separator. For a connected graph G with vertex connectivity [Formula: see text], the connectivity augmentation refers to a set S of edges whose augmentation to G increases its vertex connectivity by one. A minimum connectivity augmentation of G is the one in which S is minimum. In this paper, we focus our attention on biconnectivity augmentation for trees. Towards this end, we present a new sequential algorithm for biconnectivity augmentation in trees by simplifying the algorithm reported in [1]. The simplicity is achieved with the help of edge contraction tool. This tool helps us in getting a recursive subproblem preserving all connectivity information. Subsequently, we present a parallel algorithm to obtain a minimum biconnectivity augmentation set in trees. Our parallel algorithm essentially follows the overall structure of sequential algorithm. Our implementation is based on CREW PRAM model with [Formula: see text] processors, where [Formula: see text] refers to the maximum degree of a tree. We also show that our parallel algorithm is optimal with a processor-time product of [Formula: see text] where n is the number of vertices of a tree.

An efficient solution to the subset‐sum problem on GPU

SummaryWe present an algorithm to solve the subset‐sum problem (SSP) of capacity c and n items with weights wi,1≤i≤n, spending O(n(m − wmin)/p) time and O(n + m − wmin) space in the Concurrent Read/Concurrent Write (CRCW) PRAM model with 1≤p≤m − wmin processors, where wmin is the lowest weight and , improving both upper‐bounds. Thus, when n≤c, it is possible to solve the SSP in O(n) time in parallel environments with low memory. We also show OpenMP and CUDA implementations of this algorithm and, on Graphics Processing Unit, we obtained better performance than the best sequential and parallel algorithms known so far. Copyright © 2015 John Wiley & Sons, Ltd.

A Parallel Random Access Machine (PRAM) Model for English Language Recognizer (PRAM-ELR)

As, technology grows day by day ,computers become ever faster with its importance and having maximum computing power, computational cost also increases, development at its high end then we state that parallel computing technology (parallelism) is the main building block of this era of development and, for this purpose, therefore, all aspects have been thought about to meet the need of time. Uni-processing abstracted into parallel processing. Many visions of parallel computing included Parallel Random Access Machine (PRAM), Graphical Processing Unit (GPU) , Compute Unified Device Architecture extension in Clanguage (CUDA –C) , Local Area Multicomputer- Message Passing Interface (LAM-MPI) ,cluster and grid computer etc have been used in different fields. Many of the sequential algorithms can be implemented parallel to increase efficiency, computing power, computational cost and speed. Here, we proposed a Parallel Random Access Model (PRAM) of the algorithm of ELR – NPDA [1] to make it more efficient, fast and powerful so that, this new parallel version of ELR–NPDA [1] called PRAMELR can be parse large data set speedier.

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.

Fast Sequential and Parallel Vertex Relabelings of Km,m

Given an undirected, connected, simple graph G = (V,E), two vertex labelings LV and L'V of the vertices of G, and a label flip operation that interchanges a pair of labels on adjacent vertices, the Vertex Relabeling Problem is to transform G from LV into L'V using the flip operation. Agnarsson et al. showed solving the Vertex Relabeling Problem on arbitrary graphs can be done in θ(n2), where n is the number of vertices in G. In this article we study the Vertex Relabeling Problem on graphs Km,m and introduce the concept of parity and precise labelings. We show that, when we consider the parity labeling, the problem on graphs Km,m can be solved quickly in O(log m) time using m processors on an EREW PRAM. Additionally, we also show that the number of processors can be further reduced to [Formula: see text] in this case while the time complexity does not change. When the labeling is precise, the parallel time complexity increases by a factor of log m while the processor complexities remain m and [Formula: see text]. We also show that, when graphs are restricted to Km,m, this problem can be solved optimally in O(m) time when the labeling is parity, and can be solved in O(m log m) time when the labeling is precise, thereby improving the result in Agnarsson et al. for this specific case. Moreover, we generalize the result in the case of precise labeling to the cases when LV and L'V can be any configuration. In the end we give a conclusion and a list of some interesting open problems.

Application of Fuzzy Optimization to the Orienteering Problem

This paper deals with the orienteering problem (OP) which is a combination of two well-known problems (i.e., travelling salesman problem and the knapsack problem). OP is an NP-hard problem and is useful in appropriately modeling several challenging applications. As the parameters involved in these applications cannot be measured precisely, depicting them using crisp numbers is unrealistic. Further, the decision maker may be satisfied with graded satisfaction levels of solutions, which cannot be formulated using a crisp program. To deal with the above-stated two issues, we formulate thefuzzyorienteering problem (FOP) and provide a method to solve it. Here we state the two necessary conditions of OP of maximizing the total collected score and minimizing the time taken to traverse a path (within the specified time bound) as fuzzy goals and the remaining necessary conditions as crisp constraints. Using the max-min formulation of the fuzzy sets obtained from the fuzzy goals, we calculate the fuzzy decision sets (ZandZ∗) that contain the feasible paths and the desirable paths, respectively, along with the degrees to which they are acceptable. To efficiently solve large instances of FOP, we also present a parallel algorithm on CREW PRAM model.

On the computational power of WECPAR

Reconfigurable models were shown to be very powerful in solving many problems faster than non-reconfigurable models. WECPAR $$W(M,N,k)$$ W ( M , N , k ) is an $$M\times N$$ M × N reconfigurable model that has point-to-point reconfigurable interconnection with $$k$$ k wires between neighboring processors. This paper studies several aspects of WECPAR. We first consider solving the list ranking problem on WECPAR. Some of the results obtained show that, ranking one element in a list of $$N$$ N elements can be solved on $$W(N,N,N)$$ W ( N , N , N ) WECPAR in $$O(1)$$ O ( 1 ) time. Also, on $$W(N,N,k)$$ W ( N , N , k ) , ranking a list $$L(N)$$ L ( N ) of $$N$$ N elements can be done in $$O((\log N)(\lceil {\log _{k+1} N} \rceil ))$$ O ( ( log N ) ( ? log k + 1 N ? ) ) time. Then, we assess the relative computational power of WECPAR and transfer a large body of algorithms to work directly on WECPAR. We introduce several simulation algorithms between WECPAR and well-known models such as PRAM and RMBM. Simulation algorithms show that a PRIORITY CRCW PRAM $$P(N,S)$$ P ( N , S ) of $$N$$ N processors and $$S$$ S shared memory locations can be simulated on $$W(S,N,k)$$ W ( S , N , k ) WECPAR in $$O(\lceil {\log _{k+1} N}\rceil +\lceil {\log _{k+1} S}\rceil )$$ O ( ? log k + 1 N ? + ? log k + 1 S ? ) time. Also, we show that a PRIORITY CRCW basic RMBM( $$P,B)$$ P , B ) , of $$P$$ P processors and $$B$$ B buses can be simulated on $$W(B, P+B, k)$$ W ( B , P + B , k ) WECPAR in $$O(\lceil {\log _{k+1} (P+B)}\rceil )$$ O ( ? log k + 1 ( P + B ) ? ) time. This directly migrate a large number of algorithms to work on WECPAR with the simulation overhead.

PARALLEL WISARD OBJECT TRACKER: A RAMBASED TRACKING SYSTEM

This paper proposes the Parallel WiSARD Object Tracker (PWOT), a new object tracker based on the WiSARD weightless neural network that is robust against quantization errors. Object tracking in video is an important and challenging task in many applications. Difficulties can arise due to weather conditions, target trajectory and appearance, occlusions, lighting conditions and noise. Tracking is a high-level application and requires the object location frame by frame in real time. This paper proposes a fast hybrid image segmentation (threshold and edge detection) in YcbCr color model and a parallel RAM based discriminator that improves efficiency when quantization errors occur. The original WiSARD training algorithm was changed to allow the tracking.