Processor-efficient hypercube algorithms for the knapsack problem

Data partitioning algorithms aiming to minimize the execution time and the energy of computations in self-adaptable data-parallel applications on modern extreme-scale multicore platforms must address two critical challenges. First, they must take into account the new complexities inherent in these platforms such as severe resource contention and non-uniform memory access. Second, they must have low practical runtime and memory costs. The sequential data partitioning algorithms addressing the first challenge have a theoretical time complexity of O( $m * m * p * p$ ) where $m$ is the number of points in the discrete speed/energy function and $p$ is the number of available processors. They, however, exhibit high practical runtime cost and excessive memory footprint, therefore, rendering them impracticable for employment in self-adaptable applications executing on extreme-scale multicore platforms. We present, in this paper, the parallel data partitioning algorithms that address both the challenges. They take as input the functional models of performance and energy consumption against problem size and output workload distributions, which are globally optimal solutions. They have a low time complexity of O( $m * m * p$ ) thereby providing a linear speedup of O( $p$ ) and low memory complexity of O( $n$ ) where $n$ is the workload size expressed as a multiple of granularity. They employ dynamic programming approach, which also facilitates the easier integration of performance and energy models of communications. We experimentally study the practical cost of application of our algorithms in two data-parallel applications, matrix multiplication and fast Fourier transform, on a cluster in Grid’5000 platform. We demonstrate that their practical runtime and memory costs are low making them ideal for employment in self-adaptable applications. We also show that the parallel algorithms exhibit tremendous speedups over the sequential algorithms. Finally, using theoretical analysis for a forecast exascale platform, we demonstrate that the parallel algorithms have negligible execution times compared to the matrix multiplication application executing on the platform.

Scalable algorithms for the solution of Navier's equations of elasticity

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

An efficient parallel algorithm for a new permutation generation method is presented. The crucial task in our permutation generation algorithm is starter sets generation where listing n! permutation is dependent on starter sets. Thus the task of starter sets generation is partitioned. However the parallel algorithm with 12 initial starter sets is less efficient when numbers of processors are more than seven. For increasing performance of parallel algorithm over processors, the number of initial starter sets change to 60. This parallel algorithm is directly implemented from its sequential algorithm and integrated with Message Passing Interface (MPI) libraries. The improvement of the parallel algorithm is shown better performance in terms of speedup and efficiency.

Finite state automata are of fundamental importance in theory as well as applications in computer science. This dissertation presents several parallel algorithms for processing of them, including minimizing the number of states for a given finite state automaton, finding homing sequences for a given finite state automaton, converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. Implementation of some algorithms, as well as their experimental results, are also given. For minimization of deterministic finite automata, we present a parallel algorithm and discuss its implementation on a practical parallel machine using data parallel and message passing paradigms. Its time complexity on a p processor EREW PRAM $(p\\le n)$ for inputs of size n is $O({n\\log\\sp2n\\over p}+\\log n\\ \\log p)$ uniformly on almost all instances. The work done by our algorithm is thus within a factor of $O(\\log n)$ of the best known sequential algorithm. The space used by our algorithm is linear in the input size. The actual resource requirements of our implementations are consistent with these estimates. For finding homing sequences of deterministic finite automata, we present both deterministic and randomized algorithms. Two randomized algorithms of time complexity $O(log\\sp2n)$ are given. One of the randomized algorithms produces a homing sequence of length $O(n\\ log\\sp2n)$ for almost all DFA's with n states. The deterministic algorithm is based on a well known sequential algorithm. The implementation of the deterministic parallel algorithm shows that it can handle randomly generated instances with millions of states, and all DFA's with thousands of states using currently available parallel machines. Finally, we present an efficient parallel algorithm for converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. The resulting automaton is natural representation of a regular expression and has some important and practical uses in the document processing area. The time complexity of the algorithm is $O(\\log n)$ and the number of processors used is $O(n\\sp2).$

Parallel algorithms developed for CAD problems today suffer from three important drawbacks. First, they are machine specific and tend to perform poorly on architectures other than the one for which they were designed. Second, they cannot use the latest advances in improved versions of the sequential algorithms for solving the problem. Third, the quality of results degrade significantly during parallel execution. We address these three problems for an important CAD application: standard cell placement. We have developed a parallel placement algorithm that is portable across a range of MIMD parallel architectures. The algorithm is part of the ProperCAD project which allows the development and implementation of a parallel algorithm such that it can be executed on a wide variety of parallel machines without any change to the source. The parallel placement algorithm is based on an existing implementation of the sequential simulated annealing algorithm, TimberWolfSC 6.0 (C. Sechen and A. Sangiovanni-Vincentelli, 1985).< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Three diagnostic rapid test kits (Chembio HIV-1/2 Stat-Pak, Alere DetermineTM HIV-1/2, and Core HIV-1/2) for human immunodeficiency virus types 1 and 2 (HIV-1/2) antibodies detection were evaluated against a gold standard fourth generation ELISA (Dia-Pro). Hundred and seventy two serum samples were collected from Lulubriggs Health Center, University of Port Harcourt, Rivers State. All samples were tested for HIV-1/2 using the three rapid test (parallel algorithm and serial algorithm), and retested using the 4th generation ELISA. The results obtained were compared with those from the ELISA. The DetermineTM rapid strips had sensitivity of 66.7%, specificity of 100%, positive predictive value 100%, negative predictive value 89.4% and total agreement of 91.3%. Stat-pak and Core HIV-1/2 rapid strips both had sensitivity of 71.7%, specificity of 100%, positive predictive value 100%, and negative predictive value 90.7% and total agreement of 92.4%. Determine was mostly used by the participant laboratories 18 of 30 (60%). The performance evaluation of the testing algorithm showed that parallel algorithm is more accurate in comparison to serial algorithm. The result of this study reveals that most rapid test are less sensitive and the accuracy of serial testing algorithm is low, this implies that most acute HIV infection will be missed with rapid assay and false negative results will be reported as actual negative with serial algorithm.

High-resolution adaptive-optical systems with thousands to millions of pixels will most likely have to employ serial- or matrix-addressed spatial light modulators (e.g., microelectromechanical-system-on-VLSI spatial light modulators). We compare parallel gradient descent adaptive-optics algorithms with serial gradient descent algorithms running on serially addressed modulators. While serial algorithms have previously been shown to require more iterations than parallel algorithms, we show that, because of the limitations of the databus, each serial iteration of the algorithm on a serial modulator requires significantly less time to complete than a parallel iteration, thereby favoring the serial algorithm when time to convergence is used as the performance metric. Thus, such high-resolution serially addressed devices are generally better matched to the serial-update wavefront correction algorithm owing to the data load penalty imposed by the bandwidth-limited databus of these modulators.

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.

Electronic circuits: by E. J. Angelo, Jr. 450 pages, diagrams, 6 × 9 in. New York, McGraw-Hill Book Co. Inc., 1958.Price, $9.00.

Mainly designed for simulating the fluid motion, Smooth Particle Hydrodynamics (SPH) SPH has been widely applied to many fields, such as aerospace aircraft design and ship design. First, this paper presents an implementation of serial SPH method algorithm using the reflection method as the boundary condition. This paper describes entire process of SPH and gives detailed descriptions of some important procedures. Second, this paper realizes the corresponding parallel algorithm of SPH, which includes neighbor particle searching and building, physical attributes computation and other main SPH method procedures. Third, details of mapping different parts of the SPH serial algorithm to parallel algorithm on GPU with CUDA C as parallel programming language are also shown in this paper. Taking advantage of powerful computation ability of GPU, the experiment approximately achieves a 8X speedup that shows the high efficiency of GPU-based programming. The parallel algorithm not only achieves a high performance, but also promises a reliability result with a small error rate as the experiment result shows.

Previous chapter Next chapter Full AccessProceedings Symposium on Algorithmic Principles of Computer Systems (APOCS)Parallel In-Place Algorithms: Theory and PracticeYan Gu, Omar Obeya, and Julian ShunYan Gu, Omar Obeya, and Julian Shunpp.114 - 128Chapter DOI:https://doi.org/10.1137/1.9781611976489.9PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract Many parallel algorithms use at least linear auxiliary space in the size of the input to enable computations to be done independently without conflicts. Unfortunately, this extra space can be prohibitive for memory-limited machines, preventing large inputs from being processed. Therefore, it is desirable to design parallel in-place algorithms that use sublinear (or even polylogarithmic) auxiliary space. In this paper, we bridge the gap between theory and practice for parallel in-place (PIP) algorithms. We first define two computational models based on fork-join parallelism, which reflect modern parallel programming environments. We then introduce a variety of new parallel in-place algorithms that are simple and efficient, both in theory and in practice. Our algorithmic highlight is the Decomposable Property introduced in this paper, which enables existing non-in-place but highly-optimized parallel algorithms to be converted into parallel in-place algorithms. Using this property, we obtain algorithms for random permutation, list contraction, tree contraction, and merging that take linear work, O(n1–∊) auxiliary space, and O(n∊ · polylog(n)) span for 0 < · < 1. We also present new parallel in-place algorithms for scan, filter, merge, connectivity, biconnectivity, and minimum spanning forest using other techniques. In addition to theoretical results, we present experimental results for implementations of many of our parallel in-place algorithms. We show that on a 72-core machine with two-way hyper-threading, the parallel in-place algorithms usually outperform existing parallel algorithms for the same problems that use linear auxiliary space, indicating that the theory developed in this paper indeed leads to practical benefits in terms of both space usage and running time. Previous chapter Next chapter RelatedDetails Published:2021eISBN:978-1-61197-648-9 https://doi.org/10.1137/1.9781611976489Book Series Name:ProceedingsBook Code:APOSC21Book Pages:ii + 158

Recurrence solution of a block tridiagonal matrix equation with Neumann, Dirichlet, mixed or periodic boundary conditions

Parallel and sequential transformations on digital images

EVALUATION OF PARALLEL ALGORITHMS In order to solve computational problems by appropriate algorithms, we need to carry out their analysis. The goal of analysis is to demonstrate correctness of the algorithms (see Section 1.3) and to examine their properties that are crucial in terms of suitability for solving a problem at hand, as well as to compare performance of the algorithms and select the best one. Another aspect of analysis may be to determine whether the best algorithm we have is optimal, or in other words, no better algorithm exists. A sequential algorithm is a sequence of precisely defined steps solving a problem, that is computing the output data based on the input data. The precision in describing the steps is necessary to be able to transform the algorithm into a computer program that is the implementation of the algorithm. The computation of a sequential algorithm is performed by one processor. If we want to solve a problem by using multiple processors, then the problem should be decomposed into subproblems that can be solved in parallel. Each of the subproblems is solved by a separate algorithm, which is a component of a parallel algorithm. So the parallel algorithm consists of a certain number of separate algorithms that can be executed simultaneously. The parallel algorithm also specifies how its components use intermediate results of computation and how they synchronize their work. The basic criteria for evaluating sequential algorithms include the running time and memory requirement . The running time—or more precisely, the compute time of a processor—and the occupied memory are the amounts of resources necessary to execute an algorithm. Other evaluation criteria of sequential algorithms include universality, understood as possibility of applying an algorithm to solve a class of problems, simplicity, ease of implementation, and modification. Evaluating a parallel algorithm is more difficult than a sequential one, because an additional factor (except the size of input data) is to be considered, which is the number of processors of a parallel computer where the algorithm is implemented. A number of evaluation criteria is also greater.