Refactor CMakeLists.txt under 5_Domain_Specific

This commit is contained in:
Rob Armstrong 2024-12-16 16:10:56 -08:00
parent 7d7e0777a5
commit 11fc617794
42 changed files with 852 additions and 220 deletions

View File

@ -1,12 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(BlackScholes LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
BlackScholes.cu
BlackScholes_gold.cpp
)
# Add target for BlackScholes
add_executable(BlackScholes ${SRC_FILES})
add_executable(BlackScholes BlackScholes.cu BlackScholes_gold.cpp)
target_compile_options(BlackScholes PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(BlackScholes PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(BlackScholes 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(BlackScholes_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
BlackScholes.cpp
BlackScholes_gold.cpp
)
# Add target for BlackScholes_nvrtc
add_executable(BlackScholes_nvrtc ${SRC_FILES})
add_executable(BlackScholes_nvrtc BlackScholes.cpp BlackScholes_gold.cpp)
target_compile_options(BlackScholes_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(BlackScholes_nvrtc PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(BlackScholes_nvrtc PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_link_libraries(BlackScholes_nvrtc PRIVATE

View File

@ -1,15 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(FDTD3d LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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/FDTD3d.cpp
src/FDTD3dGPU.cu
src/FDTD3dReference.cpp
)
# Add target for FDTD3d
add_executable(FDTD3d ${SRC_FILES})
add_executable(FDTD3d src/FDTD3d.cpp src/FDTD3dGPU.cu src/FDTD3dReference.cpp)
target_compile_options(FDTD3d PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(FDTD3d PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(FDTD3d PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(FDTD3d PRIVATE

View File

@ -1,15 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(HSOpticalFlow LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
flowCUDA.cu
flowGold.cpp
main.cpp
)
# Add target for HSOpticalFlow
add_executable(HSOpticalFlow ${SRC_FILES})
add_executable(HSOpticalFlow flowCUDA.cu flowGold.cpp main.cpp)
target_compile_options(HSOpticalFlow PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(HSOpticalFlow PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(HSOpticalFlow PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(HSOpticalFlow PRIVATE

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(Mandelbrot LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
Mandelbrot_cuda.cu
Mandelbrot_gold.cpp
Mandelbrot.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for Mandelbrot
add_executable(Mandelbrot ${SRC_FILES})
add_executable(Mandelbrot Mandelbrot_cuda.cu Mandelbrot_gold.cpp Mandelbrot.cpp)
target_compile_options(Mandelbrot PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(Mandelbrot PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(Mandelbrot PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(Mandelbrot PUBLIC

View File

@ -1,16 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(MonteCarloMultiGPU LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
MonteCarlo_gold.cpp
MonteCarlo_kernel.cu
multithreading.cpp
MonteCarloMultiGPU.cpp
)
# Add target for MonteCarloMultiGPU
add_executable(MonteCarloMultiGPU ${SRC_FILES})
add_executable(MonteCarloMultiGPU MonteCarlo_gold.cpp MonteCarlo_kernel.cu multithreading.cpp MonteCarloMultiGPU.cpp)
target_compile_options(MonteCarloMultiGPU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(MonteCarloMultiGPU PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(MonteCarloMultiGPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(MonteCarloMultiGPU PRIVATE

View File

@ -1,17 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(NV12toBGRandResize LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
bgr_resize.cu
nv12_resize.cu
nv12_to_bgr_planar.cu
resize_convert_main.cpp
utils.cu
)
# Add target for NV12toBGRandResize
add_executable(NV12toBGRandResize ${SRC_FILES})
add_executable(NV12toBGRandResize bgr_resize.cu nv12_resize.cu nv12_to_bgr_planar.cu resize_convert_main.cpp utils.cu)
target_compile_options(NV12toBGRandResize PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(NV12toBGRandResize PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(NV12toBGRandResize PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(NV12toBGRandResize PRIVATE

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(SobelFilter LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
SobelFilter.cpp
SobelFilter_kernels.cu
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for SobelFilter
add_executable(SobelFilter ${SRC_FILES})
add_executable(SobelFilter SobelFilter.cpp SobelFilter_kernels.cu)
target_compile_options(SobelFilter PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(SobelFilter PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(SobelFilter PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(SobelFilter PUBLIC

View File

@ -1,16 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(SobolQRNG LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
sobol_gold.cpp
sobol_gpu.cu
sobol_primitives.cpp
sobol.cpp
)
# Add target for SobolQRNG
add_executable(SobolQRNG ${SRC_FILES})
add_executable(SobolQRNG sobol_gold.cpp sobol_gpu.cu sobol_primitives.cpp sobol.cpp)
target_compile_options(SobolQRNG PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(SobolQRNG PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(SobolQRNG PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(SobolQRNG PRIVATE

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(bicubicTexture LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
bicubicTexture.cpp
bicubicTexture_cuda.cu
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for bicubicTexture
add_executable(bicubicTexture ${SRC_FILES})
add_executable(bicubicTexture bicubicTexture.cpp bicubicTexture_cuda.cu)
target_compile_options(bicubicTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(bicubicTexture PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(bicubicTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(bicubicTexture PUBLIC

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(bilateralFilter LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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,17 +18,15 @@ find_package(OpenGL)
find_package(GLUT)
# Source file
set(SRC_FILES
bilateralFilter.cpp
bilateralFilter_cpu.cpp
bilateral_kernel.cu
bmploader.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for bilateralFilter
add_executable(bilateralFilter ${SRC_FILES})
add_executable(bilateralFilter bilateralFilter.cpp bilateralFilter_cpu.cpp bilateral_kernel.cu bmploader.cpp)
target_compile_options(bilateralFilter PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(bilateralFilter PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(bilateralFilter PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(bilateralFilter PUBLIC

View File

@ -1,15 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(binomialOptions LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
binomialOptions.cpp
binomialOptions_gold.cpp
binomialOptions_kernel.cu
)
# Add target for binomialOptions
add_executable(binomialOptions ${SRC_FILES})
add_executable(binomialOptions binomialOptions.cpp binomialOptions_gold.cpp binomialOptions_kernel.cu)
target_compile_options(binomialOptions PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(binomialOptions PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(binomialOptions PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(binomialOptions PUBLIC

View File

@ -1,15 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(binomialOptions_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
binomialOptions.cpp
binomialOptions_gold.cpp
binomialOptions_gpu.cpp
)
# Add target for binomialOptions_nvrtc
add_executable(binomialOptions_nvrtc ${SRC_FILES})
add_executable(binomialOptions_nvrtc binomialOptions.cpp binomialOptions_gold.cpp binomialOptions_gpu.cpp)
target_compile_options(binomialOptions_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(binomialOptions_nvrtc PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(binomialOptions_nvrtc PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_link_libraries(binomialOptions_nvrtc PRIVATE

View File

@ -1,15 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(convolutionFFT2D LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
convolutionFFT2D.cu
convolutionFFT2D_gold.cpp
main.cpp
)
# Add target for convolutionFFT2D
add_executable(convolutionFFT2D ${SRC_FILES})
add_executable(convolutionFFT2D convolutionFFT2D.cu convolutionFFT2D_gold.cpp main.cpp)
target_compile_options(convolutionFFT2D PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(convolutionFFT2D PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(convolutionFFT2D PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(convolutionFFT2D PRIVATE

View File

@ -1,13 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(dwtHaar1D LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
dwtHaar1D.cu
)
# Add target for dwtHaar1D
add_executable(dwtHaar1D ${SRC_FILES})
add_executable(dwtHaar1D dwtHaar1D.cu)
target_compile_options(dwtHaar1D PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(dwtHaar1D PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(dwtHaar1D PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
add_custom_command(TARGET dwtHaar1D POST_BUILD

View File

@ -1,13 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(dxtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
dxtc.cu
)
# Add target for dxtc
add_executable(dxtc ${SRC_FILES})
add_executable(dxtc dxtc.cu)
target_compile_options(dxtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(dxtc PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(dxtc PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
add_custom_command(TARGET dxtc POST_BUILD

View File

@ -1,12 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(fastWalshTransform LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
fastWalshTransform.cu
fastWalshTransform_gold.cpp
)
# Add target for fastWalshTransform
add_executable(fastWalshTransform ${SRC_FILES})
add_executable(fastWalshTransform fastWalshTransform.cu fastWalshTransform_gold.cpp)
target_compile_options(fastWalshTransform PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(fastWalshTransform PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(fastWalshTransform PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(fluidsGL LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
fluidsGL_kernels.cu
fluidsGL.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for fluidsGL
add_executable(fluidsGL ${SRC_FILES})
add_executable(fluidsGL fluidsGL_kernels.cu fluidsGL.cpp)
target_compile_options(fluidsGL PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(fluidsGL PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(fluidsGL PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(fluidsGL PUBLIC

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(fluidsGLES LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for fluidsGLES
add_executable(fluidsGLES fluidsGLES.cu)
target_compile_options(fluidsGLES PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(fluidsGLES PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(fluidsGLES PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(marchingCubes LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
marchingCubes_kernel.cu
marchingCubes.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for marchingCubes
add_executable(marchingCubes ${SRC_FILES})
add_executable(marchingCubes marchingCubes_kernel.cu marchingCubes.cpp)
target_compile_options(marchingCubes PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(marchingCubes PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(marchingCubes PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(marchingCubes PUBLIC

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(nbody LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
bodysystemcuda.cu
render_particles.cpp
nbody.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for nbody
add_executable(nbody ${SRC_FILES})
add_executable(nbody bodysystemcuda.cu render_particles.cpp nbody.cpp)
target_compile_options(nbody PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(nbody PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(nbody PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(nbody PUBLIC

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(nbody_opengles LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for nbody_opengles
add_executable(nbody_opengles nbody_opengles.cu)
target_compile_options(nbody_opengles PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(nbody_opengles PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(nbody_opengles PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(nbody_screen LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for nbody_screen
add_executable(nbody_screen nbody_screen.cu)
target_compile_options(nbody_screen PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(nbody_screen PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(nbody_screen 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(p2pBandwidthLatencyTest LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
p2pBandwidthLatencyTest.cu
)
# Add target for p2pBandwidthLatencyTest
add_executable(p2pBandwidthLatencyTest ${SRC_FILES})
add_executable(p2pBandwidthLatencyTest p2pBandwidthLatencyTest.cu)
target_compile_options(p2pBandwidthLatencyTest PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(p2pBandwidthLatencyTest PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(p2pBandwidthLatencyTest PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(postProcessGL LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
main.cpp
postProcessGL.cu
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for postProcessGL
add_executable(postProcessGL ${SRC_FILES})
add_executable(postProcessGL main.cpp postProcessGL.cu)
target_compile_options(postProcessGL PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(postProcessGL PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(postProcessGL PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(postProcessGL PUBLIC

View File

@ -1,15 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(quasirandomGenerator LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
quasirandomGenerator.cpp
quasirandomGenerator_gold.cpp
quasirandomGenerator_kernel.cu
)
# Add target for quasirandomGenerator
add_executable(quasirandomGenerator ${SRC_FILES})
add_executable(quasirandomGenerator quasirandomGenerator.cpp quasirandomGenerator_gold.cpp quasirandomGenerator_kernel.cu)
target_compile_options(quasirandomGenerator PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(quasirandomGenerator PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(quasirandomGenerator PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(quasirandomGenerator PRIVATE

View File

@ -1,14 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(quasirandomGenerator_nvrtc LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
quasirandomGenerator.cpp
quasirandomGenerator_gold.cpp
)
# Add target for quasirandomGenerator_nvrtc
add_executable(quasirandomGenerator_nvrtc ${SRC_FILES})
add_executable(quasirandomGenerator_nvrtc quasirandomGenerator.cpp quasirandomGenerator_gold.cpp)
target_compile_options(quasirandomGenerator_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(quasirandomGenerator_nvrtc PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(quasirandomGenerator_nvrtc PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_link_libraries(quasirandomGenerator_nvrtc PRIVATE

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(recursiveGaussian LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
recursiveGaussian_cuda.cu
recursiveGaussian.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for recursiveGaussian
add_executable(recursiveGaussian ${SRC_FILES})
add_executable(recursiveGaussian recursiveGaussian_cuda.cu recursiveGaussian.cpp)
target_compile_options(recursiveGaussian PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(recursiveGaussian PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(recursiveGaussian PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(recursiveGaussian PUBLIC

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleD3D11 LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for simpleD3D11
add_executable(simpleD3D11 simpleD3D11.cu)
target_compile_options(simpleD3D11 PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleD3D11 PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleD3D11 PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleD3D11Texture LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for simpleD3D11Texture
add_executable(simpleD3D11Texture simpleD3D11Texture.cu)
target_compile_options(simpleD3D11Texture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleD3D11Texture PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleD3D11Texture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleD3D12 LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for simpleD3D12
add_executable(simpleD3D12 simpleD3D12.cu)
target_compile_options(simpleD3D12 PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleD3D12 PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleD3D12 PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleGL LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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,14 +18,15 @@ find_package(OpenGL)
find_package(GLUT)
# Source file
set(SRC_FILES
simpleGL.cu
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for simpleGL
add_executable(simpleGL ${SRC_FILES})
add_executable(simpleGL simpleGL.cu)
target_compile_options(simpleGL PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleGL PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleGL PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleGL PUBLIC

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleGLES LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for simpleGLES
add_executable(simpleGLES simpleGLES.cu)
target_compile_options(simpleGLES PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleGLES PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleGLES PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleGLES_EGLOutput LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for simpleGLES_EGLOutput
add_executable(simpleGLES_EGLOutput simpleGLES_EGLOutput.cu)
target_compile_options(simpleGLES_EGLOutput PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleGLES_EGLOutput PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleGLES_EGLOutput PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleGLES_screen LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
# Add target for simpleGLES_screen
add_executable(simpleGLES_screen simpleGLES_screen.cu)
target_compile_options(simpleGLES_screen PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleGLES_screen PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleGLES_screen PROPERTIES CUDA_SEPARABLE_COMPILATION ON)

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleVulkan LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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(Vulkan)
find_package(OpenGL)
# Source file
set(SRC_FILES
main.cpp
SineWaveSimulation.cu
VulkanBaseApp.cpp
)
if(${Vulkan_FOUND})
if(${OPENGL_FOUND})
# Add target for simpleVulkan
add_executable(simpleVulkan ${SRC_FILES})
add_executable(simpleVulkan main.cpp SineWaveSimulation.cu VulkanBaseApp.cpp)
target_compile_options(simpleVulkan PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleVulkan PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleVulkan PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleVulkan PUBLIC

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(simpleVulkanMMAP LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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,17 +18,15 @@ find_package(Vulkan)
find_package(OpenGL)
# Source file
set(SRC_FILES
../../../Common/helper_multiprocess.cpp
MonteCarloPi.cu
VulkanBaseApp.cpp
main.cpp
)
if(${Vulkan_FOUND})
if(${OPENGL_FOUND})
# Add target for simpleVulkanMMAP
add_executable(simpleVulkanMMAP ${SRC_FILES})
add_executable(simpleVulkanMMAP ../../../Common/helper_multiprocess.cpp MonteCarloPi.cu VulkanBaseApp.cpp main.cpp)
target_compile_options(simpleVulkanMMAP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleVulkanMMAP PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleVulkanMMAP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleVulkanMMAP PUBLIC

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(smokeParticles LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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,21 +18,15 @@ find_package(OpenGL)
find_package(GLUT)
# Source file
set(SRC_FILES
GLSLProgram.cpp
ParticleSystem.cpp
ParticleSystem_cuda.cu
SmokeRenderer.cpp
SmokeShaders.cpp
framebufferObject.cpp
particleDemo.cpp
renderbuffer.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for smokeParticles
add_executable(smokeParticles ${SRC_FILES})
add_executable(smokeParticles GLSLProgram.cpp ParticleSystem.cpp ParticleSystem_cuda.cu SmokeRenderer.cpp SmokeShaders.cpp framebufferObject.cpp particleDemo.cpp renderbuffer.cpp)
target_compile_options(smokeParticles PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(smokeParticles PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(smokeParticles PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(smokeParticles PUBLIC

View File

@ -1,13 +1,27 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(stereoDisparity LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
stereoDisparity.cu
)
# Add target for stereoDisparity
add_executable(stereoDisparity ${SRC_FILES})
add_executable(stereoDisparity stereoDisparity.cu)
target_compile_options(stereoDisparity PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(stereoDisparity PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(stereoDisparity PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
add_custom_command(TARGET stereoDisparity POST_BUILD

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(volumeFiltering LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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,17 +18,15 @@ find_package(OpenGL)
find_package(GLUT)
# Source file
set(SRC_FILES
volume.cpp
volumeFilter_kernel.cu
volumeFiltering.cpp
volumeRender_kernel.cu
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for volumeFiltering
add_executable(volumeFiltering ${SRC_FILES})
add_executable(volumeFiltering volume.cpp volumeFilter_kernel.cu volumeFiltering.cpp volumeRender_kernel.cu)
target_compile_options(volumeFiltering PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(volumeFiltering PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(volumeFiltering PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(volumeFiltering PUBLIC

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(volumeRender LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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
volumeRender_kernel.cu
volumeRender.cpp
)
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for volumeRender
add_executable(volumeRender ${SRC_FILES})
add_executable(volumeRender volumeRender_kernel.cu volumeRender.cpp)
target_compile_options(volumeRender PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(volumeRender PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(volumeRender PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(volumeRender PUBLIC

View File

@ -1,3 +1,16 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
project(vulkanImageCUDA LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_CUDA_ARCHITECTURES 50 52 60 61 70 75 80 86 89 90)
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,14 +18,15 @@ find_package(Vulkan)
find_package(OpenGL)
# Source file
set(SRC_FILES
vulkanImageCUDA.cu
)
if(${Vulkan_FOUND})
if(${OPENGL_FOUND})
# Add target for vulkanImageCUDA
add_executable(vulkanImageCUDA ${SRC_FILES})
add_executable(vulkanImageCUDA vulkanImageCUDA.cu)
target_compile_options(vulkanImageCUDA PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(vulkanImageCUDA PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(vulkanImageCUDA PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(vulkanImageCUDA PUBLIC