Add option for LAPACK/cuSOLVER bindings for [he,sy]gvd

Author: nbeams

CMakeLists.txt

@@ -144,6 +144,7 @@ option(
 )
 option(BUILD_SHARED_LIBS "Build shared (.so, .dylib, .dll) libraries" ON)
 option(GINKGO_BUILD_HWLOC "Build Ginkgo with HWLOC. Default is OFF." OFF)
+option(GINKGO_BUILD_LAPACK "Build Ginkgo with LAPACK. Default is OFF." OFF)
 option(
     GINKGO_BUILD_PAPI_SDE
     "Build Ginkgo with PAPI SDE. Enabled if a system installation is found."
@@ -359,6 +360,12 @@ if(GINKGO_BUILD_HWLOC AND (MSVC OR WIN32 OR CYGWIN OR APPLE))
     )
 endif()
 
+set(GINKGO_HAVE_LAPACK 0)
+if(GINKGO_BUILD_LAPACK)
+    find_package(LAPACK REQUIRED)
+    set(GINKGO_HAVE_LAPACK 1)
+endif()
+
 set(GINKGO_HAVE_GPU_AWARE_MPI OFF)
 set(GINKGO_HAVE_OPENMPI_PRE_4_1_X OFF)
 if(GINKGO_BUILD_MPI)

cmake/get_info.cmake

@@ -160,7 +160,7 @@ foreach(log_type ${log_types})
     )
     ginkgo_print_module_footer(${${log_type}} "  Enabled features:")
     ginkgo_print_foreach_variable(${${log_type}}
-        "GINKGO_MIXED_PRECISION;GINKGO_HAVE_GPU_AWARE_MPI;GINKGO_ENABLE_HALF"
+        "GINKGO_MIXED_PRECISION;GINKGO_HAVE_GPU_AWARE_MPI;GINKGO_ENABLE_HALF;GINKGO_HAVE_LAPACK"
     )
     ginkgo_print_module_footer(${${log_type}} "  Tests, benchmarks and examples:")
     ginkgo_print_foreach_variable(${${log_type}}

common/cuda_hip/CMakeLists.txt

@@ -44,6 +44,7 @@ set(CUDA_HIP_SOURCES
     reorder/rcm_kernels.cpp
     solver/cb_gmres_kernels.cpp
     solver/idr_kernels.cpp
+    solver/lobpcg_kernels.cpp
     solver/multigrid_kernels.cpp
     stop/criterion_kernels.cpp
     stop/residual_norm_kernels.cpp

common/cuda_hip/base/dev_lapack_bindings.hpp

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_COMMON_CUDA_HIP_BASE_DEV_LAPACK_BINDINGS_HPP_
+#define GKO_COMMON_CUDA_HIP_BASE_DEV_LAPACK_BINDINGS_HPP_
+
+
+#if defined(GKO_COMPILING_CUDA)
+#include "cuda/base/cusolver_bindings.hpp"
+#elif defined(GKO_COMPILING_HIP)
+#include "hip/base/hipsolver_bindings.hip.hpp"
+#else
+#error "Executor definition missing"
+#endif
+
+
+#endif  // GKO_COMMON_CUDA_HIP_BASE_DEV_LAPACK_BINDINGS_HPP_

common/cuda_hip/solver/lobpcg_kernels.cpp

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "core/solver/lobpcg_kernels.hpp"
+
+#include <ginkgo/core/base/types.hpp>
+
+#include "common/cuda_hip/base/dev_lapack_bindings.hpp"
+
+#if GKO_HAVE_LAPACK
+
+
+namespace gko {
+namespace kernels {
+namespace GKO_DEVICE_NAMESPACE {
+namespace lobpcg {
+
+
+using gko::kernels::lobpcg::workspace_mode;
+
+template <typename ValueType>
+void symm_generalized_eig(std::shared_ptr<const DefaultExecutor> exec,
+                          const workspace_mode alloc,
+                          matrix::Dense<ValueType>* a,
+                          matrix::Dense<ValueType>* b,
+                          array<remove_complex<ValueType>>* e_vals,
+                          array<char>* workspace)
+{
+    const auto id = exec->get_device_id();
+    auto handle = exec->get_dev_lapack_handle();
+
+    int n = static_cast<int>(a->get_size()[1]);  // column-major
+    int lda = static_cast<int>(a->get_stride());
+    int ldb = static_cast<int>(b->get_stride());
+    int fp_buffer_num_elems;
+    if (alloc == workspace_mode::allocate) {
+        dev_lapack::sygvd_buffersize(handle, LAPACK_EIG_TYPE_1,
+                                     LAPACK_EIG_VECTOR, LAPACK_FILL_LOWER, n,
+                                     a->get_values(), lda, b->get_values(), ldb,
+                                     e_vals->get_data(), &fp_buffer_num_elems);
+        size_type total_bytes = sizeof(ValueType) * fp_buffer_num_elems;
+        workspace->resize_and_reset(total_bytes);
+    } else {
+        fp_buffer_num_elems = workspace->get_size() / sizeof(ValueType);
+    }
+    array<int> dev_info(exec, 1);
+    dev_lapack::sygvd(handle, LAPACK_EIG_TYPE_1, LAPACK_EIG_VECTOR,
+                      LAPACK_FILL_LOWER, n, a->get_values(), lda,
+                      b->get_values(), ldb, e_vals->get_data(),
+                      (ValueType*)workspace->get_data(), fp_buffer_num_elems,
+                      dev_info.get_data());
+}
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(
+    GKO_DECLARE_LOBPCG_SYMM_GENERALIZED_EIG_KERNEL);
+
+
+}  // namespace lobpcg
+}  // namespace GKO_DEVICE_NAMESPACE
+}  // namespace kernels
+}  // namespace gko
+
+#endif  // GKO_HAVE_LAPACK

core/device_hooks/common_kernels.inc.cpp

@@ -69,6 +69,7 @@
 #include "core/solver/gmres_kernels.hpp"
 #include "core/solver/idr_kernels.hpp"
 #include "core/solver/ir_kernels.hpp"
+#include "core/solver/lobpcg_kernels.hpp"
 #include "core/solver/lower_trs_kernels.hpp"
 #include "core/solver/minres_kernels.hpp"
 #include "core/solver/multigrid_kernels.hpp"
@@ -708,6 +709,17 @@ GKO_STUB_VALUE_TYPE(GKO_DECLARE_MINRES_STEP_2_KERNEL);
 }  // namespace minres
 
 
+#if GKO_HAVE_LAPACK
+namespace lobpcg {
+
+
+GKO_STUB_VALUE_TYPE(GKO_DECLARE_LOBPCG_SYMM_GENERALIZED_EIG_KERNEL);
+
+
+}  // namespace lobpcg
+#endif
+
+
 namespace sparsity_csr {
 
 

core/device_hooks/cuda_hooks.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -175,6 +175,12 @@ std::string CusparseError::get_error(int64)
 }
 
 
+std::string CusolverError::get_error(int64)
+{
+    return "ginkgo CUDA module is not compiled";
+}
+
+
 std::string CufftError::get_error(int64)
 {
     return "ginkgo CUDA module is not compiled";

core/solver/lobpcg_kernels.hpp

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_CORE_SOLVER_LOBPCG_KERNELS_HPP_
+#define GKO_CORE_SOLVER_LOBPCG_KERNELS_HPP_
+
+
+#include <ginkgo/core/base/array.hpp>
+#include <ginkgo/core/base/math.hpp>
+#include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/matrix/dense.hpp>
+
+#include "core/base/kernel_declaration.hpp"
+
+
+namespace gko {
+namespace kernels {
+namespace lobpcg {
+
+/**
+ * Set the workspace mode for LAPACK/cuSOLVER/rocSOLVER/MKL calls
+ */
+enum class workspace_mode {
+    /**
+     * Query workspace size and allocate required memory
+     */
+    allocate,
+    /**
+     * Use workspace that has already been allocated
+     */
+    use_preallocated
+};
+
+
+#define GKO_DECLARE_LOBPCG_SYMM_GENERALIZED_EIG_KERNEL(_type) \
+    void symm_generalized_eig(                                \
+        std::shared_ptr<const DefaultExecutor> exec,          \
+        const gko::kernels::lobpcg::workspace_mode alloc,     \
+        matrix::Dense<_type>* a, matrix::Dense<_type>* b,     \
+        array<remove_complex<_type>>* e_vals, array<char>* workspace)
+
+
+#define GKO_DECLARE_ALL_AS_TEMPLATES \
+    template <typename ValueType>    \
+    GKO_DECLARE_LOBPCG_SYMM_GENERALIZED_EIG_KERNEL(ValueType)
+
+
+}  // namespace lobpcg
+
+
+GKO_DECLARE_FOR_ALL_EXECUTOR_NAMESPACES(lobpcg, GKO_DECLARE_ALL_AS_TEMPLATES);
+
+
+#undef GKO_DECLARE_ALL_AS_TEMPLATES
+
+
+}  // namespace kernels
+}  // namespace gko
+
+
+#endif  // GKO_CORE_SOLVER_LOBPCG_KERNELS_HPP_

core/test/base/exception.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -44,7 +44,6 @@ TEST(ExceptionClasses, NotSupportedReturnsCorrectWhatMessage)
         error.what());
 }
 
-
 TEST(ExceptionClasses, CudaErrorReturnsCorrectWhatMessage)
 {
     gko::CudaError error("test_file.cpp", 123, "test_func", 1);
@@ -77,6 +76,16 @@ TEST(ExceptionClasses, CusparseErrorReturnsCorrectWhatMessage)
 }
 
 
+#if GKO_HAVE_LAPACK
+TEST(ExceptionClasses, CusolverErrorReturnsCorrectWhatMessage)
+{
+    gko::CusolverError error("test_file.cpp", 123, "test_func", 1);
+    std::string expected = "test_file.cpp:123: test_func: ";
+    ASSERT_EQ(expected, std::string(error.what()).substr(0, expected.size()));
+}
+#endif
+
+
 TEST(ExceptionClasses, CufftErrorReturnsCorrectWhatMessage)
 {
     gko::CufftError error("test_file.cpp", 123, "test_func", 1);
@@ -125,6 +134,16 @@ TEST(ExceptionClasses, HipfftErrorReturnsCorrectWhatMessage)
 }
 
 
+#if GKO_HAVE_LAPACK
+TEST(ExceptionClasses, LapackErrorReturnsCorrectWhatMessage)
+{
+    gko::LapackError error("test_file.cpp", 123, "test_func", 1);
+    std::string expected = "test_file.cpp:123: test_func: ";
+    ASSERT_EQ(expected, std::string(error.what()).substr(0, expected.size()));
+}
+#endif
+
+
 TEST(ExceptionClasses, DimensionMismatchReturnsCorrectWhatMessage)
 {
     gko::DimensionMismatch error("test_file.cpp", 243, "test_func", "a", 3, 4,

core/test/base/exception_helpers.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -103,6 +103,16 @@ TEST(CudaError, ReturnsCusparseError)
 }
 
 
+#if GKO_HAVE_LAPACK
+void throws_cusolver_error() { throw GKO_CUSOLVER_ERROR(0); }
+
+TEST(CudaError, ReturnsCusolverError)
+{
+    ASSERT_THROW(throws_cusolver_error(), gko::CusolverError);
+}
+#endif
+
+
 void throws_cufft_error() { throw GKO_CUFFT_ERROR(0); }
 
 TEST(CudaError, ReturnsCufftError)
@@ -150,6 +160,15 @@ TEST(HipError, ReturnsHipfftError)
     ASSERT_THROW(throws_hipfft_error(), gko::HipfftError);
 }
 
+#if GKO_HAVE_LAPACK
+void throws_lapack_error() { throw GKO_LAPACK_ERROR(0); }
+
+TEST(LapackError, ReturnsLapackError)
+{
+    ASSERT_THROW(throws_lapack_error(), gko::LapackError);
+}
+#endif
+
 
 TEST(AssertIsSquareMatrix, DoesNotThrowWhenIsSquareMatrix)
 {

cuda/CMakeLists.txt

@@ -131,6 +131,9 @@ target_link_libraries(
         CUDA::cufft
         nvtx::nvtx
 )
+if(GINKGO_BUILD_LAPACK)
+    target_link_libraries(ginkgo_cuda PRIVATE CUDA::cusolver)
+endif()
 # NVTX3 is header-only and requires dlopen/dlclose in static builds
 target_link_libraries(ginkgo_cuda PUBLIC ginkgo_device ${CMAKE_DL_LIBS})