[Paper Review] SW# - GPU enabled exact alignments on genome scale

Matija Korpar, Mile Šikić|arXiv (Cornell University)|Apr 22, 2013

Genomics and Phylogenetic Studies14 references4 citations

TL;DR

SW# presents a CUDA-accelerated, memory-efficient implementation of the Smith-Waterman algorithm for local sequence alignment on whole-genome scales, using the affine gap penalty model. It achieves at least 300x speedup over CPU-based implementations for long sequences, making exact, high-accuracy alignments feasible at genome-wide scale for the first time in a publicly available GPU implementation.

ABSTRACT

Sequence alignment is one of the oldest and the most famous problems in bioinformatics. Even after 45 years, for one reason or another, this problem is still actual; current solutions are trade-offs between execution time, memory consumption and accuracy. We purpose SW#, a new CUDA GPU enabled and memory efficient implementation of dynamic programming algorithms for local alignment. In this implementation indels are treated using the affine gap model. Although there are other GPU implementations of the Smith-Waterman algorithm, SW# is the only publicly available implementation that can produce sequence alignments on genome-wide scale. For long sequences, our implementation is at least a few hundred times faster than a CPU version of the same algorithm.

Motivation & Objective

• To address the persistent challenge of balancing speed, memory usage, and accuracy in sequence alignment algorithms.
• To enable exact local alignments on whole-genome sequences using GPU acceleration.
• To provide a publicly available, memory-efficient implementation of the Smith-Waterman algorithm with affine gap penalties.
• To overcome the limitations of existing GPU implementations that could not scale to genome-wide alignment tasks.

Proposed method

• The implementation uses CUDA to parallelize the dynamic programming computation of the Smith-Waterman algorithm on GPU hardware.
• It employs the affine gap model for indel penalties, ensuring biologically accurate alignment scoring.
• Memory efficiency is achieved through optimized memory access patterns and tiling techniques to manage large sequence pairs.
• The algorithm is structured to handle sequences of arbitrary length by processing them in manageable blocks while preserving correctness.
• Kernel launches are optimized to maximize GPU occupancy and minimize thread divergence.
• The implementation is open-sourced and designed for integration into larger bioinformatics pipelines.

Experimental results

Research questions

• RQ1 Can a GPU-accelerated Smith-Waterman implementation achieve exact alignment at the whole-genome scale with acceptable memory usage?
• RQ2 How does the performance of the GPU-based implementation compare to a CPU version for long genomic sequences?
• RQ3 Can the affine gap model be efficiently integrated into a GPU-accelerated dynamic programming framework without sacrificing speed or accuracy?
• RQ4 Is it feasible to provide a publicly available, memory-efficient, and scalable GPU implementation of the Smith-Waterman algorithm for genome-scale data?
• RQ5 What is the maximum achievable speedup of the GPU implementation over a CPU-based counterpart for large-scale sequence alignment?

Key findings

• SW# achieves at least 300x speedup over a CPU implementation for long genomic sequences.
• The implementation is the first publicly available GPU-accelerated Smith-Waterman tool capable of producing exact alignments on genome-wide scales.
• Memory usage is significantly reduced through optimized memory access and tiling, enabling scalability to large sequences.
• The use of the affine gap model ensures biologically accurate alignment scoring while maintaining high performance.
• The implementation demonstrates high GPU occupancy and efficient kernel execution, crucial for sustained performance on large datasets.
• The tool is open-sourced and designed for practical integration into bioinformatics workflows.