CMakeLists.txt

cmake_minimum_required(VERSION 3.30)

project(
    TNL
    VERSION 0.2.0
    # TODO: SPDX_LICENSE added in CMake 4.3
    #SPDX_LICENSE MIT
    DESCRIPTION "Template Numerical Library"
    HOMEPAGE_URL https://tnl-project.org/
    LANGUAGES C CXX
)

# declare all custom build options
option(TNL_USE_CUDA "Build with CUDA support" ON)
option(TNL_USE_HIP "Build with HIP support" ON)
option(TNL_USE_OPENMP "Build with OpenMP support" ON)
option(TNL_USE_MPI "Build with MPI support" ON)
option(TNL_USE_GMP "Build with GMP support" OFF)
option(TNL_USE_SYSTEM_GTEST "Use GTest installed in the local system and do not download the latest version" OFF)
option(TNL_USE_CI_FLAGS "Add additional compiler flags like -Werror that are enforced in CI builds" OFF)
option(
    TNL_USE_MARCH_NATIVE_FLAG
    "Add -march=native and -mtune=native to the list of compiler flags for the Release configuration"
    OFF
)
option(TNL_BUILD_COVERAGE "Enable code coverage reports from unit tests" OFF)
option(TNL_OFFLINE_BUILD "Offline build (i.e. without downloading libraries such as GTest)" OFF)
option(TNL_DOXYGEN_USE_CLANG "Instruct Doxygen to use Clang-assisted parsing" OFF)
option(
    TNL_EXPORT_INTERFACE_TARGETS
    "Instruct CMake to generate rules to export the TNL interface target"
    ${PROJECT_IS_TOP_LEVEL}
)

# make cache variables for install destinations
include(GNUInstallDirs)

# install paths relative to the cmake's prefix
set(TNL_TARGET_DATA_DIRECTORY "${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}")
set(TNL_TARGET_CMAKE_DIRECTORY "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")

# configure build paths
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)

# set cmake's include path so that we can include modules from
# the cmake directory in the TNL repository
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")

# set C++ standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# make cache variable so it can be used in downstream projects
set(TNL_INCLUDE_DIRS "${CMAKE_CURRENT_LIST_DIR}/src" CACHE INTERNAL "Directories where TNL headers are located")

# create the exported targets
add_library(TNL INTERFACE)
# aliases to match exported targets
add_library(TNL::TNL ALIAS TNL)

# add the include directory to the interface
if(PROJECT_IS_TOP_LEVEL)
    set(TNL_SYSTEM "")
else()
    set(TNL_SYSTEM SYSTEM)
endif()
target_include_directories(
    TNL
    ${TNL_SYSTEM}
    INTERFACE $<BUILD_INTERFACE:${TNL_INCLUDE_DIRS}> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
# add compiler features to the interface
target_compile_features(TNL INTERFACE cxx_std_17)

# set C++ compiler flags
include(cmake/cxx_flags.cmake)

# configure the project for testing with CTest/CDash
include(testing)

####
# Find the std::filesystem library
#
find_package(Filesystem REQUIRED COMPONENTS Final)
target_link_libraries(TNL INTERFACE std::filesystem)

####
# Find the threads library
#
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
set(THREADS_PREFER_PTHREAD_FLAG TRUE)
find_package(Threads REQUIRED)
target_link_libraries(TNL INTERFACE Threads::Threads)

####
# Check for OpenMP
#
find_package(OpenMP COMPONENTS CXX)
if(OPENMP_FOUND AND TNL_USE_OPENMP)
    # NOTE: OpenMP + CUDA/HIP = segfault in matrix tests (the host code built by nvcc is also not optimal)
    target_compile_definitions(TNL INTERFACE $<$<COMPILE_LANGUAGE:CXX>: HAVE_OPENMP>)
    target_include_directories(TNL SYSTEM INTERFACE $<BUILD_INTERFACE:$<$<COMPILE_LANGUAGE:CXX>: ${OpenMP_CXX_INCLUDE_DIRS}>>)
    target_compile_options(TNL INTERFACE $<$<COMPILE_LANGUAGE:CXX>: ${OpenMP_CXX_FLAGS}>)
    target_link_libraries(TNL INTERFACE $<$<LINK_LANGUAGE:CXX>: ${OpenMP_CXX_LIBRARIES}>)
    set(TNL_BUILD_OPENMP TRUE)
endif()

####
# Check for MPI
#
find_package(MPI COMPONENTS CXX)
if(MPI_CXX_FOUND AND TNL_USE_MPI)
    set(TNL_BUILD_MPI TRUE)
    # NOTE: MPI will be added selectively to the targets that need/can utilize it
    # see https://cliutils.gitlab.io/modern-cmake/chapters/packages/MPI.html
endif()

#####
# Check for CUDA
#
if(TNL_USE_CUDA)
    # set our default CUDA GPU architecture before CMake
    include(cuda_default_architecture)

    include(CheckLanguage)
    # check_language(CUDA) or enable_language(CUDA) does not work with CMAKE_EXECUTABLE_SUFFIX
    # see https://gitlab.kitware.com/cmake/cmake/-/issues/23887
    set(executable_suffix_backup "${CMAKE_EXECUTABLE_SUFFIX}")
    set(CMAKE_EXECUTABLE_SUFFIX "")
    check_language(CUDA)
    if(CMAKE_CUDA_COMPILER)
        enable_language(CUDA)
        set(TNL_BUILD_CUDA TRUE)

        # set C++ standard
        set(CMAKE_CUDA_STANDARD 17)
        set(CMAKE_CUDA_STANDARD_REQUIRED ON)
        set(CMAKE_CUDA_EXTENSIONS OFF)

        # enable separable compilation
        set(CMAKE_CUDA_SEPARABLE_COMPILATION ON)

        # set CUDA compiler flags
        include(cmake/cuda_flags.cmake)
    endif()
    set(CMAKE_EXECUTABLE_SUFFIX "${executable_suffix_backup}")
    unset(executable_suffix_backup)
endif()

if(TNL_BUILD_CUDA)
    # Add the CUB include directory to the interface target. CCCL is required
    # by CUDA itself and it is header-only, it does not matter that CCCL is
    # mostly unused in TNL. Note that the CCCL::CUB target cannot be filtered
    # with the $<COMPILE_LANGUAGE:CUDA> generator expression. The CCCL::CUB
    # target also uses the include directory as non-system directory and
    # using target_include_directories() does not allow to add the SYSTEM flag.
    find_package(CCCL REQUIRED COMPONENTS CUB)
    target_include_directories(TNL SYSTEM INTERFACE $<BUILD_INTERFACE:$<$<COMPILE_LANGUAGE:CUDA>: ${_CUB_INCLUDE_DIR}>>)
endif()

#####
# Check for HIP
#
if(TNL_USE_HIP)
    include(CheckLanguage)
    # check_language(CUDA) or enable_language(CUDA) does not work with CMAKE_EXECUTABLE_SUFFIX
    # see https://gitlab.kitware.com/cmake/cmake/-/issues/23887
    set(executable_suffix_backup "${CMAKE_EXECUTABLE_SUFFIX}")
    set(CMAKE_EXECUTABLE_SUFFIX "")
    check_language(HIP)
    if(CMAKE_HIP_COMPILER)
        enable_language(HIP)
        set(TNL_BUILD_HIP TRUE)

        # set C++ standard
        set(CMAKE_HIP_STANDARD 17)
        set(CMAKE_HIP_STANDARD_REQUIRED ON)
        set(CMAKE_HIP_EXTENSIONS OFF)

        # set HIP compiler flags
        include(cmake/hip_flags.cmake)
    endif()
    set(CMAKE_EXECUTABLE_SUFFIX "${executable_suffix_backup}")
    unset(executable_suffix_backup)
endif()

# Both CUDA and HIP compilers can be detected at the same time, but we cannot (do not want to)
# build both at the same time. Some CMake targets for CUDA and HIP have the same name and conflict.
if(TNL_BUILD_CUDA AND TNL_BUILD_HIP)
    message(WARNING "CUDA is enabled, disabling HIP.")
    set(TNL_BUILD_HIP FALSE)
endif()

# skip building host-only targets in CUDA-enabled CI jobs
if(DEFINED ENV{GITLAB_CI} AND (TNL_BUILD_CUDA OR TNL_BUILD_HIP))
    set(TNL_BUILD_CPP_TARGETS FALSE)
else()
    set(TNL_BUILD_CPP_TARGETS TRUE)
endif()

# Optionally bundled dependencies (system packages are preferred)
# Reference: https://cmake.org/cmake/help/latest/guide/using-dependencies/index.html#fetchcontent-and-find-package-integration
include(FetchTinyXML2)

####
# Test for GMP
#
if(TNL_USE_GMP)
    if(GMP_INCLUDES AND GMP_LIBRARIES)
        set(GMP_FIND_QUIETLY TRUE)
    endif(GMP_INCLUDES AND GMP_LIBRARIES)

    find_path(GMP_INCLUDES NAMES gmp.h PATHS $ENV{GMPDIR} ${INCLUDE_INSTALL_DIR})

    find_library(GMP_LIBRARIES gmp PATHS $ENV{GMPDIR} ${LIB_INSTALL_DIR})

    include(FindPackageHandleStandardArgs)
    find_package_handle_standard_args(GMP DEFAULT_MSG GMP_INCLUDES GMP_LIBRARIES)
    if(GMP_INCLUDES STREQUAL "GMP_INCLUDES-NOTFOUND" OR GMP_LIBRARIES STREQUAL "GMP_LIBRARIES-NOTFOUND")
        message("GMP was not found. Some tests for higher precision arithmetics will not be passed.")
    else()
        set(HAVE_GMP)
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${GMP_INCLUDES} -DHAVE_GMP")
        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GMP_LIBRARIES}")
        mark_as_advanced(GMP_INCLUDES GMP_LIBRARIES)
    endif()
endif()

if(TNL_EXPORT_INTERFACE_TARGETS)
    # export the interface targets
    install(TARGETS TNL EXPORT TNLTargets)
    # install a CMake file for the interface target
    install(EXPORT TNLTargets NAMESPACE TNL:: DESTINATION ${TNL_TARGET_CMAKE_DIRECTORY} COMPONENT headers)
    # install the TNLConfig.cmake file
    include(CMakePackageConfigHelpers)
    configure_package_config_file(
        "cmake/${PROJECT_NAME}Config.cmake.in"
        "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
        INSTALL_DESTINATION ${TNL_TARGET_CMAKE_DIRECTORY}
    )
    install(
        FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
        DESTINATION ${TNL_TARGET_CMAKE_DIRECTORY}
        COMPONENT headers
    )
    # install necessary modules
    install(FILES cmake/FindFilesystem.cmake DESTINATION ${TNL_TARGET_CMAKE_DIRECTORY}/Modules COMPONENT headers)
endif()

# Settings for debug build
# Note that in cmake 3.10 the FindOpenMP and FindMPI modules are broken - they do not work when
# CMAKE_EXECUTABLE_SUFFIX is not empty, see https://www.mail-archive.com/cmake@cmake.org/msg56886.html
# and https://gitlab.kitware.com/cmake/cmake/-/issues/23874
# Hence, we set this after all find_package checks.
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    set(CMAKE_EXECUTABLE_SUFFIX "-dbg${CMAKE_EXECUTABLE_SUFFIX}") # suffix for executables
    set(CMAKE_DEBUG_POSTFIX "-dbg") # suffix for libraries
endif()

# Add all subdirectories
add_subdirectory(src)
add_subdirectory(Documentation)

# export compile_commands.json so it can be used by Clang tools
# https://clang.llvm.org/docs/JSONCompilationDatabase.html
set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE INTERNAL "")

if(PROJECT_IS_TOP_LEVEL)
    # Print custom build options
    message("-- Build options:")
    message("   TNL_USE_CUDA = ${TNL_USE_CUDA}")
    message("   CMAKE_CUDA_ARCHITECTURES = ${CMAKE_CUDA_ARCHITECTURES}")
    message("   TNL_USE_HIP = ${TNL_USE_HIP}")
    message("   CMAKE_HIP_ARCHITECTURES = ${CMAKE_HIP_ARCHITECTURES}")
    message("   TNL_USE_OPENMP = ${TNL_USE_OPENMP}")
    message("   TNL_USE_MPI = ${TNL_USE_MPI}")
    message("   TNL_USE_GMP = ${TNL_USE_GMP}")
    message("   TNL_USE_SYSTEM_GTEST = ${TNL_USE_SYSTEM_GTEST}")
    message("   TNL_BUILD_COVERAGE = ${TNL_BUILD_COVERAGE}")
    message("   TNL_OFFLINE_BUILD = ${TNL_OFFLINE_BUILD}")
    # Print used compilers
    message("-- Compilers:")
    message("   CMAKE_C_COMPILER = ${CMAKE_C_COMPILER} (${CMAKE_C_COMPILER_ID})")
    message("   CMAKE_CXX_COMPILER = ${CMAKE_CXX_COMPILER} (${CMAKE_CXX_COMPILER_ID})")
    if(TNL_BUILD_CUDA)
        message("   CMAKE_CUDA_COMPILER = ${CMAKE_CUDA_COMPILER} (${CMAKE_CUDA_COMPILER_ID})")
        if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
            message("   CMAKE_CUDA_HOST_COMPILER = ${CMAKE_CUDA_HOST_COMPILER} (${CMAKE_CUDA_HOST_COMPILER_ID})")
        endif()
    endif()
    if(TNL_BUILD_HIP)
        message("   CMAKE_HIP_COMPILER = ${CMAKE_HIP_COMPILER} (${CMAKE_HIP_COMPILER_ID})")
    endif()
    # Print compiler options
    message("-- Compiler options:")
    message("   CMAKE_C_FLAGS = ${CMAKE_C_FLAGS}")
    message("   CMAKE_C_FLAGS_DEBUG = ${CMAKE_C_FLAGS_DEBUG}")
    message("   CMAKE_C_FLAGS_RELEASE = ${CMAKE_C_FLAGS_RELEASE}")
    message("   CMAKE_CXX_FLAGS = ${CMAKE_CXX_FLAGS}")
    message("   CMAKE_CXX_FLAGS_DEBUG = ${CMAKE_CXX_FLAGS_DEBUG}")
    message("   CMAKE_CXX_FLAGS_RELEASE = ${CMAKE_CXX_FLAGS_RELEASE}")
    if(TNL_BUILD_CUDA)
        message("   CMAKE_CUDA_FLAGS = ${CMAKE_CUDA_FLAGS}")
        message("   CMAKE_CUDA_FLAGS_DEBUG = ${CMAKE_CUDA_FLAGS_DEBUG}")
        message("   CMAKE_CUDA_FLAGS_RELEASE = ${CMAKE_CUDA_FLAGS_RELEASE}")
    endif()
    if(TNL_BUILD_HIP)
        message("   CMAKE_HIP_FLAGS = ${CMAKE_HIP_FLAGS}")
        message("   CMAKE_HIP_FLAGS_DEBUG = ${CMAKE_HIP_FLAGS_DEBUG}")
        message("   CMAKE_HIP_FLAGS_RELEASE = ${CMAKE_HIP_FLAGS_RELEASE}")
    endif()
    message("   CMAKE_SHARED_LIBRARY_LINK_C_FLAGS = ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS}")
    message("   CMAKE_SHARED_LIBRARY_LINK_C_FLAGS_DEBUG = ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS_DEBUG}")
    message("   CMAKE_SHARED_LIBRARY_LINK_C_FLAGS_RELEASE = ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS_RELEASE}")
    message("   CMAKE_EXE_LINKER_FLAGS = ${CMAKE_EXE_LINKER_FLAGS}")
    message("   CMAKE_EXE_LINKER_FLAGS_DEBUG = ${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
    message("   CMAKE_EXE_LINKER_FLAGS_RELEASE = ${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
    message("   CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
    message("   CMAKE_SHARED_LINKER_FLAGS_DEBUG = ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
    message("   CMAKE_SHARED_LINKER_FLAGS_RELEASE = ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")

    if(TNL_BUILD_MPI)
        message("   MPI_CXX_COMPILE_OPTIONS = ${MPI_CXX_COMPILE_OPTIONS}")
        message("   MPI_CXX_COMPILE_DEFINITIONS = ${MPI_CXX_COMPILE_DEFINITIONS}")
        message("   MPI_CXX_INCLUDE_DIRS = ${MPI_CXX_INCLUDE_DIRS}")
        message("   MPI_CXX_LINK_FLAGS = ${MPI_CXX_LINK_FLAGS}")
        message("   MPI_CXX_LIBRARIES = ${MPI_CXX_LIBRARIES}")
    endif()
endif()