Efficient CGM-based parallel algorithms for the longest common subsequence problem with multiple substring-exclusion constraints

Highlights

• Detail of the Wang et al.’s sequential dynamic programming algotihm solving the M-STR-EC-LCS problem.

• Describing of a multi-level Direct Acyclic Graph (task graph) for produce a bottom-up approach following the Wang et al.’s recursive formula for solve a M-STR-EC-LCS problem.

• Describing two BSP/CGM parallel algorithms based on our task graph.

• Experimental study.

• Comparison between theorical and computational results.

Abstract

A variant of the Longest Common Subsequence (LCS) problem is the LCS problem with multiple substring-exclusion constraints (M-STR-EC-LCS), which has great importance in many fields especially in bioinformatics. This problem consists to compute the LCS of two strings X and Y of length n and m respectively that excluded a set of d constraints $P=\{P_1,P_2,\dots ,P_d\}$ of total length r. Recently, Wang et al. proposed a sequential solution based on the dynamic programming technique that requires $\mathcal{O}\left(nmr\right)$ execution time and space. To the best of our knowledge, there is no parallel solutions for this problem. This paper describes new efficient parallel algorithms on Coarse Grained Multicomputer model (CGM) to solve this problem. Firstly, we propose a multi-level Direct Acyclic Graph (DAG) that determines the correct evaluation order of sub-problems in order to avoid redundancy due to overlap. Secondly, we propose two CGM parallel algorithms based on our DAG. The first algorithm is based on a regular partitioning of the DAG and requires $\mathcal{O}\left(\frac{nmr}{p}\right)$ execution time with $\mathcal{O}\left(p\right)$ communication rounds where p is the number of processors used. Its main drawback is high idleness time of processors because due to the dependencies between the nodes in the DAG, over time it has many idle processors. The second algorithm uses an irregular partitioning of the DAG that minimizes this idleness time by allowing the processors to stay active as long as possible. It requires $\mathcal{O}\left(\frac{nmr}{p}\right)$ execution time with $\mathcal{O}\left(kp\right)$ communication rounds. k is a constant integer allowing to setup the irregular partitioning. The both algorithms require $\mathcal{O}\left(\frac{r\left|\Sigma \right|}{p}\right)$ preprocessing time where |Σ| is the length of the alphabet. The experimental results performed show a good agreement with theoretical predictions.

Introduction

Finding the longest common subsequence (LCS) of two sequences is a well-known measurement for computing the similarity of two strings, and it is crucial in various applications. It is therefore a well-studied problem in computer science, and can be widely applied in various fields such as text and music information retrieval, file comparison, pattern matching, spelling correction and computational biology [1], [2], [3], [4]. Formally given two strings X and Y, the LCS problem consists to find another string Z which is common to X and Y and which is of maximal size. To solve this problem, Wagner and Fischer [5] firstly proposed a quadratic time and space solution based on the dynamic programing technique which find the LCS by computing the edit distance between the sequences. To ameliorate this solution, many advanced solutions were proposed in the past decade [6], [7], [8], [9].

Many variants of the LCS problem have been proposed for particular applications. For example, the mosaic LCS problem, the merged LCS problem, the cyclic chain correction problem and the block editing problem. The most recent variant which have receive most attention is the Constrained-LCS (CLCS) problem and was first addressed by Tsai [10]. More recently, Chen and Chao [11] proposed a more generalized form of the CLCS problem (GC-LCS) which is formally define as follow: given two input sequences, $X=x_1{x}_2\dots x_n$ and $Y=y_1{y}_2\dots y_m,$ of length n and m respectively, and a constraint string $P=p_1{p}_2\dots p_r,$ of length r, r ≤ min (n, m) the GC-LCS problem is a set of four problems that find the LCS of X and Y which includes/excludes P as a subsequence/substring. This set of problems can be more generalized by considering many constraints. Therefore, instead of using a single constraint P of length r, they generalize it to a set of d constraints $\{P_1,P_2,\dots ,P_d\}$ of total length r. This generalization is shown in Table 1 [11].

In this work, we tackle the problem of parallelizing the Wang et al. sequential algorithm [12] for M-STR-EC-LCS problem on the BSP/CGM model (Bulk Synchronous Parallel/Coarse Grained Multicomputer) [13], [14], [15], [16], [17]. This model seems to be the best for the design of algorithms that are not too dependent on a particular architecture. A BSP/CGM machine is a set of p processors, each having its own local memory of size s (with $\mathcal{O}\left(s\right)\gg \mathcal{O}\left(1\right)$) and connected to each other through a router able to deliver messages in point-to-point manner. Each BSP/CGM parallel algorithm is an alternation of local computations and global communication rounds. Each communication round consists in routing a single h-relation with $h=\mathcal{O}\left(s\right)$. Each CGM computation or communication round corresponds to a BSP super-step having a communication cost g × s [17]. Here, g is the cost of a communication of a word in the BSP model. In order to produce an efficient BSP/CGM parallel algorithm, the effort of the designers must be to maximize speed-up and minimize the number of communication rounds (ideally, it must be independent from the problem size, and constant in the optimum).

Many CGM-based parallel algorithms modelled by dynamic programming for some problem including the Minimum Cost Parenthesizing problem and the Optimal Binary Search Tree problem have been proposed [18], [19]. For the LCS problem, Garcia et al. [20] proposed a CGM-based solution which require $\mathcal{O}\left(\frac{n^2}{p}\right)$ computation time and p communication rounds (n is the length of the two sequences and p is the number of processors). Alves et al. [21] proposed for all-substrings LCS problem, a solution which runs in $\mathcal{O}\left(\frac{nm}{p}\right)$ time steps and $\mathcal{O}\left(\log p\right)$ communication rounds on p processors (n and m are lengths of the original strings).

Myoupo et al. [22] proposed the first CGM-based solutions for the string-excluding constrained LCS problem which require respectively $\mathcal{O}\left(\frac{nmr}{\sqrt{p}}\right)$ time steps and $\mathcal{O}\left(\sqrt{2p}\right)$ communication rounds, and $\mathcal{O}\left(\frac{nmr}{p}\right)$ time steps with $\mathcal{O}\left(p\right)$ communication rounds (n and m are the length of the two sequences, and r is length of the constraint string). However, there is no parallel solution for the M-STR-EC-LCS problem to the best of our knowledge.

Recently, Chen and Chao [11] proposed for the M-STR-IC-LCS and M-STR-EC-LCS problems an exponential solution and therefore declare without proof that they are NP-Hard. Furthermore, Wang et al. [12] proposed a simple dynamic programming algorithm (by defining a recursive formula) for the M-STR-EC-LCS problem that requires $\mathcal{O}\left(nmr\right)$ execution time and space, where n and m are the lengths of the two given input strings, and r is the total length of the d constraints. This solution uses a state machine also called finite automata defined by Aho and Corasick [23] which speedup the exact string matching of multiple patterns.

Our contribution is to propose two BSP/CGM parallel algorithms based on the Wang et al.’s sequential algorithm [12] to solve the M-STR-EC-LCS problem. Firstly, we propose a multi-level Direct Acyclic Graph (DAG) called task graph that determines the correct evaluation order of sub-problems, in order to avoid redundancy due to overlap and produce a bottom-up approach following the Wang et al.’s recursive formula that will solve the entire problem. Secondly, based on our task graph, we propose two BSP/CGM parallel algorithms. It can be summarized as follows:

• In the first algorithm, we subdivide this task graph into sub-graphs (or blocks) of same size, and distribute them fairly onto the processors. It requires $\mathcal{O}\left(\frac{nmr}{p}\right)$ execution time with $\mathcal{O}\left(p\right)$ communication rounds and $\mathcal{O}\left(\frac{r\left|\Sigma \right|}{p}\right)$ preprocessing time. |Σ| is the length of the alphabet and p is the number of processors used. This strategy promotes load-balancing between the processors, but its main drawback is high idleness time of processors. Indeed, due to the dependencies between the nodes in the DAG, over time several processors cannot be active at the same time;

• The second algorithm uses an irregular partitioning, based on the fragmentation of the blocks of the task graph, to reduce the idleness time of the processors. It requires $\mathcal{O}\left(\frac{nmr}{p}\right)$ execution time with $\mathcal{O}\left(kp\right)$ communication rounds. k is a constant integer defining the number of fragmentation to perform.

Finally, we implement our algorithms and we conclude that the experimental results performed show a good agreement with theoretical predictions.

The organization of this paper is as follow: in Section 2, we present the principle of using finite automaton to detect an occurrence of a substring in a sequence and describe its usage in the Wang et al.’s sequential algorithm. We describe our multi-level DAG model in Section 3. Our BSP/CGM algorithms are presented in Section 4 and Section 5. Section 6 presents experimental results. We end this paper with some concluding remarks and future research directions.