infernal-gpu 0.1.0__tar.gz

infernal_gpu-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+build/
+dist/
+*.egg-info/
+__pycache__/
+*.pyc
+.venv/
+venv/

infernal_gpu-0.1.0/CMakeLists.txt

@@ -0,0 +1,27 @@
+# Builds the two GPU programs and installs them into the infernal_gpu package (pip install .).
+# CUDA architectures: the local GPU by default; override with e.g.
+#   CMAKE_ARGS="-DCMAKE_CUDA_ARCHITECTURES=80;86;89" pip install .
+cmake_minimum_required(VERSION 3.24)
+if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+  set(CMAKE_CUDA_ARCHITECTURES native)
+endif()
+project(infernal_gpu LANGUAGES CXX CUDA)
+set(CMAKE_CUDA_STANDARD 14)
+set(CMAKE_CXX_STANDARD 14)
+find_package(Threads REQUIRED)
+
+set(ENGINE_SOURCES src/cyk_kernel.cu src/inside_kernel.cu src/gpu_transfer.cu src/gpu_batch_scan.cu src/scan.cu)
+set(ENGINE_DEFS IL_PARALLEL_SCAN IL_ZERO_EMISSION_SCAN BIF_RING_INDEX ROOT_STATE_FUSED INSIDE_MIN_BLOCKS_256=4)
+
+function(engine_program name)
+  add_executable(${name} ${ENGINE_SOURCES})
+  target_include_directories(${name} PRIVATE src)
+  target_compile_definitions(${name} PRIVATE ${ENGINE_DEFS} ${ARGN})
+  target_compile_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-O2 -Xcompiler=-O2>)
+  set_target_properties(${name} PROPERTIES CUDA_SEPARABLE_COMPILATION ON CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+  target_link_libraries(${name} PRIVATE Threads::Threads)
+  install(TARGETS ${name} RUNTIME DESTINATION infernal_gpu/bin)
+endfunction()
+
+engine_program(infernal-gpu-scan)                          # search
+engine_program(infernal-gpu-calibrate-scan CALIB_RECORDS)  # calibration (record emission)

infernal_gpu-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, the Infernal-GPU authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

infernal_gpu-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: infernal-gpu
+Version: 0.1.0
+Summary: GPU covariance-model calibration and search for Infernal, with results matching Infernal
+Author: Infernal-GPU authors
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Project-URL: Homepage, https://github.com/void-echo/infernal-gpu
+Project-URL: Source, https://github.com/void-echo/infernal-gpu
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Infernal-GPU
+
+Infernal-GPU is a GPU implementation of the covariance-model (CM) dynamic programming of
+[Infernal](http://eddylab.org/infernal/) 1.1.5. It provides a replacement for `cmcalibrate` that
+follows the same protocol and writes the same model file, and a CM search in which the GPU scores
+every model against every sequence while Infernal's own `cmsearch` computes the final hits, so
+scores, E-values and coordinates are Infernal's.
+
+## Requirements
+
+- Linux with an NVIDIA GPU and the CUDA toolkit (`nvcc`)
+- CMake ≥ 3.24 (fetched by pip if missing) and Python ≥ 3.8
+- Infernal 1.1.5 (`cmsearch`, `cmfetch`) for `search` and `hybrid`
+
+## Install
+
+    pip install infernal-gpu                                   # from PyPI; compiles the GPU programs
+    pip install git+https://github.com/void-echo/infernal-gpu  # or from GitHub (or `pip install .` in a clone)
+
+The GPU programs are compiled for the GPU of the build machine. To build for other or several
+architectures (A100 = 80, RTX 30xx = 86, RTX 40xx = 89 with CUDA ≥ 11.8), name them; if CMake
+does not find `nvcc`, also set `CUDACXX=/usr/local/cuda/bin/nvcc`:
+
+    CMAKE_ARGS="-DCMAKE_CUDA_ARCHITECTURES=80;86" pip install .
+
+## Usage
+
+Calibrate E-values of a model or library from `cmbuild`:
+
+    infernal-gpu calibrate model.cm model.calibrated.cm --gpu 0
+
+Calibrations on more random sequence are more accurate (sampling error falls with the square root of its
+length). To calibrate on 16 Mb, ten times the default, compile cmcalibrate's sequence generator once
+against an Infernal 1.1.5 source build and pass its output with `--seqs`:
+
+    I=infernal-1.1.5
+    cc -O2 -I$I/src -I$I/hmmer/src -I$I/easel tools/gen_calib_seqs.c $I/src/libinfernal.a \
+       $I/hmmer/src/libhmmer.a $I/easel/libeasel.a -lm -lpthread -o gen_calib_seqs
+    ./gen_calib_seqs 181 1600 10000 > random16Mb.fa          # seed, chunks, chunk length
+    infernal-gpu calibrate model.cm model.calibrated.cm --seqs random16Mb.fa --gpu 0
+
+Filter-free search of calibrated models (the hits of `cmsearch --nohmm`). E-values cover the
+`--n-models` models of the library, as in `cmscan`; the GPU is chosen with `CUDA_VISIBLE_DEVICES`:
+
+    infernal-gpu search --cm-lib Rfam.cm --n-models 4227 --fasta genome.fa \
+        --infernal-bin infernal-1.1.5/src --out-dir run1
+
+Sensitive search behind Infernal's HMM filters, with the CM stages on the GPU. It needs a second
+copy of Infernal 1.1.5, patched once so that it writes out the envelopes that pass the filters:
+
+    curl -LO http://eddylab.org/infernal/infernal-1.1.5.tar.gz
+    tar xf infernal-1.1.5.tar.gz && mv infernal-1.1.5 infernal-envdump
+    infernal-gpu patch-infernal infernal-envdump
+    (cd infernal-envdump && ./configure && make)
+    infernal-gpu hybrid --cm models.cm --fasta targets.fa --filter relaxed --gpu 0 --out-dir run2 \
+        --envdump-cmsearch infernal-envdump/src/cmsearch --infernal-bin infernal-1.1.5/src
+
+`--filter` is `default`, `mid` or `relaxed` (`--mid --Fmid 0.1`). Every command lists its options
+with `--help`.
+
+## Outputs
+
+`calibrate` writes the model file with new `ECM` lines and everything else unchanged; it works with
+`cmsearch` and `cmscan`. `search` and `hybrid` write `hits.tbl` in `cmsearch --tblout` format on the
+original sequences, the same hits as `refined_hits.tsv`, the GPU candidate regions, the native
+per-model `cmsearch` outputs and `summary.json`.
+
+## Test
+
+    INFERNAL_BIN=infernal-1.1.5/src python tests/test_infernal_gpu.py
+
+The test (about a minute; `pytest tests` also works) calibrates two models and compares their
+E-value thresholds with `cmcalibrate`, then searches a genome slice and compares every hit with
+`cmsearch --nohmm`. Its data are files from the Infernal 1.1.5 tutorial.
+
+## Citation and license
+
+Please cite: [to be added]. Infernal-GPU is distributed under the BSD 3-Clause license (`LICENSE`).

infernal_gpu-0.1.0/README.md

@@ -0,0 +1,78 @@
+# Infernal-GPU
+
+Infernal-GPU is a GPU implementation of the covariance-model (CM) dynamic programming of
+[Infernal](http://eddylab.org/infernal/) 1.1.5. It provides a replacement for `cmcalibrate` that
+follows the same protocol and writes the same model file, and a CM search in which the GPU scores
+every model against every sequence while Infernal's own `cmsearch` computes the final hits, so
+scores, E-values and coordinates are Infernal's.
+
+## Requirements
+
+- Linux with an NVIDIA GPU and the CUDA toolkit (`nvcc`)
+- CMake ≥ 3.24 (fetched by pip if missing) and Python ≥ 3.8
+- Infernal 1.1.5 (`cmsearch`, `cmfetch`) for `search` and `hybrid`
+
+## Install
+
+    pip install infernal-gpu                                   # from PyPI; compiles the GPU programs
+    pip install git+https://github.com/void-echo/infernal-gpu  # or from GitHub (or `pip install .` in a clone)
+
+The GPU programs are compiled for the GPU of the build machine. To build for other or several
+architectures (A100 = 80, RTX 30xx = 86, RTX 40xx = 89 with CUDA ≥ 11.8), name them; if CMake
+does not find `nvcc`, also set `CUDACXX=/usr/local/cuda/bin/nvcc`:
+
+    CMAKE_ARGS="-DCMAKE_CUDA_ARCHITECTURES=80;86" pip install .
+
+## Usage
+
+Calibrate E-values of a model or library from `cmbuild`:
+
+    infernal-gpu calibrate model.cm model.calibrated.cm --gpu 0
+
+Calibrations on more random sequence are more accurate (sampling error falls with the square root of its
+length). To calibrate on 16 Mb, ten times the default, compile cmcalibrate's sequence generator once
+against an Infernal 1.1.5 source build and pass its output with `--seqs`:
+
+    I=infernal-1.1.5
+    cc -O2 -I$I/src -I$I/hmmer/src -I$I/easel tools/gen_calib_seqs.c $I/src/libinfernal.a \
+       $I/hmmer/src/libhmmer.a $I/easel/libeasel.a -lm -lpthread -o gen_calib_seqs
+    ./gen_calib_seqs 181 1600 10000 > random16Mb.fa          # seed, chunks, chunk length
+    infernal-gpu calibrate model.cm model.calibrated.cm --seqs random16Mb.fa --gpu 0
+
+Filter-free search of calibrated models (the hits of `cmsearch --nohmm`). E-values cover the
+`--n-models` models of the library, as in `cmscan`; the GPU is chosen with `CUDA_VISIBLE_DEVICES`:
+
+    infernal-gpu search --cm-lib Rfam.cm --n-models 4227 --fasta genome.fa \
+        --infernal-bin infernal-1.1.5/src --out-dir run1
+
+Sensitive search behind Infernal's HMM filters, with the CM stages on the GPU. It needs a second
+copy of Infernal 1.1.5, patched once so that it writes out the envelopes that pass the filters:
+
+    curl -LO http://eddylab.org/infernal/infernal-1.1.5.tar.gz
+    tar xf infernal-1.1.5.tar.gz && mv infernal-1.1.5 infernal-envdump
+    infernal-gpu patch-infernal infernal-envdump
+    (cd infernal-envdump && ./configure && make)
+    infernal-gpu hybrid --cm models.cm --fasta targets.fa --filter relaxed --gpu 0 --out-dir run2 \
+        --envdump-cmsearch infernal-envdump/src/cmsearch --infernal-bin infernal-1.1.5/src
+
+`--filter` is `default`, `mid` or `relaxed` (`--mid --Fmid 0.1`). Every command lists its options
+with `--help`.
+
+## Outputs
+
+`calibrate` writes the model file with new `ECM` lines and everything else unchanged; it works with
+`cmsearch` and `cmscan`. `search` and `hybrid` write `hits.tbl` in `cmsearch --tblout` format on the
+original sequences, the same hits as `refined_hits.tsv`, the GPU candidate regions, the native
+per-model `cmsearch` outputs and `summary.json`.
+
+## Test
+
+    INFERNAL_BIN=infernal-1.1.5/src python tests/test_infernal_gpu.py
+
+The test (about a minute; `pytest tests` also works) calibrates two models and compares their
+E-value thresholds with `cmcalibrate`, then searches a genome slice and compares every hit with
+`cmsearch --nohmm`. Its data are files from the Infernal 1.1.5 tutorial.
+
+## Citation and license
+
+Please cite: [to be added]. Infernal-GPU is distributed under the BSD 3-Clause license (`LICENSE`).

infernal_gpu-0.1.0/infernal_gpu/__init__.py

@@ -0,0 +1,2 @@
+"""infernal-gpu: GPU-accelerated covariance-model calibration and search for Infernal."""
+__version__ = "0.1.0"

infernal_gpu-0.1.0/infernal_gpu/calibrate.py

@@ -0,0 +1,69 @@
+"""GPU replacement for `cmcalibrate` (default protocol): calibrate CM E-values and write a model file.
+
+    infernal-gpu calibrate IN.cm OUT.cm [--gpu 0]
+
+IN.cm is a model or library from cmbuild (with or without ECM lines). The scanner is the bundled
+infernal-gpu-calibrate-scan (built with -DCALIB_RECORDS). Every model is calibrated in cmcalibrate's
+four modes on cmcalibrate's own default random sequences (data/cmcalibrate_default_seed181.fa in
+this package: 160 x 10 kb from Infernal's genomic HMM, seed 181), and the four ECM lines are written
+into OUT.cm in Infernal's format; everything else in the file is copied unchanged. OUT.cm can be used
+directly by cmsearch/cmscan. --seqs selects other random sequences (e.g. longer ones for a more
+precise calibration; dbsize is taken from their total length). Python 3.8+, standard library.
+"""
+import argparse, os, subprocess, sys, tempfile, time
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+MODES = ('ECMLC', 'ECMGC', 'ECMLI', 'ECMGI')   # cm_file.c write order
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument('cm_in'); ap.add_argument('cm_out')
+    ap.add_argument('--scanner', default=str(HERE / 'bin' / 'infernal-gpu-calibrate-scan'),
+                    help='GPU scanner built with -DCALIB_RECORDS (default: the bundled one)')
+    ap.add_argument('--gpu', default=os.environ.get('CUDA_VISIBLE_DEVICES', '0'))
+    ap.add_argument('--seqs', default=str(HERE / 'data' / 'cmcalibrate_default_seed181.fa'))
+    ap.add_argument('--keep-tsv', help='also keep the per-mode calibration table here')
+    ap.add_argument('--gtailn', type=int, default=250, help='hits/Mb fitted in glocal modes (cmcalibrate --gtailn)')
+    ap.add_argument('--ltailn', type=int, default=750, help='hits/Mb fitted in local modes (cmcalibrate --ltailn)')
+    a = ap.parse_args()
+
+    env = dict(os.environ, CUDA_DEVICE_ORDER='PCI_BUS_ID', CUDA_VISIBLE_DEVICES=str(a.gpu),
+               GPU_TILE_POLICY='wave', GPU_PACKED_BEGL='auto', GPU_PACK_ALL='auto')
+    with tempfile.TemporaryDirectory() as td:
+        tsv = a.keep_tsv or str(Path(td) / 'calib.tsv')
+        t0 = time.time()
+        r = subprocess.run([a.scanner, a.cm_in, a.seqs, '--calibrate', tsv,
+                            '--gtailn', str(a.gtailn), '--ltailn', str(a.ltailn)], env=env,
+                           stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True)
+        wall = time.time() - t0
+        if r.returncode != 0:
+            sys.exit('calibration failed:\n' + '\n'.join(l for l in r.stderr.splitlines() if 'FATAL' in l or 'ERR' in l))
+        calib = {}
+        for line in open(tsv):
+            if line.startswith('#'): continue
+            f = line.rstrip('\n').split('\t')
+            # cm_name cm_acc mode lambda mu_extrap mu_orig dbsize nrandhits tailp ...
+            calib.setdefault(f[0], {})[f[2]] = (float(f[3]), float(f[4]), float(f[5]), int(float(f[6]) + 0.5), int(f[7]), float(f[8]))
+
+    out, in_header, name, n = [], False, None, 0
+    for line in open(a.cm_in):
+        if line.startswith('INFERNAL1'):
+            in_header, name = True, None
+        if in_header:
+            if line.startswith('NAME') and name is None: name = line.split()[1]
+            if line.startswith('ECM'): continue
+            if line.rstrip('\n') == 'CM':
+                c = calib.get(name, {})
+                if len(c) != 4: sys.exit(f'{name}: calibration incomplete')
+                out += [f'{m}    {c[m][0]:.5f}  {c[m][1]:10.5f}  {c[m][2]:10.5f}  {c[m][3]:10d}  {c[m][4]:10d}  {c[m][5]:.6f}\n'
+                        for m in MODES]
+                in_header = False; n += 1
+        out.append(line)
+    Path(a.cm_out).write_text(''.join(out))
+    print(f'{n} model(s) calibrated in {wall:.1f} s -> {a.cm_out}', file=sys.stderr)
+
+
+if __name__ == '__main__':
+    main()

infernal_gpu-0.1.0/infernal_gpu/cli.py

@@ -0,0 +1,56 @@
+"""infernal-gpu command line: one entry point for the package's commands.
+
+    infernal-gpu calibrate IN.cm OUT.cm [--gpu N]             GPU replacement for cmcalibrate
+    infernal-gpu search --out-dir D --cm-lib LIB --fasta F --infernal-bin DIR --n-models N [-- scanner options]
+                                                             filter-free search, streamed native refinement
+    infernal-gpu hybrid --cm LIB --fasta F --out-dir D --envdump-cmsearch X --infernal-bin DIR [--filter relaxed]
+                                                             native HMM filters + GPU CM stages
+    infernal-gpu tblout --run-dir D --out hits.tbl            export standard cmsearch tblout
+    infernal-gpu refine --hits C --fasta F --cm-lib LIB --infernal-bin DIR --n-models N --out-dir D
+                                                             native rescan of candidate regions
+    infernal-gpu patch-infernal INFERNAL_SOURCE_DIR           add the opt-in envelope output (for hybrid)
+
+The bundled GPU programs are used unless --scanner is given. Each command prints its own --help.
+Native Infernal 1.1.5 (cmsearch, cmfetch) must be installed; search and hybrid take its bin directory.
+"""
+import importlib, os, sys
+
+from . import __version__
+
+COMMANDS = {'calibrate': 'calibrate', 'search': 'search', 'hybrid': 'hybrid', 'tblout': 'tblout',
+            'refine': 'refine', 'patch-infernal': 'patch_infernal'}
+# Measured production configuration of the GPU engine (callers' settings take precedence).
+ENGINE_ENV = dict(CUDA_DEVICE_ORDER='PCI_BUS_ID', GPU_TILE_POLICY='wave', GPU_PACKED_BEGL='auto',
+                  GPU_PACK_ALL='auto', GPU_BLOCK_SIZE='128')
+# Default scanner options for filter-free search (calibrated CYK filter, NULL3 gates, 0.25-bit margin).
+SEARCH_DEFAULTS = ['--candidate-evalue', '1', '--cascade-cyk-p', '1e-4', '--null3-gate', '--cyk-margin', '0.25']
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == '--version':
+        print('infernal-gpu', __version__)
+        return 0
+    if not argv or argv[0] in ('-h', '--help', 'help') or argv[0] not in COMMANDS:
+        print(__doc__.strip())
+        return 0 if not argv or argv[0] in ('-h', '--help', 'help') else 2
+    cmd, rest = argv[0], argv[1:]
+    for k, v in ENGINE_ENV.items():
+        os.environ.setdefault(k, v)
+    if cmd == 'search' and not any(a in ('-h', '--help') for a in rest):
+        # scanner options follow '--'; add each default the caller did not set
+        head, tail = (rest[:rest.index('--')], rest[rest.index('--') + 1:]) if '--' in rest else (rest, [])
+        extra, i = [], 0
+        while i < len(SEARCH_DEFAULTS):
+            flag = SEARCH_DEFAULTS[i]
+            takes_value = i + 1 < len(SEARCH_DEFAULTS) and not SEARCH_DEFAULTS[i + 1].startswith('--')
+            if flag not in tail:
+                extra += SEARCH_DEFAULTS[i:i + 1 + takes_value]
+            i += 1 + takes_value
+        rest = head + ['--'] + extra + tail
+    sys.argv = ['infernal-gpu ' + cmd] + rest
+    return importlib.import_module('.' + COMMANDS[cmd], __package__).main()
+
+
+if __name__ == '__main__':
+    sys.exit(main())