Batched dense and sparse linear algebra in SYCL. Every operation takes a batch of matrices and picks, per shape, between BatchLAS's own kernels and the vendor library (cuBLAS, cuSOLVER, cuSPARSE), using per-GPU tuned tables.
Documentation: https://jonasdelacour.github.io/BatchLAS/ (C++ API, guides, design notes and every measurement behind a routing decision).
- Research code, no release tag. Pin to a commit.
maincarries known test failures, tracked intests/known-failures.txt(CI). - Tested on NVIDIA only: RTX 4090 (
sm_89) daily in CI, RTX PRO 6000 (sm_120), with a CUDA-enabled DPC++ and CUDA 13.2. ROCm code paths exist but are not built or run; CPU-only builds configure and build but are not exercised. - Scalar types:
float,double,std::complex<float>,std::complex<double>. - Backends: CUDA GPUs (native SYCL kernels plus cuBLAS/cuSOLVER/cuSPARSE) and a host netlib
BLAS/LAPACK backend. A vendor-free build (
-DBATCHLAS_ENABLE_VENDOR_BLAS=OFF) runs native kernels only; its gaps are listed in vendor-free status.
| Area | Operations |
|---|---|
| BLAS | gemm, gemv, symm, syrk, syr2k, trmm, trsm, hemm, herk, her2k |
| Factorizations and solvers | potrf, posv, getrf, getrs, getri, gesv, geqrf, orgqr, ormqr |
| Eigenvalues and SVD | syev, syevx (partial; direct, filtered and LOBPCG), gesvd, lanczos, ritz_values |
| Tridiagonal and reductions | sytrd, steqr, stedc, stebz, stein, tridiagonal_solver, gebrd |
| Sparse | spmm (CSR), iluk |
| Utilities | ortho, norm, cond, transpose, matrix generators; the linalg:: layer (solve, eigh, elementwise ops) |
| Python | optional pybind11 package with NumPy/SciPy interop (-DBATCHLAS_BUILD_PYTHON=ON) |
Which kernel runs for each op, and where the vendor still wins, is on the performance pages.
Requirements: CMake 3.17+, a SYCL 2020 compiler with a backend for your GPU (for NVIDIA, a
DPC++ built with --cuda or oneAPI plus the Codeplay NVIDIA plugin; stock icpx silently builds
CPU-only), and optionally LAPACKE/CBLAS and the CUDA toolkit.
git clone https://github.com/jonasdelacour/BatchLAS.git && cd BatchLAS
cmake -S . -B build -DCMAKE_CXX_COMPILER=/opt/dpcpp-cuda/bin/clang++ # your SYCL compiler
cmake --build build -j"$(nproc)"
cmake --install build --prefix "$HOME/inst"Configure output must name your GPU (Using SYCL targets: nvidia_gpu_sm_89); spir64_x86_64
alone means a CPU-only build. Consume it from CMake with the same compiler:
find_package(BatchLAS CONFIG REQUIRED)
target_link_libraries(my_app PRIVATE BatchLAS::batchlas)#include <batchlas.hh>
using namespace batchlas;
Queue ctx(Device::default_device()); // backend comes from the device
gemm(ctx, A.view(), B.view(), C.view(), {.alpha = 2.0f});
potrf(ctx, A.view(), {.uplo = Uplo::Lower});
ctx.wait(); // nothing is readable before thisMatrices are column-major in device-accessible (USM) memory.
- Toolchain, presets, CMake options, tests, benchmarks, Python: building guide.
- The API contract and the consumer recipe: C++ API; a runnable outside project: examples/consumer/.
Each op chooses its kernel from tuned/<op>.<device>.txt. A GPU without tables borrows
the nearest device's and warns once, so retune on new hardware:
cmake --preset benchmarks && cmake --build --preset benchmarks --target batchlas_tune
B=build/presets/benchmarks/tools/tune/batchlas_tune
$B --list # ops, candidates, grids
$B all --tier preview --dtype float,double --devices 0 --plan # cells and time estimate, no GPU
$B all --tier coarse --dtype float,double --devices 0 --out tunedBATCHLAS_TUNED_DIR=<dir>loads tables from another directory without a rebuild;BATCHLAS_SELECT_TRACE=1prints every choice and its runner-up.BATCHLAS_<OP>_ROUTE=<choice>pins one op's kernel (e.g.BATCHLAS_GEMM_ROUTE=vendor).- Tiers, ledger and flags: batchlas_tune; table format:
tuned/; the n-dependent constants in
tuning_params.hh: tuning constants.
MIT. See LICENSE.