OilfieldToolsNet/LBPM
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into ScaLBL

Browse Source
This commit is contained in:
Mark Berrill 2018-02-06 08:51:58 -05:00
commit 396bb07b26
3 changed files with 469 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
CMakeLists.txt
View File

@ -1,9 +1,5 @@
# Set some CMake properties # Set some CMake properties
CMAKE_MINIMUM_REQUIRED(VERSION 2.6) CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
CMAKE_POLICY(SET CMP0014 OLD)
IF ( ${CMAKE_MAJOR_VERSION} EQUAL 3 )
CMAKE_POLICY(SET CMP0026 OLD)
ENDIF()
MESSAGE("====================") MESSAGE("====================")
@ -11,32 +7,44 @@ MESSAGE("Configuring LBPM-WIA")
MESSAGE("====================") MESSAGE("====================")
# Set the project name
SET( PROJ LBPM ) # Set the project name for CMake
SET( LBPM_LIB lbpm-wia ) # Set the final library name
SET( LBPM_INC ) # Set an optional subfolder for includes (e.g. include/name/...)
SET( TEST_MAX_PROCS 16 )
# Initialize the project
PROJECT( ${PROJ} )
# Prevent users from building in place # Prevent users from building in place
IF ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}" ) IF ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}" )
MESSAGE( FATAL_ERROR "Building code in place is a bad idea" ) MESSAGE( FATAL_ERROR "Building code in place is a bad idea" )
ENDIF() ENDIF()
# Set the project name # Set the default C++ standard
PROJECT( LBPM-WIA )
IF ( NOT CXX_STD ) IF ( NOT CXX_STD )
SET( CXX_STD 11 ) SET( CXX_STD 11 )
ENDIF() ENDIF()
# Set some common paths # Set source/install paths
SET( LBPM_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ) SET( ${PROJ}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" )
SET( LBPM_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR} ) SET( ${PROJ}_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}" )
IF( PREFIX ) IF( ${PROJ}_INSTALL_DIR )
SET( LBPM_INSTALL_DIR ${PREFIX} ) SET( ${PROJ}_INSTALL_DIR "${${PROJ}_INSTALL_DIR}" )
ELSEIF( NOT LBPM_INSTALL_DIR ) ELSEIF( PREFIX )
SET( LBPM_INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR} ) SET( ${PROJ}_INSTALL_DIR "${PREFIX}" )
ELSEIF( NOT ${PROJ}_INSTALL_DIR )
SET( ${PROJ}_INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}" )
ENDIF() ENDIF()
SET( CMAKE_MODULE_PATH ${LBPM_SOURCE_DIR} ${LBPM_SOURCE_DIR}/cmake ) INCLUDE_DIRECTORIES( "${${PROJ}_INSTALL_DIR}/include" )
SET( CMAKE_MODULE_PATH ${${PROJ}_SOURCE_DIR} ${${PROJ}_SOURCE_DIR}/cmake )
# Include macros # Include macros
SET( PROJ LBPM )
INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/macros.cmake" ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/macros.cmake" )
INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/libraries.cmake" ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/libraries.cmake" )
INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/LBPM-macros.cmake" ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/LBPM-macros.cmake" )
@ -56,15 +64,6 @@ ENABLE_TESTING()
INCLUDE( CTest ) INCLUDE( CTest )
# Create custom targets for build-test, check, and distclean
ADD_CUSTOM_TARGET( doc )
ADD_CUSTOM_TARGET( latex_docs )
ADD_CUSTOM_TARGET( build-test )
ADD_CUSTOM_TARGET( build-examples )
ADD_CUSTOM_TARGET( check COMMAND make test )
ADD_DISTCLEAN( analysis null_timer tests liblbpm-wia.* cpu gpu example common visit IO threadpool )
# Check the compile mode and compile flags # Check the compile mode and compile flags
IF ( NOT ONLY_BUILD_DOCS ) IF ( NOT ONLY_BUILD_DOCS )
CONFIGURE_SYSTEM() CONFIGURE_SYSTEM()
@ -72,25 +71,27 @@ ENDIF()
# Add some directories to include # Add some directories to include
INCLUDE_DIRECTORIES( "${LBPM_INSTALL_DIR}/include" ) INCLUDE_DIRECTORIES( "${${PROJ}_INSTALL_DIR}/include" )
# Set doxygen info # Create the target for documentation
ADD_CUSTOM_TARGET( doc )
ADD_CUSTOM_TARGET( latex_docs )
CHECK_ENABLE_FLAG( USE_DOXYGEN 1 ) CHECK_ENABLE_FLAG( USE_DOXYGEN 1 )
CHECK_ENABLE_FLAG( USE_LATEX 1 ) CHECK_ENABLE_FLAG( USE_LATEX 1 )
FILE( MAKE_DIRECTORY "${LBPM_INSTALL_DIR}/doc" ) FILE( MAKE_DIRECTORY "${${PROJ}_INSTALL_DIR}/doc" )
IF ( USE_DOXYGEN ) IF ( USE_DOXYGEN )
SET( DOXYFILE_IN ${LBPM_SOURCE_DIR}/doxygen/Doxyfile.in) SET( DOXYFILE_LATEX YES )
SET( DOXY_HEADER_FILE ${LBPM_SOURCE_DIR}/doxygen/html/header.html ) SET( DOXYFILE_IN "${${PROJ}_SOURCE_DIR}/doxygen/Doxyfile.in" )
SET( DOXY_FOOTER_FILE ${LBPM_SOURCE_DIR}/doxygen/html/footer.html ) SET( DOXY_HEADER_FILE "${${PROJ}_SOURCE_DIR}/doxygen/html/header.html" )
SET( DOXYFILE_OUTPUT_DIR ${LBPM_BUILD_DIR}/doc/ ) SET( DOXY_FOOTER_FILE "${${PROJ}_SOURCE_DIR}/doxygen/html/footer.html" )
SET( DOXYFILE_SRC_HTML_DIR ${LBPM_SOURCE_DIR}/doxygen/html ) SET( DOXYFILE_OUTPUT_DIR "${${PROJ}_INSTALL_DIR}/doc" )
SET( DOXYFILE_SOURCE_DIR ${LBPM_SOURCE_DIR} ) SET( DOXYFILE_SRC_HTML_DIR "${${PROJ}_SOURCE_DIR}/doxygen/html" )
SET( DOXYFILE_SOURCE_DIR "${${PROJ}_SOURCE_DIR}" )
SET( REL_PACKAGE_HTML "" ) SET( REL_PACKAGE_HTML "" )
SET( DOXYGEN_MACROS "" ) SET( DOXYGEN_MACROS "" )
MESSAGE("DOXYGEN_MACROS = ${DOXYGEN_MACROS}") MESSAGE("DOXYGEN_MACROS = ${DOXYGEN_MACROS}")
INCLUDE( ${LBPM_SOURCE_DIR}/cmake/UseDoxygen.cmake ) INCLUDE( "${${PROJ}_SOURCE_DIR}/cmake/UseDoxygen.cmake" )
SET(DOXYFILE_LATEX "YES")
IF ( DOXYGEN_FOUND ) IF ( DOXYGEN_FOUND )
ADD_DEPENDENCIES( doxygen latex_docs ) ADD_DEPENDENCIES( doxygen latex_docs )
ADD_DEPENDENCIES( doc latex_docs doxygen ) ADD_DEPENDENCIES( doc latex_docs doxygen )
@ -100,6 +101,13 @@ IF ( USE_DOXYGEN )
ENDIF() ENDIF()
# Create custom targets for build-test, check, and distclean
ADD_CUSTOM_TARGET( build-test )
ADD_CUSTOM_TARGET( build-examples )
ADD_CUSTOM_TARGET( check COMMAND make test )
ADD_DISTCLEAN( analysis null_timer tests liblbpm-wia.* cpu gpu example common visit IO threadpool )
# Configure external packages # Configure external packages
IF ( NOT ONLY_BUILD_DOCS ) IF ( NOT ONLY_BUILD_DOCS )
CONFIGURE_MPI() # MPI must be before other libraries CONFIGURE_MPI() # MPI must be before other libraries
@ -111,15 +119,12 @@ IF ( NOT ONLY_BUILD_DOCS )
CONFIGURE_TIMER( 0 "${${PROJ}_INSTALL_DIR}/null_timer" ) CONFIGURE_TIMER( 0 "${${PROJ}_INSTALL_DIR}/null_timer" )
CONFIGURE_LINE_COVERAGE() CONFIGURE_LINE_COVERAGE()
INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/SharedPtr.cmake" ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/SharedPtr.cmake" )
CONFIGURE_SHARED_PTR( "${LBPM_INSTALL_DIR}/include" "std" ) CONFIGURE_SHARED_PTR( "${${PROJ}_INSTALL_DIR}/include" "std" )
# Set the external library link list # Set the external library link list
SET( EXTERNAL_LIBS ${EXTERNAL_LIBS} ${TIMER_LIBS} ) SET( EXTERNAL_LIBS ${EXTERNAL_LIBS} ${TIMER_LIBS} )
ENDIF() ENDIF()
# Configure internal libraries (order matters)
SET( LBPM_LIBS lbpm-wia )
# Macro to create 1,2,4 processor tests # Macro to create 1,2,4 processor tests
MACRO( ADD_LBPM_TEST_1_2_4 EXENAME ${ARGN} ) MACRO( ADD_LBPM_TEST_1_2_4 EXENAME ${ARGN} )
@ -131,7 +136,7 @@ ENDMACRO()
# Add the src directories # Add the src directories
IF ( NOT ONLY_BUILD_DOCS ) IF ( NOT ONLY_BUILD_DOCS )
BEGIN_PACKAGE_CONFIG( lbpm-wia ) BEGIN_PACKAGE_CONFIG( lbpm-wia-library )
ADD_PACKAGE_SUBDIRECTORY( common ) ADD_PACKAGE_SUBDIRECTORY( common )
ADD_PACKAGE_SUBDIRECTORY( analysis ) ADD_PACKAGE_SUBDIRECTORY( analysis )
ADD_PACKAGE_SUBDIRECTORY( IO ) ADD_PACKAGE_SUBDIRECTORY( IO )
@ -141,11 +146,12 @@ IF ( NOT ONLY_BUILD_DOCS )
ELSE() ELSE()
ADD_PACKAGE_SUBDIRECTORY( cpu ) ADD_PACKAGE_SUBDIRECTORY( cpu )
ENDIF() ENDIF()
INSTALL_LBPM_TARGET( lbpm-wia ) INSTALL_LBPM_TARGET( lbpm-wia-library )
ADD_SUBDIRECTORY( tests ) ADD_SUBDIRECTORY( tests )
ADD_SUBDIRECTORY( threadpool/test ) ADD_SUBDIRECTORY( threadpool/test )
ADD_SUBDIRECTORY( example ) ADD_SUBDIRECTORY( example )
#ADD_SUBDIRECTORY( workflows ) #ADD_SUBDIRECTORY( workflows )
INSTALL_PROJ_LIB()
ENDIF() ENDIF()

4
cmake/libraries.cmake
View File

@ -276,7 +276,7 @@ MACRO( CONFIGURE_SYSTEM )
ENDIF() ENDIF()
# Remove extra library links # Remove extra library links
# Get the compiler # Get the compiler
IDENTIFY_COMPILER() SET_COMPILER_FLAGS()
CHECK_ENABLE_FLAG( USE_STATIC 0 ) CHECK_ENABLE_FLAG( USE_STATIC 0 )
# Add system dependent flags # Add system dependent flags
MESSAGE("System is: ${CMAKE_SYSTEM_NAME}") MESSAGE("System is: ${CMAKE_SYSTEM_NAME}")
@ -330,8 +330,6 @@ MACRO( CONFIGURE_SYSTEM )
ELSE() ELSE()
MESSAGE( FATAL_ERROR "OS not detected" ) MESSAGE( FATAL_ERROR "OS not detected" )
ENDIF() ENDIF()
# Set the compile flags based on the build
SET_COMPILER_FLAGS()
# Add the static flag if necessary # Add the static flag if necessary
IF ( USE_STATIC ) IF ( USE_STATIC )
SET_STATIC_FLAGS() SET_STATIC_FLAGS()

562
cmake/macros.cmake
View File

@ -3,7 +3,8 @@ INCLUDE(CheckCSourceCompiles)
INCLUDE(CheckCXXCompilerFlag) INCLUDE(CheckCXXCompilerFlag)
INCLUDE(CheckCXXSourceCompiles) INCLUDE(CheckCXXSourceCompiles)
IF ( NOT TEST_FAIL_REGULAR_EXPRESSION ) IF ( NOT TEST_FAIL_REGULAR_EXPRESSION )
SET( TEST_FAIL_REGULAR_EXPRESSION "(FAILED)|(leaked context IDs detected)|(handles are still allocated)" ) # SET( TEST_FAIL_REGULAR_EXPRESSION "(FAILED)|(leaked context IDs detected)|(handles are still allocated)" )
SET( TEST_FAIL_REGULAR_EXPRESSION "FAILED" )
ENDIF() ENDIF()
@ -15,6 +16,9 @@ ENDIF()
IF ( NOT ${PROJ}_INSTALL_DIR ) IF ( NOT ${PROJ}_INSTALL_DIR )
MESSAGE(FATAL_ERROR "${PROJ}_INSTALL_DIR must be set before including macros.cmake") MESSAGE(FATAL_ERROR "${PROJ}_INSTALL_DIR must be set before including macros.cmake")
ENDIF() ENDIF()
IF ( NOT CMAKE_BUILD_TYPE )
MESSAGE(FATAL_ERROR "CMAKE_BUILD_TYPE must be set before including macros.cmake")
ENDIF()
# Add some default targets if they do not exist # Add some default targets if they do not exist
@ -58,6 +62,16 @@ MACRO(ASSERT test comment)
ENDMACRO(ASSERT) ENDMACRO(ASSERT)
# Set the maximum number of processors
IF ( NOT TEST_MAX_PROCS )
INCLUDE(ProcessorCount)
ProcessorCount( TEST_MAX_PROCS )
IF ( ${TEST_MAX_PROCS} EQUAL 0 )
SET( TEST_MAX_PROCS 16 )
ENDIF()
ENDIF()
# Macro to convert a m4 file # Macro to convert a m4 file
# This command converts a file of the format "global_path/file.m4" # This command converts a file of the format "global_path/file.m4"
# and convertes it to file.F. It also requires the path. # and convertes it to file.F. It also requires the path.
@ -97,7 +111,9 @@ ENDMACRO()
# Add a package to the project's library # Add a package to the project's library
MACRO( ADD_${PROJ}_LIBRARY PACKAGE ) MACRO( ADD_${PROJ}_LIBRARY PACKAGE )
SET( CURRENT_LIBRARY ${PACKAGE} )
ADD_SUBDIRECTORY( ${PACKAGE} ) ADD_SUBDIRECTORY( ${PACKAGE} )
SET( CURRENT_LIBRARY )
ENDMACRO() ENDMACRO()
@ -206,37 +222,76 @@ MACRO( INSTALL_${PROJ}_TARGET PACKAGE )
# Find all files in the current directory # Find all files in the current directory
FIND_FILES() FIND_FILES()
# Create the copy target # Create the copy target
SET( COPY_TARGET copy-${PROJ}-include ) STRING(REGEX REPLACE "${${PROJ}_SOURCE_DIR}/" "" COPY_TARGET "copy-${PROJ}-${CMAKE_CURRENT_SOURCE_DIR}-include" )
STRING(REGEX REPLACE "/" "-" COPY_TARGET ${COPY_TARGET} )
IF( NOT TARGET ${COPY_TARGET} ) IF( NOT TARGET ${COPY_TARGET} )
ADD_CUSTOM_TARGET( ${COPY_TARGET} ALL ) ADD_CUSTOM_TARGET( ${COPY_TARGET} ALL )
ADD_DEPENDENCIES( copy-${PROJ}-include ${COPY_TARGET} ) ADD_DEPENDENCIES( copy-${PROJ}-include ${COPY_TARGET} )
ENDIF() ENDIF()
# Copy the header files to the include path # Copy the header files to the include path
FILE( GLOB HFILES RELATIVE "${${PROJ}_SOURCE_DIR}" ${HEADERS} ) IF ( HEADERS )
FOREACH( HFILE ${HFILES} ) FILE( GLOB HFILES RELATIVE "${${PROJ}_SOURCE_DIR}" ${HEADERS} )
SET( SRC_FILE "${${PROJ}_SOURCE_DIR}/${HFILE}" ) FOREACH( HFILE ${HFILES} )
SET( DST_FILE "${${PROJ}_INSTALL_DIR}/include/${HFILE}" ) SET( SRC_FILE "${${PROJ}_SOURCE_DIR}/${HFILE}" )
# Only copy the headers if the exisit in the project source directory SET( DST_FILE "${${PROJ}_INSTALL_DIR}/include/${${PROJ}_INC}/${HFILE}" )
IF ( EXISTS "${SRC_FILE}" ) # Only copy the headers if the exisit in the project source directory
ADD_CUSTOM_COMMAND(TARGET ${COPY_TARGET} IF ( EXISTS "${SRC_FILE}" )
PRE_BUILD ADD_CUSTOM_COMMAND(TARGET ${COPY_TARGET}
COMMAND ${CMAKE_COMMAND} -E copy_if_different "${SRC_FILE}" "${DST_FILE}" PRE_BUILD
DEPENDS "${SRC_FILE}" COMMAND ${CMAKE_COMMAND} -E copy_if_different "${SRC_FILE}" "${DST_FILE}"
) DEPENDS "${SRC_FILE}"
ENDIF() )
ENDFOREACH() ENDIF()
ENDFOREACH()
ENDIF()
# Add the library and install the package # Add the library and install the package
IF ( NOT ONLY_BUILD_DOCS AND ( SOURCES OR CUDASOURCES ) ) IF ( NOT ONLY_BUILD_DOCS AND ( SOURCES OR CUDASOURCES ) )
IF( USE_CUDA ) # Set RPATH variables
CUDA_COMPILE( CUBINS ${CUDASOURCES} ) IF ( NOT CMAKE_RPATH_VARIABLES_SET )
SET(CMAKE_RPATH_VARIABLES_SET ON)
SET(CMAKE_SKIP_BUILD_RPATH FALSE)
SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
SET(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_RPATH} "${CMAKE_INSTALL_PREFIX}/lib")
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
SET(MACOSX_RPATH 0)
LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
ENDIF() ENDIF()
ADD_LIBRARY( ${PACKAGE} ${LIB_TYPE} ${SOURCES} ${CUBINS} ) # Add the library to the project libs list
TARGET_LINK_LIBRARIES( ${PACKAGE} ${SYSTEM_LDFLAGS} ) SET( ${PROJ}_LIBS ${${PROJ}_LIBS} ${PACKAGE} CACHE INTERNAL "")
LIST( REMOVE_DUPLICATES ${PROJ}_LIBS )
SET( ${PROJ}_LIBS ${${PROJ}_LIBS} CACHE INTERNAL "")
# Create the library
IF ( ${PROJ}_LIB )
# We are using a single project library
ADD_LIBRARY( ${PACKAGE} OBJECT ${SOURCES} ${CUDASOURCES} )
IF( USE_CUDA )
SET( ${PROJ}_CUDA_SOURCES ${${PROJ}_CUDA_SOURCES} ${CUDASOURCES} CACHE INTERNAL "")
SET( tmp ${${PROJ}_CUDA_SOURCES} )
IF ( tmp )
LIST( REMOVE_DUPLICATES tmp )
ENDIF()
SET( ${PROJ}_CUDA_SOURCES ${tmp} CACHE INTERNAL "")
ENDIF()
ELSE()
# We are creating individual libraries
IF( USE_CUDA )
CUDA_COMPILE( CUBINS ${CUDASOURCES} )
ENDIF()
ADD_LIBRARY( ${PACKAGE} ${LIB_TYPE} ${SOURCES} ${CUBINS} )
TARGET_LINK_EXTERNAL_LIBRARIES( ${PACKAGE} )
ENDIF()
# Add coverage flags to target
IF ( NOT DISABLE_TARGET_COVERAGE )
TARGET_COMPILE_DEFINITIONS( ${PACKAGE} PUBLIC ${COVERAGE_FLAGS} )
ENDIF()
# Add target dependencies
IF ( TARGET write_repo_version ) IF ( TARGET write_repo_version )
ADD_DEPENDENCIES( ${PACKAGE} write_repo_version ) ADD_DEPENDENCIES( ${PACKAGE} write_repo_version )
ENDIF() ENDIF()
ADD_DEPENDENCIES ( ${PACKAGE} copy-${PROJ}-include ) ADD_DEPENDENCIES ( ${PACKAGE} copy-${PROJ}-include )
INSTALL( TARGETS ${PACKAGE} DESTINATION ${${PROJ}_INSTALL_DIR}/lib ) IF ( NOT ${PROJ}_LIB )
INSTALL( TARGETS ${PACKAGE} DESTINATION ${${PROJ}_INSTALL_DIR}/lib )
ENDIF()
ELSE() ELSE()
ADD_CUSTOM_TARGET( ${PACKAGE} ALL ) ADD_CUSTOM_TARGET( ${PACKAGE} ALL )
ENDIF() ENDIF()
@ -247,10 +302,28 @@ MACRO( INSTALL_${PROJ}_TARGET PACKAGE )
ENDMACRO() ENDMACRO()
# Install the project library
MACRO( INSTALL_PROJ_LIB )
SET( tmp_link_list )
FOREACH ( tmp ${${PROJ}_LIBS} )
SET( tmp_link_list ${tmp_link_list} $<TARGET_OBJECTS:${tmp}> )
ENDFOREACH()
IF( USE_CUDA )
SET( ${PROJ}_CUDA_SOURCES ${${PROJ}_CUDA_SOURCES} ${CUDASOURCES} CACHE INTERNAL "")
CUDA_COMPILE( CUBINS ${${PROJ}_CUDA_SOURCES} )
ADD_LIBRARY( ${${PROJ}_LIB} ${CUBINS} ${tmp_link_list} )
ELSE()
ADD_LIBRARY( ${${PROJ}_LIB} ${tmp_link_list} )
ENDIF()
TARGET_LINK_EXTERNAL_LIBRARIES( ${${PROJ}_LIB} LINK_PUBLIC )
INSTALL( TARGETS ${${PROJ}_LIB} DESTINATION ${${PROJ}_INSTALL_DIR}/lib )
ENDMACRO()
# Macro to verify that a variable has been set # Macro to verify that a variable has been set
MACRO( VERIFY_VARIABLE VARIABLE_NAME ) MACRO( VERIFY_VARIABLE VARIABLE_NAME )
IF ( NOT ${VARIABLE_NAME} ) IF ( NOT ${VARIABLE_NAME} )
MESSAGE( FATAL_ERROR "PLease set: " ${VARIABLE_NAME} ) MESSAGE( FATAL_ERROR "Please set: " ${VARIABLE_NAME} )
ENDIF() ENDIF()
ENDMACRO() ENDMACRO()
@ -269,64 +342,64 @@ ENDMACRO()
# Macro to tell cmake to use static libraries # Macro to tell cmake to use static libraries
MACRO( SET_STATIC_FLAGS ) MACRO( SET_STATIC_FLAGS )
# Remove extra library links # Remove extra library links
set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic SET(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic
set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS) SET(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS)
set(CMAKE_SHARED_LIBRARY_C_FLAGS) # remove -fPIC
set(CMAKE_SHARED_LIBRARY_CXX_FLAGS)
set(CMAKE_SHARED_LINKER_FLAGS)
set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS) # remove -rdynamic
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
# Add the static flag if necessary # Add the static flag if necessary
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") # Add static flag SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") # Add static flag
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -static ") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -static ")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static ") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static ")
SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "-static") # Add static flag
SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "-static") # Add static flag
ENDMACRO() ENDMACRO()
# Macro to identify the compiler # Macro to identify the compiler
MACRO( IDENTIFY_COMPILER ) MACRO( IDENTIFY_COMPILER )
# SET the C/C++ compiler # SET the C/C++ compiler
IF ( CMAKE_C_COMPILER_WORKS OR CMAKE_C_COMPILER_WORKS ) IF ( CMAKE_C_COMPILER_WORKS OR CMAKE_CXX_COMPILER_WORKS )
IF( CMAKE_COMPILE_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) IF( USING_GCC OR CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR
(${CMAKE_C_COMPILER_ID} MATCHES "GNU") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "GNU") )
SET( USING_GCC TRUE ) SET( USING_GCC TRUE )
ADD_DEFINITIONS( -DUSING_GCC ) ADD_DEFINITIONS( -DUSING_GCC )
MESSAGE("Using gcc") MESSAGE("Using gcc")
ELSEIF( MSVC OR MSVC_IDE OR MSVC60 OR MSVC70 OR MSVC71 OR MSVC80 OR CMAKE_COMPILER_2005 OR MSVC90 OR MSVC10 ) ELSEIF( USING_MSVC OR MSVC OR MSVC_IDE OR MSVC60 OR MSVC70 OR MSVC71 OR MSVC80 OR CMAKE_COMPILER_2005 OR MSVC90 OR MSVC10 )
IF( NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" ) IF( NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" )
MESSAGE( FATAL_ERROR "Using microsoft compilers on non-windows system?" ) MESSAGE( FATAL_ERROR "Using microsoft compilers on non-windows system?" )
ENDIF() ENDIF()
SET( USING_MSVC TRUE ) SET( USING_MSVC TRUE )
ADD_DEFINITIONS( -DUSING_MSVC ) ADD_DEFINITIONS( -DUSING_MSVC )
MESSAGE("Using Microsoft") MESSAGE("Using Microsoft")
ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "Intel") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Intel") ) ELSEIF( USING_ICC OR (${CMAKE_C_COMPILER_ID} MATCHES "Intel") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Intel") )
SET(USING_ICC TRUE) SET(USING_ICC TRUE)
ADD_DEFINITIONS( -DUSING_ICC ) ADD_DEFINITIONS( -DUSING_ICC )
MESSAGE("Using icc") MESSAGE("Using icc")
ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "PGI") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "PGI") ) ELSEIF( USING_PGCC OR (${CMAKE_C_COMPILER_ID} MATCHES "PGI") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "PGI") )
SET(USING_PGCC TRUE) SET(USING_PGCC TRUE)
ADD_DEFINITIONS( -DUSING_PGCC ) ADD_DEFINITIONS( -DUSING_PGCC )
MESSAGE("Using pgCC") MESSAGE("Using pgCC")
ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "CRAY") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "CRAY") OR ELSEIF( USING_CRAY OR (${CMAKE_C_COMPILER_ID} MATCHES "CRAY") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "CRAY") OR
(${CMAKE_C_COMPILER_ID} MATCHES "Cray") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Cray") ) (${CMAKE_C_COMPILER_ID} MATCHES "Cray") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Cray") )
SET(USING_CRAY TRUE) SET(USING_CRAY TRUE)
ADD_DEFINITIONS( -DUSING_CRAY ) ADD_DEFINITIONS( -DUSING_CRAY )
MESSAGE("Using Cray") MESSAGE("Using Cray")
ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "CLANG") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "CLANG") OR ELSEIF( USING_CLANG OR (${CMAKE_C_COMPILER_ID} MATCHES "CLANG") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "CLANG") OR
(${CMAKE_C_COMPILER_ID} MATCHES "Clang") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") ) (${CMAKE_C_COMPILER_ID} MATCHES "Clang") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") )
SET(USING_CLANG TRUE) SET(USING_CLANG TRUE)
ADD_DEFINITIONS( -DUSING_CLANG ) ADD_DEFINITIONS( -DUSING_CLANG )
MESSAGE("Using Clang") MESSAGE("Using Clang")
ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "XL") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "XL") )
SET(USING_XL TRUE)
ADD_DEFINITIONS( -DUSING_XL )
MESSAGE("Using XL")
ELSE() ELSE()
SET(USING_DEFAULT TRUE) MESSAGE( "CMAKE_C_COMPILER=${CMAKE_C_COMPILER}")
MESSAGE("${CMAKE_C_COMPILER_ID}") MESSAGE( "CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}")
MESSAGE(WARNING "Unknown C/C++ compiler, default flags will be used") MESSAGE( "CMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}")
MESSAGE( "CMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}")
MESSAGE(FATAL_ERROR "Unknown C/C++ compiler")
ENDIF() ENDIF()
ENDIF() ENDIF()
# SET the Fortran++ compiler # SET the Fortran++ compiler
IF ( CMAKE_Fortran_COMPILER_WORKS ) IF ( CMAKE_Fortran_COMPILER_WORKS )
IF( CMAKE_COMPILE_IS_GFORTRAN OR (${CMAKE_Fortran_COMPILER_ID} MATCHES "GNU") ) IF( CMAKE_COMPILER_IS_GNUG77 OR (${CMAKE_Fortran_COMPILER_ID} MATCHES "GNU") )
SET( USING_GFORTRAN TRUE ) SET( USING_GFORTRAN TRUE )
MESSAGE("Using gfortran") MESSAGE("Using gfortran")
ELSEIF ( (${CMAKE_Fortran_COMPILER_ID} MATCHES "Intel") ) ELSEIF ( (${CMAKE_Fortran_COMPILER_ID} MATCHES "Intel") )
@ -335,10 +408,14 @@ MACRO( IDENTIFY_COMPILER )
ELSEIF ( ${CMAKE_Fortran_COMPILER_ID} MATCHES "PGI") ELSEIF ( ${CMAKE_Fortran_COMPILER_ID} MATCHES "PGI")
SET(USING_PGF90 TRUE) SET(USING_PGF90 TRUE)
MESSAGE("Using pgf90") MESSAGE("Using pgf90")
ELSEIF ( (${CMAKE_Fortran_COMPILER_ID} MATCHES "CLANG") OR (${CMAKE_Fortran_COMPILER_ID} MATCHES "Clang") OR
(${CMAKE_Fortran_COMPILER_ID} MATCHES "FLANG") OR (${CMAKE_Fortran_COMPILER_ID} MATCHES "Flang") )
SET(USING_FLANG TRUE)
MESSAGE("Using flang")
ELSE() ELSE()
SET(USING_DEFAULT TRUE) MESSAGE( "CMAKE_Fortran_COMPILER=${CMAKE_Fortran_COMPILER}")
MESSAGE("${CMAKE_Fortran_COMPILER_ID}") MESSAGE( "CMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}")
MESSAGE("Unknown Fortran compiler, default flags will be used") MESSAGE(FATAL_ERROR "Unknown Fortran compiler (${CMAKE_Fortran_COMPILER_ID})")
ENDIF() ENDIF()
ENDIF() ENDIF()
ENDMACRO() ENDMACRO()
@ -350,12 +427,12 @@ MACRO( SET_WARNINGS )
# Add gcc specific compiler options # Add gcc specific compiler options
# Note: adding -Wlogical-op causes a wierd linking error on Titan using the nvcc wrapper: # Note: adding -Wlogical-op causes a wierd linking error on Titan using the nvcc wrapper:
# /usr/bin/ld: cannot find gical-op: No such file or directory # /usr/bin/ld: cannot find gical-op: No such file or directory
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wcast-align -Wlogical-op -Wno-char-subscripts -Wno-unused-parameter -Wno-unused-variable") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wcast-align -Wlogical-op -Wno-char-subscripts -Wno-unused-parameter -Wno-unused-variable") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Woverloaded-virtual -Wsign-compare")
ELSEIF ( USING_MSVC ) ELSEIF ( USING_MSVC )
# Add Microsoft specifc compiler options # Add Microsoft specifc compiler options
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _SCL_SECURE_NO_WARNINGS /D _CRT_SECURE_NO_WARNINGS /D _ITERATOR_DEBUG_LEVEL=0" ) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _SCL_SECURE_NO_WARNINGS /D _CRT_SECURE_NO_WARNINGS /D _ITERATOR_DEBUG_LEVEL=0 /wd4267" )
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D _SCL_SECURE_NO_WARNINGS /D _CRT_SECURE_NO_WARNINGS /D _ITERATOR_DEBUG_LEVEL=0" ) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D _SCL_SECURE_NO_WARNINGS /D _CRT_SECURE_NO_WARNINGS /D _ITERATOR_DEBUG_LEVEL=0 /wd4267" )
ELSEIF ( USING_ICC ) ELSEIF ( USING_ICC )
# Add Intel specifc compiler options # Add Intel specifc compiler options
SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall" ) SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall" )
@ -372,12 +449,14 @@ MACRO( SET_WARNINGS )
SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} --diag_suppress 111,128,185") SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} --diag_suppress 111,128,185")
ELSEIF ( USING_CLANG ) ELSEIF ( USING_CLANG )
# Add default compiler options # Add default compiler options
SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall -Wno-char-subscripts -Wno-unused-private-field -Wno-unused-variable") SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall")
SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall -Wno-char-subscripts -Wno-unused-private-field -Wno-unused-variable") SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall -Wno-missing-braces -Wmissing-field-initializers -ftemplate-depth=1024")
ELSEIF ( USING_DEFAULT ) ELSEIF ( USING_XL )
# Add default compiler options # Add default compiler options
SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS}") SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall")
SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS}") SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall -ftemplate-depth=512")
ELSE ( )
MESSAGE("Compiler specific features are not set for this compiler")
ENDIF() ENDIF()
ENDMACRO() ENDMACRO()
@ -387,6 +466,8 @@ MACRO( ADD_USER_FLAGS )
STRING( STRIP "${CMAKE_C_FLAGS} ${CFLAGS} ${CFLAGS_EXTRA}" CMAKE_C_FLAGS ) STRING( STRIP "${CMAKE_C_FLAGS} ${CFLAGS} ${CFLAGS_EXTRA}" CMAKE_C_FLAGS )
STRING( STRIP "${CMAKE_CXX_FLAGS} ${CXXFLAGS} ${CXXFLAGS_EXTRA}" CMAKE_CXX_FLAGS ) STRING( STRIP "${CMAKE_CXX_FLAGS} ${CXXFLAGS} ${CXXFLAGS_EXTRA}" CMAKE_CXX_FLAGS )
STRING( STRIP "${CMAKE_Fortran_FLAGS} ${FFLAGS} ${FFLAGS_EXTRA}" CMAKE_Fortran_FLAGS ) STRING( STRIP "${CMAKE_Fortran_FLAGS} ${FFLAGS} ${FFLAGS_EXTRA}" CMAKE_Fortran_FLAGS )
STRING( STRIP "${LDFLAGS} ${LDFLAGS_EXTRA}" LDFLAGS )
STRING( STRIP "${LDLIBS} ${LDLIBS_EXTRA}" LDLIBS )
ENDMACRO() ENDMACRO()
@ -443,6 +524,15 @@ MACRO( ADD_CXX_STD )
ELSE() ELSE()
MESSAGE(FATAL_ERROR "Unknown standard") MESSAGE(FATAL_ERROR "Unknown standard")
ENDIF() ENDIF()
ELSEIF ( USING_XL )
# XL: -std=
IF ( ( ${CXX_STD} STREQUAL "98") OR ( ${CXX_STD} STREQUAL "11" ) )
SET( CXX_STD_FLAG -std=c++${CXX_STD} )
ELSEIF ( ${CXX_STD} STREQUAL "14" )
SET( CXX_STD_FLAG -std=c++1y )
ELSE()
MESSAGE(FATAL_ERROR "Unknown standard")
ENDIF()
ELSEIF ( USING_DEFAULT ) ELSEIF ( USING_DEFAULT )
# Default: do nothing # Default: do nothing
ENDIF() ENDIF()
@ -457,8 +547,8 @@ MACRO( SET_COMPILER_FLAGS )
IDENTIFY_COMPILER() IDENTIFY_COMPILER()
# Set the default flags for each build type # Set the default flags for each build type
IF ( USING_MSVC ) IF ( USING_MSVC )
SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG /DEBUG /Od /EHsc /MDd /Zi /Z7" ) SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG /DEBUG /Od /EHsc /MDd /Z7" )
SET(CMAKE_CXX_FLAGS_DEBUG "-D_DEBUG /DEBUG /Od /EHsc /MDd /Zi /Z7" ) SET(CMAKE_CXX_FLAGS_DEBUG "-D_DEBUG /DEBUG /Od /EHsc /MDd /Z7" )
SET(CMAKE_C_FLAGS_RELEASE "/O2 /EHsc /MD" ) SET(CMAKE_C_FLAGS_RELEASE "/O2 /EHsc /MD" )
SET(CMAKE_CXX_FLAGS_RELEASE "/O2 /EHsc /MD" ) SET(CMAKE_CXX_FLAGS_RELEASE "/O2 /EHsc /MD" )
ELSE() ELSE()
@ -478,7 +568,7 @@ MACRO( SET_COMPILER_FLAGS )
SET( DISABLE_GXX_DEBUG ON ) SET( DISABLE_GXX_DEBUG ON )
ENDIF() ENDIF()
# Set debug definitions # Set debug definitions
IF ( ${CMAKE_BUILD_TYPE} STREQUAL "Debug" ) IF ( ${CMAKE_BUILD_TYPE} STREQUAL "Debug" AND NOT ("${CMAKE_CXX_FLAGS_DEBUG}" MATCHES "-D_DEBUG") )
SET( CMAKE_C_FLAGS_DEBUG " ${CMAKE_C_FLAGS_DEBUG} -DDEBUG -D_DEBUG" ) SET( CMAKE_C_FLAGS_DEBUG " ${CMAKE_C_FLAGS_DEBUG} -DDEBUG -D_DEBUG" )
SET( CMAKE_CXX_FLAGS_DEBUG " ${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -D_DEBUG" ) SET( CMAKE_CXX_FLAGS_DEBUG " ${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -D_DEBUG" )
ENDIF() ENDIF()
@ -494,8 +584,12 @@ MACRO( SET_COMPILER_FLAGS )
# Set the warnings to use # Set the warnings to use
SET_WARNINGS() SET_WARNINGS()
# Test the compile flags # Test the compile flags
CHECK_C_COMPILER_FLAG( "${CMAKE_C_FLAGS}" CHECK_C_FLAGS ) IF ( CMAKE_C_COMPILER_WORKS )
CHECK_CXX_COMPILER_FLAG( "${CMAKE_CXX_FLAGS}" CHECK_CXX_FLAGS ) CHECK_C_COMPILER_FLAG( "${CMAKE_C_FLAGS}" CHECK_C_FLAGS )
ENDIF()
IF ( CMAKE_CXX_COMPILER_WORKS )
CHECK_CXX_COMPILER_FLAG( "${CMAKE_CXX_FLAGS}" CHECK_CXX_FLAGS )
ENDIF()
IF ( ( NOT CHECK_C_FLAGS ) OR ( NOT CHECK_CXX_FLAGS ) ) IF ( ( NOT CHECK_C_FLAGS ) OR ( NOT CHECK_CXX_FLAGS ) )
IF ( USING_CRAY ) IF ( USING_CRAY )
MESSAGE(WARNING "Invalid C/CXX flags detected:\n" MESSAGE(WARNING "Invalid C/CXX flags detected:\n"
@ -592,6 +686,87 @@ FUNCTION( COPY_EXAMPLE_DATA_FILE FILENAME )
ENDFUNCTION() ENDFUNCTION()
# Macro to copy a mesh file
MACRO( COPY_MESH_FILE MESHNAME )
# Check the local data directory
FILE( GLOB MESHPATH "${CMAKE_CURRENT_SOURCE_DIR}/data/${MESHNAME}" )
# Search all data paths
FOREACH ( path ${${PROJ}_DATA} )
# Check the DATA directory
IF ( NOT MESHPATH )
FILE( GLOB MESHPATH "${path}/${MESHNAME}" )
ENDIF()
# Check the DATA/vvu directory
IF ( NOT MESHPATH )
FILE( GLOB MESHPATH "${path}/vvu/meshes/${MESHNAME}" )
ENDIF()
# Check the DATA/meshes directory
IF ( NOT MESHPATH )
FILE( GLOB_RECURSE MESHPATH "${path}/meshes/*/${MESHNAME}" )
ENDIF()
# Check the entire DATA directory
IF ( NOT MESHPATH )
FILE( GLOB_RECURSE MESHPATH "${path}/*/${MESHNAME}" )
ENDIF()
ENDFOREACH()
# We have either found the mesh or failed
IF ( NOT MESHPATH )
MESSAGE ( WARNING "Cannot find mesh: " ${MESHNAME} )
ELSE ()
SET( MESHPATH2 )
FOREACH( tmp ${MESHPATH} )
SET( MESHPATH2 "${tmp}" )
ENDFOREACH()
STRING(REGEX REPLACE "//${MESHNAME}" "" MESHPATH "${MESHPATH2}" )
STRING(REGEX REPLACE "${MESHNAME}" "" MESHPATH "${MESHPATH}" )
COPY_DATA_FILE( "${MESHPATH}/${MESHNAME}" "${CMAKE_CURRENT_BINARY_DIR}/${MESHNAME}" )
ENDIF()
ENDMACRO()
# Link the libraries to the given target
MACRO( TARGET_LINK_EXTERNAL_LIBRARIES TARGET_NAME )
FOREACH ( tmp ${TPL_LIBS} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
FOREACH ( tmp ${EXTERNAL_LIBS} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
FOREACH ( tmp ${LAPACK_LIBS} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
FOREACH ( tmp ${BLAS_LIBS} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
FOREACH ( tmp ${BLAS_LAPACK_LIBS} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
FOREACH ( tmp ${CUDA_LIBS} ${CUDA_LIBRARIES} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
ENDMACRO()
# Choose the debug or optimized library based on the build type
FUNCTION( KEEP_BUILD_LIBRARIES VAR )
IF ( ${CMAKE_BUILD_TYPE} STREQUAL "Debug" )
SET( build_type debug )
ELSE()
SET( build_type optimized )
ENDIF()
SET( build ${build_type} )
SET( LIBS )
FOREACH ( tmp ${${VAR}} )
IF ( ( ${tmp} STREQUAL debug ) OR ( ${tmp} STREQUAL optimized ) )
SET( build ${tmp} )
ELSEIF ( ${build} STREQUAL ${build_type} )
SET( LIBS ${LIBS} ${tmp} )
ENDIF()
ENDFOREACH()
SET( ${VAR} ${LIBS} PARENT_SCOPE )
ENDFUNCTION()
# Macro to add the dependencies and libraries to an executable # Macro to add the dependencies and libraries to an executable
MACRO( ADD_PROJ_EXE_DEP EXE ) MACRO( ADD_PROJ_EXE_DEP EXE )
# Add the package dependencies # Add the package dependencies
@ -607,18 +782,25 @@ MACRO( ADD_PROJ_EXE_DEP EXE )
ADD_DEPENDENCIES( ${EXE} copy-${PROJ}-Data ) ADD_DEPENDENCIES( ${EXE} copy-${PROJ}-Data )
ENDIF() ENDIF()
# Add the project libraries # Add the project libraries
TARGET_LINK_LIBRARIES( ${EXE} ${${PROJ}_LIBS} ${${PROJ}_LIBS} ) IF ( ${PROJ}_LIB )
TARGET_LINK_LIBRARIES( ${EXE} ${${PROJ}_LIB} )
ELSE()
TARGET_LINK_LIBRARIES( ${EXE} ${${PROJ}_LIBS} ${${PROJ}_LIBS} )
ENDIF()
TARGET_LINK_LIBRARIES( ${EXE} ${${PROJECT_NAME}_LIBRARIES} ) TARGET_LINK_LIBRARIES( ${EXE} ${${PROJECT_NAME}_LIBRARIES} )
# Add external libraries # Add coverage flags to target
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS}" ) IF ( NOT DISABLE_TARGET_COVERAGE )
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS_EXTRA}" ) TARGET_COMPILE_DEFINITIONS( ${EXE} PUBLIC ${COVERAGE_FLAGS} )
ENDIF()
# Link to external libraries
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS} ${LDFLAGS_EXTRA}" )
TARGET_LINK_LIBRARIES( ${EXE} ${LINK_LIBRARIES} ) TARGET_LINK_LIBRARIES( ${EXE} ${LINK_LIBRARIES} )
TARGET_LINK_LIBRARIES( ${EXE} ${CUDA_LIBS} ${CUDA_LIBRARIES} ) TARGET_LINK_LIBRARIES( ${EXE} ${CUDA_LIBS} ${CUDA_LIBRARIES} )
TARGET_LINK_LIBRARIES( ${EXE} ${EXTERNAL_LIBS} ) TARGET_LINK_EXTERNAL_LIBRARIES( ${EXE} )
IF ( USE_MPI OR USE_EXT_MPI OR HAVE_MPI ) IF ( USE_MPI OR USE_EXT_MPI OR HAVE_MPI )
TARGET_LINK_LIBRARIES( ${EXE} ${MPI_LINK_FLAGS} ${MPI_LIBRARIES} ) TARGET_LINK_LIBRARIES( ${EXE} ${MPI_LIBRARIES} )
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${MPI_LINK_FLAGS} " )
ENDIF() ENDIF()
TARGET_LINK_LIBRARIES( ${EXE} ${LAPACK_LIBS} ${BLAS_LIBS} ${BLAS_LAPACK_LIBS} )
TARGET_LINK_LIBRARIES( ${EXE} ${COVERAGE_LIBS} ${LDLIBS} ${LDLIBS_EXTRA} ) TARGET_LINK_LIBRARIES( ${EXE} ${COVERAGE_LIBS} ${LDLIBS} ${LDLIBS_EXTRA} )
TARGET_LINK_LIBRARIES( ${EXE} ${SYSTEM_LIBS} ${SYSTEM_LDFLAGS} ) TARGET_LINK_LIBRARIES( ${EXE} ${SYSTEM_LIBS} ${SYSTEM_LDFLAGS} )
ENDMACRO() ENDMACRO()
@ -627,6 +809,12 @@ ENDMACRO()
# Check if we want to keep the test # Check if we want to keep the test
FUNCTION( KEEP_TEST RESULT ) FUNCTION( KEEP_TEST RESULT )
SET( ${RESULT} 1 PARENT_SCOPE ) SET( ${RESULT} 1 PARENT_SCOPE )
IF ( NOT DEFINED ${PACKAGE_NAME}_ENABLE_TESTS )
SET( ${PACKAGE_NAME}_ENABLE_TESTS 1 )
ENDIF()
IF ( NOT ${PACKAGE_NAME}_ENABLE_TESTS )
SET( ${RESULT} 0 PARENT_SCOPE )
ENDIF()
IF ( ONLY_BUILD_DOCS ) IF ( ONLY_BUILD_DOCS )
SET( ${RESULT} 0 PARENT_SCOPE ) SET( ${RESULT} 0 PARENT_SCOPE )
ENDIF() ENDIF()
@ -640,13 +828,13 @@ FUNCTION( ADD_PROJ_PROVISIONAL_TEST EXEFILE )
IF ( NOT RESULT ) IF ( NOT RESULT )
RETURN() RETURN()
ENDIF() ENDIF()
# Check if test has already been added # Check if the target does not exist (may not be added yet or we are re-configuring)
SET( tmp ) IF ( NOT TARGET ${EXEFILE} )
IF ( TARGET ${EXEFILE} ) GLOBAL_SET( ${EXEFILE}-BINDIR )
GET_TARGET_PROPERTY(tmp ${EXEFILE} LOCATION)
STRING(REGEX REPLACE "//" "/" tmp "${tmp}" )
ENDIF() ENDIF()
IF ( NOT tmp ) # Check if test has already been added
IF ( NOT ${EXEFILE}-BINDIR )
GLOBAL_SET( ${EXEFILE}-BINDIR "${CMAKE_CURRENT_BINARY_DIR}" )
# The target has not been added # The target has not been added
SET( CXXFILE ${EXEFILE} ) SET( CXXFILE ${EXEFILE} )
SET( TESTS_SO_FAR ${TESTS_SO_FAR} ${EXEFILE} ) SET( TESTS_SO_FAR ${TESTS_SO_FAR} ${EXEFILE} )
@ -657,22 +845,19 @@ FUNCTION( ADD_PROJ_PROVISIONAL_TEST EXEFILE )
ADD_EXECUTABLE( ${EXEFILE} EXCLUDE_FROM_ALL ${CXXFILE} ) ADD_EXECUTABLE( ${EXEFILE} EXCLUDE_FROM_ALL ${CXXFILE} )
ENDIF() ENDIF()
ADD_PROJ_EXE_DEP( ${EXEFILE} ) ADD_PROJ_EXE_DEP( ${EXEFILE} )
ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}" ) IF ( CURRENT_LIBRARY )
# The correct target has already been added IF ( NOT TARGET ${CURRENT_LIBRARY}-test )
ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.exe" ) ADD_CUSTOM_TARGET( ${CURRENT_LIBRARY}-test )
# The correct target has already been added ENDIF()
ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/$(Configuration)/${EXEFILE}.exe" ) ADD_DEPENDENCIES( ${CURRENT_LIBRARY}-test ${EXEFILE} )
# The correct target has already been added ENDIF()
ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/${EXEFILE}" ) ELSEIF ( NOT ${EXEFILE-BINDIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR} )
# The correct target has already been added
ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/$(OutDir)/${EXEFILE}.exe" )
# The correct target has already been added
ELSE()
# We are trying to add 2 different tests with the same name # We are trying to add 2 different tests with the same name
MESSAGE( "Existing test: ${tmp}" ) MESSAGE( "Existing test: ${EXEFILE-BINDIR}/${EXEFILE}" )
MESSAGE( "New test: ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}" ) MESSAGE( "New test: ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}" )
MESSAGE( FATAL_ERROR "Trying to add 2 different tests with the same name" ) MESSAGE( FATAL_ERROR "Trying to add 2 different tests with the same name" )
ENDIF() ENDIF()
SET( LAST_TEST ${EXEFILE} PARENT_SCOPE )
ENDFUNCTION() ENDFUNCTION()
FUNCTION( ADD_${PROJ}_PROVISIONAL_TEST EXEFILE ) FUNCTION( ADD_${PROJ}_PROVISIONAL_TEST EXEFILE )
ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} )
@ -696,12 +881,14 @@ ENDMACRO()
# Function to add the resource locks to an executable # Function to add the resource locks to an executable
FUNCTION( ADD_RESOURCE_LOCK TESTNAME EXEFILE ${ARGN} ) FUNCTION( ADD_RESOURCE_LOCK TESTNAME EXEFILE ${ARGN} )
IF ( NOT ARGN ) IF ( NOT DISABLE_RESOURCE_LOCK )
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) IF ( NOT ARGN )
ELSE() SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} )
FOREACH( tmp ${ARGN} ) ELSE()
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${tmp} ) FOREACH( tmp ${ARGN} )
ENDFOREACH() SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${tmp} )
ENDFOREACH()
ENDIF()
ENDIF() ENDIF()
ENDFUNCTION() ENDFUNCTION()
@ -716,12 +903,11 @@ FUNCTION( ADD_${PROJ}_TEST EXEFILE ${ARGN} )
# Add the provisional test # Add the provisional test
ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} )
CREATE_TEST_NAME( ${EXEFILE} ${ARGN} ) CREATE_TEST_NAME( ${EXEFILE} ${ARGN} )
GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION)
STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" )
IF ( USE_MPI_FOR_SERIAL_TESTS ) IF ( USE_MPI_FOR_SERIAL_TESTS )
ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} 1 ${EXE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} 1 $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none )
ELSE() ELSE()
ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
ENDIF() ENDIF()
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 )
ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} )
@ -737,8 +923,6 @@ FUNCTION( ADD_${PROJ}_WEEKLY_TEST EXEFILE PROCS ${ARGN} )
ENDIF() ENDIF()
# Add the provisional test # Add the provisional test
ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} )
GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION)
STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" )
IF( ${PROCS} STREQUAL "1" ) IF( ${PROCS} STREQUAL "1" )
CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} ) CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} )
ELSEIF( (USE_MPI OR USE_EXT_MPI) AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) ELSEIF( (USE_MPI OR USE_EXT_MPI) AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) )
@ -749,16 +933,18 @@ FUNCTION( ADD_${PROJ}_WEEKLY_TEST EXEFILE PROCS ${ARGN} )
ELSEIF( ${PROCS} STREQUAL "1" ) ELSEIF( ${PROCS} STREQUAL "1" )
CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} ) CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} )
IF ( USE_MPI_FOR_SERIAL_TESTS ) IF ( USE_MPI_FOR_SERIAL_TESTS )
ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} 1 ${EXE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} 1 $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none )
ELSE() ELSE()
ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
ENDIF() ENDIF()
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 )
ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} )
ELSEIF( (USE_MPI OR USE_EXT_MPI) AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) ELSEIF( (USE_MPI OR USE_EXT_MPI) AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) )
CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs_WEEKLY" ${ARGN} ) CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs_WEEKLY" ${ARGN} )
ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} )
SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none )
ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} )
ENDIF() ENDIF()
ENDFUNCTION() ENDFUNCTION()
@ -773,15 +959,14 @@ FUNCTION( ADD_${PROJ}_TEST_PARALLEL EXEFILE PROCS ${ARGN} )
ENDIF() ENDIF()
# Add the provisional test # Add the provisional test
ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} )
GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION)
STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" )
CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs" ${ARGN} ) CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs" ${ARGN} )
IF ( NOT ( USE_MPI OR USE_EXT_MPI ) ) IF ( NOT ( USE_MPI OR USE_EXT_MPI ) )
MESSAGE("Disabling test ${TESTNAME} (configured without MPI)") MESSAGE("Disabling test ${TESTNAME} (configured without MPI)")
ELSEIF ( ${PROCS} GREATER ${TEST_MAX_PROCS} ) ELSEIF ( ${PROCS} GREATER ${TEST_MAX_PROCS} )
MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS})") MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS})")
ELSE() ELSE()
ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none )
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} )
ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} )
ENDIF() ENDIF()
@ -792,18 +977,17 @@ ENDFUNCTION()
# This allows us to correctly compute the number of processors used by the test # This allows us to correctly compute the number of processors used by the test
MACRO( ADD_${PROJ}_TEST_THREAD_MPI EXEFILE PROCS THREADS ${ARGN} ) MACRO( ADD_${PROJ}_TEST_THREAD_MPI EXEFILE PROCS THREADS ${ARGN} )
ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} )
GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION)
STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" )
CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs_${THREADS}threads" ${ARGN} ) CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs_${THREADS}threads" ${ARGN} )
MATH( EXPR TOT_PROCS "${PROCS} * ${THREADS}" ) MATH( EXPR TOT_PROCS "${PROCS} * ${THREADS}" )
IF ( ${TOT_PROCS} GREATER ${TEST_MAX_PROCS} ) IF ( ${TOT_PROCS} GREATER ${TEST_MAX_PROCS} )
MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS}") MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS})")
ELSEIF ( ( ${PROCS} STREQUAL "1" ) AND NOT USE_MPI_FOR_SERIAL_TESTS ) ELSEIF ( ( ${PROCS} STREQUAL "1" ) AND NOT USE_MPI_FOR_SERIAL_TESTS )
ADD_TEST ( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
SET_TESTS_PROPERTIES ( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} ) SET_TESTS_PROPERTIES ( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} )
ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} )
ELSEIF ( USE_MPI OR USE_EXT_MPI ) ELSEIF ( USE_MPI OR USE_EXT_MPI )
ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none )
SET_TESTS_PROPERTIES ( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} ) SET_TESTS_PROPERTIES ( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} )
ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} )
ENDIF() ENDIF()
@ -829,19 +1013,17 @@ FUNCTION( ADD_${PROJ}_EXAMPLE EXEFILE PROCS ${ARGN} )
ENDIF() ENDIF()
# Add the provisional test # Add the provisional test
ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} )
GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION)
STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" )
ADD_DEPENDENCIES( build-examples ${EXEFILE} ) ADD_DEPENDENCIES( build-examples ${EXEFILE} )
GET_TARGET_PROPERTY(EXE2 ${EXEFILE} LOCATION)
ADD_CUSTOM_COMMAND( TARGET ${EXEFILE} POST_BUILD ADD_CUSTOM_COMMAND( TARGET ${EXEFILE} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy ${EXE2} "${EXAMPLE_INSTALL_DIR}/${EXEFILE}" COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${LAST_TEST}> "${EXAMPLE_INSTALL_DIR}/${EXEFILE}"
) )
IF( ${PROCS} STREQUAL "1" AND (NOT USE_MPI_FOR_SERIAL_TESTS) ) IF( ${PROCS} STREQUAL "1" AND (NOT USE_MPI_FOR_SERIAL_TESTS) )
CREATE_TEST_NAME( "example--${EXEFILE}" ${ARGN} ) CREATE_TEST_NAME( "example--${EXEFILE}" ${ARGN} )
ADD_TEST( ${TESTNAME} ${EXE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
ELSEIF ( USE_EXT_MPI AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) ELSEIF ( USE_EXT_MPI AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) )
CREATE_TEST_NAME( "example--${EXEFILE}_${PROCS}procs" ${ARGN} ) CREATE_TEST_NAME( "example--${EXEFILE}_${PROCS}procs" ${ARGN} )
ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) ADD_TEST( NAME ${TESTNAME} COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} $<TARGET_FILE:${LAST_TEST}> ${ARGN} )
SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none )
ENDIF() ENDIF()
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} )
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} )
@ -874,9 +1056,9 @@ MACRO( CHECK_ENABLE_FLAG FLAG DEFAULT )
SET( ${FLAG} ${DEFAULT} ) SET( ${FLAG} ${DEFAULT} )
ELSEIF( ${FLAG} STREQUAL "" ) ELSEIF( ${FLAG} STREQUAL "" )
SET( ${FLAG} ${DEFAULT} ) SET( ${FLAG} ${DEFAULT} )
ELSEIF( ( ${${FLAG}} STREQUAL "false" ) OR ( ${${FLAG}} STREQUAL "0" ) OR ( ${${FLAG}} STREQUAL "OFF" ) ) ELSEIF( ( ${${FLAG}} STREQUAL "FALSE" ) OR ( ${${FLAG}} STREQUAL "false" ) OR ( ${${FLAG}} STREQUAL "0" ) OR ( ${${FLAG}} STREQUAL "OFF" ) )
SET( ${FLAG} 0 ) SET( ${FLAG} 0 )
ELSEIF( ( ${${FLAG}} STREQUAL "true" ) OR ( ${${FLAG}} STREQUAL "1" ) OR ( ${${FLAG}} STREQUAL "ON" ) ) ELSEIF( ( ${${FLAG}} STREQUAL "TRUE" ) OR ( ${${FLAG}} STREQUAL "true" ) OR ( ${${FLAG}} STREQUAL "1" ) OR ( ${${FLAG}} STREQUAL "ON" ) )
SET( ${FLAG} 1 ) SET( ${FLAG} 1 )
ELSE() ELSE()
MESSAGE( "Bad value for ${FLAG} (${${FLAG}}); use true or false" ) MESSAGE( "Bad value for ${FLAG} (${${FLAG}}); use true or false" )
@ -909,27 +1091,30 @@ ENDMACRO()
FUNCTION( ADD_MATLAB_MEX MEXFILE ) FUNCTION( ADD_MATLAB_MEX MEXFILE )
# Set the MEX compiler and default link flags # Set the MEX compiler and default link flags
IF ( USING_MSVC ) IF ( USING_MSVC )
SET( MEX "\"${MATLAB_DIRECTORY}/bin/mex.bat\"" )
SET( MEX_LDFLAGS ${MEX_LDFLAGS} -L${CMAKE_CURRENT_BINARY_DIR}/.. SET( MEX_LDFLAGS ${MEX_LDFLAGS} -L${CMAKE_CURRENT_BINARY_DIR}/..
-L${CMAKE_CURRENT_BINARY_DIR}/../Debug -L${CMAKE_CURRENT_BINARY_DIR} ) -L${CMAKE_CURRENT_BINARY_DIR}/../Debug -L${CMAKE_CURRENT_BINARY_DIR} )
ELSE()
SET( MEX "${MATLAB_DIRECTORY}/bin/mex" )
SET( MEX_LDFLAGS ${MEX_LDFLAGS} )
ENDIF() ENDIF()
SET( MEX_LDFLAGS ${MEX_LDFLAGS} -L${CMAKE_CURRENT_BINARY_DIR}/.. ${SYSTEM_LDFLAGS} ) SET( MEX_LDFLAGS ${MEX_LDFLAGS} -L${CMAKE_CURRENT_BINARY_DIR}/.. -L${CMAKE_CURRENT_BINARY_DIR}/../.. ${SYSTEM_LDFLAGS} )
SET( MEX_LIBS ${MEX_LIBS} ${SYSTEM_LIBS} ) SET( MEX_LIBS ${MEX_LIBS} ${SYSTEM_LIBS} )
IF ( NOT USING_MSVC ) IF ( NOT USING_MSVC )
FOREACH( rpath ${CMAKE_INSTALL_RPATH} ) FOREACH( rpath ${CMAKE_INSTALL_RPATH} )
SET( MEX_LDFLAGS ${MEX_LDFLAGS} "-Wl,-rpath,${rpath},--no-undefined" ) SET( MEX_LDFLAGS ${MEX_LDFLAGS} "-Wl,-rpath,${rpath},--no-undefined" )
ENDFOREACH() ENDFOREACH()
ENDIF() ENDIF()
IF ( "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" )
SET( MEX_FLAGS ${MEX_FLAGS} -g )
ELSEIF ( "${CMAKE_BUILD_TYPE}" STREQUAL "Release" )
SET( MEX_FLAGS ${MEX_FLAGS} -O )
ELSE()
MESSAGE( FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}" )
ENDIF()
# Create the mex comamnd # Create the mex comamnd
STRING(REGEX REPLACE "[.]cpp" "" TARGET ${MEXFILE}) STRING(REGEX REPLACE "[.]cpp" "" TARGET ${MEXFILE})
STRING(REGEX REPLACE "[.]c" "" TARGET ${TARGET}) STRING(REGEX REPLACE "[.]c" "" TARGET ${TARGET})
FILE(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}" ) FILE(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}" )
IF ( USING_MSVC ) IF ( USING_MSVC )
SET( MEX_BAT_FILE "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/compile_mex.bat" ) SET( MEX_BAT_FILE "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/compile_mex.bat" )
FILE( WRITE "${MEX_BAT_FILE}" "${MEX} \"${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE}\" " ) FILE( WRITE "${MEX_BAT_FILE}" "${MEX_EXE} \"${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE}\" " )
APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_FLAGS}" "\"" "\" " ) APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_FLAGS}" "\"" "\" " )
APPEND_LIST( "${MEX_BAT_FILE}" "${COMPFLAGS}" "\"" "\" " ) APPEND_LIST( "${MEX_BAT_FILE}" "${COMPFLAGS}" "\"" "\" " )
APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_INCLUDE}" "\"" "\" " ) APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_INCLUDE}" "\"" "\" " )
@ -940,7 +1125,7 @@ FUNCTION( ADD_MATLAB_MEX MEXFILE )
ELSE() ELSE()
STRING(REPLACE " " ";" MEX_CFLAGS "$$CFLAGS ${CMAKE_C_FLAGS}") STRING(REPLACE " " ";" MEX_CFLAGS "$$CFLAGS ${CMAKE_C_FLAGS}")
STRING(REPLACE " " ";" MEX_CXXFLAGS "$$CXXFLAGS ${CMAKE_CXX_FLAGS}") STRING(REPLACE " " ";" MEX_CXXFLAGS "$$CXXFLAGS ${CMAKE_CXX_FLAGS}")
SET( MEX_COMMAND ${MEX} ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE} SET( MEX_COMMAND ${MEX_EXE} ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE}
${MEX_FLAGS} ${MEX_INCLUDE} ${MEX_FLAGS} ${MEX_INCLUDE}
CFLAGS="${MEX_CFLAGS}" CFLAGS="${MEX_CFLAGS}"
CXXFLAGS="${MEX_CXXFLAGS}" CXXFLAGS="${MEX_CXXFLAGS}"
@ -952,7 +1137,7 @@ FUNCTION( ADD_MATLAB_MEX MEXFILE )
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION} OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION}
COMMAND ${MEX_COMMAND} COMMAND ${MEX_COMMAND}
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/${TARGET}.${MEX_EXTENSION}" "${CMAKE_CURRENT_BINARY_DIR}" COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/${TARGET}.${MEX_EXTENSION}" "${CMAKE_CURRENT_BINARY_DIR}"
COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/${TARGET}.${MEX_EXTENSION}" "${${PROJ}_INSTALL_DIR}/matlab" COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/${TARGET}.${MEX_EXTENSION}" "${${PROJ}_INSTALL_DIR}/mex"
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}
DEPENDS ${${PROJ}_LIBS} ${MATLAB_TARGET} ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE} DEPENDS ${${PROJ}_LIBS} ${MATLAB_TARGET} ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE}
) )
@ -960,44 +1145,106 @@ FUNCTION( ADD_MATLAB_MEX MEXFILE )
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION} DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE} DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE}
) )
ADD_DEPENDENCIES( ${TARGET} ${${PROJ}_LIBS} ${MATLAB_TARGET} ) IF ( MATLAB_TARGET )
ADD_DEPENDENCIES( ${TARGET} ${MATLAB_TARGET} )
ENDIF()
IF ( ${PROJ}_LIBS )
ADD_DEPENDENCIES( ${TARGET} ${${PROJ}_LIBS} )
ENDIF()
ADD_DEPENDENCIES( mex ${TARGET} ) ADD_DEPENDENCIES( mex ${TARGET} )
INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION} DESTINATION ${${PROJ}_INSTALL_DIR}/mex ) SET( MEX_FILES2 ${MEX_FILES} "${${PROJ}_INSTALL_DIR}/mex/${TARGET}.${MEX_EXTENSION}" )
LIST( REMOVE_DUPLICATES MEX_FILES2 )
SET( MEX_FILES ${MEX_FILES2} CACHE INTERNAL "" )
ENDFUNCTION() ENDFUNCTION()
# Add a matlab test # Add a matlab test
MACRO( ADD_MATLAB_TEST EXEFILE ${ARGN} ) MACRO( ADD_MATLAB_TEST EXEFILE ${ARGN} )
FIND_PROGRAM( MATLAB_EXE NAME matlab ) IF ( NOT MATLAB_EXE )
MESSAGE( FATAL_ERROR "MATLAB_EXE not set, did you call CREATE_MATLAB_WRAPPER()" )
ENDIF()
CONFIGURE_FILE( ${EXEFILE}.m ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.m ) CONFIGURE_FILE( ${EXEFILE}.m ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.m )
CREATE_TEST_NAME( MATLAB ${EXEFILE} ${ARGN} ) CREATE_TEST_NAME( MATLAB ${EXEFILE} ${ARGN} )
IF ( USING_MSVC ) IF ( USING_MSVC )
SET( MATLAB_OPTIONS "-nodisplay" "-nodesktop" "-wait" "-logfile" "log_${EXEFILE}" ) SET( MATLAB_OPTIONS "-logfile" "log_${EXEFILE}" )
ELSE()
SET( MATLAB_OPTIONS "-nojvm -nosplash -nodisplay" )
ENDIF() ENDIF()
SET( MATLAB_COMMAND "addpath('${${PROJ}_BINARY_DIR}/matlab'); try, ${EXEFILE}, catch ME, ME, exit(1), end, disp('ALL TESTS PASSED'); exit(0)" ) SET( MATLAB_COMMAND "try, ${EXEFILE}, catch ME, ME, clear all global, exit(1), end, disp('ALL TESTS PASSED'); exit(0)" )
SET( MATLAB_DEBUGGER_OPTIONS ) SET( MATLAB_DEBUGGER_OPTIONS )
IF ( MATLAB_DEBUGGER ) IF ( MATLAB_DEBUGGER )
SET( MATLAB_DEBUGGER_OPTIONS -D${MATLAB_DEBUGGER} ) SET( MATLAB_DEBUGGER_OPTIONS -D${MATLAB_DEBUGGER} )
STRING(REPLACE "\"" "" MATLAB_DEBUGGER_OPTIONS "${MATLAB_DEBUGGER_OPTIONS}") STRING(REPLACE "\"" "" MATLAB_DEBUGGER_OPTIONS "${MATLAB_DEBUGGER_OPTIONS}")
ENDIF() ENDIF()
IF ( USING_MSVC ) ADD_TEST( NAME ${TESTNAME} COMMAND "${MATLAB_EXE}" ${MATLAB_OPTIONS} -r "${MATLAB_COMMAND}" ${MATLAB_DEBUGGER_OPTIONS} )
FILE( WRITE "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat" "@echo off\n")
FILE( APPEND "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat" "matlab ")
APPEND_LIST( "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat" "${MATLAB_OPTIONS}" "" " " )
FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat " -r \"${MATLAB_COMMAND}\" ${MATLAB_DEBUGGER_OPTIONS}\n" )
FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat "@echo on\n")
FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat "type log_${EXEFILE}\n" )
ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat )
ELSE()
ADD_TEST( ${TESTNAME} matlab ${MATLAB_OPTIONS} -r "${MATLAB_COMMAND}" ${MATLAB_DEBUGGER_OPTIONS} )
ENDIF()
SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES PASS_REGULAR_EXPRESSION "ALL TESTS PASSED" FAIL_REGULAR_EXPRESSION "FAILED" ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES PASS_REGULAR_EXPRESSION "ALL TESTS PASSED" FAIL_REGULAR_EXPRESSION "FAILED" )
SET_PROPERTY(TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT RATES_DIRECTORY=${RATES_DIRECTORY} ) SET_PROPERTY(TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT RATES_DIRECTORY=${RATES_DIRECTORY} )
ENDMACRO() ENDMACRO()
# Create a script to start matlab preloading libraries
FUNCTION( CREATE_MATLAB_WRAPPER )
SET( tmp_libs ${MEX_LIBCXX} ${MEX_FILES} )
STRING(REGEX REPLACE ";" ":" tmp_libs "${tmp_libs}")
STRING(REGEX REPLACE ";" ":" tmp_path "${MATLABPATH}")
FIND_PROGRAM( MATLAB_EXE2 NAME matlab PATHS "${MATLAB_DIRECTORY}/bin" NO_DEFAULT_PATH )
IF ( USING_MSVC )
# Create a matlab wrapper for windows
SET( MATLAB_GUI "${CMAKE_CURRENT_BINARY_DIR}/tmp/matlab-gui.bat" )
SET( MATLAB_CMD "${CMAKE_CURRENT_BINARY_DIR}/tmp/matlab-cmd.bat" )
SET( MATLAB_INSTALL_CMD "matlab-cmd.bat" )
FILE( WRITE "${MATLAB_GUI}" "@echo off\n")
FILE( WRITE "${MATLAB_CMD}" "@echo off\n")
FILE( APPEND "${MATLAB_GUI}" "matlab -singleCompThread -nosplash %*\n")
FILE( APPEND "${MATLAB_CMD}" "matlab -singleCompThread -nosplash -nodisplay -nodesktop -wait %*\n")
FILE( WRITE "${MATLAB_GUI}" "@echo on\n")
FILE( WRITE "$${MATLAB_CMD}" "@echo on\n")
ELSE()
# Create a matlab wrapper for linux/mac
SET( MATLAB_GUI "${CMAKE_CURRENT_BINARY_DIR}/tmp/matlab-gui" )
SET( MATLAB_CMD "${CMAKE_CURRENT_BINARY_DIR}/tmp/matlab-cmd" )
SET( MATLAB_INSTALL_CMD "matlab-cmd" )
FILE( WRITE "${MATLAB_GUI}" "LD_PRELOAD=\"${tmp_libs}\" MATLABPATH=\"${tmp_path}\" \"${MATLAB_EXE2}\" -singleCompThread -nosplash \"$@\"\n")
FILE( WRITE "${MATLAB_CMD}" "LD_PRELOAD=\"${tmp_libs}\" MATLABPATH=\"${tmp_path}\" \"${MATLAB_EXE2}\" -singleCompThread -nosplash -nodisplay -nojvm \"$@\"\n")
ENDIF()
FILE( COPY "${MATLAB_GUI}" DESTINATION "${${PROJ}_INSTALL_DIR}/mex"
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE )
FILE( COPY "${MATLAB_CMD}" DESTINATION "${${PROJ}_INSTALL_DIR}/mex"
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE )
SET( MATLAB_EXE "${${PROJ}_INSTALL_DIR}/mex/${MATLAB_INSTALL_CMD}" CACHE INTERNAL "" )
ENDFUNCTION()
# Macro to change the classification of a package
MACRO( SET_PACKAGE_CLASSIFICATION PACKAGE_LIST PACKAGE_NAME CLASS )
LIST(FIND ${PACKAGE_LIST} ${PACKAGE_NAME} PACKAGE_NAME_IDX)
IF (PACKAGE_NAME_IDX EQUAL -1)
MESSAGE(FATAL_ERROR "Package ${PACKAGE_NAME} not found in list of packages!")
ELSE()
MATH(EXPR PACKAGE_CLASSIFICATION_IDX "${PACKAGE_NAME_IDX}+2")
LIST(INSERT ${PACKAGE_LIST} ${PACKAGE_CLASSIFICATION_IDX} ${CLASS})
MATH(EXPR PACKAGE_CLASSIFICATION_IDX "${PACKAGE_CLASSIFICATION_IDX} + 1")
LIST(REMOVE_AT ${PACKAGE_LIST} ${PACKAGE_CLASSIFICATION_IDX})
ENDIF()
ENDMACRO()
# Macro to "disable" a package on the given platform (this mearly changes it to experimental)
MACRO( PACKAGE_DISABLE_ON_PLATFORMS PACKAGE_LIST PACKAGE_NAME )
FOREACH(HOSTTYPE ${ARGN})
IF (${PROJECT_NAME}_HOSTTYPE STREQUAL ${HOSTTYPE})
SET_PACKAGE_CLASSIFICATION(${PACKAGE_LIST} ${PACKAGE_NAME} EX)
IF (${PROJECT_NAME}_ENABLE_${PACKAGE_NAME})
MESSAGE(
"\n***"
"\n*** WARNING: User has set ${PROJECT_NAME}_ENABLE_${PACKAGE_NAME}=ON but the"
"\n*** package ${PACKAGE_NAME} is not supported on this platform type '${HOSTTYPE}'!"
"\n***\n"
)
ENDIF()
ENDIF()
ENDFOREACH()
ENDMACRO()
# Append a list to a file # Append a list to a file
FUNCTION( APPEND_LIST FILENAME VARS PREFIX POSTFIX ) FUNCTION( APPEND_LIST FILENAME VARS PREFIX POSTFIX )
FOREACH( tmp ${VARS} ) FOREACH( tmp ${VARS} )
@ -1040,6 +1287,8 @@ MACRO( ADD_DISTCLEAN ${ARGN} )
#tmp# #tmp#
bin bin
cmake cmake
cppclean
compile_commands.json
${ARGN} ${ARGN}
) )
ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution) ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
@ -1097,3 +1346,32 @@ FUNCTION( WRITE_REPO_VERSION FILENAME )
ENDFUNCTION() ENDFUNCTION()
# Check if we can include a python module
FUNCTION( FIND_PYTHON_MODULE MODULE)
STRING(TOUPPER ${MODULE} MODULE2)
SET( PY_${MODULE}_FOUND FALSE )
IF ( NOT PY_${MODULE2} )
IF ( ARGC GREATER 1 AND ARGV1 STREQUAL "REQUIRED" )
SET(PY_${MODULE2}_FIND_REQUIRED TRUE)
ENDIF()
SET( CMD "import ${MODULE}; print('Success')" )
EXECUTE_PROCESS(COMMAND "${PYTHON_EXECUTABLE}" "-c" "${CMD}"
RESULT_VARIABLE _${MODULE2}_status
OUTPUT_VARIABLE _${MODULE2}_output
ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE )
IF ( "${_${MODULE2}_output}" STREQUAL "Success" )
SET( PY_${MODULE2}_FOUND TRUE )
ENDIF()
ELSE()
SET( PY_${MODULE2}_FOUND TRUE )
ENDIF()
IF ( PY_${MODULE2}_FOUND )
MESSAGE( STATUS "Performing Test PYTHON_${MODULE2} - Success" )
ELSE()
MESSAGE( STATUS "Performing Test PYTHON_${MODULE2} - Failure" )
ENDIF()
IF ( NOT PY_${MODULE2}_FOUND AND PY_${MODULE2}_FIND_REQUIRED )
MESSAGE( FATAL_ERROR "Unable to find required python module: ${MODULE2}" )
ENDIF()
SET( PY_${MODULE2}_FOUND ${PY_${MODULE2}_FOUND} PARENT_SCOPE )
ENDFUNCTION(FIND_PYTHON_MODULE)