EFFICIENT GENOMIC SEQUENCING THROUGH HARDWARE

ACCELERATION

ABSTRACT:-Sequence alignment is an important component in bioinformatics. Different

protein sequence and DNA sequence aligners are used for this purpose. Accelerators are
becoming increasingly commonplace in delivering high performance computing. In
this paper we reviewed the literature and find the hardware accelerated platform like GPUs,
FPGAs, Big data that is used for efficient, scalable and for faster DNA or protein sequencing

Introduction

DNA sequencing is the process of determining the CLASSIFICATION OF LITERATURE

accurate order nucleotide along chromosome and
genomes.DNA sequencing is essential for a deep
understanding of human genetics[2],Next
Generation Sequencing also known as high
throughput Sequencing, NGS has changed the
study of Genomics, NGS allows to sequence DNA
more quickly and inexpensive than previous
Sanger, So this fast reduction in the cost of DNA
Sequencing is making it an accessible method for
researchers to use it at level that was never before
possible.the sequencer can produce millions of
short reads in parallel, small fragments of DNA
called short reads the NGS output so called Short
reads. NGS platform are able to generate large
amounts of DNA Sequencing date ranges up to
hundreds of GB's, However, Due to large volume of
data it would take long time to compute, for this
purpose there is an urgent need to develop
scalable high performance computational
solutions to address these challenges. For this
purpose the author used CPU, GPU’s, FPGA’s, big
data techniques, cluster based and distributed
based computing to solve these challenges.
In this section we classified the literature based
on hardware platform.we analyzed and
compared some of the approaches used and
proposed by authors in the research papers to
accelerate DNA and Protein Sequencing.
Using GPU’s
Graphical Processing Unit is a computer part
that makes a computer work and tick over
speedily. GPU is used to tackle computational
challenges, and commonly used in many
bioinformatics tools to accelerate the
computationally intensive algorithms and
improve their performance.
In paper [21] the author presents a Graphical
Processing Units(GPUs) accelerated Smith-
Waterman for protein sequence
alignment.Smith-waterman(S-W) set of rules is a
superior sequence alignment method for organic
databases, however its computational
complexity makes it too sluggish for realistic
purposes. Heuristics primarily based
approximate techniques like FASTA and BLAST
offer quicker solutions but at the cost of
decreased accuracy. Also the increasing extent
and ranging lengths of sequences require
execution proficient rebuilding of these
databases. Subsequently to come up with a
precise and quick arrangement it’s far fairly
preferred to hurry up with the S-W set of rules,
an elite protein arrangement for Graphics
processing Units (GPUs). The brand new
implementation improves overall performance
by advancing the database association also;
decreasing the quantity of memory gets to wipe
out transfer speed bottlenecks. The
implementation is referred to as Database
Optimized Protein alignment (DOPA) and it
achieves a performance of 21.4 Giga cell updates
per second which is 1.13 times higher than the
quickest GPU implementation up to now.
In paper [22] the authors evaluate two different
implementation methods to accelerate the pair-
HMMs forward algorithm using different
datasets to compare the performance. Inter-task
parallelization and intra-task parallelization are
the way to accelerate PFA on GPU. In inter-task
parallelization the whole processing is mapped
to a single thread. Several copies of algorithm
running in parallel. Each thread implements the
algorithm independently. In intra-task
parallelization the algorithm is mapped to a
single thread block. This method requires a
whole block of threads to compute a single copy
of algorithm. This reduces the no of copies of the
algorithm that can executed in parallel on the
GPUs compared to the inter-task
parallelization.Operation of PFA are in the
floating-point domain.The GPU implementations
with reorganized dataset achieve larger
throughput than with original dataset.The inter-
task implementation with reorganized dataset
achieved the biggest throughput, which is 12.79
GCUPS.the inter-task implementation with
reorganized dataset is 18.19x faster than with
originaldataset.Reorganizing the dataset makes
intra-task implementation 2.19x faster.With
original dataset, it is better to use intra-task
implementation.The intra-task implementation
with original dataset is 7.5x faster than the inter-
task implementation with original dataset. The
intra-task implementation has the highest
throughput as high as 23.56 GCUPS
In paper [23] the author presents, to accelerate
the PFA on GPU to improve the performance of
GATK HC. This paper is extended version of
work published in [22].After executing all the
implementations and comparing performance using
different real data sets, Pair HMMs Forward
algorithm achieved a speed of upto5.47x over
existing GPU-based implementations. The naïve
intra task implementation is the fastest over all the
GPU-base implementation when the number of
read haplotypes pairs in each chunk is small.The
inter-task implementation can’t use the GPU
resources efficiently when the size of the datasets
reduced to 200 pairs.
In paper[24] theauthor presents, a GPU
acceleration of the GATK haplotype Caller, and
load-balanced multi-process optimization that
divides the genome into regions of different
sizes to ensure a more equaldistribution of
computation load between different processes
and to address its implementation limitation
which forces the sequential executionof the
program and prevents effective utilization of
hardware acceleration.In single-threaded mode,
the GPU-based GATK HC is 1.71xfaster than the
baseline implementation and 1.21x faster
thanthe vectorized GATK HC implementation. In
multi-threaded mode, the GATK HC workflow
limits the performance improvement achievable
by accelerating the pair-HMMs kernel. In multi-
process mode, the GPU-based GATK HC
implementation is the fastest. In addition, the
GPU-based implementation achieves up to 2.04x
and 1.40x speedup in load-balanced multi-
process mode over the baseline implementation
and vectorized GATK HC implementation in non-
load-balanced multi-process mode.

In paper[25] the authorpresents, a high
performance GPU accelerated set of API(GASAL)
for pairwise sequence alignment of DNA and
RNA sequences. The GASAL APIs provide
accelerated kernels for local, global as well as
semi-global alignment, allowing the computation
of the alignment score, and optionally the start
and end positions of the alignment.this library
contain functions that enable fast alignment of
sequences and can be easily integrated in
computer programs developed for NGS data
analysis. One to one as well as all-to-all and one-
to-many- pairwise alignment can be performed.
The sequences are first packed into unsigned 32-
bit integer, followed by performing the
alignment. The total execution time is the sum of
data packing, data copying and alignment kernel
times. Without computing start-position GASAL
performs the alignment in much less time as
compared to SSW and NVBIO. With start-
position computing the speed of GASAL and
NVBIO is nearly the same. Hence GASAL is 2-4x
faster and gives more speedup over state-of-the-
art libraries making it a good choice for
sequence alignment
USING FPGAs
Field Programmable Gate Arrays(FPGAs) with
their flexible and reprogrammable substrate, are
a natural fit for a computationally intensive
algorithm.
In paper [26] the authors proposed a novel
systolic array design to accelerate the pair-
HMMs forward algorithm on FPGAs, analyze a
number of optimization techniques to improve
performance and presents an implementation of
the design on the convey supercomputing
platform.A number of architectural features
have been implemented to improve the
performance of the design, such as early exit
points to increase the utilization of the array for
small sequence sizes, as well as on-chip
buffering to enable the processing of long
sequences effectively. FPGA implementation of
the pair-HMMs forward algorithm is upto67x
faster.
In paper [27] the authors proposes the first
accelerated implementation of BWA-MEM.
BWA-MEMis a popular genome sequence
algorithm widely used in NGS genomics pipeline,
it is the latest and generally recommended for
high quality queries as it is faster and more
accurate[28] A characteristics work load of this
algorithm is to align millions of DNA reads
against a reference genome, the BWA-MEM
processes reads in batches in which the kernel
processes a batch of reads The BWA-MEM
algorithm alignment procedure generally
consists of three main kernels 1-SMEM
Generation 2-Seed Extension 3-Output
Generation[29]. BWA-MEM implements multi-
threaded execution of all three kernels. The
authors propose and evaluate a number of
FPGA-based systolic array architectures,
presenting optimizations generally applicable to
variable length Smith-Waterman execution.By
optimizing one of the three main kernels of BWA-
MEM, 45% increase in application performance
was observed.By implementing the seed extension
kernel as a systolic array, 3x faster performance is
achieved than software only execution.The
dynamic programming type of algorithm used in
seed extension kernel is a much better fit for
execution on an FPGA
In paper [30] the authors proposes highly
optimized Smith-Waterman implementation on
Intel FPGAs using OpenCL. This implementation
is both faster and more efficient than other
current Smith-Waterman implementations.
Compared to using normal hardware description
languages, using a high-level language such as
OpenCL has two main benefits. First, OpenCL is
more expressive (our Processing Element kernel
code in OpenCL requires 90 lines of code
compared to about 450 lines of VHDL).
Second,OpenCL development has more
convenient testing and de- bugging
capabilities.obtaining a theoretical performance of
214 GCUPS.
In paper [31] the authors
Using Big Data
Big data is a term used to refer to data sets that
are too large or complex for traditional data
processing application software to deal with.
In paper[] the authors using the apache spark
big data framework. The simultaneous
multithreading improves the performance of
BWA for all systems, increasing performance by
up to 87% for Spark. Spark has up to 27% better
performance for high system utilization. Spark is
able to sustain high performance when the
system is over-utilized. Spark versions divide
the input dataset of short reads into a number of
smaller files referred to as chunks.Spark system
is more capable of handling higher number of
threads.
In paper[] the authors propose StreamBWA, a
new framework that allows the BWA mem
program to run on a cluster in a distributed
fashion, at the same time while the input data is
being streamed into the cluster.this streaming
distributed approach is approximately 2x faster
than the non-streaming approach.compared to
SparkBWA, StreamBWA is almost 5x faster. Our
framework consist of two utilites. One is the
StreamBWA and the other is the chunker
program.
In paper [] the authors a new Spartk based
framework called SparkGA that allow a DNA
pipeline to run efficiently & cost effectively on a
scalable computational cluster. SparkGA uses in-
memory computation capabilities to improve
the performance of the framework. SparkGA is
about 71% faster than other state of the art
solutions, In recent years a number of bigdata
framework have emerged to efficiently manage and
process large datasets in a easy way. SparkGA
addresses the problem by implementing a memory
effiecient load balancing step, SparkGA runs the
pipeline in three differenct steps: DNA mapping &
static load balancing, dynamic load balancing &
SAM to BAM and marking of duplicates and
variant discovery.Ensuring Scalability, allow to run
the framework on low cost nodes upto 16 GB of
memory, achieving accuracy is 99.9981%. When
deployed on a 20 node IBM power* cluster, Spark
GA can complete the GATK best practice pipeline
in 90 minutes. It is 71% faster than the state-of-the-
art solutions.
Conclusion
In this paper, we studied various Papers related to
sequence alignment algorithms. The S-W algorithm
proved to be the most accurate one to carry out
sequence alignment; however it needs an
exceptionally long time to complete making it the
most suitable alternative for hardware acceleration.
REFERENCES
[21] LaiqHasanMarijnKentieZaid Al-Ars
33rd Annual International Conference of
the IEEE EMBS
Boston, Massachusetts USA, August 30 -
September 3, 2011
[22] ShanshanRen,KoenBertels,Zaid Al-Ars
 2016 IEEE International Conference on
Bioinformatics and Biomedicine (BIBM)

[23] ShanshanRen, KoenBertels and Zaid Al-

Ars

2018 Evolutionary Bioinformatics Volume

14: 1–12

[25] Nauman Ahmed, Hamid Mushtaq,

KoenBertels and Zaid Al-Ars

2017 IEEE International Conference on

Bioinformatics and Biomedicine (BIBM)

[26] ShanshanRen, Vlad-MihaiSima, Zaid AI-

Ars

2015 IEEE International Conference on

Bioinformatics and Biomedicine (BIBM)

[27]

[28] H. Li. Burrows-Wheeler Aligner.http://bio-

bwa.sourceforge.net/.Accessed: 2014-11-
04.

[29] Ernst Joachim Houtgast, Vlad-MihaiSima,

KoenBertels and Zaid Al-Ars

An FPGA-Based Systolic Array to Accelerate

the BWA-MEM Genomic Mapping
Algorithm

[30] Ernst Joachim Houtgast, Vlad-MihaiSima,

Zaid Al-Ars

2017 IEEE 17th International Conference

on Bioinformatics and Bioengineering