Supercharging Genomics Alignment with AMD Instinct GPUs

Bringing minimap2 DNA/RNA alignment closer to production-scale sequencing analysis with ROCm and HIP

minimap2 is among the most widely used tools for DNA and RNA read alignment, but its compute-intensive stages have traditionally run CPU-only — even on GPU-equipped systems. We present a heterogeneous CPU-GPU implementation of minimap2 for AMD Instinct™ GPUs, built with ROCm™ and HIP, that keeps seeding on the CPU while offloading the two dominant stages — chaining and base-level alignment — to the GPU. GPU acceleration is enabled with simple command-line flags and auto-tuned per architecture from a single binary, leaving existing workflows and CPU-only deployments unchanged.

On an AMD Instinct™ MI300X, our implementation delivers higher end-to-end throughput than a competing GPU solution across all three minimap2 presets (PacBio HiFi, PacBio CLR, and Oxford Nanopore), with up to 1.78× higher throughput and the largest gains on long-read workloads^**.

This implementation is available today through a limited early-access evaluation program, sign up below.

Introduction

Genomics is reshaping medicine, agriculture, and our understanding of life itself. In the span of two decades, sequencing a human genome has gone from a billion-dollar, decade-long effort to a routine clinical procedure. Today, scientists read DNA to trace disease outbreaks in real time, identify cancer mutations in individual patients, guide drug development, and study the genetic diversity of entire populations.

Modern sequencing machines do this at an enormous scale, producing digital fragments of genetic information called reads.

These reads are like millions, sometimes billions, of short or long puzzle pieces. By themselves, they do not immediately tell us where they came from in the genome. Before researchers can interpret the data, each read must be compared against a known reference genome to determine its likely location. This process is called read alignment. Read alignment is one of the foundational steps in genomics. It is often the first major computational stage after sequencing, and it affects almost everything that comes next: detecting genetic variants, identifying disease-causing mutations, tracking pathogens, assembling genomes, studying RNA expression, and comparing individuals across populations.

The challenge is scale.

The human genome contains more than three billion DNA bases. A modern sequencing run can generate millions to billions of reads. Each read must be searched, matched, scored, and aligned against a large reference. As sequencing becomes faster and cheaper, the amount of data grows faster than traditional CPU-only analysis pipelines can comfortably handle.

That bottleneck matters.

To address this challenge, we accelerated key stages of minimap2¹, one of the most widely used tools for DNA and RNA read alignment, on AMD Instinct™ GPUs using ROCm™ and HIP. This work is available today as a limited early-access evaluation program, with a sign-up link at the end of this post.

The minimap2 pipeline has three stages. First, seeding: quickly scanning the reference to find approximate locations where each read might belong — like finding candidate page numbers before reading the full text. Second, chaining: grouping those candidate locations into ordered intervals that span a plausible alignment region — like identifying which page numbers form a coherent chapter. Third, alignment: precisely confirming and scoring the match between the read and the reference at each candidate location. On large datasets, chaining and alignment together dominate wall time — often 80–90% of total runtime — making them the primary targets for acceleration.

AMD Instinct GPUs are increasingly deployed alongside CPUs in modern HPC systems, offering high memory bandwidth (5.3 TB/s on MI300X³ and 8 TB/s on MI355X⁷) and massive parallelism through the ROCm open software stack. Yet read alignment pipelines have historically left this hardware underutilized, continuing to run CPU-only even on GPU-equipped nodes. At the same time, many modern sequencing platforms now ship with embedded GPUs, highlighting a missed opportunity—and a compelling avenue—for accelerating bioinformatics workloads directly at the source, and for AMD to play a larger role in this emerging compute paradigm.

The result is a heterogeneous CPU-GPU implementation of minimap2 that preserves familiar workflows while moving the most computationally intensive stages of the pipeline onto AMD GPUs. This is not only about making one tool faster. It is about helping genomics move from high-throughput data generation toward production-scale biological analysis.

A Heterogeneous End-to-End minimap2 Pipeline 

Our implementation keeps the parts of minimap2 that are well suited to CPUs on the CPU, while moving the most compute-intensive stages to the GPU.

The CPU continues to handle input processing, minimizer sketching, index lookup, and seed generation, these stages involve control flow and sparse data access patterns. Seeding is also retained on CPU because it relies on querying a large hash-based index structure (the minimizer index) in a sequential, memory-access-heavy pattern that is difficult to parallelize efficiently across GPU threads.  Chaining and pairwise alignment are offloaded to the GPU, where they can run independently across thousands of reads simultaneously. 

All three stages are also exposed as standalone modular binaries (mm2_seed, mm2_chain, and mm2_align), each producing JSON stage outputs to support debugging, benchmarking, and custom pipeline development. For effective GPU execution of this fine-grained workload, we introduce alignment batching, along with efficient memory management, reducing kernel launch overheads and per alignment allocation costs.

This architecture allows the CPU and GPU to operate together: while the GPU processes batches of chaining and alignment work, the CPU can prepare additional reads as shown in Figure 1. This improves utilization and helps turn minimap2 from a CPU-bound tool into a pipeline that takes advantage of modern accelerated systems.

GPU features are enabled via command line flags (--gpu-chain, --gpu-align), and the GPU configurations are auto-tuned according to the specific architecture, with no recompilation needed. This allows us to create specific profiles to extract maximum performance on different GPUs with a single binary. CPU-only deployments are completely unaffected.

GPU-accelerated Chaining: Finding Structure in Millions of Candidate Matches 

After the seeding stage identifies thousands of short exact matches (anchors) between a read and the reference genome, chaining links these anchors into co-linear chains groups of seeds that appear in the same order and orientation on both sequences. This is formulated as a 1-D Dynamic Programming problem (DP) over sorted anchor sets, where each anchor's score depends on preceding anchors within a defined distance threshold.

For long reads, chaining becomes a computational bottleneck: a single read can produce hundreds of thousands of anchors, and the quadratic nature of the pairwise comparisons make this stage dominate runtime. However, when many reads are batched together, the combined anchor arrays grow large enough to saturate GPU memory bandwidth and expose massive data-level parallelism, making this stage a strong candidate for GPU acceleration.

The chaining DP evaluates many anchor pairs independently — a natural fit for GPU parallelism. We offload this work to AMD Instinct GPUs using HIP (AMD's GPU programming framework), keeping the CPU free to do other work simultaneously.

The GPU chaining algorithm runs in two main steps: (a) find ranges: for each seed, figure out which earlier seeds are close enough to be valid predecessors (using a binary search); and (b) compute scores: for each valid pair, calculate a chaining score and track the best predecessor. This is the expensive DP step that benefits most from parallelism.

A key challenge is load balance. Genomics data is irregular. Some reads produce small anchor sets; others produce very large ones. Some chains are easy to process; others require much more work. A naive GPU implementation could leave many compute units underutilized. To address this, seeds are grouped into segments (independent sub-chains), and segments are processed differently based on size:

• small segments are handled by a single group of 64 threads,
• medium segments are handled by one thread block, and
• large segments are processed by a dedicated kernel with work-stealing for load balance.

This matters because real biological data rarely produces uniform workloads. A practical accelerator must adapt to the data, not assume idealized inputs.

By doing so, chaining becomes a GPU-parallel stage that can take advantage of the memory bandwidth and parallelism of AMD Instinct GPUs.

GPU-Accelerated Alignment: Batching Dynamic Programming at Scale

After chaining identifies candidate mappings, minimap2 performs base-level alignment.

This is the stage that determines the detailed relationship between the read and the reference. It fills gaps between anchors with full dynamic programming (Smith-Waterman[SC4.1])⁴ and produces the CIGAR⁵ [VP5.1]string — a compact encoding of the alignment — which describes the sequence of operations (matches, mismatches, insertions, and deletions) needed to align the read. For long reads with many chains and large gaps between anchors, this DP work adds up quickly.

This stage is essential for accurate genomics analysis. It is also computationally expensive.

Minimap2 uses the Suzuki–Kasahara⁶ dynamic programming formulation [SC6.1]with a double affine gap model. Our implementation offloads three alignment kernels to the GPU: gap fill (full banded DP between anchors), right extension, and left extension. Each kernel evaluates a banded DP recurrence over six state arrays that encode short  and long gap penalties, along with a traceback matrix for CIGAR reconstruction. 

The challenge is that individual alignments can be too small or too variable to use the GPU efficiently one at a time. Launching a GPU kernel for each alignment would introduce too much overhead. Allocating and freeing GPU memory for every alignment would also be costly.

To amortize per alignment overheads, we batch multiple independent alignments into a single kernel launch, subject to configurable limits on alignment count and device memory usage. Query and target sequences are packed into contiguous buffers, and prefix sum offsets allow each thread block to locate its data. Batching reduces kernel launches and synchronization points from per alignment to per batch, enabling higher occupancy and sustained throughput.

We also eliminate allocation overhead by using persistent GPU buffers that are allocated once and reused across batch flushes, clearing buffers with device memsets rather than deallocation. To accommodate variable batch sizes, buffers grow dynamically when required but are otherwise reused, allowing allocations to stabilize after a small number of growth events. In practice, most batches reuse existing buffers without any overhead.

Together, batching and reusing memory, growing memory and asynchronous GPU kernel calls shift GPU alignment costs from launch and allocation overheads back to the DP computation itself. This enables the gap fill and extension kernels to scale with aggregate alignment work rather than the number of individual alignments, resulting in improved GPU utilization and measurable end to end speedup.

Performance Results**

We evaluate the ROCm-enabled minimap2 [SC9.1]on a single AMD Instinct MI300X GPU [SC10.1]paired with a dual-socket AMD EPYC 9654 host (96 cores per socket, 1.5 TB RAM). The software stack uses Ubuntu 24.04, ROCm 7.2.1, GCC 13, and HIP from the ROCm SDK. The baseline for comparison is the upstream lh3/minimap2 version 2.24 running on CPU only. Benchmarking data was obtained from the Human Pangenome Project².

Early performance results on the AMD Instinct MI300X show moderate advantages over the competing GPU solution across all three minimap2 presets. At 16 threads, AMD outperforms the competition by 1.09× on HiFi reads (map-hifi), 1.78× on PacBio CLR reads (map-pb), and 1.72× on Oxford Nanopore long reads (map-ont). At 32 threads the trend holds, with AMD delivering 1.01×, 1.76×, and 1.60× better throughput than the competing solution on map-hifi, map-pb, and map-ont respectively. The most significant gains appear on PacBio CLR and ONT workloads, where AMD consistently delivers over 1.6× higher throughput than the competition across both thread configurations.

Scientific Impact: Faster Alignment Enables Larger Biological Questions

Speed matters because scale changes the questions scientists can ask.

When read mapping is slow, researchers are forced to make compromises. They may analyze fewer samples, reduce coverage, or limit parameter explorations. Accelerating minimap2 on AMD GPUs help reduce these constraints.

Minimap2 on AMD Instinct GPU acceleration transforms it from a CPU-centric workload into a heterogeneous computing pipeline. Our results show that the most compute-intensive stages of minimap2 can be efficiently accelerated on AMD Instinct GPUs using HIP and ROCm. The modular pipeline makes it easier for researchers and developers to inspect, benchmark, and extend individual stages, creating a foundation for future optimization and broader adoption across sequencing workloads.

By bringing minimap2 to AMD Instinct GPUs, we move DNA/RNA read alignment closer to real-time, production-scale genomics, enabling scientists to spend less time waiting for data to align and more time discovering what the data means.

Try It Yourself — Get Early Access 

GPU-accelerated minimap2 on AMD Instinct™ GPUs is available now through a limited early-access evaluation program. Run the ROCm™/HIP build on your own datasets, compare GPU performance against your CPU baselines, and collaborate with AMD through a dedicated support channel for tuning and feature discussion — your feedback shapes packaging, defaults, and the roadmap. Sign up for the GPU-accelerated minimap2 evaluation program.