Merge pull request #49 from cpp-best-practices/cuda

Author: aminya

README.md

@@ -102,6 +102,7 @@ It gets the following named parameters that can have different values in front o
 - `MSVC_WARNINGS`: Override the defaults for the MSVC warnings
 - `CLANG_WARNINGS`: Override the defaults for the CLANG warnings
 - `GCC_WARNINGS`: Override the defaults for the GCC warnings
+- `CUDA_WARNINGS`: Override the defaults for the CUDA warnings
 - `CONAN_OPTIONS`: Extra Conan options
 
 ## `run_vcpkg` function
@@ -125,6 +126,17 @@ A very useful function that accepts the same arguments as `target_link_libraries
 
 Similar to `target_include_directories`, but it suppresses the warnings. It is useful if you want to include some external directories directly.
 
+## `target_link_cuda` function
+
+A function that links Cuda to the given target.
+
+```cmake
+add_executable(main_cuda main.cu)
+target_compile_features(main_cuda PRIVATE cxx_std_17)
+target_link_libraries(main_cuda PRIVATE project_options project_warnings)
+target_link_cuda(main_cuda)
+```
+
 ## Changing the project_options dynamically
 
 During the test and development, it can be useful to change options on the fly. For example, to enable sanitizers when running tests. You can include `DynamicOptions.cmake`, which imports the `dynamic_project_options` function.

src/CompilerWarnings.cmake

@@ -8,7 +8,8 @@ function(
   WARNINGS_AS_ERRORS
   MSVC_WARNINGS
   CLANG_WARNINGS
-  GCC_WARNINGS)
+  GCC_WARNINGS
+  CUDA_WARNINGS)
   if("${MSVC_WARNINGS}" STREQUAL "")
     set(MSVC_WARNINGS
         /W4 # Baseline reasonable warnings
@@ -69,6 +70,17 @@ function(
     )
   endif()
 
+  if("${CUDA_WARNINGS}" STREQUAL "")
+    set(CUDA_WARNINGS
+        -Wall
+        -Wextra
+        -Wunused
+        -Wconversion
+        -Wshadow
+        # TODO add more Cuda warnings
+    )
+  endif()
+
   if(WARNINGS_AS_ERRORS)
     message(TRACE "Warnings are treated as errors")
     list(APPEND CLANG_WARNINGS -Werror)
@@ -77,15 +89,27 @@ function(
   endif()
 
   if(MSVC)
-    set(PROJECT_WARNINGS ${MSVC_WARNINGS})
+    set(PROJECT_WARNINGS_CXX ${MSVC_WARNINGS})
   elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
-    set(PROJECT_WARNINGS ${CLANG_WARNINGS})
+    set(PROJECT_WARNINGS_CXX ${CLANG_WARNINGS})
   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    set(PROJECT_WARNINGS ${GCC_WARNINGS})
+    set(PROJECT_WARNINGS_CXX ${GCC_WARNINGS})
   else()
-    message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
+    message(AUTHOR_WARNING "No compiler warnings set for CXX compiler: '${CMAKE_CXX_COMPILER_ID}'")
+    # TODO support Intel compiler
   endif()
 
-  target_compile_options(${project_name} INTERFACE ${PROJECT_WARNINGS})
+  # use the same warning flags for C
+  set(PROJECT_WARNINGS_C "${PROJECT_WARNINGS_CXX}")
+
+  set(PROJECT_WARNINGS_CUDA "${CUDA_WARNINGS}")
 
+  target_compile_options(
+    ${project_name}
+    INTERFACE # C++ warnings
+              $<$<COMPILE_LANGUAGE:CXX>:${PROJECT_WARNINGS_CXX}>
+              # C warnings
+              $<$<COMPILE_LANGUAGE:C>:${PROJECT_WARNINGS_C}>
+              # Cuda warnings
+              $<$<COMPILE_LANGUAGE:CUDA>:${PROJECT_WARNINGS_CUDA}>)
 endfunction()

src/Cuda.cmake

@@ -0,0 +1,48 @@
+# ! target_link_cuda
+# A function that links Cuda to the given target
+#
+# # Example
+# add_executable(main_cuda main.cu)
+# target_compile_features(main_cuda PRIVATE cxx_std_17)
+# target_link_libraries(main_cuda PRIVATE project_options project_warnings)
+# target_link_cuda(main_cuda)
+#
+macro(target_link_cuda target)
+  # optional named CUDA_WARNINGS
+  set(oneValueArgs CUDA_WARNINGS)
+  cmake_parse_arguments(
+    _cuda_args
+    ""
+    "${oneValueArgs}"
+    ""
+    ${ARGN})
+
+  # add CUDA to cmake language
+  enable_language(CUDA)
+
+  # use the same C++ standard if not specified
+  if("${CMAKE_CUDA_STANDARD}" STREQUAL "")
+    set(CMAKE_CUDA_STANDARD "${CMAKE_CXX_STANDARD}")
+  endif()
+
+  # -fPIC
+  set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+  # We need to explicitly state that we need all CUDA files in the
+  # ${target} library to be built with -dc as the member functions
+  # could be called by other libraries and executables
+  set_target_properties(${target} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+  if(APPLE)
+    # We need to add the path to the driver (libcuda.dylib) as an rpath,
+    # so that the static cuda runtime can find it at runtime.
+    set_property(TARGET ${target} PROPERTY BUILD_RPATH ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES})
+  endif()
+
+  if(WIN32 AND "$ENV{VSCMD_VER}" STREQUAL "")
+    message(
+      WARNING
+        "Compiling Cuda on Windows outside the Visual Studio Commant prompt or without running `vcvarsall.bat x64` probably fails"
+    )
+  endif()
+endmacro()

src/Index.cmake

@@ -10,6 +10,8 @@ include("${ProjectOptions_SRC_DIR}/Vcpkg.cmake")
 
 include("${ProjectOptions_SRC_DIR}/SystemLink.cmake")
 
+include("${ProjectOptions_SRC_DIR}/Cuda.cmake")
+
 #
 # Params:
 # - WARNINGS_AS_ERRORS: Treat compiler warnings as errors
@@ -35,6 +37,7 @@ include("${ProjectOptions_SRC_DIR}/SystemLink.cmake")
 # - MSVC_WARNINGS: Override the defaults for the MSVC warnings
 # - CLANG_WARNINGS: Override the defaults for the CLANG warnings
 # - GCC_WARNINGS: Override the defaults for the GCC warnings
+# - CUDA_WARNINGS: Override the defaults for the CUDA warnings
 # - CONAN_OPTIONS: Extra Conan options
 #
 # NOTE: cmake-lint [C0103] Invalid macro name "project_options" doesn't match `[0-9A-Z_]+`
@@ -118,7 +121,8 @@ macro(project_options)
     "${WARNINGS_AS_ERRORS}"
     "${ProjectOptions_MSVC_WARNINGS}"
     "${ProjectOptions_CLANG_WARNINGS}"
-    "${ProjectOptions_GCC_WARNINGS}")
+    "${ProjectOptions_GCC_WARNINGS}"
+    "${ProjectOptions_CUDA_WARNINGS}")
 
   include("${ProjectOptions_SRC_DIR}/Tests.cmake")
   if(${ProjectOptions_ENABLE_COVERAGE})

src/StandardProjectSettings.cmake

@@ -19,9 +19,20 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # Enhance error reporting and compiler messages
 if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
-  add_compile_options(-fcolor-diagnostics)
+  if(WIN32)
+    # On Windows cuda nvcc uses cl and not clang
+    add_compile_options($<$<COMPILE_LANGUAGE:C>:-fcolor-diagnostics> $<$<COMPILE_LANGUAGE:CXX>:-fcolor-diagnostics>)
+  else()
+    add_compile_options(-fcolor-diagnostics)
+  endif()
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  add_compile_options(-fdiagnostics-color=always)
+  if(WIN32)
+    # On Windows cuda nvcc uses cl and not gcc
+    add_compile_options($<$<COMPILE_LANGUAGE:C>:-fdiagnostics-color=always>
+                        $<$<COMPILE_LANGUAGE:CXX>:-fdiagnostics-color=always>)
+  else()
+    add_compile_options(-fdiagnostics-color=always)
+  endif()
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND MSVC_VERSION GREATER 1900)
   add_compile_options(/diagnostics:column)
 else()