PMS6MC: A Multicore Algorithm for Motif Discovery

Abstract

We develop an efficient multicore algorithm, PMS6MC, for the (l, d)-motif discovery problem in which we are to find all strings of length l that appear in every string of a given set of strings with at most d mismatches. PMS6MC is based on PMS6, which is currently the fastest single-core algorithm for motif discovery in large instances. The speedup, relative to PMS6, attained by our multicore algorithm ranges from a high of 6.62 for the (17,6) challenging instances to a low of 2.75 for the (13,4) challenging instances on an Intel 6-core system. We estimate that PMS6MC is 2 to 4 times faster than other parallel algorithms for motif search on large instances.

I. Introduction

Motifs are patterns found in Biological sequences. These common patterns in different sequences help in understanding gene functions and lead to the design of better drugs to combat diseases. Several versions of the motif search problem have been studied the literature. In this paper, we consider the version known as the Planted Motif Search (PMS), or (l, d) motif search problem. In PMS, we are given n input strings and two integers l and d and we are to find all the strings M of length l (also referred to as l-mers) that are substrings of every input sequence¹ with at most d mismatches. The d-neighborhood of an l-mer s is defined to be the set of all the strings that differ from s in at most d positions. So, for an l-mer M to be motif for n input strings, there has to be a substring in each of those n input strings that is in the d-neighborhood of M.

The PMS problem is known to be NP-hard [13]. Consequently, PMS is often solved by approximation algorithms that do not guarantee to produce every motif present in the input. Exact algorithms for PMS, on the other hand, have exponential worst-case complexity but find every motif. MEME [3] and GibbsDNA [19] are two approximation algorithms which calculate the probability matrix of each character in different motif positions using statistical tools. CONSENSUS [15] first aligns the input sequences using statistical measures and then tries to extract the motifs. Randomized algorithms such as one by Buhler and Tompa [4] are also proposed for PMS. Local search strategies, e.g. by Price et al. [22] searches d-neighborhood of some set of l-mers from the input. MULTIPROFILER [17] and Profile-Branching [22] are two algorithms that also use local search. The WINNOWER algorithm [21], proposed by Pevzner maps PMS problem to that of finding large cliques in a graph and then applies common approximation techniques used in graph algorithms.

Although exact algorithms have worst-case exponential complexity, for many small instances of interest they are able to find all motifs within a reasonable amount of time using a modern computer. MITRA [12] is an exact algorithm for PMS that uses a modified trie called Mismatch trie to spell out the motifs one character at a time. SPELLER [26], SMILE [20], RISO [5], RISOTTO [23], CENSUS [14] all use some form of suffix tree or trie to direct motif discovery. Voting algorithms such as [6] use an indicator array of size equal to the number of all possible strings of length l. For each l-mer in the d-neighborhood of every l-mer from the input, the corresponding entry in the array is set. The entries that have been set by every input sequence or has “votes” from every input sequence are the motifs. Kauska and Pavlovic [18] designed an algorithm to output motif stems i.e. a superset of motifs using regular expression. The PMS series of algorithms (PMS1-PMS6, PMSP, and PMSPrune) solve PMS instances relatively fast using a reasonable amount of storage for data structures. PMS1, PMS2 and PMS3 [24] first sorts the d-neighborhood of input l-mers using radix sort and then intersects them to find the motifs. PMS4 [25] proposes a very general technique to reduce the run time of any exact algorithm by examining only k input sequences out of total n input sequences. PMSP [9] extends this idea further by only examining the d-neighborhood of the l-mers from the first input sequence. PMSPrune [9] improves upon PMSP by using dynamic programming branch-and-bound algorithm while exploring the d-neighborhoods. Pampa [10] uses wildcards to first determine the motif patterns and then does a exhaustive search within possible mappings of the pattern to find the motifs. PMS5 [11] improves other algorithms from PMS series by efficiently computing the intersection of the d-neighborhood of l-mers without generating the entire d-neighborhoods for all the l-mers. PMS6 [2], which is the fastest algorithm in the series, get its speedup by grouping l-mers whose d-neighborhood computation follows a similar process.

Since exact algorithms for motif search are compute intensive, it is natural to attempt parallelizations that reduce the observed run time. Dasari, Desh and Zubair [7] have proposed a multi-core motif search algorithm that is based on the voting approach. They followed this work with another parallel algorithm for Graphics Processing Units (GPUs) [8] based on examining the branches of a suffix tree in parallel.

In this paper, we develop a multi-core version of PMS6 by generating and processing many d-neighborhoods in parallel. In Section II we introduce some notations and definitions used throughout the paper and also describe the PMS6 algorithm in detail. The techniques used to develop PMS6MC are described in Section III. The performance of PMS6MC is compared to that of other parallel motif search algorithms and PMS6 in Section IV.

II. PMS6

A. Notations and Definitions

We use the same notations and definitions as in [11]. An l-mer is simply any string of length l. r is an l-mer of s iff (a) r is an l-mer and (b) r is a substring of s. The notation r ε_l s denotes an l-mer r of s. The Hamming distance, d_H(s, t), between two equal length strings s and t is the number of places where they differ and the d-neighborhood, B_d(s), of a string s, is {x|d_H(x, s) ≤ d}. Let N(l, d) = |B_d(s)|. It is easy to see that $N(l,d)={\sum }_{i=0}^d\left(\begin{array}{c}\hfill l\hfill \\ \hfill i\hfill \end{array}\right){(|\mathrm{\Sigma }|-1)}^i$, where ∑ is the alphabet in use. We also define B_d(x, y, z) to be B_d(x) ∩ B_d(y) ∩ B_d(z). For a set of triples C, we define B_d(C) as ∪(_x,y,z)εC(B_d(x, y, z)). We note that x is an (l, d) motif of a set S of strings if and only if (a) |x| = l and (b) every s ε S has an l-mer (called an instance of x) whose Hamming distance from x is at most d. The set of (l, d) motifs of S is denoted M_l,d(S).

B. Overview

PMS6, which is presently the fastest exact algorithm to compute M_l,d(S) for large (l, d), was proposed by Bandyopadhyay, Sahni and Rajasekaran [2]. This algorithm (Figure 1) first computes a superset, Q′, of the motifs of S. This superset is then pruned to M_l,d(S) by the function output Motifs, which examines the l-mers in Q′ one by one determining which are valid motifs. This determination is done in a brute force manner.

Figure 1.

PMS6 [2]

To compute Q′, PMS6 examines triples (x, y, z), where x is an l-mer of s₁ and y and z are l-mers of s_2kand s_2k+1, respectively for some fixed k. These triples are first partitioned into equivalence classes based on the number of positions in the l-mers of a triple that are of each of 5 different types (see below). Next, we compute the B_dfor all triples by classes. This two step process is elaborated below.

Step 1: Form Equivalence Classes. Classify each position i of the triple (x, y, z), into one of the following five types [11]:

• Type 1: x[i] = y[i] = z[i].

• Type 2: x[i] = y[i] ≠ z[i].

• Type 3: x[i] = z[i] ≠ y[i].

• Type 4: x[i] ≠ y[i] = z[i].

• Type 5: x[i] ≠ y[i], x[i] 6= z[i], y[i] 6= z[i].

The triples (x, y, z) of l-mers such that x ε_l s₁, y ε_ls_2kand z ε_l s_2k+1 are partitioned into classes C(n₁, ⋯, n₅) where n_jdenotes the type j positions in the triple (x, y, z) (for 1 ≤ j ≤ 5).

Step 2: Compute B_d for all triples by classes. For each class C(n₁, ⋯, n₅), the union, B_d(C), of B_d(x, y, z) for all triples in that class is computed. We note that the union of all B_d (C)s is the set of all motifs of x, s_2k, and s_2k+1.

III. PMS6MC

A. Overview

PMS6MC exploits the parallelism present in the PMS6 algorithm. First, there is outer-level parallelism where the motif search for many x’s from s₁ can be carried out in parallel (i.e., several iterations of the outer for loop of Figure 1 are run in parallel). Second, there is inner-level parallelism where the individual steps of the inner for loop of Figure 1 can be done in parallel. Outer-level parallelism is limited by the amount of memory available. We have designed PMS6MC to be flexible in terms of its memory and thread requirements. The total number of threads can be set depending on the number of cores and available memory of the system. The threads are grouped into thread blocks. Each thread block operates on a different x from s₁. The threads assigned to a thread block cooperate to find the motifs corresponding to a particular x. The threads use the syncthreads() primitive function to synchronize. This function can be implemented using the thread library synchronization mechanism available under different operating systems. We denote thread block i as T [i] while the threads within thread block i are denoted by T [i][j].

B. Outer-level parallelism

In this, each thread block processes a different x from s₁ and calls the function find Motif At This X() (Figure 2). Once a thread block is done with its assigned x it moves on to the next x from s₁ which is not processed yet. Threads in a thread block execute the function find Motif At This X() to find if there is any motif in the d-neighborhood of x.

Figure 2.

PMS6MC outer level loop

C. Inner-level parallelization

Finding motifs in the d-neighborhood of a particular x from s₁ is done by finding the motifs of x and the strings s_2kand s_2k+1 for $k=1\cdots \lfloor \frac{n-1}{2}\rfloor$ . As described in Figure 1, this is a 4 step process. These steps are done cooperatively by all threads in a thread block. First, we find the equivalence classes for x and l-mers from s_2kand s_2+1k. For any triple (x, y, z) from an equivalence class we know the number of l-mers w which are at a distance d from x, y and z from pre-computed tables. Hence, by multiplying the number of triples with the number of possible w’s we determine the total number of w’s for each equivalence class. We denote this number by |B_d(C)|. Next, we compute B_d(C) for these equivalence classes in decreasing order of |B_d(C)| in parallel by the threads in the thread block. This order helps in load balancing between different threads as each will be computing |B_d(C)| in parallel. This is akin to using the LPT scheduling rule to minimize finish time. Then we need to store B_d(C)s in Q if k = 1; i.e., when finding motifs between x, s₂ and s₃. This can be done during the previous step while computing B_d(C). For k ≥ 2, we need to intersect the set of all B_d(C)s with Q. When the size of Q falls below a certain threshold, we need to execute the function output Motifs to find out which l-mers in Q are valid motifs. The different steps for find Motif At This X() are given in Figure 3. Reader is referred to [1] for a detailed description of each step along with the pseudocode.

Figure 3.

Finding motifs in parallel

IV. Experimental results

We evaluated the performance of PMS6MC on the challenging instances described in [11]. For each (l, d) that characterizes a challenging instance, we generated 20 random strings of length 600 each. Next, a random motif of length l was generated and planted at random positions in each of the 20 strings. The planted motif was then randomly mutated in exactly d randomly chosen positions. For each (l, d) value up to (19,7), we generated 20 instances and for larger (l, d) values, we generated 5 instances. The average run times for each (l, d) value are reported in this section. Since the variation in run times across instances was rather small, we do not report the standard deviation. Even though we test our algorithm using only synthetic data sets, several authors (e.g., [11]) have shown that PMS codes that work well on the kind of synthetic data used by us also work well on real data.

A. PMS6MC implementation

PMS6MC is implemented using the pthreads (POSIX Threads) library under Linux on an Intel 6-core system with each core running at 3.3GHz. We experimented with different degrees of outer-level (number of thread blocks) and inner-level (number of threads in a thread block) parallelism for different challenging instances. For smaller instances (e.g. (13,4) and (15,5)), the performance is limited by the memory bandwidth of the system. Hence, increasing the degree of inner or outer level parallelism does not have much effect on the run time as most of the threads stall for memory access. For larger instances, the number of thread blocks is limited by the available memory of the system. Figure 4 gives the number of thread blocks and the number of threads in a thread block for different challenging instances which produces the optimum performance.

Figure 4.

Degree of inner and outer level parallelism for PMS6MC

B. PMS6 and PMS6MC

We compare the run times of PMS6 and PMS6MC on an Intel 6-core system with each core running at 3.3GHz. PMS6 takes 22 seconds on an average to solve (15,5) instances and 19 hours on an average to solve (23,9) instances. PMS6MC, on the other hand, takes 8 seconds on an average to solve (15,5) instances and 3.5 hours on an average to solve (23,9) instances. The speedup achieved by PMS6MC over PMS6 varies from a low of 2.75 for (13,4) instances to a high of 6.62 for (21,8) instances. For (19,7) and larger instances PMS6MC achieves a speedup of over 5. The run times for various challenging instances are given in Figure 5.

Figure 5.

Run times for PMS6 and PMS6MC

C. PMS6MC and other parallel algorithms

We estimate that PMS6MC can solve (19,7) instances 3.6 times faster than mSPELLER-16 using the 16-core CPU of [8] and about 2 times faster than gSPELLER-4 using 4 GPU devices. The detailed derivation of these estimates is given in [1]

V. Conclusion

We have developed a multicore version of PMS6 that achieves a speedup that ranges from a low of 2.75 for (13,4) challenging instances to a high of 6.62 for (17,6) challenging instances on a 6-core CPU. Our multicore algorithm is able to solve (23,9) challenging instances in 3.5 hours while the single core PMS6 algorithm takes 19 hours. We estimate that our multicore algorithm is faster than other parallel algorithms for the motif search problem on large challenging instances. For example, we estimate that PMS6MC can solve (19,7) instances 3.6 times faster than mSPELLER-16 using the 16-core CPU of [8] and about 2 times faster than gSPELLER-4 using 4 GPU devices.