Parallel Approximation Algorithms Research Articles

Parallel Algorithms for Hierarchical Nucleus Decomposition

Nucleus decompositions have been shown to be a useful tool for finding dense subgraphs. The coreness value of a clique represents its density based on the number of other cliques it is adjacent to. One useful output of nucleus decomposition is to generate a hierarchy among dense subgraphs at different resolutions. However, existing parallel algorithms for nucleus decomposition do not generate this hierarchy, and only compute the coreness values. This paper presents a scalable parallel algorithm for hierarchy construction, with practical optimizations, such as interleaving the coreness computation with hierarchy construction and using a concurrent union-find data structure in an innovative way to generate the hierarchy. We also introduce a parallel approximation algorithm for nucleus decomposition, which achieves much lower span in theory and better performance in practice. We prove strong theoretical bounds on the work and span (parallel time) of our algorithms. On a 30-core machine with two-way hyper-threading, our parallel hierarchy construction algorithm achieves up to a 58.84x speedup over the state-of-the-art sequential hierarchy construction algorithm by Sariyuce et al. and up to a 30.96x self-relative parallel speedup. On the same machine, our approximation algorithm achieves a 3.3x speedup over our exact algorithm, while generating coreness estimates with a multiplicative error of 1.33x on average.

Fast Parallel Algorithms for Counting and Listing Triangles in Big Graphs

Big graphs (networks) arising in numerous application areas pose significant challengesfor graph analysts as these graphs grow to billions of nodes and edges and are prohibitively large to fit in the main memory. Finding the number of triangles in a graph is an important problem in the mining and analysis of graphs. In this article, we present two efficient MPI-based distributed memory parallel algorithms for counting triangles in big graphs. The first algorithm employs overlapping partitioning and efficient load balancing schemes to provide a very fast parallel algorithm. The algorithm scales well to networks with billions of nodes and can compute the exact number of triangles in a network with 10 billion edges in 16 minutes. The second algorithm divides the network into non-overlapping partitions leading to a space-efficient algorithm. Our results on both artificial and real-world networks demonstrate a significant space saving with this algorithm. We also present a novel approach that reduces communication cost drastically leading the algorithm to both a space- and runtime-efficient algorithm. Further, we demonstrate how our algorithms can be used to list all triangles in a graph and compute clustering coefficients of nodes. Our algorithm can also be adapted to a parallel approximation algorithm using an edge sparsification method.

Scheduling parallel identical machines to minimize makespan:A parallel approximation algorithm

Approximation algorithms for scheduling parallel machines have been studied for decades, leading to significant progress in terms of their approximation guarantees. The algorithms that provide near optimal performance are not feasible to use in practice due to their huge execution time requirements, thus underscoring the importance of developing efficient parallel approximation algorithms with near-optimal performance guarantees that are suitable for execution on current parallel systems, such as multi-core systems. We present the design and analysis of a parallel approximation algorithm for the problem of scheduling jobs on parallel identical machines to minimize makespan. The design of the parallel approximation algorithm is based on the best existing polynomial-time approximation scheme (PTAS) for the problem. To the best of our knowledge, this is the first practical parallel approximation algorithm for the minimum makespan scheduling problem that maintains the approximation guarantees of the sequential PTAS and it is specifically designed for execution on shared-memory parallel machines. We implement and run the algorithm on a large multi-core system and perform an extensive experimental analysis on data generated from realistic probability distributions. The results show that our proposed parallel approximation algorithm achieves significant speedup with respect to both the sequential PTAS and the CPLEX-based solver that solves the mixed integer program formulation of the problem.

A parallel approximate string matching under Levenshtein distance on graphics processing units using warp-shuffle operations

Approximate string matching with k-differences has a number of practical applications, ranging from pattern recognition to computational biology. This paper proposes an efficient memory-access algorithm for parallel approximate string matching with k-differences on Graphics Processing Units (GPUs). In the proposed algorithm, all threads in the same GPUs warp share data using warp-shuffle operation instead of accessing the shared memory. Moreover, we implement the proposed algorithm by exploiting the memory structure of GPUs to optimize its performance. Experiment results for real DNA packages revealed that the performance of the proposed algorithm and its implementation archived up to 122.64 and 1.53 times compared to that of sequential algorithm on CPU and previous parallel approximate string matching algorithm on GPUs, respectively.

A parallel approximate SS-ELM algorithm based on MapReduce for large-scale datasets

Extreme Learning Machine (ELM) algorithm not only has gained much attention of many scholars and researchers, but also has been widely applied in recent years especially when dealing with big data because of its better generalization performance and learning speed. The proposal of SS-ELM (semi-supervised Extreme Learning Machine) extends ELM algorithm to the area of semi-supervised learning which is an important issue of machine learning on big data. However, the original SS-ELM algorithm needs to store the data in the memory before processing it, so that it could not handle large and web-scale data sets which are of frequent appearance in the era of big data. To solve this problem, this paper firstly proposes an efficient parallel SS-ELM (PSS-ELM) algorithm on MapReduce model, adopting a series of optimizations to improve its performance. Then, a parallel approximate SS-ELM Algorithm based on MapReduce (PASS-ELM) is proposed. PASS-ELM is based on the approximate adjacent similarity matrix (AASM) algorithm, which leverages the Locality-Sensitive Hashing (LSH) scheme to calculate the approximate adjacent similarity matrix, thus greatly reducing the complexity and occupied memory. The proposed AASM algorithm is general, because the calculation of the adjacent similarity matrix is the key operation in many other machine learning algorithms. The experimental results have demonstrated that the proposed PASS-ELM algorithm can efficiently process very large-scale data sets with a good performance, without significantly impacting the accuracy of the results.

Parallel approximation algorithms for minimum routing cost spanning tree

With the popularity of internet, more and more data is transferred in the network. With the enormous information, the network bandwidth is still a bottleneck. The internet must provide high quality of service to ensure that the information can be transferred fluently. There are some common factors that can affect the quality of services, such as delay time, building cost, routing cost, loss probability, and bandwidth. Estimation of some factors, such as building cost, can be solved in polynomial time, but the estimations of other factors, such as finding the minimum routing cost spanning tree MRCT, are NP-hard problems. In this paper, we focus on improving two MRCT approximation algorithms 2 and 15/8 approximation with parallel-computing methods and obtain the impressive experiment results with reduced calculation time.

Accelerated Visualization of Dynamic Molecular Surfaces

AbstractMolecular surfaces play an important role in studying the interactions between molecules. Visualizing the dynamic behavior of molecules is particularly interesting to gain insights into a molecular system. Only recently it has become possible to interactively visualize dynamic molecular surfaces using ray casting techniques.In this paper, we show how to further accelerate the construction and the rendering of the solvent excluded surface (SES) and the molecular skin surface (MSS). We propose several improvements to reduce the update times for displaying these molecular surfaces. First, we adopt a parallel approximate Voronoi diagram algorithm to compute the MSS. This accelerates the MSS computation by more than one order of magnitude on a single core. Second, we demonstrate that the contour‐buildup algorithm is ideally suited for computing the SES due to its inherently parallel structure. For both parallel algorithms, we observe good scalability up to 8 cores and, thus, obtain interactive frame rates for molecular dynamics trajectories of up to twenty thousand atoms for the SES and up to a few thousand atoms for the MSS. Third, we reduce the rendering time for the SES using tight‐fitting bounding quadrangles as rasterization primitives. These primitives also accelerate the rendering of the MSS. With these improvements, the interactive visualization of the MSS of dynamic trajectories of a few thousand atoms becomes for the first time possible. Nevertheless, the SES remains a few times faster than the MSS.

The complexity of linear programming in [formula omitted]-form

Linear programming in ( γ , κ )-form is a restricted class of linear programming (LP) introduced in [L. Trevisan, Parallel approximation algorithms by positive linear programming. Algorithmica 21 (1998) 72–88]. Since [L. Trevisan, Erratum: A correction to parallel approximation algorithms by positive linear programming. Algorithmica 27 (2000) 115–119] the complexity of ( γ , κ )-form LP is an open problem. In this work, we show that LP in ( γ , κ )-form is P-Complete to be approximated within any constant factor. An immediate consequence is that the extension of Positive Linear Programming (PLP) where the coefficients (matrix A) can have negative values is also P-Complete to be approximated within any constant factor.

The approximability of non-Boolean satisfiability problems and restricted integer programming

In this paper we present improved approximation algorithms for two classes of maximization problems defined in Barland et al. (J. Comput. System Sci. 57(2) (1998) 144). Our factors of approximation substantially improve the previous known results and are close to the best possible. On the other hand, we show that the approximation results in the framework of Barland et al. hold also in the parallel setting, and thus we have a new common framework for both computational settings. We prove almost tight non-approximability results, thus solving a main open question of Barland et al. We obtain the results through the constraint satisfaction problem over multi-valued domains, for which we develop approximation algorithms and show non-approximability results. Our parallel approximation algorithms are based on linear programming and random rounding; they are better than previously known sequential algorithms. The non-approximability results are based on new recent progress in the fields of probabilistically checkable proofs and multi-prover one-round proof systems.

A Parallel Solution to Infer Genetic Network Architectures in Gene Expression Analysis

With the recent DNA-microarray technology, it is possible to measure the expression levels of thousands of genes simultaneously in the same experiment. A genetic network is a model that describes how the expression level of each gene is affected by the expression levels of other genes in the network. In this paper we explore the use of parallel computers to infer genetic network architectures in gene expression analysis. Given the results of an experiment with n genes and m measures over time ( m [UNKNOWN] n), we consider the problem of finding a subset of genes ( k genes, where k [UNKNOWN] n) that explain the expression level of a given target gene under study. We consider the coarse-grained multicomputer (CGM) model, with p processors. We first present a sequential approximation algorithm of O( m4 n) time and O( m2 n) space. The main result is a new parallel approximation algorithm that determines the k genes in O( m4 n/p) local computing time plus O( k) communication rounds, and with space requirement of O( m2 n/p). The p factor in the parallel time and space complexities indicates a good parallelization. To our knowledge there are no CGM algorithms for the problem considered in this paper. We also show promising experimental results on a Beowulf machine. As will be shown in our experiments, we observe very promising speedups results, especially in the cases where the number of genes studied exceeds 4000. Notice that even with current microarray technology, microchips with around 15,000 spots are already possible. The proposed parallel method constitutes thus an excellent example of application of high-performance computing in this important field.

Parallel frequent set counting

Computing the frequent subsets of large multi-attribute data is a key component of local pattern detection data mining algorithms. It is both computation- and data-intensive. The standard parallel algorithms require multiple passes through the data. The cost of data access may easily outweigh any performance gained by parallelizing the computational part. We address two opportunities for performance improvement: using a parallel approximate algorithm that requires only a single pass over the data; and using a probabilistic technique to avoid generating most of the lattice of subsets implied by each object's data. The computation required is only slightly greater than levelwise algorithms, but the amount of data access is much smaller.

Parallel approximation algorithms for maximum weighted matching in general graphs

The problem of computing a matching of maximum weight in a given edge-weighted graph is not known to be P -hard or in RNC . This paper presents two parallel approximation algorithms for this problem. The first is an RNC -approximation scheme, i.e., an RNC algorithm that computes a matching of weight at least 1−ε times the maximum for any fixed constant ε>0. The other is an NC approximation algorithm achieving an approximation ratio of 1/(2+ε) for any fixed constant ε>0.

Erratum: A Correction to ``Parallel Approximation Algorithms by Positive Linear Programming''

This note points out and corrects a mistake in the paper ``Parallel Approximation Algorithms by Positive Linear Programming'' [Algorithmica , 21:72—88]. The mistake was discovered by Pavlos Efraimidis.

The parallel complexity of approximating the high degree subgraph problem

The high degree subgraph problem is to find a subgraph H of a graph G such that the minimum degree of H is as large as possible. This problem is known to be P-hard so that parallel approximation algorithms are very important for it. Our first goal is to determine how effectively the approximation algorithm based on a well-known extremal graph result parallelizes. In particular, we show that two natural decision problems associated with this algorithm are P-complete: these results suggest that the parallel implementation of the algorithm itself requires more sophisticated techniques. Successively, we study the high degree subgraph problem for random graphs with any edge probability function and we provide different parallel approximation algorithms depending on the type of this function.

Parallel Approximation Algorithms by Positive Linear Programming

Several sequential approximation algorithms for combinatorial optimization problems are based on the following paradigm: solve a linear or semidefinite programming relaxation, then use randomized rounding to convert fractional solutions of the relaxation into integer solutions for the original combinatorial problem. We demonstrate that such a paradigm can also yield parallel approximation algorithms by showing how to convert certain linear programming relaxations into essentially equivalent positive linear programming [LN] relaxations that can be near-optimally solved in NC. Building on this technique, and finding some new linear programming relaxations, we develop improved parallel approximation algorithms for Max Sat, Max Directed Cut, and Maxk CSP. The Max Sat algorithm essentially matches the best approximation obtainable with sequential algorithms and has a fast sequential version. The Maxk CSP algorithm improves even over previous sequential algorithms. We also show a connection between probabilistic proof checking and a restricted version of Maxk CSP. This implies that our approximation algorithm for Maxk CSP can be used to prove inclusion in P for certain PCP classes.

Primal-Dual RNC Approximation Algorithms for Set Cover and Covering Integer Programs

We build on the classical greedy sequential set cover algorithm, in the spirit of the primal-dual schema, to obtain simple parallel approximation algorithms for the set cover problem and its generalizations. Our algorithms use randomization, and our randomized voting lemmas may be of independent interest. Fast parallel approximation algorithms were known before for set cover, though not for the generalizations considered in this paper.

Tight approximations for resource constrained scheduling and bin packing

We consider the following resource constrained scheduling problem. We are given m identical processors, s resources R 1, …, R s with upper bounds b 1, …, b s , n independent jobs T 1, …, T n of unit length, where each job T j has a start time r j ϵ N, requires one processor and an amount R i ( j) ϵ {0, 1} of resource R i , i = 1, …, s. The optimization problem is to schedule the jobs at discrete times in N subject to the processor, resource and start-time constraints so that the latest scheduling time is minimum. Multidimensional bin packing is a special case of this problem. Resource constrained scheduling can be relaxed in a natural way when one allows the scheduling of fraction of jobs. Let C opt (resp. C) be the minimum schedule size for the integral (resp. fractional scheduling). While the computation of C opt is a NP-hard problem, C can be computed by linear programming in polynomial time. In case of zero start times Röck and Schmidt (1983) showed for the integral problem a polynomial-time approximation within ( (m 2 )C opt and de la Vega and Lueker (1981), improving a classical result of Garey et al. (1976), gave for every ε > 0 a linear time algorithm with an asymptotic approximation guarantee of ( s + ε) C opt . The main contributions of this paper include the first polynomial-time algorithm approximating C opt for every ε ϵ (0, 1) within a factor of 1 + ε for instances with b i = Ω(ε −2log(Cs)) for all i and m = Ω(ε −2log C) , and a proof that the achieved approximation under the given conditions is best possible, unless P = NP. Furthermore, in some cases we give for every fixed α > 1 a parallel 2α-factor approximation algorithm.

Parallel constructions of maximal path sets and applications to short superstrings

It is shown that the problem of finding a maximal set of paths in a given (undirected or directed) graph is in NC. This result is then used to obtain three parallel approximation algorithms for the shortest superstring problem. The first is an NC algorithm achieving a compression ratio of 1 3 + ε for any ε > 0. The second is an RNC algorithm achieving a compression ratio of 38 63 ≈ 0.603 . The third is an RNC algorithm achieving an approximation ratio of 2 50 63 ≈ 2.793 . All the results significantly improve on the best previous ones.

A Primal-Dual Parallel Approximation Technique Applied to Weighted Set and Vertex Covers

We give an efficient deterministic parallel approximation algorithm for the minimum-weight vertex- and set-cover problems and their duals (edge/element packing). The algorithm is simple and suitable for distributed implementation. It fits no existing paradigm for fast, efficient parallel algorithms-it uses only "local" information at each step, yet is deterministic. (Generally, such algorithms have required randomization.) The result demonstrates that linear-programming primal-dual approximation techniques can lead to fast, efficient parallel algorithms. The presentation does not assume knowledge of such techniques.

A systolic-based parallel bin packing algorithm

A systolic based parallel approximation algorithm that obtains solutions to the I-D bin packing problem is presented. The algorithm has an asymptotic error bound of 1.5 and time complexity O(n). An experimental study demonstrates that the heuristic offers improved packing and execution performance over parallelizations of two well-known serial algorithms. >