Refactor CMakeLists.txt under 4_CUDA_Libraries

2025-04-10 18:22:11 +01:00 · 2024-12-16 14:38:36 -08:00 · 2024-12-16 14:38:36 -08:00 · 00999c1789
commit 00999c1789
parent 090f957854
33 changed files with 627 additions and 178 deletions
--- a/Samples/4_CUDA_Libraries/FilterBorderControlNPP/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/FilterBorderControlNPP/CMakeLists.txt
@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(FilterBorderControlNPP LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(
    ../../../Common
@ -5,16 +18,16 @@ include_directories(
 )

 # Source file
-set(SRC_FILES
-    FilterBorderControlNPP.cpp
-)
-
-
 find_package(FreeImage)

 if(${FreeImage_FOUND})
    # Add target for FilterBorderControlNPP
-    add_executable(FilterBorderControlNPP ${SRC_FILES})
+    add_executable(FilterBorderControlNPP FilterBorderControlNPP.cpp)
+
+target_compile_options(FilterBorderControlNPP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(FilterBorderControlNPP PRIVATE cxx_std_17 cuda_std_17)
+
    set_target_properties(FilterBorderControlNPP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

    target_include_directories(FilterBorderControlNPP PRIVATE
--- a/Samples/4_CUDA_Libraries/MersenneTwisterGP11213/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/MersenneTwisterGP11213/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(MersenneTwisterGP11213 LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    MersenneTwister.cpp
-)
-
 # Add target for MersenneTwisterGP11213
-add_executable(MersenneTwisterGP11213 ${SRC_FILES})
+add_executable(MersenneTwisterGP11213 MersenneTwister.cpp)
+
+target_compile_options(MersenneTwisterGP11213 PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(MersenneTwisterGP11213 PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(MersenneTwisterGP11213 PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(MersenneTwisterGP11213 PRIVATE
--- a/Samples/4_CUDA_Libraries/batchCUBLAS/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/batchCUBLAS/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(batchCUBLAS LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    batchCUBLAS.cpp
-)
-
 # Add target for batchCUBLAS
-add_executable(batchCUBLAS ${SRC_FILES})
+add_executable(batchCUBLAS batchCUBLAS.cpp)
+
+target_compile_options(batchCUBLAS PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(batchCUBLAS PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(batchCUBLAS PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(batchCUBLAS PRIVATE
--- a/Samples/4_CUDA_Libraries/boxFilterNPP/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/boxFilterNPP/CMakeLists.txt
@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(boxFilterNPP LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(
    ../../../Common
@ -5,15 +18,16 @@ include_directories(
 )

 # Source file
-set(SRC_FILES
-    boxFilterNPP.cpp
-)
-
 find_package(FreeImage)

 if(${FreeImage_FOUND})
    # Add target for boxFilterNPP
-    add_executable(boxFilterNPP ${SRC_FILES})
+    add_executable(boxFilterNPP boxFilterNPP.cpp)
+
+target_compile_options(boxFilterNPP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(boxFilterNPP PRIVATE cxx_std_17 cuda_std_17)
+
    set_target_properties(boxFilterNPP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

    target_include_directories(boxFilterNPP PRIVATE
--- a/Samples/4_CUDA_Libraries/cannyEdgeDetectorNPP/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/cannyEdgeDetectorNPP/CMakeLists.txt
@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cannyEdgeDetectorNPP LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(
    ../../../Common
@ -5,15 +18,16 @@ include_directories(
 )

 # Source file
-set(SRC_FILES
-    cannyEdgeDetectorNPP.cpp
-)
-
 find_package(FreeImage)

 if(${FreeImage_FOUND})
    # Add target for cannyEdgeDetectorNPP
-    add_executable(cannyEdgeDetectorNPP ${SRC_FILES})
+    add_executable(cannyEdgeDetectorNPP cannyEdgeDetectorNPP.cpp)
+
+target_compile_options(cannyEdgeDetectorNPP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cannyEdgeDetectorNPP PRIVATE cxx_std_17 cuda_std_17)
+
    set_target_properties(cannyEdgeDetectorNPP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

    target_include_directories(cannyEdgeDetectorNPP PRIVATE
--- a/Samples/4_CUDA_Libraries/conjugateGradient/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/conjugateGradient/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(conjugateGradient LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    main.cpp
-)
-
 # Add target for conjugateGradient
-add_executable(conjugateGradient ${SRC_FILES})
+add_executable(conjugateGradient main.cpp)
+
+target_compile_options(conjugateGradient PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(conjugateGradient PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(conjugateGradient PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(conjugateGradient PRIVATE
--- a/Samples/4_CUDA_Libraries/conjugateGradientCudaGraphs/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/conjugateGradientCudaGraphs/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(conjugateGradientCudaGraphs LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    conjugateGradientCudaGraphs.cu
-)
-
 # Add target for conjugateGradientCudaGraphs
-add_executable(conjugateGradientCudaGraphs ${SRC_FILES})
+add_executable(conjugateGradientCudaGraphs conjugateGradientCudaGraphs.cu)
+
+target_compile_options(conjugateGradientCudaGraphs PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(conjugateGradientCudaGraphs PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(conjugateGradientCudaGraphs PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_link_libraries(conjugateGradientCudaGraphs PRIVATE
--- a/Samples/4_CUDA_Libraries/conjugateGradientMultiBlockCG/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/conjugateGradientMultiBlockCG/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(conjugateGradientMultiBlockCG LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    conjugateGradientMultiBlockCG.cu
-)
-
 # Add target for conjugateGradientMultiBlockCG
-add_executable(conjugateGradientMultiBlockCG ${SRC_FILES})
+add_executable(conjugateGradientMultiBlockCG conjugateGradientMultiBlockCG.cu)
+
+target_compile_options(conjugateGradientMultiBlockCG PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(conjugateGradientMultiBlockCG PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(conjugateGradientMultiBlockCG PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_link_libraries(conjugateGradientMultiBlockCG PRIVATE
--- a/Samples/4_CUDA_Libraries/conjugateGradientMultiDeviceCG/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/conjugateGradientMultiDeviceCG/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(conjugateGradientMultiDeviceCG LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    conjugateGradientMultiDeviceCG.cu
-)
-
 # Add target for conjugateGradientMultiDeviceCG
-add_executable(conjugateGradientMultiDeviceCG ${SRC_FILES})
+add_executable(conjugateGradientMultiDeviceCG conjugateGradientMultiDeviceCG.cu)
+
+target_compile_options(conjugateGradientMultiDeviceCG PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(conjugateGradientMultiDeviceCG PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(conjugateGradientMultiDeviceCG PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_link_libraries(conjugateGradientMultiDeviceCG PRIVATE
--- a/Samples/4_CUDA_Libraries/conjugateGradientPrecond/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/conjugateGradientPrecond/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(conjugateGradientPrecond LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    main.cpp
-)
-
 # Add target for conjugateGradientPrecond
-add_executable(conjugateGradientPrecond ${SRC_FILES})
+add_executable(conjugateGradientPrecond main.cpp)
+
+target_compile_options(conjugateGradientPrecond PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(conjugateGradientPrecond PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(conjugateGradientPrecond PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(conjugateGradientPrecond PRIVATE
--- a/Samples/4_CUDA_Libraries/conjugateGradientUM/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/conjugateGradientUM/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(conjugateGradientUM LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    main.cpp
-)
-
 # Add target for conjugateGradientUM
-add_executable(conjugateGradientUM ${SRC_FILES})
+add_executable(conjugateGradientUM main.cpp)
+
+target_compile_options(conjugateGradientUM PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(conjugateGradientUM PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(conjugateGradientUM PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(conjugateGradientUM PRIVATE
--- a/Samples/4_CUDA_Libraries/cuSolverDn_LinearSolver/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/cuSolverDn_LinearSolver/CMakeLists.txt
@ -1,15 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cuSolverDn_LinearSolver LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    cuSolverDn_LinearSolver.cpp
-    mmio.c
-    mmio_wrapper.cpp
-)
-
 # Add target for cuSolverDn_LinearSolver
-add_executable(cuSolverDn_LinearSolver ${SRC_FILES})
+add_executable(cuSolverDn_LinearSolver cuSolverDn_LinearSolver.cpp mmio.c mmio_wrapper.cpp)
+
+target_compile_options(cuSolverDn_LinearSolver PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cuSolverDn_LinearSolver PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cuSolverDn_LinearSolver PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(cuSolverDn_LinearSolver PRIVATE
--- a/Samples/4_CUDA_Libraries/cuSolverRf/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/cuSolverRf/CMakeLists.txt
@ -1,15 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cuSolverRf LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    cuSolverRf.cpp
-    mmio.c
-    mmio_wrapper.cpp
-)
-
 # Add target for cuSolverRf
-add_executable(cuSolverRf ${SRC_FILES})
+add_executable(cuSolverRf cuSolverRf.cpp mmio.c mmio_wrapper.cpp)
+
+target_compile_options(cuSolverRf PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cuSolverRf PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cuSolverRf PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(cuSolverRf PRIVATE
--- a/Samples/4_CUDA_Libraries/cuSolverSp_LinearSolver/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/cuSolverSp_LinearSolver/CMakeLists.txt
@ -1,15 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cuSolverSp_LinearSolver LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    cuSolverSp_LinearSolver.cpp
-    mmio.c
-    mmio_wrapper.cpp
-)
-
 # Add target for cuSolverSp_LinearSolver
-add_executable(cuSolverSp_LinearSolver ${SRC_FILES})
+add_executable(cuSolverSp_LinearSolver cuSolverSp_LinearSolver.cpp mmio.c mmio_wrapper.cpp)
+
+target_compile_options(cuSolverSp_LinearSolver PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cuSolverSp_LinearSolver PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cuSolverSp_LinearSolver PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(cuSolverSp_LinearSolver PRIVATE
--- a/Samples/4_CUDA_Libraries/cuSolverSp_LowlevelCholesky/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/cuSolverSp_LowlevelCholesky/CMakeLists.txt
@ -1,15 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cuSolverSp_LowlevelCholesky LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    cuSolverSp_LowlevelCholesky.cpp
-    mmio.c
-    mmio_wrapper.cpp
-)
-
 # Add target for cuSolverSp_LowlevelCholesky
-add_executable(cuSolverSp_LowlevelCholesky ${SRC_FILES})
+add_executable(cuSolverSp_LowlevelCholesky cuSolverSp_LowlevelCholesky.cpp mmio.c mmio_wrapper.cpp)
+
+target_compile_options(cuSolverSp_LowlevelCholesky PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cuSolverSp_LowlevelCholesky PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cuSolverSp_LowlevelCholesky PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(cuSolverSp_LowlevelCholesky PRIVATE
--- a/Samples/4_CUDA_Libraries/cuSolverSp_LowlevelQR/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/cuSolverSp_LowlevelQR/CMakeLists.txt
@ -1,15 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cuSolverSp_LowlevelQR LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    cuSolverSp_LowlevelQR.cpp
-    mmio.c
-    mmio_wrapper.cpp
-)
-
 # Add target for cuSolverSp_LowlevelQR
-add_executable(cuSolverSp_LowlevelQR ${SRC_FILES})
+add_executable(cuSolverSp_LowlevelQR cuSolverSp_LowlevelQR.cpp mmio.c mmio_wrapper.cpp)
+
+target_compile_options(cuSolverSp_LowlevelQR PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cuSolverSp_LowlevelQR PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cuSolverSp_LowlevelQR PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(cuSolverSp_LowlevelQR PRIVATE
--- a/Samples/4_CUDA_Libraries/freeImageInteropNPP/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/freeImageInteropNPP/CMakeLists.txt
@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(freeImageInteropNPP LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(
    ../../../Common
@ -5,15 +18,16 @@ include_directories(
 )

 # Source file
-set(SRC_FILES
-    freeImageInteropNPP.cpp
-)
-
 find_package(FreeImage)

 if(${FreeImage_FOUND})
    # Add target for freeImageInteropNPP
-    add_executable(freeImageInteropNPP ${SRC_FILES})
+    add_executable(freeImageInteropNPP freeImageInteropNPP.cpp)
+
+target_compile_options(freeImageInteropNPP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(freeImageInteropNPP PRIVATE cxx_std_17 cuda_std_17)
+
    set_target_properties(freeImageInteropNPP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

    target_include_directories(freeImageInteropNPP PRIVATE
--- a/Samples/4_CUDA_Libraries/histEqualizationNPP/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/histEqualizationNPP/CMakeLists.txt
@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(histEqualizationNPP LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(
    ../../../Common
@ -5,15 +18,16 @@ include_directories(
 )

 # Source file
-set(SRC_FILES
-    histEqualizationNPP.cpp
-)
-
 find_package(FreeImage)

 if(${FreeImage_FOUND})
    # Add target for histEqualizationNPP
-    add_executable(histEqualizationNPP ${SRC_FILES})
+    add_executable(histEqualizationNPP histEqualizationNPP.cpp)
+
+target_compile_options(histEqualizationNPP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(histEqualizationNPP PRIVATE cxx_std_17 cuda_std_17)
+
    set_target_properties(histEqualizationNPP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

    target_include_directories(histEqualizationNPP PRIVATE
--- a/Samples/4_CUDA_Libraries/jitLto/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/jitLto/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(jitLto LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    jitLto.cpp
-)
-
 # Add target for jitLto
-add_executable(jitLto ${SRC_FILES})
+add_executable(jitLto jitLto.cpp)
+
+target_compile_options(jitLto PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(jitLto PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(jitLto PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(jitLto PRIVATE
--- a/Samples/4_CUDA_Libraries/lineOfSight/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/lineOfSight/CMakeLists.txt
@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(lineOfSight LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    lineOfSight.cu
-)
-
 # Add target for lineOfSight
-add_executable(lineOfSight ${SRC_FILES})
+add_executable(lineOfSight lineOfSight.cu)
+
+target_compile_options(lineOfSight PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(lineOfSight PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(lineOfSight PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
--- a/Samples/4_CUDA_Libraries/matrixMulCUBLAS/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/matrixMulCUBLAS/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(matrixMulCUBLAS LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    matrixMulCUBLAS.cpp
-)
-
 # Add target for matrixMulCUBLAS
-add_executable(matrixMulCUBLAS ${SRC_FILES})
+add_executable(matrixMulCUBLAS matrixMulCUBLAS.cpp)
+
+target_compile_options(matrixMulCUBLAS PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(matrixMulCUBLAS PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(matrixMulCUBLAS PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(matrixMulCUBLAS PRIVATE
--- a/Samples/4_CUDA_Libraries/nvJPEG/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/nvJPEG/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(nvJPEG LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    nvJPEG.cpp
-)
-
 # Add target for nvJPEG
-add_executable(nvJPEG ${SRC_FILES})
+add_executable(nvJPEG nvJPEG.cpp)
+
+target_compile_options(nvJPEG PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(nvJPEG PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(nvJPEG PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(nvJPEG PRIVATE
--- a/Samples/4_CUDA_Libraries/nvJPEG_encoder/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/nvJPEG_encoder/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(nvJPEG_encoder LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    nvJPEG_encoder.cpp
-)
-
 # Add target for nvJPEG_encoder
-add_executable(nvJPEG_encoder ${SRC_FILES})
+add_executable(nvJPEG_encoder nvJPEG_encoder.cpp)
+
+target_compile_options(nvJPEG_encoder PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(nvJPEG_encoder PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(nvJPEG_encoder PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(nvJPEG_encoder PRIVATE
--- a/Samples/4_CUDA_Libraries/oceanFFT/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/oceanFFT/CMakeLists.txt
@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(oceanFFT LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

@ -5,15 +18,15 @@ find_package(OpenGL)
 find_package(GLUT)

 # Source file
-set(SRC_FILES
-    oceanFFT.cpp
-    oceanFFT_kernel.cu
-)
-
 if(${OpenGL_FOUND})
    if (${GLUT_FOUND})
        # Add target for oceanFFT
-        add_executable(oceanFFT ${SRC_FILES})
+        add_executable(oceanFFT oceanFFT.cpp oceanFFT_kernel.cu)
+
+target_compile_options(oceanFFT PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(oceanFFT PRIVATE cxx_std_17 cuda_std_17)
+
        set_target_properties(oceanFFT PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

        target_include_directories(oceanFFT PUBLIC
--- a/Samples/4_CUDA_Libraries/randomFog/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/randomFog/CMakeLists.txt
@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(randomFog LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

@ -5,15 +18,15 @@ find_package(OpenGL)
 find_package(GLUT)

 # Source file
-set(SRC_FILES
-    randomFog.cpp
-    rng.cpp
-)
-
 if(${OpenGL_FOUND})
    if (${GLUT_FOUND})
        # Add target for randomFog
-        add_executable(randomFog ${SRC_FILES})
+        add_executable(randomFog randomFog.cpp rng.cpp)
+
+target_compile_options(randomFog PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(randomFog PRIVATE cxx_std_17 cuda_std_17)
+
        set_target_properties(randomFog PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

        target_include_directories(randomFog PUBLIC
--- a/Samples/4_CUDA_Libraries/simpleCUBLAS/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/simpleCUBLAS/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCUBLAS LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    simpleCUBLAS.cpp
-)
-
 # Add target for simpleCUBLAS
-add_executable(simpleCUBLAS ${SRC_FILES})
+add_executable(simpleCUBLAS simpleCUBLAS.cpp)
+
+target_compile_options(simpleCUBLAS PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUBLAS PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCUBLAS PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(simpleCUBLAS PRIVATE
--- a/Samples/4_CUDA_Libraries/simpleCUBLASXT/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/simpleCUBLASXT/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCUBLASXT LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    simpleCUBLASXT.cpp
-)
-
 # Add target for simpleCUBLASXT
-add_executable(simpleCUBLASXT ${SRC_FILES})
+add_executable(simpleCUBLASXT simpleCUBLASXT.cpp)
+
+target_compile_options(simpleCUBLASXT PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUBLASXT PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCUBLASXT PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(simpleCUBLASXT PRIVATE
--- a/Samples/4_CUDA_Libraries/simpleCUBLAS_LU/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/simpleCUBLAS_LU/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCUBLAS_LU LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    simpleCUBLAS_LU.cpp
-)
-
 # Add target for simpleCUBLAS_LU
-add_executable(simpleCUBLAS_LU ${SRC_FILES})
+add_executable(simpleCUBLAS_LU simpleCUBLAS_LU.cpp)
+
+target_compile_options(simpleCUBLAS_LU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUBLAS_LU PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCUBLAS_LU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(simpleCUBLAS_LU PRIVATE
--- a/Samples/4_CUDA_Libraries/simpleCUFFT/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/simpleCUFFT/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCUFFT LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    simpleCUFFT.cu
-)
-
 # Add target for simpleCUFFT
-add_executable(simpleCUFFT ${SRC_FILES})
+add_executable(simpleCUFFT simpleCUFFT.cu)
+
+target_compile_options(simpleCUFFT PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUFFT PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCUFFT PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_link_libraries(simpleCUFFT PRIVATE
--- a/Samples/4_CUDA_Libraries/simpleCUFFT_2d_MGPU/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/simpleCUFFT_2d_MGPU/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCUFFT_2d_MGPU LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    simpleCUFFT_2d_MGPU.cu
-)
-
 # Add target for simpleCUFFT_2d_MGPU
-add_executable(simpleCUFFT_2d_MGPU ${SRC_FILES})
+add_executable(simpleCUFFT_2d_MGPU simpleCUFFT_2d_MGPU.cu)
+
+target_compile_options(simpleCUFFT_2d_MGPU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUFFT_2d_MGPU PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCUFFT_2d_MGPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_link_libraries(simpleCUFFT_2d_MGPU PRIVATE
--- a/Samples/4_CUDA_Libraries/simpleCUFFT_MGPU/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/simpleCUFFT_MGPU/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCUFFT_MGPU LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    simpleCUFFT_MGPU.cu
-)
-
 # Add target for simpleCUFFT_MGPU
-add_executable(simpleCUFFT_MGPU ${SRC_FILES})
+add_executable(simpleCUFFT_MGPU simpleCUFFT_MGPU.cu)
+
+target_compile_options(simpleCUFFT_MGPU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUFFT_MGPU PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCUFFT_MGPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_link_libraries(simpleCUFFT_MGPU PRIVATE
--- a/Samples/4_CUDA_Libraries/simpleCUFFT_callback/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/simpleCUFFT_callback/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCUFFT_callback LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    simpleCUFFT_callback.cu
-)
-
 # Add target for simpleCUFFT_callback
-add_executable(simpleCUFFT_callback ${SRC_FILES})
+add_executable(simpleCUFFT_callback simpleCUFFT_callback.cu)
+
+target_compile_options(simpleCUFFT_callback PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUFFT_callback PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCUFFT_callback PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_link_libraries(simpleCUFFT_callback PRIVATE
--- a/Samples/4_CUDA_Libraries/watershedSegmentationNPP/CMakeLists.txt
+++ b/Samples/4_CUDA_Libraries/watershedSegmentationNPP/CMakeLists.txt
@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(watershedSegmentationNPP LANGUAGES C CXX CUDA)
+
+find_package(CUDAToolkit REQUIRED)
+
+set(CMAKE_CUDA_ARCHITECTURES "native")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
+endif()
+
 # Include directories and libraries
 include_directories(../../../Common)

 # Source file
-set(SRC_FILES
-    watershedSegmentationNPP.cpp
-)
-
 # Add target for watershedSegmentationNPP
-add_executable(watershedSegmentationNPP ${SRC_FILES})
+add_executable(watershedSegmentationNPP watershedSegmentationNPP.cpp)
+
+target_compile_options(watershedSegmentationNPP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(watershedSegmentationNPP PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(watershedSegmentationNPP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

 target_include_directories(watershedSegmentationNPP PRIVATE