FLIPonCUDA/CMakeLists.txt at main · keptsecret/FLIPonCUDA · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
cmake_minimum_required(VERSION 3.17)
project(FOC LANGUAGES CXX CUDA)

include(CheckLanguage)
check_language(CUDA)

if (MSVC)
    list(APPEND FOC_DEFINITIONS "FOC_IS_MSVC" "_CRT_SECURE_NO_WARNINGS")
    list(APPEND FOC_DEFINITIONS "FOC_IS_MSVC" "_ENABLE_EXTENDED_ALIGNED_STORAGE")
endif ()

option(CUDA_ENABLED "Enable GPU acceleration" ON)
if (CUDA_ENABLED)
    list(APPEND FOC_DEFINITIONS "FOC_BUILD_GPU")
endif ()

set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

###########################################################################
# CUDA

find_package(CUDAToolkit REQUIRED)

include_directories(${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})

add_library(foc_warnings INTERFACE)
target_compile_options(
        foc_warnings
        INTERFACE
        #"$<$<COMPILE_LANGUAGE:CUDA>:SHELL:-Xptxas --warn-on-double-precision-use>"
        "$<$<COMPILE_LANGUAGE:CUDA>:SHELL:-Xcudafe --diag_suppress=partial_override>"
        "$<$<COMPILE_LANGUAGE:CUDA>:SHELL:-Xcudafe --diag_suppress=virtual_function_decl_hidden>"
        "$<$<COMPILE_LANGUAGE:CUDA>:SHELL:-Xcudafe --diag_suppress=integer_sign_change>"
        "$<$<COMPILE_LANGUAGE:CUDA>:SHELL:-Xcudafe --diag_suppress=declared_but_not_referenced>"
        # WAR invalid warnings about this with "if constexpr"
        "$<$<COMPILE_LANGUAGE:CUDA>:SHELL:-Xcudafe --diag_suppress=implicit_return_from_non_void_function>"
)

string(APPEND CMAKE_CUDA_FLAGS " -Xnvlink -suppress-stack-size-warning -Wno-deprecated-gpu-targets")

add_library(cuda_build_configuration INTERFACE)
target_compile_options(
        cuda_build_configuration
        INTERFACE
        "$<$<COMPILE_LANGUAGE:CUDA>:--std=c++17;--use_fast_math;--expt-relaxed-constexpr;--extended-lambda;--forward-unknown-to-host-compiler>"
        "$<$<COMPILE_LANGUAGE:CUDA>:$<IF:$<AND:$<CONFIG:Debug>,$<NOT:$<BOOL:$<TARGET_PROPERTY:CUDA_PTX_COMPILATION>>>>,-G;-g,-lineinfo;-maxrregcount;128>>"
        "$<$<COMPILE_LANGUAGE:CXX>:/bigobj>"
        "$<$<CONFIG:DEBUG>:-G>"
)

###########################################################################

set(FOC_HEADERS
        src/foc.h
        src/vecmath.h
        src/array3d.h
        src/markerparticle.h
        src/macgrid.h
        src/cellmaterialgrid.h
        src/pressuresolver.h
        src/particleadvector.h
        src/fluidsim.h
        )

set(FOC_SOURCE
        src/macgrid.cpp
        src/cellmaterialgrid.cpp
        src/pressuresolver.cpp
        src/particleadvector.cpp
        src/fluidsim.cpp
        )

set(FOC_UTIL_HEADERS
        src/util/array3dview.h
        src/util/scalarfield.h
        src/util/trianglemesh.h
        src/util/particlemesher.h
        src/util/polygonizer.h
        )

set(FOC_UTIL_SOURCE
        src/util/scalarfield.cpp
        src/util/trianglemesh.cpp
        src/util/particlemesher.cpp
        src/util/polygonizer.cpp
        )

if (CUDA_ENABLED)
    set(FOC_GPU_HEADERS
            src/gpu/util.h
            src/gpu/kernels.h
            )

    set(FOC_GPU_SOURCE
            src/gpu/tricubicinterpolate.cu
            src/gpu/scalarfieldgpu.cu
            )

    set_source_files_properties(
            ${FOC_HEADERS}
            ${FOC_SOURCE}
            ${FOC_UTIL_HEADERS}
            ${FOC_UTIL_SOURCE}

            ${FOC_GPU_HEADERS}
            ${FOC_GPU_SOURCE}

            PROPERTIES LANGUAGE CUDA
    )
endif ()

add_library(flipfluidsim_lib STATIC
        ${FOC_HEADERS}
        ${FOC_SOURCE}
        ${FOC_UTIL_HEADERS}
        ${FOC_UTIL_SOURCE}
        ${FOC_GPU_HEADERS}
        ${FOC_GPU_SOURCE}
        )

target_compile_definitions(flipfluidsim_lib PRIVATE ${FOC_DEFINITIONS})

set_property(TARGET flipfluidsim_lib PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
set_property(TARGET flipfluidsim_lib PROPERTY CUDA_ARCHITECTURES all-major)

target_include_directories(flipfluidsim_lib PUBLIC
        src
        )

target_compile_options(flipfluidsim_lib PUBLIC ${FOC_CXX_FLAGS})
target_link_libraries(flipfluidsim_lib PRIVATE foc_warnings $<$<BOOL:CUDA_ENABLED>:cuda_build_configuration>)

if (WIN32)
    # Avoid a name clash when building on Visual Studio
    set_target_properties(flipfluidsim_lib PROPERTIES OUTPUT_NAME libfoc)
endif ()

set(ALL_FOC_LIBS
        flipfluidsim_lib
        )

if (CUDA_ENABLED)
    set_target_properties(flipfluidsim_lib PROPERTIES
            CUDA_SEPARABLE_COMPILATION ON)
endif ()

add_executable(flipfluidsim_exe src/foc.cpp)

target_compile_definitions(flipfluidsim_exe PRIVATE ${FOC_DEFINITIONS})
target_compile_options(flipfluidsim_exe PRIVATE ${FOC_CXX_FLAGS})
target_include_directories(flipfluidsim_exe PRIVATE src)
target_link_libraries(flipfluidsim_exe ${ALL_FOC_LIBS} foc_warnings)

set_target_properties(flipfluidsim_exe PROPERTIES OUTPUT_NAME foc)

install(TARGETS
        flipfluidsim_exe
        DESTINATION
        bin
        )

install(TARGETS
        flipfluidsim_lib
        DESTINATION
        lib
        )