FPGA Based Agrep for DNA Microarray Sequence Searching

Transcription

1 2009 International Conference on Computer Engineering and Applications IPCSIT vol.2 (20) (20) IACSIT Press, Singapore FPGA Based Agrep for DNA Microarray Sequence Searching Gabriel F. Villorente, 2 Mark Oliver L. Ouano, 3 Mary Grace C. Dy Jongco, 4 Emilyn B. Escabarte Research and Development Division, Advanced Science and Technology Institute Department of Science and Technology Abstract. DNA sequence matching done on a large database that grows exponentially is a fundamental task in Bioinformatics. The exponential growth drives the need to increase computational power. One of the emerging means for accelerating bioinformatics applications is through cluster computing; however, many research activities are done against these clusters. With the aim to offload straightforward tasks such as sequence matching from these cluster nodes, this paper utilizes the capability of FPGA to parallelize such processes and introduces a hardware-based implementation of Agrep, a fast text searching algorithm capable to allow approximate matches. The design was implemented in Opal Kelly XEM300 and was tested using DNA microarray sequences from the NCBI virus probe database. Results indicate significant improvement in performance in terms of runtime and throughput as compared to a software-based Agrep. Keywords: FPGA, Agrep, Bioinformatics, high-performance computing, reconfigurable computing, text searching, sequence searching, DNA.. Introduction Cluster computing offers cost effective solution to high performance computing applications. Such of these applications are those in Bioinformatics. These applications range from database sequence searching to pattern alignment, restriction enzyme mapping, and others. In all of these highly compute intensive applications, sequence searching or pattern matching is present. In addition, rapid growth in databases (e.g. GenBank) propels the need for higher computational power. If many applications are running altogether on the cluster, simple iterative operations would only eat up resources and compete with critical and computationally intensive tasks. A solution to this it to offload simple operations such as sequence matching to auxiliary compute nodes thereby improving performance using reconfigurable hardware technology to parallelize processes... Objectives This project aims to implement Agrep, a fast text searching algorithm, on a Field Programmable Gate Array (FPGA) as an auxiliary computing peripheral..2. Project Scope The auxiliary computing peripheral will be used to search DNA micro array sequences from the NCBI Virus Probe database. Each Agrep module supports a query length from 0 to 70 DNA characters. Inexact string matching is also allowed, tolerating a maximum of 3-character errors. The prototype implemented in this study runs on Opal Kelly XEM300 attached to a USB port of a host computer. Tel.: (+632) loc 30 Fax: (+632) address: gabo@asti.dost.gov.ph; 2 markoliver@asti.dost.gov.ph; 3 gracedj@asti.dost.gov.ph; 4 emilyn@asti.dost.gov.ph 206

2 2. Agrep Algorithm The Agrep, popularly known as an approximate grep, is a fast text searching algorithm. It was developed by Sun Wu and Udi Manber from the Department of Computer Science, University of Arizona. This string searching algorithm incorporates possible errors; hence, this makes the process more flexible to cater to approximate string matches. With a string query compared against a database, the algorithm can detect exact and approximate matches, which are those with insertions, deletions, and substitutions. The approximate matches are introduced to find all substrings with a measure of closeness relative to the query pattern. File Stream Query String Character Masking Set of Characters Exact Matching R Rshift[ R ]AND S 0 = 0 j+ j c Matching with Errors: Insertion d d d R = j Rshift[ Rj ]AND Sc OR R + j Deletion R = Rshift[ R ]AND S OR Rshift[ R ] d d d j+ j c j+ Substitution R Rshift R S Rshift R d = d d j+ [ j ]AND c OR [ j ] Agrep Algorithm Fig. : Agrep Algorithm. Agrep algorithm is composed of two stages stage, character masking and stage 2, scanning stage. Character masking generates bit arrays with the same size as the query string that denotes characters that appear in the pattern. Every character in the file stream with a generated mask enters the scanning stage. The scanning stage performs the shift, OR, and AND operations depending on a set of working equations for exact match and matches with insertion(s), deletion(s) and substitution(s). 3. Design and Implementation 3.. Agrep Hardware Fig. 2: Agrep base module. Fig. 3: Agrep d-error module. 207

3 Agrep hardware implementation is designed to be modular. The d-error module, connected to the base module, checks for the approximate match. The number of errors that can be detected depends on how many times the d-error module is replicated and cascaded System Architecture Fig. 4 shows the system overview. It is a computer cluster composed of servers. One of the servers has the database and this where the FPGA board is attached to for the purpose of optimum performance. The entire system (FPGA based Agrep) is subdivided into two, software and hardware, which communicates through the USB protocol. Fig. 4: System Overview Software It manages the sequence of events during runtime as well as the function calls to perform the search. It has the following components: Database - a collection of DNA microarray sequences File Table - written here are the locations to search in User Interface - a web based user interface FrontPanel DLL - a library of functions for USB communications FPGA setup - setups the FPGA board Read Block - obtains the results from the FPGA Search Process - conducts the actual search process Preprocess - parses the database prior to actual processing of the database Fig. 5: Software Block Diagram. 208

4 Software has two main processes, preprocessing and the actual search process. Preprocessing s task is to extract the DNA microarray sequence from the files, check and replace invalid characters ( A, C, T & G only are allowed), perform conversion from 8-bit ASCII to 2-bit code and save the results into a dbase file. On the search process, the query and dbase files are transmitted to the board; then, the FPGA performs the search. Once done, the result data is transmitted back. The software presents the result as a text file where the user interface block presents it to the user after reading the file FPGA Fig. 6: Block Diagram of FPGA Design. FPGA design architecture, as illustrated above, is designed to implement Agrep algorithm in hardware and to communicate to the host software through the USB protocol. Each of the blocks is described below. HDL Host Interface - handles FPGA-PC communication Expander - generates the file stream masks Query - accepts the query file from the software including the query length Agrep Modules - perform the actual searching Result Counter - counter that increments if there is a match and/or approximate match First In First Out Buffer - used for temporary storage DCM (Digital Clock Manager) - provides the clock signals The FPGA accepts data streams from the software and performs the search. A total of 8 Agrep modules are embedded in the FPGA. Each Agrep module has a corresponding set of counters that increments if there is a match and/or approximate match for that specific file. The result of the counters are then temporarily stored in a First in First out Buffer. Subsequently, it transmits the data back in the buffer to the software. The software then writes the output file for that session. 4. Verification Test cases were introduced to compare the performance of the hardware developed with that of software implementation run on a computer with a 2.2 GHz Intel Pentium dual-core processor and a 2 GB RAM. The test cases for the system comprise seven queries of lengths 0, 20, 30, 40, 50, 60 and 70 characters. Multiple simulations were performed by replicating the database size from (x = 43 MB) to 2x, 3x, 4x, 5x, 6x, 7x, 8x, 9x, and 0x for each set of query sequences. Shown below are the sequences used for verification. Fig. 7: DNA Virus Probe microarray sequence for Human Herpesvirus (Probe ID ). 209

5 Fig. 8: Summary of the runtime results of software and hardware implementations. 5. Performance Evaluation Fig. 9: Speedup of hardware over software implementation. It can be observed from the figure above that the speedup increases as the size of the database and query length increases. The peak CPU usage levels are also compared. The CPU usage of the software implementation reached 58% versus the 38% peak usage of the PC + FPGA setup. 6. Conclusion In conclusion, an 8-core FPGA-based Agrep was implemented and deployed in the Philippine e-science Grid, with the task of offloading DNA microarray sequence searching operations from the cluster. Consequently, using this implementation, up to 20 times boost in performance was achieved. 7. References [] Ahmad, Cluster Computing: A Glance at Recent Events, IEEE Technical Committee on Scalable Computing, [2] S. Wu and U. Manber, Fast Text Searching With Errors, Technical Report TR 9-, Department of Computer Science, University of Arizona, Tucson, AZ8572, June 99. [3] Opal Kelly, FrontPanel User Manual, [4] E. Sotiriades, C. Kozanitis, and A. Dollas, FPGA based Architecture for DNA Sequence Comparison and Database Search, Microprocessor and Hardware Laboratory, Technical University of Crete, Chania 7300 Greece, [5] N. Pappas, Searching Biological Sequence Databases Using Distributed Adaptive Computing, Department of Electrical and Computer Engineering, Virginia Polytechnic Institute and State University, Blacksburg Virginia, January