New CMake CUDA tools, better cross platform support

.github/workflows/ci.yml

@@ -79,7 +79,8 @@ jobs:
         id: configure
         shell: bash
         run: |
-          if [ "${{ runner.os }}" -eq "Windows" ]
+          rm -f ${{ env.build_dir }}/CMakeCache.txt
+          if [ "${{ runner.os }}" = "Windows" ]
           then
             cmake . -B "${{ env.build_dir }}" -G "${{ matrix.visual_studio }}" -A x64
           else

CMakeLists.txt

@@ -4,27 +4,17 @@
 
 # CMake
 
-cmake_minimum_required( VERSION 3.11 )
+cmake_minimum_required( VERSION 3.18 )
 set_property( GLOBAL PROPERTY USE_FOLDERS ON )
+cmake_policy(SET CMP0091 NEW)
 
 if( NOT PROJECT_NAME )
-  project( Gpufit VERSION 1.2.0 )
+  project( Gpufit VERSION 1.2.0 LANGUAGES CUDA CXX)
   include( CTest )
 endif()
 
 if( NOT CMAKE_CXX_STANDARD )
-	set( CMAKE_CXX_STANDARD 14 )
-endif()
-
-if( MSVC ) # link runtime statically with MSVC
-  foreach( type ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE} )
-    string( TOUPPER ${type} TYPE )
-    foreach( flags CMAKE_C_FLAGS_${TYPE} CMAKE_CXX_FLAGS_${TYPE} )
-      get_property( help CACHE ${flags} PROPERTY HELPSTRING )
-      string( REPLACE "/MD" "/MT" ${flags} "${${flags}}" )
-      set( ${flags} "${${flags}}" CACHE STRING "${help}" FORCE )
-    endforeach()
-  endforeach()
+	set( CMAKE_CXX_STANDARD 11 )
 endif()
 
 function( add_launcher target executable arguments working_directory )
@@ -103,14 +93,14 @@ endif()
 
 # Python
 
-find_package( PythonInterp )
-if( PYTHONINTERP_FOUND )
+find_package( Python )
+if( Python_FOUND )
   function( add_python_launcher target )
     set( paths "${CMAKE_BINARY_DIR}/$(Configuration)" ${ARGN} )
     list( GET paths -1 working_directory )
     string( REPLACE ";" "')\nsys.path.append('" paths "${paths}" )
     set( arguments "-i -c \"import sys\nsys.path.append('${paths}')\"" )
-    add_launcher( ${target} "${PYTHON_EXECUTABLE}" "${arguments}" "${working_directory}" )
+    add_launcher( ${target} "${Python_EXECUTABLE}" "${arguments}" "${working_directory}" )
   endfunction()
 endif()
 
@@ -144,6 +134,14 @@ add_subdirectory( Gpufit )
 
 add_subdirectory( examples/c++/gpu_vs_cpu_profiling )
 
+
+# link runtime statically with MSVC
+set_property(TARGET Gpufit PROPERTY
+  MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+set_property(TARGET Cpufit PROPERTY
+  MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+
+
 # Launcher
 #
 # Uses the following variables:
@@ -173,7 +171,7 @@ if( Matlab_FOUND )
   endif()
 endif()
 
-if( PYTHONINTERP_FOUND )
+if( Python_FOUND )
   set( Python_WORKING_DIRECTORY "${home}" CACHE PATH "Python working directory" )
   if( Python_WORKING_DIRECTORY )
     add_custom_target( RUN_PYTHON )
@@ -184,6 +182,13 @@ if( PYTHONINTERP_FOUND )
       "${Python_WORKING_DIRECTORY}"
     )
   endif()
+  if( UNIX )
+    # Copy over install file for python integration
+    file(COPY "${CMAKE_SOURCE_DIR}/package/install_gpufit_python.sh" 
+      DESTINATION "${CMAKE_BINARY_DIR}" 
+      FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
+    ) 
+  endif()
 endif()
 
 # Tests

Gpufit/CMakeLists.txt

@@ -1,135 +1,61 @@
 
 # CUDA
 #
-# Uses the following variables:
-#
-#   CUDA_ARCHITECTURES (Default All)
-#   -- Argument passed to CUDA_SELECT_NVCC_ARCH_FLAGS(...)
-#      resulting in code_generation_flags
-#      (see http://cmake.org/cmake/help/v3.7/module/FindCUDA.html).
-#      CUDA_ARCHITECTURES: Auto | Common | All | ARCH_AND_PTX ...
-#      Auto: Detects local machine GPU architecture.
-#      Common: Covers common subset of architectures.
-#      All: Covers all known architectures.
-#      ARCH_AND_PTX: NAME | NUM.NUM | NUM.NUM(NUM.NUM) | NUM.NUM+PTX
-#      NAME: Fermi Kepler Maxwell Kepler+Tegra Kepler+Tesla Maxwell+Tegra Pascal
-#      NUM: Any number.
-#      Only those pairs are currently accepted by NVCC though:
-#        2.0 2.1 3.0 3.2 3.5 3.7 5.0 5.2 5.3 6.0 6.2
-#      Examples:
-#        2.1(2.0) results in
-#          -gencode;arch=compute_20,code=sm_21
-#        Kepler+Tesla results in
-#          -gencode;arch=compute_37,code=sm_37
-#        6.2+PTX results in
-#          -gencode;arch=compute_62,code=sm_62;-gencode;arch=compute_62,code=compute_62
-#
-#   CUDA_NVCC_FLAGS (Default ${code_generation_flags})
-#   -- Additional NVCC command line arguments
-#      (see http://cmake.org/cmake/help/v3.7/module/FindCUDA.html).
-#      NOTE that multiple arguments must be semi-colon delimited
-#      (e.g. --compiler-options;-Wall)
-#
-#   Multiple CUDA versions installed, specify which version to use
-#      Set CUDA_BIN_PATH before running CMake or CUDA_TOOLKIT_ROOT_DIR after first configuration
-#      to installation folder of desired CUDA version
-
-find_package( CUDA 6.5 REQUIRED )
-
-set( CUDA_ARCHITECTURES ${DEFAULT_CUDA_ARCH} CACHE STRING
-  "Auto | Common | All | ... see CUDA_SELECT_NVCC_ARCH_FLAGS(...)" )
-
-if( CUDA_ARCHITECTURES STREQUAL Auto )
-
-  set( file ${PROJECT_BINARY_DIR}/detect_cuda_architectures.cpp )
-  file( WRITE ${file} ""
-    "#include <cuda_runtime.h>\n"
-    "#include <cstdio>\n"
-    "int main()\n"
-    "{\n"
-    "  int count = 0;\n"
-    "  if (cudaSuccess != cudaGetDeviceCount(&count)) return -1;\n"
-    "  if (count == 0) return -1;\n"
-    "  for (int device = 0; device < count; ++device)\n"
-    "  {\n"
-    "    cudaDeviceProp prop;\n"
-    "    if (cudaSuccess == cudaGetDeviceProperties(&prop, device))\n"
-    "      std::printf(\"%d.%d \", prop.major, prop.minor);\n"
-    "  }\n"
-    "  return 0;\n"
-    "}\n"
-  )
-  try_run( run_result compile_result ${PROJECT_BINARY_DIR} ${file}
-    CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${CUDA_INCLUDE_DIRS}"
-    LINK_LIBRARIES ${CUDA_LIBRARIES}
-    RUN_OUTPUT_VARIABLE architectures
-  )
-  if( run_result EQUAL 0 )
-    string( REPLACE "2.1" "2.1(2.0)" architectures "${architectures}" )
-    if( CUDA_VERSION VERSION_LESS "7.0" )
-      string( REGEX REPLACE "3\\.[27]|5\\.[23]|6\\.[01]" "5.2+PTX" architectures "${architectures}" )
-    elseif( CUDA_VERSION VERSION_LESS "8.0" )
-      string( REGEX REPLACE "5\\.3|6\\.[01]" "5.3+PTX" architectures "${architectures}" )
-    endif()
-    set( CUDA_ARCHITECTURES "${architectures}" )
-  endif()
-
-elseif( CUDA_ARCHITECTURES STREQUAL All )
+# Uses the CMAKE standard CUDA tools
+
+cmake_minimum_required(VERSION 3.18)
+
+if(NOT DEFINED CMAKE_CUDA_STANDARD)
+    set(CMAKE_CUDA_STANDARD 11)
+    set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+endif()
+
+
+message( STATUS "CMAKE_CUDA_COMPILER_VERSION=${CMAKE_CUDA_COMPILER_VERSION}")
+
 
 # All does not include the latest PTX!
-  set( CUDA_ARCHITECTURES "" )
+  set( CMAKE_CUDA_ARCHITECTURES_D "" )
 
-  if( CUDA_VERSION VERSION_LESS "12.0" )
-    list( INSERT CUDA_ARCHITECTURES 0 "3.5" "5.0" "5.2" )
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_LESS "12.0" )
+    list( INSERT CMAKE_CUDA_ARCHITECTURES_D 0 35 50 52 )
   endif()
-  if( CUDA_VERSION VERSION_LESS "11.0" )
-    list( INSERT CUDA_ARCHITECTURES 0 "3.0" "3.2")
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_LESS "11.0" )
+    list( INSERT CMAKE_CUDA_ARCHITECTURES_D 0 30 32)
   endif()
-  if( CUDA_VERSION VERSION_LESS "9.0" )
-    list( INSERT CUDA_ARCHITECTURES 0 "2.0" "2.1(2.0)" )
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_LESS "9.0" )
+    list( INSERT CMAKE_CUDA_ARCHITECTURES_D 0 20 21 )
   endif()
-
-  if( CUDA_VERSION VERSION_GREATER "6.5" )
-      list( APPEND CUDA_ARCHITECTURES "5.3" )
+
+
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER "6.5" )
+      list( APPEND CMAKE_CUDA_ARCHITECTURES_D 53 )
   endif()
 
-  if( CUDA_VERSION VERSION_GREATER "7.5" )
-    list( APPEND CUDA_ARCHITECTURES "6.0" "6.1" )
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER "7.5" )
+    list( APPEND CMAKE_CUDA_ARCHITECTURES_D 60 61 )
   endif()
 
-  if( CUDA_VERSION VERSION_GREATER "8.0" )
-    list( APPEND CUDA_ARCHITECTURES "7.0" "7.2")
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER "8.0" )
+    list( APPEND CMAKE_CUDA_ARCHITECTURES_D 70 72)
   endif()
 
-  if( CUDA_VERSION VERSION_GREATER "9.2" )
-    list( APPEND CUDA_ARCHITECTURES "7.5" )
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER "9.2" )
+    list( APPEND CMAKE_CUDA_ARCHITECTURES_D 75 )
   endif()
 
-  if( CUDA_VERSION VERSION_GREATER "10.2" )
-    list( APPEND CUDA_ARCHITECTURES "8.0" )
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER "10.2" )
+    list( APPEND CMAKE_CUDA_ARCHITECTURES_D 80 )
   endif()
 
-  if( CUDA_VERSION VERSION_GREATER "11.0" )
-    list( APPEND CUDA_ARCHITECTURES "8.6" )
+  if( CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER "11.0" )
+    list( APPEND CMAKE_CUDA_ARCHITECTURES_D 86 )
   endif()
-
-  string( APPEND CUDA_ARCHITECTURES "+PTX" )
-
-endif()
-
-message( STATUS "CUDA_ARCHITECTURES=${CUDA_ARCHITECTURES}" )
+#  string( APPEND CMAKE_CUDA_ARCHITECTURES "+PTX" ) 
+  set( CMAKE_CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES_D}" CACHE STRING "List of architectures to compile, default is all")
 
-CUDA_SELECT_NVCC_ARCH_FLAGS( code_generation_flags "${CUDA_ARCHITECTURES}" )
-list( APPEND CUDA_NVCC_FLAGS ${code_generation_flags} )
-
-message( STATUS "CUDA_NVCC_FLAGS=${code_generation_flags}" )
-
-if( NOT WIN32 )
-	list( APPEND CUDA_NVCC_FLAGS --std=c++11)
-endif()
 
 # Gpufit
-
 set( GpuHeaders
 	gpufit.h
 	constants.h
@@ -177,7 +103,7 @@ source_group("CUDA Source Files" FILES ${GpuCudaSources})
 source_group("CUDA Model Files" FILES ${GpuCudaModels})
 source_group("CUDA Estimator Files" FILES ${GpuCudaEstimators})
 
-cuda_add_library( Gpufit SHARED
+add_library( Gpufit SHARED
 	${GpuHeaders}
 	${GpuSources}
 	${GpuCudaHeaders}
@@ -192,38 +118,21 @@ set_target_properties( Gpufit
 		CXX_VISIBILITY_PRESET hidden
 )
 
-# USE_CUBLAS
-if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND CUDA_VERSION VERSION_GREATER "6.5")
+target_include_directories( Gpufit SYSTEM PUBLIC ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
+
+# USE_CUBLAS    
+if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER "6.5")
 	set( USE_CUBLAS ${DEFAULT_USE_CUBLAS} CACHE BOOL "ON | OFF")
 	if( USE_CUBLAS )
-        if ( WIN32 )
-	    if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND CUDA_VERSION VERSION_GREATER_EQUAL "10")
-                set( CUBLAS_DLL "${CUDA_TOOLKIT_ROOT_DIR}/bin/cublas64_${CUDA_VERSION_MAJOR}.dll" )
-	    else()
-		set( CUBLAS_DLL "${CUDA_TOOLKIT_ROOT_DIR}/bin/cublas64_${CUDA_VERSION_MAJOR}${CUDA_VERSION_MINOR}.dll" )
-	    endif()
-            add_custom_command( TARGET Gpufit POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E
-                    copy_if_different ${CUBLAS_DLL} $<TARGET_FILE_DIR:Gpufit> )
-        else()
-            find_cuda_helper_libs(cublas_static)
-            find_cuda_helper_libs(cublasLt_static)
-            find_cuda_helper_libs(culibos)
-
-            set( CUDA_CUBLAS_LIBRARIES 
-                ${CUDA_cublas_static_LIBRARY}
-                ${CUDA_cublasLt_static_LIBRARY}
-                ${CUDA_cudart_static_LIBRARY}
-                ${CUDA_culibos_LIBRARY}
-                dl
-                pthread
-                rt )
-        endif()
-
-		add_definitions( -DUSE_CUBLAS )
-
-        target_link_libraries( Gpufit ${CUDA_CUBLAS_LIBRARIES} )
-	endif()
+            find_package(CUDAToolkit REQUIRED)
+            set( STATIC_CUBLAS ON CACHE BOOL "ON | OFF")
+            if ( STATIC_CUBLAS )
+                target_link_libraries( Gpufit CUDA::cublas_static CUDA::cublasLt_static)
+            else ()
+                target_link_libraries( Gpufit CUDA::cublas CUDA::cublasLt)
+            endif ()
+            add_definitions( -DUSE_CUBLAS )
+        endif() 
 elseif( CMAKE_SIZEOF_VOID_P EQUAL 4 )
 	message( STATUS "CUBLAS: 32-bit architecture detected; USE_CUBLAS flag ignored." )
 elseif( CUDA_VERSION VERSION_LESS "7.0" )

Gpufit/python/CMakeLists.txt

@@ -40,7 +40,7 @@ add_custom_target( PYTHON_PACKAGE
 set_property( TARGET PYTHON_PACKAGE PROPERTY FOLDER CMakePredefinedTargets )
 add_dependencies( PYTHON_PACKAGE Gpufit )
 
-if( NOT PYTHONINTERP_FOUND )
+if( NOT Python_FOUND )
   message( STATUS "Python NOT found - skipping creation of Python wheel!" )
   return()
 endif()
@@ -49,9 +49,9 @@ endif()
 
 add_custom_target( PYTHON_WHEEL ALL
   COMMAND ${CMAKE_COMMAND} -E
-    chdir ${build_directory} "${PYTHON_EXECUTABLE}" setup.py clean --all
+    chdir ${build_directory} "${Python_EXECUTABLE}" setup.py clean --all
   COMMAND ${CMAKE_COMMAND} -E
-    chdir ${build_directory} "${PYTHON_EXECUTABLE}" setup.py bdist_wheel
+    chdir ${build_directory} "${Python_EXECUTABLE}" setup.py bdist_wheel
   COMMENT "Preparing Python Wheel"
 )
 set_property( TARGET PYTHON_WHEEL PROPERTY FOLDER CMakePredefinedTargets )

Gpufit/tests/CMakeLists.txt

@@ -10,3 +10,11 @@ add_boost_test( Gpufit Gauss_Fit_2D_Rotated )
 add_boost_test( Gpufit Cauchy_Fit_2D_Elliptic )
 add_boost_test( Gpufit Fletcher_Powell_Helix_Fit )
 add_boost_test( Gpufit Brown_Dennis_Fit )
+
+if( UNIX )
+  # Copy over run tests script
+  file(COPY "${CMAKE_SOURCE_DIR}/Gpufit/tests/test_all.sh" 
+    DESTINATION "${CMAKE_BINARY_DIR}" 
+    FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
+  ) 
+endif()

Gpufit/tests/test_all.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+printf "Gauss 2D Rotated\n"
+./Gpufit_Test_Gauss_Fit_2D_Rotated
+
+printf "\nGauss 2D Elliptic\n"
+./Gpufit_Test_Gauss_Fit_2D_Elliptic
+
+printf "\nGauss 2D\n"
+./Gpufit_Test_Gauss_Fit_2D
+
+printf "\nGauss 1D\n"
+./Gpufit_Test_Gauss_Fit_1D
+
+printf "\nLinear 1D\n"
+./Gpufit_Test_Linear_Fit_1D
+
+printf "\nFletcher Powell Helix\n"
+./Gpufit_Test_Fletcher_Powell_Helix_Fit
+
+printf "\nError Handling\n"
+./Gpufit_Test_Error_Handling
+
+printf "\nCauchy Fit 2D Elliptic\n"
+./Gpufit_Test_Cauchy_Fit_2D_Elliptic
+
+printf "\nBrown Dennis\n"
+./Gpufit_Test_Brown_Dennis_Fit
+
+printf "\nTest Consistency\n"
+./Cpufit_Gpufit_Test_Consistency
+
+
+