Refactor CMakeLists.txt under 3_CUDA_Features

Samples/3_CUDA_Features/StreamPriorities/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(StreamPriorities 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
-    StreamPriorities.cu
-)
-
 # Add target for StreamPriorities
-add_executable(StreamPriorities ${SRC_FILES})
+add_executable(StreamPriorities StreamPriorities.cu)
+
+target_compile_options(StreamPriorities PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(StreamPriorities PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(StreamPriorities PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/bf16TensorCoreGemm/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(bf16TensorCoreGemm 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
-    bf16TensorCoreGemm.cu
-)
-
 # Add target for bf16TensorCoreGemm
-add_executable(bf16TensorCoreGemm ${SRC_FILES})
+add_executable(bf16TensorCoreGemm bf16TensorCoreGemm.cu)
+
+target_compile_options(bf16TensorCoreGemm PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(bf16TensorCoreGemm PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(bf16TensorCoreGemm PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/binaryPartitionCG/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(binaryPartitionCG 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
-    binaryPartitionCG.cu
-)
-
 # Add target for binaryPartitionCG
-add_executable(binaryPartitionCG ${SRC_FILES})
+add_executable(binaryPartitionCG binaryPartitionCG.cu)
+
+target_compile_options(binaryPartitionCG PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(binaryPartitionCG PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(binaryPartitionCG PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/bindlessTexture/CMakeLists.txt

@@ -1,3 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(bindlessTexture 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
-    bindlessTexture.cpp
-    bindlessTexture_kernel.cu
-)
-
 if(${OpenGL_FOUND})
     if (${GLUT_FOUND})
         # Add target for bindlessTexture
-        add_executable(bindlessTexture ${SRC_FILES})
+        add_executable(bindlessTexture bindlessTexture.cpp bindlessTexture_kernel.cu)
+
+target_compile_options(bindlessTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(bindlessTexture PRIVATE cxx_std_17 cuda_std_17)
+
         set_target_properties(bindlessTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
         target_include_directories(bindlessTexture PUBLIC

Samples/3_CUDA_Features/cdpAdvancedQuicksort/CMakeLists.txt

@@ -1,12 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cdpAdvancedQuicksort 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
-    cdpAdvancedQuicksort.cu
-    cdpBitonicSort.cu
-)
-
 # Add target for cdpAdvancedQuicksort
-add_executable(cdpAdvancedQuicksort ${SRC_FILES})
+add_executable(cdpAdvancedQuicksort cdpAdvancedQuicksort.cu cdpBitonicSort.cu)
+
+target_compile_options(cdpAdvancedQuicksort PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cdpAdvancedQuicksort PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cdpAdvancedQuicksort PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/cdpBezierTessellation/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cdpBezierTessellation 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
-    BezierLineCDP.cu
-)
-
 # Add target for cdpBezierTessellation
-add_executable(cdpBezierTessellation ${SRC_FILES})
+add_executable(cdpBezierTessellation BezierLineCDP.cu)
+
+target_compile_options(cdpBezierTessellation PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cdpBezierTessellation PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cdpBezierTessellation PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/cdpQuadtree/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cdpQuadtree 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
-    cdpQuadtree.cu
-)
-
 # Add target for cdpQuadtree
-add_executable(cdpQuadtree ${SRC_FILES})
+add_executable(cdpQuadtree cdpQuadtree.cu)
+
+target_compile_options(cdpQuadtree PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cdpQuadtree PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cdpQuadtree PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/cdpSimplePrint/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cdpSimplePrint 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
-    cdpSimplePrint.cu
-)
-
 # Add target for cdpSimplePrint
-add_executable(cdpSimplePrint ${SRC_FILES})
+add_executable(cdpSimplePrint cdpSimplePrint.cu)
+
+target_compile_options(cdpSimplePrint PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cdpSimplePrint PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cdpSimplePrint PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/cdpSimpleQuicksort/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cdpSimpleQuicksort 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
-    cdpSimpleQuicksort.cu
-)
-
 # Add target for cdpSimpleQuicksort
-add_executable(cdpSimpleQuicksort ${SRC_FILES})
+add_executable(cdpSimpleQuicksort cdpSimpleQuicksort.cu)
+
+target_compile_options(cdpSimpleQuicksort PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cdpSimpleQuicksort PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cdpSimpleQuicksort PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/cudaCompressibleMemory/CMakeLists.txt

@@ -1,14 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cudaCompressibleMemory 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
-    compMalloc.cpp
-    saxpy.cu
-)
-
 # Add target for cudaCompressibleMemory
-add_executable(cudaCompressibleMemory ${SRC_FILES})
+add_executable(cudaCompressibleMemory compMalloc.cpp saxpy.cu)
+
+target_compile_options(cudaCompressibleMemory PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cudaCompressibleMemory PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cudaCompressibleMemory PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
 target_include_directories(cudaCompressibleMemory PRIVATE

Samples/3_CUDA_Features/cudaTensorCoreGemm/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(cudaTensorCoreGemm 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
-    cudaTensorCoreGemm.cu
-)
-
 # Add target for cudaTensorCoreGemm
-add_executable(cudaTensorCoreGemm ${SRC_FILES})
+add_executable(cudaTensorCoreGemm cudaTensorCoreGemm.cu)
+
+target_compile_options(cudaTensorCoreGemm PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cudaTensorCoreGemm PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(cudaTensorCoreGemm PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/dmmaTensorCoreGemm/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(dmmaTensorCoreGemm 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
-    dmmaTensorCoreGemm.cu
-)
-
 # Add target for dmmaTensorCoreGemm
-add_executable(dmmaTensorCoreGemm ${SRC_FILES})
+add_executable(dmmaTensorCoreGemm dmmaTensorCoreGemm.cu)
+
+target_compile_options(dmmaTensorCoreGemm PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(dmmaTensorCoreGemm PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(dmmaTensorCoreGemm PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/globalToShmemAsyncCopy/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(globalToShmemAsyncCopy 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
-    globalToShmemAsyncCopy.cu
-)
-
 # Add target for globalToShmemAsyncCopy
-add_executable(globalToShmemAsyncCopy ${SRC_FILES})
+add_executable(globalToShmemAsyncCopy globalToShmemAsyncCopy.cu)
+
+target_compile_options(globalToShmemAsyncCopy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(globalToShmemAsyncCopy PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(globalToShmemAsyncCopy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/graphConditionalNodes/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(graphConditionalNodes 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
-    graphConditionalNodes.cu
-)
-
 # Add target for graphConditionalNodes
-add_executable(graphConditionalNodes ${SRC_FILES})
+add_executable(graphConditionalNodes graphConditionalNodes.cu)
+
+target_compile_options(graphConditionalNodes PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(graphConditionalNodes PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(graphConditionalNodes PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/graphMemoryFootprint/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(graphMemoryFootprint 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
-    graphMemoryFootprint.cu
-)
-
 # Add target for graphMemoryFootprint
-add_executable(graphMemoryFootprint ${SRC_FILES})
+add_executable(graphMemoryFootprint graphMemoryFootprint.cu)
+
+target_compile_options(graphMemoryFootprint PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(graphMemoryFootprint PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(graphMemoryFootprint PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/graphMemoryNodes/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(graphMemoryNodes 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
-    graphMemoryNodes.cu
-)
-
 # Add target for graphMemoryNodes
-add_executable(graphMemoryNodes ${SRC_FILES})
+add_executable(graphMemoryNodes graphMemoryNodes.cu)
+
+target_compile_options(graphMemoryNodes PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(graphMemoryNodes PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(graphMemoryNodes PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/immaTensorCoreGemm/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(immaTensorCoreGemm 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
-    immaTensorCoreGemm.cu
-)
-
 # Add target for immaTensorCoreGemm
-add_executable(immaTensorCoreGemm ${SRC_FILES})
+add_executable(immaTensorCoreGemm immaTensorCoreGemm.cu)
+
+target_compile_options(immaTensorCoreGemm PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(immaTensorCoreGemm PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(immaTensorCoreGemm PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/jacobiCudaGraphs/CMakeLists.txt

@@ -1,14 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(jacobiCudaGraphs 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
-    jacobi.cu
-    main.cpp
-)
-
 # Add target for jacobiCudaGraphs
-add_executable(jacobiCudaGraphs ${SRC_FILES})
+add_executable(jacobiCudaGraphs jacobi.cu main.cpp)
+
+target_compile_options(jacobiCudaGraphs PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(jacobiCudaGraphs PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(jacobiCudaGraphs PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
 target_include_directories(jacobiCudaGraphs PRIVATE

Samples/3_CUDA_Features/memMapIPCDrv/CMakeLists.txt

@@ -1,14 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(memMapIPCDrv 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
-    memMapIpc.cpp
-    ../../../Common/helper_multiprocess.cpp
-)
-
 # Add target for memMapIPCDrv
-add_executable(memMapIPCDrv ${SRC_FILES})
+add_executable(memMapIPCDrv memMapIpc.cpp ../../../Common/helper_multiprocess.cpp)
+
+target_compile_options(memMapIPCDrv PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(memMapIPCDrv PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(memMapIPCDrv PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
 target_include_directories(memMapIPCDrv PRIVATE

Samples/3_CUDA_Features/newdelete/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(newdelete 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
-    newdelete.cu
-)
-
 # Add target for newdelete
-add_executable(newdelete ${SRC_FILES})
+add_executable(newdelete newdelete.cu)
+
+target_compile_options(newdelete PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(newdelete PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(newdelete PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/ptxjit/CMakeLists.txt

@@ -1,13 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(ptxjit 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
-    ptxjit.cpp
-)
-
 # Add target for ptxjit
-add_executable(ptxjit ${SRC_FILES})
+add_executable(ptxjit ptxjit.cpp)
+
+target_compile_options(ptxjit PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(ptxjit PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(ptxjit PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
 target_include_directories(ptxjit PRIVATE

Samples/3_CUDA_Features/simpleCudaGraphs/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(simpleCudaGraphs 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
-    simpleCudaGraphs.cu
-)
-
 # Add target for simpleCudaGraphs
-add_executable(simpleCudaGraphs ${SRC_FILES})
+add_executable(simpleCudaGraphs simpleCudaGraphs.cu)
+
+target_compile_options(simpleCudaGraphs PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCudaGraphs PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCudaGraphs PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/tf32TensorCoreGemm/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(tf32TensorCoreGemm 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
-    tf32TensorCoreGemm.cu
-)
-
 # Add target for tf32TensorCoreGemm
-add_executable(tf32TensorCoreGemm ${SRC_FILES})
+add_executable(tf32TensorCoreGemm tf32TensorCoreGemm.cu)
+
+target_compile_options(tf32TensorCoreGemm PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(tf32TensorCoreGemm PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(tf32TensorCoreGemm PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

Samples/3_CUDA_Features/warpAggregatedAtomicsCG/CMakeLists.txt

@@ -1,11 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
+
+project(warpAggregatedAtomicsCG 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
-    warpAggregatedAtomicsCG.cu
-)
-
 # Add target for warpAggregatedAtomicsCG
-add_executable(warpAggregatedAtomicsCG ${SRC_FILES})
+add_executable(warpAggregatedAtomicsCG warpAggregatedAtomicsCG.cu)
+
+target_compile_options(warpAggregatedAtomicsCG PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(warpAggregatedAtomicsCG PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(warpAggregatedAtomicsCG PROPERTIES CUDA_SEPARABLE_COMPILATION ON)