mirror of
https://gitlab.com/libeigen/eigen.git
synced 2026-04-10 11:34:33 +08:00
GPU: Add library dispatch module (DeviceMatrix, cuBLAS, cuSOLVER)
Add Eigen/GPU module: A standalone GPU library dispatch layer where DeviceMatrix<Scalar> operations map 1:1 to cuBLAS/cuSOLVER calls. CPU and GPU solvers coexist in the same binary with compatible syntax. Core infrastructure: - DeviceMatrix<Scalar>: RAII dense column-major GPU memory wrapper with async host transfer (fromHost/toHost) and CUDA event-based cross-stream synchronization. - GpuContext: Unified execution context owning a CUDA stream + cuBLAS handle + cuSOLVER handle. Thread-local default with explicit override via setThreadLocal(). Stream-borrowing constructor for integration. - DeviceBuffer: Typed RAII device allocation with move semantics. cuBLAS dispatch (expression syntax): - GEMM: d_C = d_A.adjoint() * d_B (cublasXgemm) - TRSM: d_X = d_A.triangularView<Lower>().solve(d_B) (cublasXtrsm) - SYMM/HEMM: d_C = d_A.selfadjointView<Lower>() * d_B (cublasXsymm) - SYRK/HERK: d_C = d_A * d_A.adjoint() (cublasXsyrk) cuSOLVER dispatch: - GpuLLT: Cached Cholesky factorization (cusolverDnXpotrf + Xpotrs) - GpuLU: Cached LU factorization (cusolverDnXgetrf + Xgetrs) - Solver chaining: auto x = d_A.llt().solve(d_B) - Solver expressions with .device(ctx) for explicit stream control. CI: Bump CUDA container to Ubuntu 22.04 (CMake 3.22), GCC 10->11, Clang 12->14. Bump cmake_minimum_required to 3.17 for FindCUDAToolkit. Tests: gpu_cublas.cpp, gpu_cusolver_llt.cpp, gpu_cusolver_lu.cpp, gpu_device_matrix.cpp, gpu_library_example.cu Benchmarks: bench_gpu_solvers.cpp, bench_gpu_chaining.cpp, bench_gpu_batching.cpp
This commit is contained in:
Rasmus Munk Larsen
@@ -43,3 +43,10 @@ add_subdirectory(Householder)
|
||||
add_subdirectory(Solvers)
|
||||
add_subdirectory(Tuning)
|
||||
add_subdirectory(BLAS)
|
||||
|
||||
# GPU benchmarks have their own CMake project (needs CUDAToolkit).
|
||||
# They can also be built standalone: cmake -B build -S benchmarks/GPU
|
||||
find_package(CUDAToolkit QUIET)
|
||||
if(CUDAToolkit_FOUND)
|
||||
add_subdirectory(GPU)
|
||||
endif()
|
||||
|
||||
53
benchmarks/GPU/CMakeLists.txt
Normal file
53
benchmarks/GPU/CMakeLists.txt
Normal file
@@ -0,0 +1,53 @@
|
||||
# GPU benchmarks require CUDA runtime + cuSOLVER.
|
||||
# Build separately from the main benchmark tree since they need CUDA toolchain.
|
||||
#
|
||||
# Usage:
|
||||
# cmake -G Ninja -B build-bench-gpu -S benchmarks/GPU \
|
||||
# -DCMAKE_CUDA_ARCHITECTURES=89
|
||||
# cmake --build build-bench-gpu
|
||||
#
|
||||
# Profiling:
|
||||
# nsys profile --trace=cuda ./build-bench-gpu/bench_gpu_solvers
|
||||
# ncu --set full -o profile ./build-bench-gpu/bench_gpu_solvers --benchmark_filter=BM_GpuLLT_Compute/4096
|
||||
|
||||
cmake_minimum_required(VERSION 3.18)
|
||||
project(EigenGpuBenchmarks CXX)
|
||||
|
||||
find_package(benchmark REQUIRED)
|
||||
find_package(CUDAToolkit REQUIRED)
|
||||
|
||||
set(EIGEN_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../..")
|
||||
|
||||
function(eigen_add_gpu_benchmark name source)
|
||||
cmake_parse_arguments(BENCH "" "" "LIBRARIES;DEFINITIONS" ${ARGN})
|
||||
if(NOT IS_ABSOLUTE "${source}")
|
||||
set(source "${CMAKE_CURRENT_SOURCE_DIR}/${source}")
|
||||
endif()
|
||||
add_executable(${name} ${source})
|
||||
target_include_directories(${name} PRIVATE
|
||||
${EIGEN_SOURCE_DIR}
|
||||
${CUDAToolkit_INCLUDE_DIRS})
|
||||
target_link_libraries(${name} PRIVATE
|
||||
benchmark::benchmark benchmark::benchmark_main
|
||||
CUDA::cudart CUDA::cusolver CUDA::cublas)
|
||||
if(BENCH_LIBRARIES)
|
||||
target_link_libraries(${name} PRIVATE ${BENCH_LIBRARIES})
|
||||
endif()
|
||||
target_compile_options(${name} PRIVATE -O3 -DNDEBUG)
|
||||
target_compile_definitions(${name} PRIVATE EIGEN_USE_GPU)
|
||||
if(BENCH_DEFINITIONS)
|
||||
target_compile_definitions(${name} PRIVATE ${BENCH_DEFINITIONS})
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
# Solver benchmarks: LLT/LU compute + solve, host vs device paths, CPU baselines.
|
||||
eigen_add_gpu_benchmark(bench_gpu_solvers bench_gpu_solvers.cpp)
|
||||
eigen_add_gpu_benchmark(bench_gpu_solvers_float bench_gpu_solvers.cpp DEFINITIONS SCALAR=float)
|
||||
|
||||
# Chaining benchmarks: async pipeline efficiency, host-roundtrip vs device chain.
|
||||
eigen_add_gpu_benchmark(bench_gpu_chaining bench_gpu_chaining.cpp)
|
||||
eigen_add_gpu_benchmark(bench_gpu_chaining_float bench_gpu_chaining.cpp DEFINITIONS SCALAR=float)
|
||||
|
||||
# Batching benchmarks: multi-stream concurrency for many small systems.
|
||||
eigen_add_gpu_benchmark(bench_gpu_batching bench_gpu_batching.cpp)
|
||||
eigen_add_gpu_benchmark(bench_gpu_batching_float bench_gpu_batching.cpp DEFINITIONS SCALAR=float)
|
||||
268
benchmarks/GPU/bench_gpu_batching.cpp
Normal file
268
benchmarks/GPU/bench_gpu_batching.cpp
Normal file
@@ -0,0 +1,268 @@
|
||||
// GPU batching benchmarks: multi-stream concurrency for many small solves.
|
||||
//
|
||||
// Each GpuLLT/GpuLU owns its own CUDA stream. This benchmark measures how
|
||||
// well multiple solver instances overlap on the GPU, which is critical for
|
||||
// workloads like robotics (many small systems) and SLAM (batched poses).
|
||||
//
|
||||
// Compares:
|
||||
// 1. Sequential: one solver handles all systems one by one
|
||||
// 2. Batched: N solvers on N streams, all launched before any sync
|
||||
// 3. CPU baseline: Eigen LLT on host
|
||||
//
|
||||
// For Nsight Systems: batched mode should show overlapping kernels on
|
||||
// different streams in the timeline view.
|
||||
//
|
||||
// nsys profile --trace=cuda ./bench_gpu_batching
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
#include <Eigen/Cholesky>
|
||||
#include <Eigen/GPU>
|
||||
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
#ifndef SCALAR
|
||||
#define SCALAR double
|
||||
#endif
|
||||
|
||||
using Scalar = SCALAR;
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
|
||||
static Mat make_spd(Index n) {
|
||||
Mat M = Mat::Random(n, n);
|
||||
return M.adjoint() * M + Mat::Identity(n, n) * static_cast<Scalar>(n);
|
||||
}
|
||||
|
||||
static void cuda_warmup() {
|
||||
static bool done = false;
|
||||
if (!done) {
|
||||
void* p;
|
||||
cudaMalloc(&p, 1);
|
||||
cudaFree(p);
|
||||
done = true;
|
||||
}
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Sequential: one solver, N systems solved one after another
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Batch_Sequential(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int batch_size = static_cast<int>(state.range(1));
|
||||
|
||||
// Pre-generate all SPD matrices and RHS vectors.
|
||||
std::vector<Mat> As(batch_size);
|
||||
std::vector<Mat> Bs(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
As[i] = make_spd(n);
|
||||
Bs[i] = Mat::Random(n, 1);
|
||||
}
|
||||
|
||||
GpuLLT<Scalar> llt;
|
||||
|
||||
for (auto _ : state) {
|
||||
std::vector<Mat> results(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
llt.compute(As[i]);
|
||||
results[i] = llt.solve(Bs[i]);
|
||||
}
|
||||
benchmark::DoNotOptimize(results.back().data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["batch"] = batch_size;
|
||||
state.counters["total_solves"] = batch_size;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Sequential with DeviceMatrix (avoid re-upload of A each iteration)
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Batch_Sequential_Device(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int batch_size = static_cast<int>(state.range(1));
|
||||
|
||||
std::vector<Mat> As(batch_size);
|
||||
std::vector<Mat> Bs(batch_size);
|
||||
std::vector<DeviceMatrix<Scalar>> d_As(batch_size);
|
||||
std::vector<DeviceMatrix<Scalar>> d_Bs(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
As[i] = make_spd(n);
|
||||
Bs[i] = Mat::Random(n, 1);
|
||||
d_As[i] = DeviceMatrix<Scalar>::fromHost(As[i]);
|
||||
d_Bs[i] = DeviceMatrix<Scalar>::fromHost(Bs[i]);
|
||||
}
|
||||
|
||||
GpuLLT<Scalar> llt;
|
||||
|
||||
for (auto _ : state) {
|
||||
std::vector<Mat> results(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
llt.compute(d_As[i]);
|
||||
DeviceMatrix<Scalar> d_X = llt.solve(d_Bs[i]);
|
||||
results[i] = d_X.toHost();
|
||||
}
|
||||
benchmark::DoNotOptimize(results.back().data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["batch"] = batch_size;
|
||||
state.counters["total_solves"] = batch_size;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Batched: N solvers on N streams, overlapping execution
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Batch_MultiStream(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int batch_size = static_cast<int>(state.range(1));
|
||||
|
||||
std::vector<Mat> As(batch_size);
|
||||
std::vector<Mat> Bs(batch_size);
|
||||
std::vector<DeviceMatrix<Scalar>> d_As(batch_size);
|
||||
std::vector<DeviceMatrix<Scalar>> d_Bs(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
As[i] = make_spd(n);
|
||||
Bs[i] = Mat::Random(n, 1);
|
||||
d_As[i] = DeviceMatrix<Scalar>::fromHost(As[i]);
|
||||
d_Bs[i] = DeviceMatrix<Scalar>::fromHost(Bs[i]);
|
||||
}
|
||||
|
||||
// N solvers = N independent CUDA streams.
|
||||
std::vector<std::unique_ptr<GpuLLT<Scalar>>> solvers(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
solvers[i] = std::make_unique<GpuLLT<Scalar>>();
|
||||
}
|
||||
|
||||
for (auto _ : state) {
|
||||
// Phase 1: launch all factorizations (async, different streams).
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
solvers[i]->compute(d_As[i]);
|
||||
}
|
||||
|
||||
// Phase 2: launch all solves (async, different streams).
|
||||
std::vector<DeviceMatrix<Scalar>> d_Xs(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
d_Xs[i] = solvers[i]->solve(d_Bs[i]);
|
||||
}
|
||||
|
||||
// Phase 3: download all results.
|
||||
std::vector<Mat> results(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
results[i] = d_Xs[i].toHost();
|
||||
}
|
||||
benchmark::DoNotOptimize(results.back().data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["batch"] = batch_size;
|
||||
state.counters["streams"] = batch_size;
|
||||
state.counters["total_solves"] = batch_size;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Batched with async download (overlap D2H with computation)
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Batch_MultiStream_AsyncDownload(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int batch_size = static_cast<int>(state.range(1));
|
||||
|
||||
std::vector<Mat> As(batch_size);
|
||||
std::vector<Mat> Bs(batch_size);
|
||||
std::vector<DeviceMatrix<Scalar>> d_As(batch_size);
|
||||
std::vector<DeviceMatrix<Scalar>> d_Bs(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
As[i] = make_spd(n);
|
||||
Bs[i] = Mat::Random(n, 1);
|
||||
d_As[i] = DeviceMatrix<Scalar>::fromHost(As[i]);
|
||||
d_Bs[i] = DeviceMatrix<Scalar>::fromHost(Bs[i]);
|
||||
}
|
||||
|
||||
std::vector<std::unique_ptr<GpuLLT<Scalar>>> solvers(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
solvers[i] = std::make_unique<GpuLLT<Scalar>>();
|
||||
}
|
||||
|
||||
for (auto _ : state) {
|
||||
// Launch all compute + solve.
|
||||
std::vector<DeviceMatrix<Scalar>> d_Xs(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
solvers[i]->compute(d_As[i]);
|
||||
d_Xs[i] = solvers[i]->solve(d_Bs[i]);
|
||||
}
|
||||
|
||||
// Enqueue all async downloads.
|
||||
std::vector<HostTransfer<Scalar>> transfers;
|
||||
transfers.reserve(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
transfers.push_back(d_Xs[i].toHostAsync());
|
||||
}
|
||||
|
||||
// Collect all results.
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
benchmark::DoNotOptimize(transfers[i].get().data());
|
||||
}
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["batch"] = batch_size;
|
||||
state.counters["streams"] = batch_size;
|
||||
state.counters["total_solves"] = batch_size;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// CPU baseline: Eigen LLT on host, sequential
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Batch_CPU(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
const int batch_size = static_cast<int>(state.range(1));
|
||||
|
||||
std::vector<Mat> As(batch_size);
|
||||
std::vector<Mat> Bs(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
As[i] = make_spd(n);
|
||||
Bs[i] = Mat::Random(n, 1);
|
||||
}
|
||||
|
||||
for (auto _ : state) {
|
||||
std::vector<Mat> results(batch_size);
|
||||
for (int i = 0; i < batch_size; ++i) {
|
||||
LLT<Mat> llt(As[i]);
|
||||
results[i] = llt.solve(Bs[i]);
|
||||
}
|
||||
benchmark::DoNotOptimize(results.back().data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["batch"] = batch_size;
|
||||
state.counters["total_solves"] = batch_size;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Registration
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
// clang-format off
|
||||
// Args: {matrix_size, batch_size}
|
||||
// Small matrices with large batches are the interesting case for multi-stream.
|
||||
BENCHMARK(BM_Batch_Sequential)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Batch_Sequential_Device)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Batch_MultiStream)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Batch_MultiStream_AsyncDownload)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Batch_CPU)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond);
|
||||
|
||||
// Also run larger sizes with moderate batching.
|
||||
BENCHMARK(BM_Batch_MultiStream)->ArgsProduct({{512, 1024, 2048}, {1, 4, 8}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Batch_MultiStream_AsyncDownload)->ArgsProduct({{512, 1024, 2048}, {1, 4, 8}})->Unit(benchmark::kMicrosecond);
|
||||
// clang-format on
|
||||
216
benchmarks/GPU/bench_gpu_chaining.cpp
Normal file
216
benchmarks/GPU/bench_gpu_chaining.cpp
Normal file
@@ -0,0 +1,216 @@
|
||||
// GPU chaining benchmarks: measure async pipeline efficiency.
|
||||
//
|
||||
// Compares:
|
||||
// 1. Host round-trip per solve (baseline)
|
||||
// 2. DeviceMatrix chaining (no host round-trip between solves)
|
||||
// 3. Varying chain lengths (1, 2, 4, 8 consecutive solves)
|
||||
//
|
||||
// For Nsight Systems: look for gaps between kernel launches in the timeline.
|
||||
// Host round-trip creates visible idle gaps; chaining should show back-to-back kernels.
|
||||
//
|
||||
// nsys profile --trace=cuda,nvtx ./bench_gpu_chaining
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
#include <Eigen/Cholesky>
|
||||
#include <Eigen/GPU>
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
#ifndef SCALAR
|
||||
#define SCALAR double
|
||||
#endif
|
||||
|
||||
using Scalar = SCALAR;
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
|
||||
static Mat make_spd(Index n) {
|
||||
Mat M = Mat::Random(n, n);
|
||||
return M.adjoint() * M + Mat::Identity(n, n) * static_cast<Scalar>(n);
|
||||
}
|
||||
|
||||
static void cuda_warmup() {
|
||||
static bool done = false;
|
||||
if (!done) {
|
||||
void* p;
|
||||
cudaMalloc(&p, 1);
|
||||
cudaFree(p);
|
||||
done = true;
|
||||
}
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Baseline: host round-trip between every solve
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Chain_HostRoundtrip(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int chain_len = static_cast<int>(state.range(1));
|
||||
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, 1);
|
||||
GpuLLT<Scalar> llt(A);
|
||||
|
||||
for (auto _ : state) {
|
||||
Mat X = B;
|
||||
for (int i = 0; i < chain_len; ++i) {
|
||||
X = llt.solve(X); // host → device → host each time
|
||||
}
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["chain"] = chain_len;
|
||||
state.counters["solves/iter"] = chain_len;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// DeviceMatrix chaining: no host round-trip between solves
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Chain_Device(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int chain_len = static_cast<int>(state.range(1));
|
||||
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, 1);
|
||||
GpuLLT<Scalar> llt(A);
|
||||
auto d_B = DeviceMatrix<Scalar>::fromHost(B);
|
||||
|
||||
for (auto _ : state) {
|
||||
DeviceMatrix<Scalar> d_X = llt.solve(d_B);
|
||||
for (int i = 1; i < chain_len; ++i) {
|
||||
d_X = llt.solve(d_X); // device → device, fully async
|
||||
}
|
||||
Mat X = d_X.toHost(); // single sync at end
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["chain"] = chain_len;
|
||||
state.counters["solves/iter"] = chain_len;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// DeviceMatrix chaining with async download (overlap D2H with next iteration)
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Chain_DeviceAsync(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int chain_len = static_cast<int>(state.range(1));
|
||||
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, 1);
|
||||
GpuLLT<Scalar> llt(A);
|
||||
auto d_B = DeviceMatrix<Scalar>::fromHost(B);
|
||||
|
||||
for (auto _ : state) {
|
||||
DeviceMatrix<Scalar> d_X = llt.solve(d_B);
|
||||
for (int i = 1; i < chain_len; ++i) {
|
||||
d_X = llt.solve(d_X);
|
||||
}
|
||||
auto transfer = d_X.toHostAsync();
|
||||
Mat X = transfer.get();
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["chain"] = chain_len;
|
||||
state.counters["solves/iter"] = chain_len;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Pure GPU chain (no download — measures kernel-only throughput)
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_Chain_DeviceNoDownload(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int chain_len = static_cast<int>(state.range(1));
|
||||
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, 1);
|
||||
GpuLLT<Scalar> llt(A);
|
||||
auto d_B = DeviceMatrix<Scalar>::fromHost(B);
|
||||
|
||||
for (auto _ : state) {
|
||||
DeviceMatrix<Scalar> d_X = llt.solve(d_B);
|
||||
for (int i = 1; i < chain_len; ++i) {
|
||||
d_X = llt.solve(d_X);
|
||||
}
|
||||
cudaStreamSynchronize(llt.stream());
|
||||
benchmark::DoNotOptimize(d_X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["chain"] = chain_len;
|
||||
state.counters["solves/iter"] = chain_len;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Compute + solve chain (full pipeline: factorize, then chain solves)
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_FullPipeline_Host(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int chain_len = static_cast<int>(state.range(1));
|
||||
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, 1);
|
||||
|
||||
for (auto _ : state) {
|
||||
GpuLLT<Scalar> llt(A);
|
||||
Mat X = B;
|
||||
for (int i = 0; i < chain_len; ++i) {
|
||||
X = llt.solve(X);
|
||||
}
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["chain"] = chain_len;
|
||||
}
|
||||
|
||||
static void BM_FullPipeline_Device(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const int chain_len = static_cast<int>(state.range(1));
|
||||
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, 1);
|
||||
|
||||
for (auto _ : state) {
|
||||
auto d_A = DeviceMatrix<Scalar>::fromHost(A);
|
||||
auto d_B = DeviceMatrix<Scalar>::fromHost(B);
|
||||
GpuLLT<Scalar> llt;
|
||||
llt.compute(d_A);
|
||||
DeviceMatrix<Scalar> d_X = llt.solve(d_B);
|
||||
for (int i = 1; i < chain_len; ++i) {
|
||||
d_X = llt.solve(d_X);
|
||||
}
|
||||
Mat X = d_X.toHost();
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["chain"] = chain_len;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Registration
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
// clang-format off
|
||||
// Args: {matrix_size, chain_length}
|
||||
BENCHMARK(BM_Chain_HostRoundtrip)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Chain_Device)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Chain_DeviceAsync)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_Chain_DeviceNoDownload)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond);
|
||||
|
||||
BENCHMARK(BM_FullPipeline_Host)->ArgsProduct({{256, 1024, 4096}, {1, 4}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_FullPipeline_Device)->ArgsProduct({{256, 1024, 4096}, {1, 4}})->Unit(benchmark::kMicrosecond);
|
||||
// clang-format on
|
||||
296
benchmarks/GPU/bench_gpu_solvers.cpp
Normal file
296
benchmarks/GPU/bench_gpu_solvers.cpp
Normal file
@@ -0,0 +1,296 @@
|
||||
// GPU solver benchmarks: GpuLLT and GpuLU compute + solve throughput.
|
||||
//
|
||||
// Measures factorization and solve performance for the host-matrix and
|
||||
// DeviceMatrix code paths across a range of matrix sizes.
|
||||
//
|
||||
// For Nsight Systems profiling:
|
||||
// nsys profile --trace=cuda,nvtx ./bench_gpu_solvers
|
||||
//
|
||||
// For Nsight Compute kernel analysis:
|
||||
// ncu --set full -o profile ./bench_gpu_solvers --benchmark_filter=BM_GpuLLT_Compute/4096
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
#include <Eigen/Cholesky>
|
||||
#include <Eigen/GPU>
|
||||
#include <Eigen/LU>
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
#ifndef SCALAR
|
||||
#define SCALAR double
|
||||
#endif
|
||||
|
||||
using Scalar = SCALAR;
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static Mat make_spd(Index n) {
|
||||
Mat M = Mat::Random(n, n);
|
||||
return M.adjoint() * M + Mat::Identity(n, n) * static_cast<Scalar>(n);
|
||||
}
|
||||
|
||||
// CUDA warm-up: ensure the GPU is initialized before timing.
|
||||
static void cuda_warmup() {
|
||||
static bool done = false;
|
||||
if (!done) {
|
||||
void* p;
|
||||
cudaMalloc(&p, 1);
|
||||
cudaFree(p);
|
||||
done = true;
|
||||
}
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// GpuLLT benchmarks
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
// Factorize from host matrix (includes H2D upload).
|
||||
static void BM_GpuLLT_Compute_Host(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
Mat A = make_spd(n);
|
||||
GpuLLT<Scalar> llt;
|
||||
|
||||
for (auto _ : state) {
|
||||
llt.compute(A);
|
||||
if (llt.info() != Success) state.SkipWithError("factorization failed");
|
||||
}
|
||||
|
||||
double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
|
||||
state.counters["GFLOPS"] =
|
||||
benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
|
||||
state.counters["n"] = n;
|
||||
}
|
||||
|
||||
// Factorize from DeviceMatrix (D2D copy path).
|
||||
static void BM_GpuLLT_Compute_Device(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
Mat A = make_spd(n);
|
||||
auto d_A = DeviceMatrix<Scalar>::fromHost(A);
|
||||
GpuLLT<Scalar> llt;
|
||||
|
||||
for (auto _ : state) {
|
||||
llt.compute(d_A);
|
||||
if (llt.info() != Success) state.SkipWithError("factorization failed");
|
||||
}
|
||||
|
||||
double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
|
||||
state.counters["GFLOPS"] =
|
||||
benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
|
||||
state.counters["n"] = n;
|
||||
}
|
||||
|
||||
// Factorize from DeviceMatrix (move path, no copy).
|
||||
static void BM_GpuLLT_Compute_DeviceMove(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
Mat A = make_spd(n);
|
||||
GpuLLT<Scalar> llt;
|
||||
|
||||
for (auto _ : state) {
|
||||
auto d_A = DeviceMatrix<Scalar>::fromHost(A);
|
||||
llt.compute(std::move(d_A));
|
||||
if (llt.info() != Success) state.SkipWithError("factorization failed");
|
||||
}
|
||||
|
||||
double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
|
||||
state.counters["GFLOPS"] =
|
||||
benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
|
||||
state.counters["n"] = n;
|
||||
}
|
||||
|
||||
// Solve from host matrix (H2D + potrs + D2H).
|
||||
static void BM_GpuLLT_Solve_Host(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const Index nrhs = state.range(1);
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, nrhs);
|
||||
GpuLLT<Scalar> llt(A);
|
||||
|
||||
for (auto _ : state) {
|
||||
Mat X = llt.solve(B);
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["nrhs"] = nrhs;
|
||||
}
|
||||
|
||||
// Solve from DeviceMatrix (D2D + potrs, async, toHost at end).
|
||||
static void BM_GpuLLT_Solve_Device(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const Index nrhs = state.range(1);
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, nrhs);
|
||||
GpuLLT<Scalar> llt(A);
|
||||
auto d_B = DeviceMatrix<Scalar>::fromHost(B);
|
||||
|
||||
for (auto _ : state) {
|
||||
DeviceMatrix<Scalar> d_X = llt.solve(d_B);
|
||||
Mat X = d_X.toHost();
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["nrhs"] = nrhs;
|
||||
}
|
||||
|
||||
// Solve staying entirely on device (no toHost — measures pure GPU time).
|
||||
static void BM_GpuLLT_Solve_DeviceOnly(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const Index nrhs = state.range(1);
|
||||
Mat A = make_spd(n);
|
||||
Mat B = Mat::Random(n, nrhs);
|
||||
GpuLLT<Scalar> llt(A);
|
||||
auto d_B = DeviceMatrix<Scalar>::fromHost(B);
|
||||
|
||||
for (auto _ : state) {
|
||||
DeviceMatrix<Scalar> d_X = llt.solve(d_B);
|
||||
// Force completion without D2H transfer.
|
||||
cudaStreamSynchronize(llt.stream());
|
||||
benchmark::DoNotOptimize(d_X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["nrhs"] = nrhs;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// GpuLU benchmarks
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_GpuLU_Compute_Host(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
Mat A = Mat::Random(n, n);
|
||||
GpuLU<Scalar> lu;
|
||||
|
||||
for (auto _ : state) {
|
||||
lu.compute(A);
|
||||
if (lu.info() != Success) state.SkipWithError("factorization failed");
|
||||
}
|
||||
|
||||
double flops = 2.0 / 3.0 * static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n);
|
||||
state.counters["GFLOPS"] =
|
||||
benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
|
||||
state.counters["n"] = n;
|
||||
}
|
||||
|
||||
static void BM_GpuLU_Compute_Device(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
Mat A = Mat::Random(n, n);
|
||||
auto d_A = DeviceMatrix<Scalar>::fromHost(A);
|
||||
GpuLU<Scalar> lu;
|
||||
|
||||
for (auto _ : state) {
|
||||
lu.compute(d_A);
|
||||
if (lu.info() != Success) state.SkipWithError("factorization failed");
|
||||
}
|
||||
|
||||
double flops = 2.0 / 3.0 * static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n);
|
||||
state.counters["GFLOPS"] =
|
||||
benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
|
||||
state.counters["n"] = n;
|
||||
}
|
||||
|
||||
static void BM_GpuLU_Solve_Host(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const Index nrhs = state.range(1);
|
||||
Mat A = Mat::Random(n, n);
|
||||
Mat B = Mat::Random(n, nrhs);
|
||||
GpuLU<Scalar> lu(A);
|
||||
|
||||
for (auto _ : state) {
|
||||
Mat X = lu.solve(B);
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["nrhs"] = nrhs;
|
||||
}
|
||||
|
||||
static void BM_GpuLU_Solve_Device(benchmark::State& state) {
|
||||
cuda_warmup();
|
||||
const Index n = state.range(0);
|
||||
const Index nrhs = state.range(1);
|
||||
Mat A = Mat::Random(n, n);
|
||||
Mat B = Mat::Random(n, nrhs);
|
||||
GpuLU<Scalar> lu(A);
|
||||
auto d_B = DeviceMatrix<Scalar>::fromHost(B);
|
||||
|
||||
for (auto _ : state) {
|
||||
DeviceMatrix<Scalar> d_X = lu.solve(d_B);
|
||||
Mat X = d_X.toHost();
|
||||
benchmark::DoNotOptimize(X.data());
|
||||
}
|
||||
|
||||
state.counters["n"] = n;
|
||||
state.counters["nrhs"] = nrhs;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// CPU baselines for comparison
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
static void BM_CpuLLT_Compute(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
Mat A = make_spd(n);
|
||||
LLT<Mat> llt;
|
||||
|
||||
for (auto _ : state) {
|
||||
llt.compute(A);
|
||||
benchmark::DoNotOptimize(llt.matrixLLT().data());
|
||||
}
|
||||
|
||||
double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
|
||||
state.counters["GFLOPS"] =
|
||||
benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
|
||||
state.counters["n"] = n;
|
||||
}
|
||||
|
||||
static void BM_CpuLU_Compute(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
Mat A = Mat::Random(n, n);
|
||||
PartialPivLU<Mat> lu;
|
||||
|
||||
for (auto _ : state) {
|
||||
lu.compute(A);
|
||||
benchmark::DoNotOptimize(lu.matrixLU().data());
|
||||
}
|
||||
|
||||
double flops = 2.0 / 3.0 * static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n);
|
||||
state.counters["GFLOPS"] =
|
||||
benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
|
||||
state.counters["n"] = n;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Registration
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
// clang-format off
|
||||
BENCHMARK(BM_GpuLLT_Compute_Host)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLLT_Compute_Device)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLLT_Compute_DeviceMove)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLLT_Solve_Host)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLLT_Solve_Device)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLLT_Solve_DeviceOnly)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond);
|
||||
|
||||
BENCHMARK(BM_GpuLU_Compute_Host)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLU_Compute_Device)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLU_Solve_Host)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_GpuLU_Solve_Device)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond);
|
||||
|
||||
BENCHMARK(BM_CpuLLT_Compute)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond);
|
||||
BENCHMARK(BM_CpuLU_Compute)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond);
|
||||
// clang-format on
|
||||
Reference in New Issue
Block a user