Make CUDA optional dependency (lots of cleanup needed.

ORNL · Oct 19, 2023 · 5c5bdd8 · 5c5bdd8
1 parent 7a920be
commit 5c5bdd8
Show file tree

Hide file tree

Showing 11 changed files with 96 additions and 19 deletions.
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -14,6 +14,7 @@ target_link_libraries(klu_klu.exe PRIVATE ReSolve)
 add_executable(klu_klu_standalone.exe r_KLU_KLU_standalone.cpp)
 target_link_libraries(klu_klu_standalone.exe PRIVATE ReSolve)
 
+# Create CUDA examples
 if(RESOLVE_USE_CUDA)
 
   # Build example with KLU factorization and GLU refactorization

diff --git a/examples/r_KLU_KLU.cpp b/examples/r_KLU_KLU.cpp
@@ -1,5 +1,6 @@
 #include <string>
 #include <iostream>
+#include <cmath>
 
 #include <resolve/matrix/Coo.hpp>
 #include <resolve/matrix/Csr.hpp>

diff --git a/examples/r_KLU_KLU_standalone.cpp b/examples/r_KLU_KLU_standalone.cpp
@@ -1,5 +1,6 @@
 #include <string>
 #include <iostream>
+#include <cmath>
 
 #include <resolve/matrix/Coo.hpp>
 #include <resolve/matrix/Csr.hpp>

diff --git a/resolve/CMakeLists.txt b/resolve/CMakeLists.txt
@@ -8,16 +8,21 @@
 
 add_subdirectory(utilities)
 
+# C++ files
 set(ReSolve_SRC
     LinSolver.cpp
     LinSolverDirectKLU.cpp
+)
+
+# C++ code that links to CUDA SDK libraries
+set(ReSolve_CUDASDK_SRC
     LinSolverIterativeFGMRES.cpp
     GramSchmidt.cpp
     LinSolverDirectCuSolverGLU.cpp
     LinSolverDirectCuSolverRf.cpp
 )
 
-
+# Header files to be installed
 set(ReSolve_HEADER_INSTALL
     Common.hpp
     cusolver_defs.hpp
@@ -71,17 +76,21 @@ set(ReSolve_Targets_List
     resolve_workspace
 )
 
+# If CUDA support is enabled add CUDA SDK specific code and dependencies
 if(RESOLVE_USE_CUDA)
+  set(ReSolve_SRC ${ReSolve_SRC} ${ReSolve_CUDASDK_SRC})
   set(ReSolve_Targets_List ${ReSolve_Targets_List} resolve_backend_cuda)
 endif()
 
+# If no GPU support is enabled, link to dummy device backend
 if(NOT RESOLVE_USE_GPU)
     set(ReSolve_Targets_List ${ReSolve_Targets_List} resolve_backend_cpu)
 endif()
 
-
+# Set installable targets
 install(TARGETS ${ReSolve_Targets_List} EXPORT ReSolveTargets)
 
+# Create ReSolve library
 add_library(ReSolve SHARED ${ReSolve_SRC})
 
 target_include_directories(ReSolve INTERFACE 
@@ -92,10 +101,12 @@ target_include_directories(ReSolve INTERFACE
 # TODO: Make this PRIVATE dependency (requires refactoring ReSolve code)
 target_link_libraries(ReSolve PUBLIC ${ReSolve_Targets_List})
 
+# Install targets
 install(TARGETS ReSolve
         EXPORT ReSolveTargets
         ARCHIVE DESTINATION lib
         LIBRARY DESTINATION lib)
+
 # install include headers
 install(FILES ${ReSolve_HEADER_INSTALL} DESTINATION include/resolve)
 
diff --git a/resolve/cpu/CMakeLists.txt b/resolve/cpu/CMakeLists.txt
@@ -8,6 +8,7 @@
 
 set(ReSolve_CPU_SRC
     MemoryUtils.cpp
+    cpuVectorKernels.cpp
 )
 
 set(ReSolve_CPU_HEADER_INSTALL

diff --git a/resolve/cpu/cpuVectorKernels.cpp b/resolve/cpu/cpuVectorKernels.cpp
@@ -0,0 +1,15 @@
+#include <resolve/Common.hpp>
+#include <resolve/vector/VectorKernels.hpp>
+
+
+namespace ReSolve { namespace vector {
+
+
+void set_array_const(index_type n, real_type val, real_type* arr)
+{
+  for(index_type i = 0; i < n; ++i) {
+    arr[i] = val;
+  }
+}
+
+}} // namespace ReSolve::vector
diff --git a/resolve/matrix/CMakeLists.txt b/resolve/matrix/CMakeLists.txt
@@ -6,7 +6,7 @@
 
 ]]
 
-
+# C++ code
 set(Matrix_SRC 
     io.cpp
     Sparse.cpp
@@ -15,10 +15,14 @@ set(Matrix_SRC
     Coo.cpp
     MatrixHandler.cpp
     MatrixHandlerCpu.cpp
-    MatrixHandlerCuda.cpp
 )
 
+# C++ code that depends on CUDA SDK libraries
+set(Matrix_CUDASDK_SRC 
+    MatrixHandlerCuda.cpp
+)
 
+# Header files to be installed
 set(Matrix_HEADER_INSTALL
     io.hpp
     Sparse.hpp
@@ -28,13 +32,23 @@ set(Matrix_HEADER_INSTALL
     MatrixHandler.hpp
 )
 
+# Add CUDA matrix handler if CUDA support is enabled
+if(RESOLVE_USE_CUDA)
+  set(Matrix_SRC ${Matrix_SRC} ${Matrix_CUDASDK_SRC})
+endif()
+
+
 # Build shared library ReSolve::matrix
 add_library(resolve_matrix SHARED ${Matrix_SRC})
 
+# Link to CUDA ReSolve backend if CUDA is support enabled
 if (RESOLVE_USE_CUDA)
-    target_link_libraries(resolve_matrix PUBLIC resolve_backend_cuda)
-else()
-    target_link_libraries(resolve_matrix PUBLIC resolve_backend_cpu)
+  target_link_libraries(resolve_matrix PUBLIC resolve_backend_cuda)
+endif()
+
+# Link to dummy device backend if GPU support is not enabled
+if (NOT RESOLVE_USE_GPU)
+  target_link_libraries(resolve_matrix PUBLIC resolve_backend_cpu)
 endif()
 
 

diff --git a/resolve/matrix/MatrixHandler.cpp b/resolve/matrix/MatrixHandler.cpp
@@ -9,7 +9,10 @@
 #include <resolve/utilities/misc/IndexValuePair.hpp>
 #include "MatrixHandler.hpp"
 #include "MatrixHandlerCpu.hpp"
+
+#ifdef RESOLVE_USE_CUDA
 #include "MatrixHandlerCuda.hpp"
+#endif
 
 namespace ReSolve {
   // Create a shortcut name for Logger static class
@@ -28,7 +31,9 @@ namespace ReSolve {
   {
     this->new_matrix_ = true;
     cpuImpl_  = new MatrixHandlerCpu();
+#ifdef RESOLVE_USE_CUDA
     cudaImpl_ = new MatrixHandlerCuda();
+#endif
   }
 
   /**
@@ -62,13 +67,15 @@ namespace ReSolve {
    * 
    * @post A CUDA implementation instance is created with supplied workspace.
    */
+#ifdef RESOLVE_USE_CUDA
   MatrixHandler::MatrixHandler(LinAlgWorkspaceCUDA* new_workspace)
   {
     cpuImpl_  = new MatrixHandlerCpu();
     cudaImpl_ = new MatrixHandlerCuda(new_workspace);
     isCpuEnabled_  = true;
     isCudaEnabled_ = true;
   }
+#endif
 
   void MatrixHandler::setValuesChanged(bool isValuesChanged, std::string memspace)
   {

diff --git a/resolve/vector/CMakeLists.txt b/resolve/vector/CMakeLists.txt
@@ -6,29 +6,43 @@
 
 ]]
 
-
+# C++ code
 set(Vector_SRC 
     Vector.cpp
     VectorHandler.cpp
     VectorHandlerCpu.cpp
-    VectorHandlerCuda.cpp
 )
 
+# C++ code that depends on CUDA SDK libraries
+set(Vector_CUDASDK_SRC 
+    VectorHandlerCuda.cpp
+)
 
+# Header files to be installed
 set(Vector_HEADER_INSTALL
     Vector.hpp
     VectorHandler.hpp
     VectorKernels.hpp
 )
 
+# Add CUDA vector handler if CUDA support is enabled
+if(RESOLVE_USE_CUDA)
+  set(Vector_SRC ${Vector_SRC} ${Vector_CUDASDK_SRC})
+endif()
+
 add_library(resolve_vector SHARED ${Vector_SRC})
 
+# Link to ReSolve CUDA backend if CUDA is enabled
 if (RESOLVE_USE_CUDA)
-    target_link_libraries(resolve_vector PUBLIC resolve_backend_cuda)
-else()
-    target_link_libraries(resolve_vector PUBLIC resolve_backend_cpu)
+  target_link_libraries(resolve_vector PUBLIC resolve_backend_cuda)
 endif()
 
+# If no GPU is enabled link to dummy device backend
+if(NOT RESOLVE_USE_GPU)
+  target_link_libraries(resolve_vector PUBLIC resolve_backend_cpu)
+endif(NOT RESOLVE_USE_GPU)
+
+
 target_include_directories(resolve_vector INTERFACE
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
     $<INSTALL_INTERFACE:include>

diff --git a/resolve/vector/VectorHandler.cpp b/resolve/vector/VectorHandler.cpp
@@ -1,14 +1,17 @@
 #include <iostream>
+#include <cmath>
 
 #include <resolve/utilities/logger/Logger.hpp>
-#include <resolve/cuda/cudaKernels.h>
 #include <resolve/vector/Vector.hpp>
 #include <resolve/workspace/LinAlgWorkspace.hpp>
 #include <resolve/vector/VectorHandlerImpl.hpp>
 #include <resolve/vector/VectorHandlerCpu.hpp>
-#include <resolve/vector/VectorHandlerCuda.hpp>
 #include "VectorHandler.hpp"
 
+#ifdef RESOLVE_USE_CUDA
+#include <resolve/vector/VectorHandlerCuda.hpp>
+#endif
+
 namespace ReSolve {
   using out = io::Logger;
 
@@ -32,6 +35,7 @@ namespace ReSolve {
     isCpuEnabled_ = true;
   }
 
+#ifdef RESOLVE_USE_CUDA
   /** 
    * @brief constructor
    * 
@@ -45,6 +49,7 @@ namespace ReSolve {
     isCudaEnabled_ = true;
     isCpuEnabled_  = true;
   }
+#endif
 
   /** 
    * @brief destructor     

diff --git a/resolve/workspace/CMakeLists.txt b/resolve/workspace/CMakeLists.txt
@@ -6,11 +6,13 @@
 
 ]]
 
+# C++ code
 set(ReSolve_Workspace_SRC
   LinAlgWorkspaceCpu.cpp
 )
 
-set(ReSolve_Workspace_CUDA_SRC # consider adding a separate dir for cuda-sdk dependent code
+# C++ code that depends on CUDA SDK libraries
+set(ReSolve_Workspace_CUDASDK_SRC
     LinAlgWorkspaceCUDA.cpp
 )
 
@@ -20,12 +22,17 @@ set(ReSolve_Workspace_HEADER_INSTALL
   LinAlgWorkspaceCUDA.hpp
 )
 
+# If cuda is enabled, add CUDA SDK workspace files
+if(RESOLVE_USE_CUDA)
+  set(ReSolve_Workspace_SRC ${ReSolve_Workspace_SRC} ${ReSolve_Workspace_CUDASDK_SRC})
+endif()
+
+add_library(resolve_workspace SHARED ${ReSolve_Workspace_SRC})
+
+# If CUDA is enabled, link to ReSolve CUDA backend
 if(RESOLVE_USE_CUDA)
-  add_library(resolve_workspace SHARED ${ReSolve_Workspace_SRC} ${ReSolve_Workspace_CUDA_SRC})
   target_link_libraries(resolve_workspace PUBLIC resolve_backend_cuda)
-else(RESOLVE_USE_CUDA)  
-  add_library(resolve_workspace SHARED ${ReSolve_Workspace_SRC})
-endif(RESOLVE_USE_CUDA)
+endif(RESOLVE_USE_CUDA)  
 
 target_include_directories(resolve_workspace INTERFACE
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>