What runs on CUDA?

Use this page to decide whether cudaverse can accelerate the part of your analysis that matters. “Yes” means the numerical work runs with CUDA. “Partly” means cudaverse uses CUDA for some steps and an established R package for the rest.

CUDA task summary

Task Runs with CUDA? What you receive in R
Dense tensor operations Yes A GPU tensor until you call to_cpu()
Matrix multiplication and summaries Yes A GPU tensor
SVD and PCA Yes An R model that can reuse GPU results
Pairwise distances Yes A regular R distance matrix
Exact kNN Yes Neighbour indices and distances
k-means Yes An R clustering result
Sparse storage, normalization, and multiplication Yes A GPU sparse object
Sparse PCA followed by exact kNN Yes Final neighbour results
kNN graph construction Partly A sparse Matrix graph
Louvain and Leiden Partly Community labels
UMAP and t-SNE Partly Embedding coordinates
Diffusion map Partly Embedding coordinates

Use device = "cuda" for tasks that must run on an eligible CUDA backend and inspect cuda_provenance() for the actual stage boundary.

Dense CUDA example

library(cudaverse)
cuda_select_device("cuda")

set.seed(1)
x <- matrix(rnorm(10000 * 100), nrow = 10000)
x_gpu <- cuda_tensor(x, device = "cuda", dtype = "float32")

product_gpu <- tensor_matmul(t(x_gpu), x_gpu)
reduced_gpu <- tensor_sum(product_gpu, dim = 1)
pca <- cuda_pca(x_gpu, n_components = 20, device = "cuda")
neighbors <- cuda_knn(pca$x, k = 15, device = "cuda")

tensor_device(reduced_gpu)
cuda_provenance(neighbors)

The tensor operations and PCA scores stay on the GPU. Only the final neighbour matrices are returned as ordinary R objects.

Sparse CUDA example

counts <- Matrix::rsparsematrix(10000, 100, density = 0.03)
counts@x <- abs(counts@x)

counts_gpu <- cuda_sparse(counts, device = "cuda")
normalized_gpu <- sparse_normalize(
  counts_gpu,
  margin = "rows",
  scale_factor = 10000,
  log1p = TRUE
)
feature_totals_gpu <- sparse_row_sums(t(normalized_gpu))
sparse_pca <- cuda_pca(normalized_gpu, n_components = 20, device = "cuda")
sparse_neighbors <- cuda_knn(
  sparse_pca$x,
  k = 15,
  device = "cuda"
)

sparse_info(normalized_gpu)
cuda_provenance(sparse_neighbors)

Graph and embedding workflows

GPU acceleration of PCA and exact kNN can still reduce the cost before graph or embedding stages, but the current graph clustering and UMAP/t-SNE implementations are not described as native CUDA.

pca <- cuda_pca(x, n_components = 20, device = "cuda")
neighbors <- cuda_knn(pca$x, k = 15, device = "cuda")

graph <- cuda_knn_graph(neighbors)
communities <- cuda_leiden(graph)
embedding <- cuda_umap(pca$x)

cuda_provenance(communities)
cuda_provenance(embedding)

The provenance record shows the CUDA preprocessing stages and the intentional host stages separately. This makes it possible to use the accelerated portion without presenting the complete workflow as GPU-resident.

The lightweight backend

The native backend loads the NVIDIA libraries already installed on your computer and does not require LibTorch. The selected backend is always visible in diagnostics and provenance.

diagnostics <- cuda_diagnostics()
diagnostics$selected_backend
diagnostics$backend_status

An explicit CUDA request is strict: if CUDA is not ready, cudaverse stops and shows diagnostic guidance instead of silently changing where the work runs.