Refactor CMakeLists.txt under 2_Concepts_and_Techniques

This commit is contained in:
Rob Armstrong 2024-12-16 14:34:20 -08:00
parent 281daef279
commit ea694a4b0d
33 changed files with 627 additions and 212 deletions

View File

@ -1,20 +1,30 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(EGLStream_CUDA_CrossGPU 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)
find_package(EGL)
# Source file
set(SRC_FILES
cuda_consumer.cpp
cuda_producer.cpp
eglstrm_common.cpp
kernel.cu
main.cpp
)
if(${EGL_FOUND})
# Add target for EGLStream_CUDA_CrossGPU
add_executable(EGLStream_CUDA_CrossGPU ${SRC_FILES})
add_executable(EGLStream_CUDA_CrossGPU cuda_consumer.cpp cuda_producer.cpp eglstrm_common.cpp kernel.cu main.cpp)
target_compile_options(EGLStream_CUDA_CrossGPU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(EGLStream_CUDA_CrossGPU PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(EGLStream_CUDA_CrossGPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(EGLStream_CUDA_CrossGPU PUBLIC

View File

@ -1,19 +1,30 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(EGLStream_CUDA_Interop 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)
find_package(EGL)
# Source file
set(SRC_FILES
cuda_consumer.cpp
cuda_producer.cpp
eglstrm_common.cpp
main.cpp
)
if(${EGL_FOUND})
# Add target for EGLStream_CUDA_Interop
add_executable(EGLStream_CUDA_Interop ${SRC_FILES})
add_executable(EGLStream_CUDA_Interop cuda_consumer.cpp cuda_producer.cpp eglstrm_common.cpp main.cpp)
target_compile_options(EGLStream_CUDA_Interop PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(EGLStream_CUDA_Interop PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(EGLStream_CUDA_Interop PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(EGLStream_CUDA_Interop PUBLIC

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(EGLSync_CUDAEvent_Interop 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)
@ -6,15 +19,16 @@ find_package(X11)
find_package(OpenGL)
# Source file
set(SRC_FILES
EGLSync_CUDAEvent_Interop.cu
)
if(${OpenGL_FOUND})
if(${EGL_FOUND})
if(${X11_FOUND})
# Add target for EGLSync_CUDAEvent_Interop
add_executable(EGLSync_CUDAEvent_Interop ${SRC_FILES})
add_executable(EGLSync_CUDAEvent_Interop EGLSync_CUDAEvent_Interop.cu)
target_compile_options(EGLSync_CUDAEvent_Interop PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(EGLSync_CUDAEvent_Interop PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(EGLSync_CUDAEvent_Interop PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(EGLSync_CUDAEvent_Interop PUBLIC

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(particles 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,18 +18,15 @@ find_package(OpenGL)
find_package(GLUT)
# Source file
set(SRC_FILES
particleSystem.cpp
particleSystem_cuda.cu
particles.cpp
render_particles.cpp
shaders.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for particles
add_executable(particles ${SRC_FILES})
add_executable(particles particleSystem.cpp particleSystem_cuda.cu particles.cpp render_particles.cpp shaders.cpp)
target_compile_options(particles PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(particles PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(particles PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(particles PUBLIC

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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