Carlos Eduardo Rodrigues Alves

Parallel dynamic programming for solving the string editing problem on a CGM/BSP

In this paper we present a coarse-grained parallel algorithm for solving the string edit distance problem for a string A and all substrings of a string C. Our method is based on a novel CGM/BSP parallel dynamic programming technique for computing all highest scoring paths in a weighted grid graph. The algorithm requires \log p rounds/supersteps and O(\fracn^2p\log m) local computation, where

A parallel wavefront algorithm for efficient biological sequence comparison

p

Alignment with non-overlapping inversions in O ( n 3 )-time

is the number of processors, p^2 \leq m \leq n. To our knowledge, this is the first efficient CGM/BSP algorithm for the alignment of all substrings of C with A. Furthermore, the CGM/BSP parallel dynamic programming technique presented is of interest in its own right and we expect it to lead to other parallel dynamic programming methods for the CGM/BSP.

An all-substrings common subsequence algorithm

In this paper we present a parallel wavefront algorithm for computing an alignment between two strings A and C, with |A| = m and |C| = n. On a distributed memory parallel computer of p processors each with O((m + n)/p) memory, the proposed algorithm requires O(p) communication rounds and O(mn/p) local computing time. The novelty of this algorithm is based on a compromise between the workload of each processor and the number of communication rounds required, expressed by a parameter called α. The proposed algorithm is expressed in terms of this parameter that can be tuned to obtain the best overall parallel time in a given implementation. We show very promising experimental results obtained on a 64-node Beowulf machine. A characteristic of the wavefront communication requirement is that each processor communicates with few other processors. This makes it very suitable as a potential application for grid computing.

BSP/CGM Algorithms for Maximum Subsequence and Maximum Subarray

Alignments of sequences are widely used for biological sequence comparisons. Only biological events like mutations, insertions and deletions are usually modeled and other biological events like inversions are not automatically detected by the usual alignment algorithms. Alignment with inversions does not have a known polynomial algorithm and a simplification to the problem that considers only non-overlapping inversions were proposed by Schoniger and Waterman [20] in 1992 as well as a corresponding O(n6) solution. An improvement to an algorithm with O(n3 logn)-time complexity was announced in an extended abstract [1] and, in this present paper, we give an algorithm that solves this simplified problem in O(n3)-time and O(n2)-space in the more general framework of an edit graph. Inversions have recently [4,7,13,17] been discovered to be very important in Comparative Genomics and Scherer et al. in 2005 [11] experimentally verified inversions that were found to be polymorphic in the human genome. Moreover, 10% of the 1,576 putative inversions reported overlap RefSeq genes in the human genome. We believe our new algorithms may open the possibility to more detailed studies of inversions on DNA sequences using exact optimization algorithms and we hope this may be particularly interesting if applied to regions around known rearrangements boundaries. Scherer report 29 such cases and prioritize them as candidates for biological and evolutionary studies.

A BSP/CGM algorithm for the all-substrings longest common subsequence problem

Abstract Given two strings A and B of lengths n a and n b , n a ⩽ n b , respectively, the all-substrings longest common subsequence (ALCS) problem obtains, for every substring B ′ of B, the length of the longest string that is a subsequence of both A and B ′ . The ALCS problem has many applications, such as finding approximate tandem repeats in strings, solving the circular alignment of two strings and finding the alignment of one string with several others that have a common substring. We present an algorithm to prepare the basic data structure for ALCS queries that takes O ( n a n b ) time and O ( n a + n b ) space. After this preparation, it is possible to build a matrix of size O ( n b 2 ) that allows any LCS length to be retrieved in constant time. Some trade-offs between the space required and the querying time are discussed. To our knowledge, this is the first algorithm in the literature for the ALCS problem.

A BSP/CGM algorithm for finding all maximal contiguous subsequences of a sequence of numbers

The maximum subsequence problem finds the contiguous subsequence of n real numbers with the highest sum. This problem appears in the analysis of DNA or protein sequences. It can be solved sequentially in O(n) time. In the 2-D version, given an n × n array A, the maximum subarray of A is the contiguous subarray that has the maximum sum. The sequential algorithm for the maximum subarray problem takes O(n 3) time. We present efficient BSP/CGM parallel algorithms that require a constant number of communication rounds for both problems. In the first algorithm, the sequence stored on each processor is reduced to only five numbers, so that the resulting values can be concentrated on a single processor which runs an adaptation of the sequential algorithm to obtain the result. The parallel algorithm requires O(n/p) computing time. In the second algorithm, the input array is partitioned equally among the processors and we first reduce each subarray to a sequence, and then apply the first algorithm to solve it. The parallel algorithm takes O(n 3/p) computing time. The good performance of the parallel algorithms is confirmed by experimental results run on a 64-node Beowulf parallel computer.

Efficient Parallel Implementation of Transitive Closure of Digraphs

Given two strings X and Y of lengths m and n, respectively, the all-substrings longest common subsequence (ALCS) problem obtains the lengths of the subsequences common to X and any substring of Y. The sequential algorithm takes O(mn) time and O(n) space. We present a parallel algorithm for ALCS on a coarse-grained multicomputer (BSP/CGM) model with p < /spl radic/m processors that takes O(mn/p) time and O(n/spl radic/m) space per processor, with O(log p) communication rounds. The proposed parallel algorithm also solves the well-known LCS problem. To our knowledge this is the best BSP/CGM algorithm for the ALCS problem in the literature.

Comparison of genomes using high-performance parallel computing

Given a sequence A of real numbers, we wish to find a list of all non-overlapping contiguous subsequences of A that are maximal. A maximal subsequence M of A has the property that no proper subsequence of M has a greater sum of values. Furthermore, M may not be contained properly within any subsequence of A with this property. This problem can be solved sequentially in linear time. We present a BSP/CGM algorithm that uses p processors and takes O (|A|/p) time and O (|A|/p) space per processor. The algorithm uses a constant number of communication rounds of size at most O (|A|/p). Thus the algorithm achieves linear speed-up and is highly scalable.

Efficient representations of row-sorted 1-variant matrices for parallel string applications

Based on a CGM/BSP parallel algorithm for computing the transitive closure of an acyclic directed graph (digraph), we present a modified version that works for any digraph and show very promising implementation results. The original CGM/BSP algorithm for acyclic digraphs uses a linear extension labeling of the vertices. With this labeling, the original algorithm can be shown to require log p + 1 communication rounds, where p is the number of processors. The modified CGM/BSP algorithm works for any digraph and does not use the linear extension labeling. In theory the modified version no longer guarantees the O(log p) bound on the number of communication rounds, as shown by an artificially elaborated example that requires more than log p + 1 communication rounds. In practice, however, all the graphs tested use at most log p + 1 communication rounds. The implementation results are very promising and show the efficiency and scalability of the proposed modified algorithm, and compare favorably with other parallel implementations.