GPU offload via TornadoVM: 570× faster all-pairs alignment, 18× faster ASA, identical results #1158

Summary

• All-pairs alignment scores (Alignments.getAllPairsScores / getAllPairsScorers, the guide-tree stage of getMultipleSequenceAlignment): 570–680× faster than current BioJava on 20k–40k pairs. For global alignment the GPU is also 3–7× faster than parasail, a SIMD C library, on 32 threads, with identical scores.
• Surface area (AsaCalculator): up to 18× faster on a 2.4M-atom capsid (6.8 s → 0.37 s), and 14× faster than FreeSASA.
• Identical results: integer-identical alignment scores (BioJava, GPU and parasail all agree), identical guide trees, bit-identical per-atom ASA.
• Part of this needs no GPU. The same algorithms in plain Java are ~25× faster (alignment scores) and 4–6× faster (ASA) than BioJava on the CPU.

https://github.com/beehive-lab/TornadoVM

What is TornadoVM? An open-source framework for OpenJDK/GraalVM that compiles plain Java code to run on GPUs (NVIDIA CUDA, OpenCL on AMD/Intel, Apple Metal). You write GPU compute kernels in plain Java, and most of BioJava's existing loops map 1-1 onto them. No CUDA or C++ is needed: TornadoVM handles the kernels and data transfers, with a fallback to the JVM.

Numbers

i9-13900K (32 threads) vs RTX 4090, BioJava 7.3.0. Times are end-to-end, including host↔device transfers. "Lean Java" is the same algorithm as the GPU kernel in plain Java on all 32 threads, i.e. the fair Java baseline. The C libraries run on exactly the same inputs.

All-pairs alignment scores (BLOSUM62, gap open 10 / extend 1)

Accessible surface area (Shrake-Rupley, 1000 points)

Caveats, to be upfront:

• Local alignment: for Smith-Waterman the GPU only matches parasail (1–2×), because parasail's 8-bit SIMD lanes are very efficient there. Against BioJava and lean Java, the gains for local alignment are the same as for global alignment.
• Small inputs: the GPU wins from about 1k pairs. Below that the lean Java path is used automatically.
• Other devices: the same code gives identical results on the RTX 4090 through OpenCL and on an Intel UHD 770 iGPU. The iGPU is slower than the CPU, though.

Why it's faster

• Alignment: getAllPairsScores only needs the score, but every pair currently builds a full traceback matrix with an object per cell. A linear-memory DP on primitive ints gives the same scores ~25× faster on the CPU. On the GPU, each thread aligns one pair using a strip-mined DP, at about 250 GCUPS.
• ASA: a cell-grid neighbour search and an early-exit occlusion test on flat arrays, with neighbours sorted by distance. It uses double precision and BioJava's sphere points, so the output is bit-identical. On the GPU it runs as one fused kernel per atom, with the neighbour list in on-chip memory.

Try it (one command)

Code, parity tests and benchmarks: https://github.com/mikepapadim/biojava-tornadovm-extensions

./bench.sh downloads TornadoVM and BioJava 7.3.0 from Maven Central. It then runs the parity tests (exact equality against BioJava) and the benchmarks. scripts/external/compare.sh reproduces the parasail and FreeSASA comparison. Methodology and full tables are in FINDINGS.md.

For users it is a one-line change with the same API and the same output:

new AsaCalculator(structure, 1.4, 1000, nThreads, false);         // before
new TornadoAsaCalculator(structure, 1.4, 1000, nThreads, false);  // after

Without a GPU or TornadoVM, it runs the lean Java path, which also gives identical results and is still several times faster than today.

Proposed contributions

1. CPU-only, no new dependencies: a score-only fast path for getAllPairsScores (GLOBAL/LOCAL) and a faster AsaCalculator, validated against the current implementation.
2. Optional GPU backend: a separate module (no TornadoVM dependency in any core module), off by default, with automatic CPU fallback.

Questions

1. Would you accept (1)? Is (2) of interest?
2. For (2), which home do you prefer: (a) a module in this repo, (b) a separate biojava-* repo, or (c) an external plugin that you link to?
3. Are there other hot spots users complain about? For example, profiling CE puts ~71% of its time in CECalculator.dpAlign, a DP that could get the same treatment. All-vs-all structure superposition (QCP) would map well onto GPU matrix multiplication.

We're happy to extend this to other parts of BioJava (e.g. CE), adapt it to your conventions, and support it long term, whichever home you prefer. I'm also happy to keep the first PR small and start with the CPU fast path.