Parallel and sequential transformations on digital images

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.

Over the years many interesting and efficient parallel algorithms have been developed to solve a wide variety of problems, but not much attention has been paid to studying the inherent parallelism in sequential algorithms---i.e., understanding the depth of their dependence structure, and how shallow dependence structures might beused to develop efficient parallel implementations. In this talk I will describe recent work on analyzing the dependence depth of iterative sequential algorithms---ones that loop over a collection of elements. Many of these algorithms have deep dependence chains in the worst case, but shallow chains (polylog w.h.p.) if the elements are randomly ordered. Examples include many fundamental algorithms: the Knuth shuffle for random permutations, sorting by insertion into a binary search tree, greedy maximal independent set (MIS), greedy maximal matching, greedy graph-coloring, counting cycles in a permutation, incremental k-dimensional linear programming, and incremental 2d Delaunay triangulation. An advantage of the approach is that it can lead to very simple and efficient parallel algorithms. Our MIS algorithm, for example can be coded in a dozen or so lines, and is significantly faster than Luby's algorithm on modern multicore machines. Also the approach encourages snapping the view that sequential and parallel algorithms are distinct, and instead thinking of algorithms, in general, as collections of instructions with dependences among them.

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.

To evaluate serologic testing algorithms for human immunodeficiency virus (HIV) based on a combination of rapid assays among persons with HIV-1 (non-B subtypes) infection, HIV-2 infection, and HIV-1-HIV-2 dual infections in Abidjan, Ivory Coast, a total of 1,216 sera with known HIV serologic status were used to evaluate the sensitivity and specificity of four rapid assays: Determine HIV-1/2, Capillus HIV-1/HIV-2, HIV-SPOT, and Genie II HIV-1/HIV-2. Two serum panels obtained from patients recently infected with HIV-1 subtypes B and non-B were also included. Based on sensitivity and specificity, three of the four rapid assays were evaluated prospectively in parallel (serum samples tested by two simultaneous rapid assays) and serial (serum samples tested by two consecutive rapid assays) testing algorithms. All assays were 100% sensitive, and specificities ranged from 99.4 to 100%. In the prospective evaluation, both the parallel and serial algorithms were 100% sensitive and specific. Our results suggest that rapid assays have high sensitivity and specificity and, when used in parallel or serial testing algorithms, yield results similar to those of enzyme-linked immunosorbent assay-based testing strategies. HIV serodiagnosis based on rapid assays may be a valuable alternative in implementing HIV prevention and surveillance programs in areas where sophisticated laboratories are difficult to establish.

In this chapter, we define the Boolean association rules and give a formulation of the problem of mining for such rules. Next, we devise sequential and parallel algorithms, based on search space partitioning, that solve this problem. In Section 2.1, we describe the basic objects involved in the problem of mining for association rules. We briefly discuss the relationship between the support/confidence measures and probability. We also discuss the relationship between the association rules and the logical implication. The procedure proposed in [S96] is considered to solve the mining problem. It consists of the following steps: (1) enumerate all frequent attribute sets, and (2) derive all association rules from this set. In Section 2.2, following and extending ideas proposed in [Z98], we identify the search space attached to the mining problem to the powerset 2 A , where A is the set of attributes involved. We define a family of equivalence relations over 2 A that are used in Section 2.3 to derive a partitioning procedure. The procedure is based on recursive bisection and consists of progressively splitting the powerset into finer and finer equivalence classes. Section 2.4 shows that the classes can be processed independently of one another. A join operator, stable with respect to the class partitioning, is proposed for this purpose. The join operator is next used within two partition-based algorithms for frequent attribute set enumeration: a sequential algorithm (Section 2.5) and a parallel one (Section 2.6). The latter requires both initial and dynamic load balancing. These issues are discussed in Section 2.6 where load balancing algorithms are given. Once the set of frequent attribute sets has been found, this set is processed in order to discover all association rules. This is the topic of Section 2.7 where two algorithms (a sequential algorithm and a parallel one) are described.

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.

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.

We present a parallel Delaunay refinement algorithm for generating well-shaped meshes in both two and three dimensions. Like its sequential counterparts, the parallel algorithm iteratively improves the quality of a mesh by inserting new points, the Steiner points, into the input domain while maintaining the Delaunay triangulation. The Steiner points are carefully chosen from a set of candidates that includes the circumcenters of poorly-shaped triangular elements. We introduce a notion of independence among possible Steiner points that can be inserted simultaneously during Delaunay refinements and show that such a set of independent points can be constructed efficiently and that the number of parallel iterations is O( log 2Δ), where Δ is the spread of the input — the ratio of the longest to the shortest pairwise distances among input features. In addition, we show that the parallel insertion of these set of points can be realized by sequential Delaunay refinement algorithms such as by Ruppert's algorithm in two dimensions and Shewchuk's algorithm in three dimensions. Therefore, our parallel Delaunay refinement algorithm provides the same shape quality and mesh-size guarantees as these sequential algorithms. For generating quasi-uniform meshes, such as those produced by Chew's algorithms, the number of parallel iterations is in fact O( log Δ). To the best of our knowledge, our algorithm is the first provably polylog(Δ) time parallel Delaunay-refinement algorithm that generates well-shaped meshes of size within a constant factor of the best possible.

Algorithms for generalized vertex-rankings of partial [formula omitted]-trees

We present sequential and parallel Monte Carlo algorithms for computing the solvent accessible surface area of protein molecules. The basic idea underlying our algorithms is to generate points uniformly at random on the surface of spheres obtained by increasing the van der Waals’ radii of the atoms with the van der Waals’ radius of the solvent molecule and to test the points for accessibility. We also present an efficient algorithm to compute sphere intersections more efficiently using domain specific knowledge. The expected running time of our sequential algorithm is O(n+s), where n is the number of atoms in the protein and s is the number of points generated. We also provide error bounds as a function of the sample size. Our parallel algorithm can use O(n) processors and provides linear speedup. Computing sphere intersections is common to the various approaches for solving this problem and our algorithm to compute the intersections can be used by them. It takes only O(n) sequential time, which compares favorably with existing algorithms that take O(n 2) worst-case time.KeywordsParallel AlgorithmHash TableAccessible Surface AreaSequential AlgorithmMonte Carlo ApproachThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Building on Kahn and Plotkin's theory of concrete data structures and sequential functions, Berry and Curien defined an intensional model of sequential algorithms between concrete data structures. In this paper we report on an attempt to develop a similar intensional model of concurrent computation. We present a notion of parallel algorithm between concrete data structures, together with suitable application and currying operations. We define an intensional strictness ordering on parallel algorithms, with respect to which application is well behaved (at first-order types). We define the input—output function computed by a parallel algorithm, and we show that every parallel algorithm computes a continuous function. Thus, a parallel algorithm may be viewed as a continuous function together with a parallel computation strategy. In contrast, a Berry—Curien sequential algorithm may be viewed as a sequential function together with a sequential computation strategy. The intensional strictness ordering on parallel algorithms corresponds to the pointwise ordering on the functions they compute, in the same sense that the set-inclusion ordering used by Berry and Curien on sequential algorithms corresponds to the stable ordering on the functions they compute. We believe that the ideas and results presented here constitute a first step towards a fuller understanding of the intensional semantics of parallelism, even though the model presented here is not yet general enough to provide a satisfactory account of higher-order algorithms, and lacks a notion of composition for algorithms. We present some ideas for overcoming these deficiencies and some directions for further research.

This paper proposes a variable neighborhood distance transformation algorithm for two‐ and three‐dimensional (2‐D and 3‐D) digital binary pictures which is based on a new concept called path extension. The properties and performance of the method are experimentally evaluated. An algorithm was constructed using path extension which calculates the variable neighborhood distance for all one pixels in a 2‐D picture, using a sequence of four and eight neighborhoods composed in an appropriate way.In previous distance transformation algorithms, the distance for the central pixel under consideration is calculated uniquely from the distances of several neighborhood pixels, while the distance transformation in the path extension algorithm is executed by determining the distances of several neighborhood pixels from the distance of the central pixel under consideration.This paper proposes a serial path extension algorithm and two parallel path extension algorithms for both 2‐D and 3‐D pictures. For comparison of performance, one serial and one parallel algorithm, which are modifications of the traditional fixed neighborhood algorithms, are further analyzed. Finally, the results of an experimental evaluation are presented for computation time in the five proposed algorithms.

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.

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>

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.