lukasplevac/cuda-samples
1
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2025-04-10 18:22:11 +01:00
Code Issues Packages Projects Releases Wiki Activity

Make target compile options, language standards target-specific

Browse Source
This commit is contained in:
Rob Armstrong 2024-12-16 12:01:03 -08:00
parent 1bb070deba
commit 8d2e39c395
47 changed files with 277 additions and 577 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Samples/0_Introduction/CMakeLists.txt
View File

@ -6,18 +6,11 @@ project(simpleCallback LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
add_subdirectory(UnifiedMemoryStreams)
add_subdirectory(asyncAPI)

18
Samples/0_Introduction/UnifiedMemoryStreams/CMakeLists.txt
View File

@ -6,31 +6,25 @@ project(UnifiedMemoryStreams LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
UnifiedMemoryStreams.cu
)
find_package(OpenMP REQUIRED)
if(${OpenMP_FOUND})
# Add target for UnifiedMemoryStreams
add_executable(UnifiedMemoryStreams ${SRC_FILES})
add_executable(UnifiedMemoryStreams UnifiedMemoryStreams.cu)
target_compile_options(UnifiedMemoryStreams PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(UnifiedMemoryStreams PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(UnifiedMemoryStreams PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_link_libraries(UnifiedMemoryStreams PUBLIC

18
Samples/0_Introduction/asyncAPI/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(asyncAPI LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
asyncAPI.cu
)
# Add target for asyncAPI
add_executable(asyncAPI ${SRC_FILES})
add_executable(asyncAPI asyncAPI.cu)
target_compile_options(asyncAPI PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(asyncAPI PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(asyncAPI PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/clock/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(clock LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
clock.cu
)
# Add target for asyncAPI
add_executable(clock ${SRC_FILES})
add_executable(clock clock.cu)
target_compile_options(clock PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(clock PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(clock PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/clock_nvrtc/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(clock_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
clock.cpp
)
# Add sample target executable
add_executable(clock_nvrtc ${SRC_FILES})
add_executable(clock_nvrtc clock.cpp)
target_compile_options(clock_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(clock_nvrtc PRIVATE cxx_std_17 cuda_std_17)
target_link_libraries(clock_nvrtc PRIVATE
CUDA::nvrtc
)

18
Samples/0_Introduction/cudaOpenMP/CMakeLists.txt
View File

@ -6,31 +6,25 @@ project(cudaOpenMP LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
find_package(OpenMP)
# Source file
set(SRC_FILES
cudaOpenMP.cu
)
if(OpenMP_CXX_FOUND)
# Add target for asyncAPI
add_executable(cudaOpenMP ${SRC_FILES})
add_executable(cudaOpenMP cudaOpenMP.cu)
target_compile_options(cudaOpenMP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(cudaOpenMP PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(cudaOpenMP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_link_libraries(cudaOpenMP PUBLIC
OpenMP::OpenMP_CXX

18
Samples/0_Introduction/fp16ScalarProduct/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(fp16ScalarProduct LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
fp16ScalarProduct.cu
)
# Add target for asyncAPI
add_executable(fp16ScalarProduct ${SRC_FILES})
add_executable(fp16ScalarProduct fp16ScalarProduct.cu)
target_compile_options(fp16ScalarProduct PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(fp16ScalarProduct PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(fp16ScalarProduct PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/matrixMul/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(matrixMul LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
matrixMul.cu
)
# Add target for asyncAPI
add_executable(matrixMul ${SRC_FILES})
add_executable(matrixMul matrixMul.cu)
target_compile_options(matrixMul PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(matrixMul PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(matrixMul PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/matrixMulDrv/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(matrixMulDrv LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
matrixMulDrv.cpp
)
# Add target for matrixMulDrv
add_executable(matrixMulDrv ${SRC_FILES})
add_executable(matrixMulDrv matrixMulDrv.cpp)
target_compile_options(matrixMulDrv PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(matrixMulDrv PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(matrixMulDrv PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(matrixMulDrv PRIVATE

24
Samples/0_Introduction/matrixMulDynlinkJIT/CMakeLists.txt
View File

@ -6,34 +6,22 @@ project(matrixMulDynlinkJIT LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
cuda_drvapi_dynlink.c
matrixMulDynlinkJIT.cpp
matrixMul_gold.cpp
matrixMul_kernel_32_ptxdump.c
matrixMul_kernel_64_ptxdump.c
)
# Add target for matrixMulDynlinkJIT
add_executable(matrixMulDynlinkJIT ${SRC_FILES})
add_executable(matrixMulDynlinkJIT cuda_drvapi_dynlink.c matrixMulDynlinkJIT.cpp matrixMul_gold.cpp matrixMul_kernel_32_ptxdump.c matrixMul_kernel_64_ptxdump.c)
target_compile_options(matrixMulDynlinkJIT PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(matrixMulDynlinkJIT PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(matrixMulDynlinkJIT PROPERTIES
CUDA_SEPARABLE_COMPILATION ON
POSITION_INDEPENDENT_CODE OFF

18
Samples/0_Introduction/matrixMul_nvrtc/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(matrixMul_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
matrixMul.cpp
)
# Add sample target executable
add_executable(matrixMul_nvrtc ${SRC_FILES})
add_executable(matrixMul_nvrtc matrixMul.cpp)
target_compile_options(matrixMul_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(matrixMul_nvrtc PRIVATE cxx_std_17 cuda_std_17)
target_link_libraries(matrixMul_nvrtc PRIVATE
CUDA::nvrtc
)

21
Samples/0_Introduction/mergeSort/CMakeLists.txt
View File

@ -6,31 +6,22 @@ project(mergeSort LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
mergeSort.cu
main.cpp
mergeSort_host.cpp
mergeSort_validate.cpp
)
# Add target for mergeSort
add_executable(mergeSort ${SRC_FILES})
add_executable(mergeSort mergeSort.cu main.cpp mergeSort_host.cpp mergeSort_validate.cpp)
target_compile_options(mergeSort PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(mergeSort PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(mergeSort PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(mergeSort PRIVATE
${CUDAToolkit_INCLUDE_DIRS}

18
Samples/0_Introduction/simpleAWBarrier/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleAWBarrier LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleAWBarrier.cu
)
# Add target for simpleAWBarrier
add_executable(simpleAWBarrier ${SRC_FILES})
add_executable(simpleAWBarrier simpleAWBarrier.cu)
target_compile_options(simpleAWBarrier PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleAWBarrier PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleAWBarrier PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleAssert/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleAssert LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleAssert.cu
)
# Add target for simpleAssert
add_executable(simpleAssert ${SRC_FILES})
add_executable(simpleAssert simpleAssert.cu)
target_compile_options(simpleAssert PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleAssert PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleAssert PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleAssert_nvrtc/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(simpleAssert_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleAssert.cpp
)
# Add sample target executable
add_executable(simpleAssert_nvrtc ${SRC_FILES})
add_executable(simpleAssert_nvrtc simpleAssert.cpp)
target_compile_options(simpleAssert_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleAssert_nvrtc PRIVATE cxx_std_17 cuda_std_17)
target_link_libraries(simpleAssert_nvrtc PRIVATE
CUDA::nvrtc
)

19
Samples/0_Introduction/simpleAtomicIntrinsics/CMakeLists.txt
View File

@ -6,27 +6,20 @@ project(simpleAtomicIntrinsics LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleAtomicIntrinsics.cu
simpleAtomicIntrinsics_cpu.cpp
)
# Add target for simpleAtomicIntrinsics
add_executable(simpleAtomicIntrinsics ${SRC_FILES})
add_executable(simpleAtomicIntrinsics simpleAtomicIntrinsics.cu simpleAtomicIntrinsics_cpu.cpp)
target_compile_options(simpleAtomicIntrinsics PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleAtomicIntrinsics PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleAtomicIntrinsics PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

19
Samples/0_Introduction/simpleAtomicIntrinsics_nvrtc/CMakeLists.txt
View File

@ -6,29 +6,22 @@ project(simpleAtomicIntrinsics_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleAtomicIntrinsics_cpu.cpp
simpleAtomicIntrinsics.cpp
)
# Add sample target executable
add_executable(simpleAtomicIntrinsics_nvrtc ${SRC_FILES})
add_executable(simpleAtomicIntrinsics_nvrtc simpleAtomicIntrinsics_cpu.cpp simpleAtomicIntrinsics.cpp)
target_compile_options(simpleAtomicIntrinsics_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleAtomicIntrinsics_nvrtc PRIVATE cxx_std_17 cuda_std_17)
target_link_libraries(simpleAtomicIntrinsics_nvrtc PRIVATE
CUDA::nvrtc
)

18
Samples/0_Introduction/simpleAttributes/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleAttributes LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleAttributes.cu
)
# Add target for simpleAttributes
add_executable(simpleAttributes ${SRC_FILES})
add_executable(simpleAttributes simpleAttributes.cu)
target_compile_options(simpleAttributes PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleAttributes PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleAttributes PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

20
Samples/0_Introduction/simpleCUDA2GL/CMakeLists.txt
View File

@ -6,18 +6,11 @@ project(simpleCUDA2GL LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
@ -25,16 +18,15 @@ find_package(OpenGL)
find_package(GLUT)
# Source file
set(SRC_FILES
simpleCUDA2GL.cu
main.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for simpleCUDA2GL
add_executable(simpleCUDA2GL ${SRC_FILES})
add_executable(simpleCUDA2GL simpleCUDA2GL.cu main.cpp)
target_compile_options(simpleCUDA2GL PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleCUDA2GL PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleCUDA2GL PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleCUDA2GL PUBLIC

19
Samples/0_Introduction/simpleCallback/CMakeLists.txt
View File

@ -6,27 +6,20 @@ project(simpleCallback LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleCallback.cu
multithreading.cpp
)
# Add target for simpleCallback
add_executable(simpleCallback ${SRC_FILES})
add_executable(simpleCallback simpleCallback.cu multithreading.cpp)
target_compile_options(simpleCallback PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleCallback PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleCallback PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleCooperativeGroups/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleCooperativeGroups LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleCooperativeGroups.cu
)
# Add target for simpleCooperativeGroups
add_executable(simpleCooperativeGroups ${SRC_FILES})
add_executable(simpleCooperativeGroups simpleCooperativeGroups.cu)
target_compile_options(simpleCooperativeGroups PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleCooperativeGroups PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleCooperativeGroups PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleCubemapTexture/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleCubemapTexture LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleCubemapTexture.cu
)
# Add target for simpleCubemapTexture
add_executable(simpleCubemapTexture ${SRC_FILES})
add_executable(simpleCubemapTexture simpleCubemapTexture.cu)
target_compile_options(simpleCubemapTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleCubemapTexture PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleCubemapTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

19
Samples/0_Introduction/simpleDrvRuntime/CMakeLists.txt
View File

@ -6,29 +6,24 @@ project(simpleDrvRuntime LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleDrvRuntime.cpp
)
# Add target for simpleDrvRuntime
add_executable(simpleDrvRuntime ${SRC_FILES})
add_executable(simpleDrvRuntime simpleDrvRuntime.cpp)
target_compile_options(simpleDrvRuntime PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleDrvRuntime PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleDrvRuntime PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleDrvRuntime PRIVATE
${CUDAToolkit_INCLUDE_DIRS}
)

18
Samples/0_Introduction/simpleHyperQ/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleHyperQ LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleHyperQ.cu
)
# Add target for simpleHyperQ
add_executable(simpleHyperQ ${SRC_FILES})
add_executable(simpleHyperQ simpleHyperQ.cu)
target_compile_options(simpleHyperQ PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleHyperQ PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleHyperQ PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

19
Samples/0_Introduction/simpleIPC/CMakeLists.txt
View File

@ -6,27 +6,20 @@ project(simpleIPC LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleIPC.cu
../../../Common/helper_multiprocess.cpp
)
# Add target for simpleIPC
add_executable(simpleIPC ${SRC_FILES})
add_executable(simpleIPC simpleIPC.cu ../../../Common/helper_multiprocess.cpp)
target_compile_options(simpleIPC PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleIPC PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleIPC PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleLayeredTexture/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleLayeredTexture LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleLayeredTexture.cu
)
# Add target for simpleLayeredTexture
add_executable(simpleLayeredTexture ${SRC_FILES})
add_executable(simpleLayeredTexture simpleLayeredTexture.cu)
target_compile_options(simpleLayeredTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleLayeredTexture PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleLayeredTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

19
Samples/0_Introduction/simpleMPI/CMakeLists.txt
View File

@ -6,32 +6,25 @@ project(simpleMPI LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
find_package(MPI)
# Source file
set(SRC_FILES
simpleMPI.cpp
simpleMPI.cu
)
if(${MPI_FOUND})
# Add target for simpleMPI
add_executable(simpleMPI ${SRC_FILES})
add_executable(simpleMPI simpleMPI.cpp simpleMPI.cu)
target_compile_options(simpleMPI PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleMPI PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleMPI PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleMPI PUBLIC

18
Samples/0_Introduction/simpleMultiCopy/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleMultiCopy LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleMultiCopy.cu
)
# Add target for simpleMultiCopy
add_executable(simpleMultiCopy ${SRC_FILES})
add_executable(simpleMultiCopy simpleMultiCopy.cu)
target_compile_options(simpleMultiCopy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleMultiCopy PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleMultiCopy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleMultiGPU/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleMultiGPU LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleMultiGPU.cu
)
# Add target for simpleMultiGPU
add_executable(simpleMultiGPU ${SRC_FILES})
add_executable(simpleMultiGPU simpleMultiGPU.cu)
target_compile_options(simpleMultiGPU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleMultiGPU PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleMultiGPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleOccupancy/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleOccupancy LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleOccupancy.cu
)
# Add target for simpleOccupancy
add_executable(simpleOccupancy ${SRC_FILES})
add_executable(simpleOccupancy simpleOccupancy.cu)
target_compile_options(simpleOccupancy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleOccupancy PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleOccupancy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleP2P/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleP2P LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleP2P.cu
)
# Add target for simpleP2P
add_executable(simpleP2P ${SRC_FILES})
add_executable(simpleP2P simpleP2P.cu)
target_compile_options(simpleP2P PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleP2P PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleP2P PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simplePitchLinearTexture/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simplePitchLinearTexture LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simplePitchLinearTexture.cu
)
# Add target for simplePitchLinearTexture
add_executable(simplePitchLinearTexture ${SRC_FILES})
add_executable(simplePitchLinearTexture simplePitchLinearTexture.cu)
target_compile_options(simplePitchLinearTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simplePitchLinearTexture PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simplePitchLinearTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simplePrintf/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simplePrintf LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simplePrintf.cu
)
# Add target for simplePrintf
add_executable(simplePrintf ${SRC_FILES})
add_executable(simplePrintf simplePrintf.cu)
target_compile_options(simplePrintf PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simplePrintf PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simplePrintf PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleStreams/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleStreams LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleStreams.cu
)
# Add target for simpleStreams
add_executable(simpleStreams ${SRC_FILES})
add_executable(simpleStreams simpleStreams.cu)
target_compile_options(simpleStreams PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleStreams PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleStreams PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleSurfaceWrite/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(simpleSurfaceWrite LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleSurfaceWrite.cu
)
# Add target for simpleSurfaceWrite
add_executable(simpleSurfaceWrite ${SRC_FILES})
add_executable(simpleSurfaceWrite simpleSurfaceWrite.cu)
target_compile_options(simpleSurfaceWrite PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleSurfaceWrite PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleSurfaceWrite PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
# Copy data to the output directory

18
Samples/0_Introduction/simpleTemplates/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleTemplates LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleTemplates.cu
)
# Add target for simpleTemplates
add_executable(simpleTemplates ${SRC_FILES})
add_executable(simpleTemplates simpleTemplates.cu)
target_compile_options(simpleTemplates PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleTemplates PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleTemplates PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleTexture/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleTexture LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleTexture.cu
)
# Add target for simpleTexture
add_executable(simpleTexture ${SRC_FILES})
add_executable(simpleTexture simpleTexture.cu)
target_compile_options(simpleTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleTexture PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

19
Samples/0_Introduction/simpleTexture3D/CMakeLists.txt
View File

@ -6,18 +6,11 @@ project(simpleTexture3D LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
@ -25,15 +18,15 @@ find_package(OpenGL)
find_package(GLUT)
# Source file
set(SRC_FILES
simpleTexture3D_kernel.cu
simpleTexture3D.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for simpleTexture3D
add_executable(simpleTexture3D ${SRC_FILES})
add_executable(simpleTexture3D simpleTexture3D_kernel.cu simpleTexture3D.cpp)
target_compile_options(simpleTexture3D PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleTexture3D PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleTexture3D PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleTexture3D PUBLIC

18
Samples/0_Introduction/simpleTextureDrv/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(simpleTextureDrv LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleTextureDrv.cpp
)
# Add target for simpleTextureDrv
add_executable(simpleTextureDrv ${SRC_FILES})
add_executable(simpleTextureDrv simpleTextureDrv.cpp)
target_compile_options(simpleTextureDrv PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleTextureDrv PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleTextureDrv PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleTextureDrv PRIVATE
${CUDAToolkit_INCLUDE_DIRS}

18
Samples/0_Introduction/simpleVoteIntrinsics/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleVoteIntrinsics LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleVoteIntrinsics.cu
)
# Add target for simpleVoteIntrinsics
add_executable(simpleVoteIntrinsics ${SRC_FILES})
add_executable(simpleVoteIntrinsics simpleVoteIntrinsics.cu)
target_compile_options(simpleVoteIntrinsics PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleVoteIntrinsics PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleVoteIntrinsics PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/simpleZeroCopy/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(simpleZeroCopy LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
simpleZeroCopy.cu
)
# Add target for simpleZeroCopy
add_executable(simpleZeroCopy ${SRC_FILES})
add_executable(simpleZeroCopy simpleZeroCopy.cu)
target_compile_options(simpleZeroCopy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleZeroCopy PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleZeroCopy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/systemWideAtomics/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(systemWideAtomics LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
systemWideAtomics.cu
)
# Add target for systemWideAtomics
add_executable(systemWideAtomics ${SRC_FILES})
add_executable(systemWideAtomics systemWideAtomics.cu)
target_compile_options(systemWideAtomics PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(systemWideAtomics PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(systemWideAtomics PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/template/CMakeLists.txt
View File

@ -6,27 +6,21 @@ project(template LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
template.cu
)
# Add target for template
add_executable(template ${SRC_FILES})
add_executable(template template.cu)
target_compile_options(template PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(template PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(template PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/vectorAdd/CMakeLists.txt
View File

@ -6,26 +6,20 @@ project(vectorAdd LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
vectorAdd.cu
)
# Add target for vectorAdd
add_executable(vectorAdd ${SRC_FILES})
add_executable(vectorAdd vectorAdd.cu)
target_compile_options(vectorAdd PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(vectorAdd PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(vectorAdd PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

18
Samples/0_Introduction/vectorAddDrv/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(vectorAddDrv LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
vectorAddDrv.cpp
)
# Add target for vectorAddDrv
add_executable(vectorAddDrv ${SRC_FILES})
add_executable(vectorAddDrv vectorAddDrv.cpp)
target_compile_options(vectorAddDrv PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(vectorAddDrv PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(vectorAddDrv PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(vectorAddDrv PRIVATE
${CUDAToolkit_INCLUDE_DIRS}

19
Samples/0_Introduction/vectorAddMMAP/CMakeLists.txt
View File

@ -6,29 +6,22 @@ project(vectorAddMMAP LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
vectorAddMMAP.cpp
multidevicealloc_memmap.cpp
)
# Add target for vectorAddMMAP
add_executable(vectorAddMMAP ${SRC_FILES})
add_executable(vectorAddMMAP vectorAddMMAP.cpp multidevicealloc_memmap.cpp)
target_compile_options(vectorAddMMAP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(vectorAddMMAP PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(vectorAddMMAP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(vectorAddMMAP PRIVATE
${CUDAToolkit_INCLUDE_DIRS}

18
Samples/0_Introduction/vectorAdd_nvrtc/CMakeLists.txt
View File

@ -6,28 +6,22 @@ project(vectorAdd_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_ARCHITECTURES "native")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (expensive)
endif()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
# Include directories and libraries
include_directories(../../../Common)
# Source file
set(SRC_FILES
vectorAdd.cpp
)
# Add sample target executable
add_executable(vectorAdd_nvrtc ${SRC_FILES})
add_executable(vectorAdd_nvrtc vectorAdd.cpp)
target_compile_options(vectorAdd_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(vectorAdd_nvrtc PRIVATE cxx_std_17 cuda_std_17)
target_link_libraries(vectorAdd_nvrtc PRIVATE
CUDA::nvrtc
)