From 26375fba2589c4dc0d69095662b93e1588a79f1b Mon Sep 17 00:00:00 2001 From: Mark Berrill Date: Tue, 30 Jan 2018 08:25:34 -0500 Subject: [PATCH] Updating CMake build system --- CMakeLists.txt | 90 +++---- cmake/libraries.cmake | 4 +- cmake/macros.cmake | 562 +++++++++++++++++++++++++++++++----------- 3 files changed, 469 insertions(+), 187 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index eaa34297..67379518 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,5 @@ # Set some CMake properties -CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -CMAKE_POLICY(SET CMP0014 OLD) -IF ( ${CMAKE_MAJOR_VERSION} EQUAL 3 ) - CMAKE_POLICY(SET CMP0026 OLD) -ENDIF() +CMAKE_MINIMUM_REQUIRED(VERSION 3.1) MESSAGE("====================") @@ -11,32 +7,44 @@ MESSAGE("Configuring LBPM-WIA") 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 IF ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}" ) MESSAGE( FATAL_ERROR "Building code in place is a bad idea" ) ENDIF() -# Set the project name -PROJECT( LBPM-WIA ) +# Set the default C++ standard IF ( NOT CXX_STD ) SET( CXX_STD 11 ) ENDIF() -# Set some common paths -SET( LBPM_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ) -SET( LBPM_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR} ) -IF( PREFIX ) - SET( LBPM_INSTALL_DIR ${PREFIX} ) -ELSEIF( NOT LBPM_INSTALL_DIR ) - SET( LBPM_INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR} ) +# Set source/install paths +SET( ${PROJ}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" ) +SET( ${PROJ}_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}" ) +IF( ${PROJ}_INSTALL_DIR ) + SET( ${PROJ}_INSTALL_DIR "${${PROJ}_INSTALL_DIR}" ) +ELSEIF( PREFIX ) + SET( ${PROJ}_INSTALL_DIR "${PREFIX}" ) +ELSEIF( NOT ${PROJ}_INSTALL_DIR ) + SET( ${PROJ}_INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}" ) 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 -SET( PROJ LBPM ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/macros.cmake" ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/libraries.cmake" ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/LBPM-macros.cmake" ) @@ -56,15 +64,6 @@ ENABLE_TESTING() 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 IF ( NOT ONLY_BUILD_DOCS ) CONFIGURE_SYSTEM() @@ -72,25 +71,27 @@ ENDIF() # 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_LATEX 1 ) -FILE( MAKE_DIRECTORY "${LBPM_INSTALL_DIR}/doc" ) +FILE( MAKE_DIRECTORY "${${PROJ}_INSTALL_DIR}/doc" ) IF ( USE_DOXYGEN ) - SET( DOXYFILE_IN ${LBPM_SOURCE_DIR}/doxygen/Doxyfile.in) - SET( DOXY_HEADER_FILE ${LBPM_SOURCE_DIR}/doxygen/html/header.html ) - SET( DOXY_FOOTER_FILE ${LBPM_SOURCE_DIR}/doxygen/html/footer.html ) - SET( DOXYFILE_OUTPUT_DIR ${LBPM_BUILD_DIR}/doc/ ) - SET( DOXYFILE_SRC_HTML_DIR ${LBPM_SOURCE_DIR}/doxygen/html ) - SET( DOXYFILE_SOURCE_DIR ${LBPM_SOURCE_DIR} ) + SET( DOXYFILE_LATEX YES ) + SET( DOXYFILE_IN "${${PROJ}_SOURCE_DIR}/doxygen/Doxyfile.in" ) + SET( DOXY_HEADER_FILE "${${PROJ}_SOURCE_DIR}/doxygen/html/header.html" ) + SET( DOXY_FOOTER_FILE "${${PROJ}_SOURCE_DIR}/doxygen/html/footer.html" ) + SET( DOXYFILE_OUTPUT_DIR "${${PROJ}_INSTALL_DIR}/doc" ) + SET( DOXYFILE_SRC_HTML_DIR "${${PROJ}_SOURCE_DIR}/doxygen/html" ) + SET( DOXYFILE_SOURCE_DIR "${${PROJ}_SOURCE_DIR}" ) SET( REL_PACKAGE_HTML "" ) SET( DOXYGEN_MACROS "" ) MESSAGE("DOXYGEN_MACROS = ${DOXYGEN_MACROS}") - INCLUDE( ${LBPM_SOURCE_DIR}/cmake/UseDoxygen.cmake ) - SET(DOXYFILE_LATEX "YES") + INCLUDE( "${${PROJ}_SOURCE_DIR}/cmake/UseDoxygen.cmake" ) IF ( DOXYGEN_FOUND ) ADD_DEPENDENCIES( doxygen latex_docs ) ADD_DEPENDENCIES( doc latex_docs doxygen ) @@ -100,6 +101,13 @@ IF ( USE_DOXYGEN ) 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 IF ( NOT ONLY_BUILD_DOCS ) 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_LINE_COVERAGE() 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( EXTERNAL_LIBS ${EXTERNAL_LIBS} ${TIMER_LIBS} ) ENDIF() -# Configure internal libraries (order matters) -SET( LBPM_LIBS lbpm-wia ) - # Macro to create 1,2,4 processor tests MACRO( ADD_LBPM_TEST_1_2_4 EXENAME ${ARGN} ) @@ -131,7 +136,7 @@ ENDMACRO() # Add the src directories IF ( NOT ONLY_BUILD_DOCS ) - BEGIN_PACKAGE_CONFIG( lbpm-wia ) + BEGIN_PACKAGE_CONFIG( lbpm-wia-library ) ADD_PACKAGE_SUBDIRECTORY( common ) ADD_PACKAGE_SUBDIRECTORY( analysis ) ADD_PACKAGE_SUBDIRECTORY( IO ) @@ -141,11 +146,12 @@ IF ( NOT ONLY_BUILD_DOCS ) ELSE() ADD_PACKAGE_SUBDIRECTORY( cpu ) ENDIF() - INSTALL_LBPM_TARGET( lbpm-wia ) + INSTALL_LBPM_TARGET( lbpm-wia-library ) ADD_SUBDIRECTORY( tests ) ADD_SUBDIRECTORY( threadpool/test ) ADD_SUBDIRECTORY( example ) #ADD_SUBDIRECTORY( workflows ) + INSTALL_PROJ_LIB() ENDIF() diff --git a/cmake/libraries.cmake b/cmake/libraries.cmake index 14740168..f9b4e578 100644 --- a/cmake/libraries.cmake +++ b/cmake/libraries.cmake @@ -276,7 +276,7 @@ MACRO( CONFIGURE_SYSTEM ) ENDIF() # Remove extra library links # Get the compiler - IDENTIFY_COMPILER() + SET_COMPILER_FLAGS() CHECK_ENABLE_FLAG( USE_STATIC 0 ) # Add system dependent flags MESSAGE("System is: ${CMAKE_SYSTEM_NAME}") @@ -330,8 +330,6 @@ MACRO( CONFIGURE_SYSTEM ) ELSE() MESSAGE( FATAL_ERROR "OS not detected" ) ENDIF() - # Set the compile flags based on the build - SET_COMPILER_FLAGS() # Add the static flag if necessary IF ( USE_STATIC ) SET_STATIC_FLAGS() diff --git a/cmake/macros.cmake b/cmake/macros.cmake index a556f6cf..27342c06 100644 --- a/cmake/macros.cmake +++ b/cmake/macros.cmake @@ -3,7 +3,8 @@ INCLUDE(CheckCSourceCompiles) INCLUDE(CheckCXXCompilerFlag) INCLUDE(CheckCXXSourceCompiles) 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() @@ -15,6 +16,9 @@ ENDIF() IF ( NOT ${PROJ}_INSTALL_DIR ) MESSAGE(FATAL_ERROR "${PROJ}_INSTALL_DIR must be set before including macros.cmake") 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 @@ -58,6 +62,16 @@ MACRO(ASSERT test comment) 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 # This command converts a file of the format "global_path/file.m4" # and convertes it to file.F. It also requires the path. @@ -97,7 +111,9 @@ ENDMACRO() # Add a package to the project's library MACRO( ADD_${PROJ}_LIBRARY PACKAGE ) + SET( CURRENT_LIBRARY ${PACKAGE} ) ADD_SUBDIRECTORY( ${PACKAGE} ) + SET( CURRENT_LIBRARY ) ENDMACRO() @@ -206,37 +222,76 @@ MACRO( INSTALL_${PROJ}_TARGET PACKAGE ) # Find all files in the current directory FIND_FILES() # 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} ) ADD_CUSTOM_TARGET( ${COPY_TARGET} ALL ) ADD_DEPENDENCIES( copy-${PROJ}-include ${COPY_TARGET} ) ENDIF() # Copy the header files to the include path - FILE( GLOB HFILES RELATIVE "${${PROJ}_SOURCE_DIR}" ${HEADERS} ) - FOREACH( HFILE ${HFILES} ) - SET( SRC_FILE "${${PROJ}_SOURCE_DIR}/${HFILE}" ) - SET( DST_FILE "${${PROJ}_INSTALL_DIR}/include/${HFILE}" ) - # Only copy the headers if the exisit in the project source directory - IF ( EXISTS "${SRC_FILE}" ) - ADD_CUSTOM_COMMAND(TARGET ${COPY_TARGET} - PRE_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different "${SRC_FILE}" "${DST_FILE}" - DEPENDS "${SRC_FILE}" - ) - ENDIF() - ENDFOREACH() + IF ( HEADERS ) + FILE( GLOB HFILES RELATIVE "${${PROJ}_SOURCE_DIR}" ${HEADERS} ) + FOREACH( HFILE ${HFILES} ) + SET( SRC_FILE "${${PROJ}_SOURCE_DIR}/${HFILE}" ) + SET( DST_FILE "${${PROJ}_INSTALL_DIR}/include/${${PROJ}_INC}/${HFILE}" ) + # Only copy the headers if the exisit in the project source directory + IF ( EXISTS "${SRC_FILE}" ) + ADD_CUSTOM_COMMAND(TARGET ${COPY_TARGET} + PRE_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different "${SRC_FILE}" "${DST_FILE}" + DEPENDS "${SRC_FILE}" + ) + ENDIF() + ENDFOREACH() + ENDIF() # Add the library and install the package IF ( NOT ONLY_BUILD_DOCS AND ( SOURCES OR CUDASOURCES ) ) - IF( USE_CUDA ) - CUDA_COMPILE( CUBINS ${CUDASOURCES} ) + # Set RPATH variables + 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() - ADD_LIBRARY( ${PACKAGE} ${LIB_TYPE} ${SOURCES} ${CUBINS} ) - TARGET_LINK_LIBRARIES( ${PACKAGE} ${SYSTEM_LDFLAGS} ) + # Add the library to the project libs list + 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 ) ADD_DEPENDENCIES( ${PACKAGE} write_repo_version ) ENDIF() 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() ADD_CUSTOM_TARGET( ${PACKAGE} ALL ) ENDIF() @@ -247,10 +302,28 @@ MACRO( INSTALL_${PROJ}_TARGET PACKAGE ) ENDMACRO() +# Install the project library +MACRO( INSTALL_PROJ_LIB ) + SET( tmp_link_list ) + FOREACH ( tmp ${${PROJ}_LIBS} ) + SET( tmp_link_list ${tmp_link_list} $ ) + 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( VERIFY_VARIABLE VARIABLE_NAME ) IF ( NOT ${VARIABLE_NAME} ) - MESSAGE( FATAL_ERROR "PLease set: " ${VARIABLE_NAME} ) + MESSAGE( FATAL_ERROR "Please set: " ${VARIABLE_NAME} ) ENDIF() ENDMACRO() @@ -269,64 +342,64 @@ ENDMACRO() # Macro to tell cmake to use static libraries MACRO( SET_STATIC_FLAGS ) # Remove extra library links - set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic - 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) + SET(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic + SET(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS) # Add the static flag if necessary SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") # Add static flag SET(CMAKE_C_FLAGS "${CMAKE_C_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() # Macro to identify the compiler MACRO( IDENTIFY_COMPILER ) # SET the C/C++ compiler - IF ( CMAKE_C_COMPILER_WORKS OR CMAKE_C_COMPILER_WORKS ) - IF( CMAKE_COMPILE_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) + IF ( CMAKE_C_COMPILER_WORKS OR CMAKE_CXX_COMPILER_WORKS ) + 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 ) ADD_DEFINITIONS( -DUSING_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" ) MESSAGE( FATAL_ERROR "Using microsoft compilers on non-windows system?" ) ENDIF() SET( USING_MSVC TRUE ) ADD_DEFINITIONS( -DUSING_MSVC ) 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) ADD_DEFINITIONS( -DUSING_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) ADD_DEFINITIONS( -DUSING_PGCC ) MESSAGE("Using pgCC") - ELSEIF( (${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") ) + 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") ) SET(USING_CRAY TRUE) ADD_DEFINITIONS( -DUSING_CRAY ) MESSAGE("Using Cray") - ELSEIF( (${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") ) + 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") ) SET(USING_CLANG TRUE) ADD_DEFINITIONS( -DUSING_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() - SET(USING_DEFAULT TRUE) - MESSAGE("${CMAKE_C_COMPILER_ID}") - MESSAGE(WARNING "Unknown C/C++ compiler, default flags will be used") + MESSAGE( "CMAKE_C_COMPILER=${CMAKE_C_COMPILER}") + MESSAGE( "CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}") + 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() # SET the Fortran++ compiler 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 ) MESSAGE("Using gfortran") ELSEIF ( (${CMAKE_Fortran_COMPILER_ID} MATCHES "Intel") ) @@ -335,10 +408,14 @@ MACRO( IDENTIFY_COMPILER ) ELSEIF ( ${CMAKE_Fortran_COMPILER_ID} MATCHES "PGI") SET(USING_PGF90 TRUE) 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() - SET(USING_DEFAULT TRUE) - MESSAGE("${CMAKE_Fortran_COMPILER_ID}") - MESSAGE("Unknown Fortran compiler, default flags will be used") + MESSAGE( "CMAKE_Fortran_COMPILER=${CMAKE_Fortran_COMPILER}") + MESSAGE( "CMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}") + MESSAGE(FATAL_ERROR "Unknown Fortran compiler (${CMAKE_Fortran_COMPILER_ID})") ENDIF() ENDIF() ENDMACRO() @@ -350,12 +427,12 @@ MACRO( SET_WARNINGS ) # Add gcc specific compiler options # 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 - SET(CMAKE_C_FLAGS "${CMAKE_C_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 -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 -Woverloaded-virtual -Wsign-compare") ELSEIF ( USING_MSVC ) # 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_CXX_FLAGS "${CMAKE_CXX_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 /wd4267" ) ELSEIF ( USING_ICC ) # Add Intel specifc compiler options 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") ELSEIF ( USING_CLANG ) # Add default compiler options - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall -Wno-char-subscripts -Wno-unused-private-field -Wno-unused-variable") - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall -Wno-char-subscripts -Wno-unused-private-field -Wno-unused-variable") - ELSEIF ( USING_DEFAULT ) + SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall") + SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall -Wno-missing-braces -Wmissing-field-initializers -ftemplate-depth=1024") + ELSEIF ( USING_XL ) # Add default compiler options - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS}") - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS}") + SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall") + SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall -ftemplate-depth=512") + ELSE ( ) + MESSAGE("Compiler specific features are not set for this compiler") ENDIF() ENDMACRO() @@ -387,6 +466,8 @@ MACRO( ADD_USER_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_Fortran_FLAGS} ${FFLAGS} ${FFLAGS_EXTRA}" CMAKE_Fortran_FLAGS ) + STRING( STRIP "${LDFLAGS} ${LDFLAGS_EXTRA}" LDFLAGS ) + STRING( STRIP "${LDLIBS} ${LDLIBS_EXTRA}" LDLIBS ) ENDMACRO() @@ -443,6 +524,15 @@ MACRO( ADD_CXX_STD ) ELSE() MESSAGE(FATAL_ERROR "Unknown standard") 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 ) # Default: do nothing ENDIF() @@ -457,8 +547,8 @@ MACRO( SET_COMPILER_FLAGS ) IDENTIFY_COMPILER() # Set the default flags for each build type IF ( USING_MSVC ) - SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG /DEBUG /Od /EHsc /MDd /Zi /Z7" ) - SET(CMAKE_CXX_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 /Z7" ) SET(CMAKE_C_FLAGS_RELEASE "/O2 /EHsc /MD" ) SET(CMAKE_CXX_FLAGS_RELEASE "/O2 /EHsc /MD" ) ELSE() @@ -478,7 +568,7 @@ MACRO( SET_COMPILER_FLAGS ) SET( DISABLE_GXX_DEBUG ON ) ENDIF() # 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_CXX_FLAGS_DEBUG " ${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -D_DEBUG" ) ENDIF() @@ -494,8 +584,12 @@ MACRO( SET_COMPILER_FLAGS ) # Set the warnings to use SET_WARNINGS() # Test the compile flags - CHECK_C_COMPILER_FLAG( "${CMAKE_C_FLAGS}" CHECK_C_FLAGS ) - CHECK_CXX_COMPILER_FLAG( "${CMAKE_CXX_FLAGS}" CHECK_CXX_FLAGS ) + IF ( CMAKE_C_COMPILER_WORKS ) + 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 ( USING_CRAY ) MESSAGE(WARNING "Invalid C/CXX flags detected:\n" @@ -592,6 +686,87 @@ FUNCTION( COPY_EXAMPLE_DATA_FILE FILENAME ) 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( ADD_PROJ_EXE_DEP EXE ) # Add the package dependencies @@ -607,18 +782,25 @@ MACRO( ADD_PROJ_EXE_DEP EXE ) ADD_DEPENDENCIES( ${EXE} copy-${PROJ}-Data ) ENDIF() # 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} ) - # Add external libraries - SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS}" ) - SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS_EXTRA}" ) + # Add coverage flags to target + IF ( NOT DISABLE_TARGET_COVERAGE ) + 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} ${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 ) - 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() - TARGET_LINK_LIBRARIES( ${EXE} ${LAPACK_LIBS} ${BLAS_LIBS} ${BLAS_LAPACK_LIBS} ) TARGET_LINK_LIBRARIES( ${EXE} ${COVERAGE_LIBS} ${LDLIBS} ${LDLIBS_EXTRA} ) TARGET_LINK_LIBRARIES( ${EXE} ${SYSTEM_LIBS} ${SYSTEM_LDFLAGS} ) ENDMACRO() @@ -627,6 +809,12 @@ ENDMACRO() # Check if we want to keep the test FUNCTION( KEEP_TEST RESULT ) 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 ) SET( ${RESULT} 0 PARENT_SCOPE ) ENDIF() @@ -640,13 +828,13 @@ FUNCTION( ADD_PROJ_PROVISIONAL_TEST EXEFILE ) IF ( NOT RESULT ) RETURN() ENDIF() - # Check if test has already been added - SET( tmp ) - IF ( TARGET ${EXEFILE} ) - GET_TARGET_PROPERTY(tmp ${EXEFILE} LOCATION) - STRING(REGEX REPLACE "//" "/" tmp "${tmp}" ) + # Check if the target does not exist (may not be added yet or we are re-configuring) + IF ( NOT TARGET ${EXEFILE} ) + GLOBAL_SET( ${EXEFILE}-BINDIR ) 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 SET( CXXFILE ${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} ) ENDIF() ADD_PROJ_EXE_DEP( ${EXEFILE} ) - ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}" ) - # The correct target has already been added - ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.exe" ) - # The correct target has already been added - ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/$(Configuration)/${EXEFILE}.exe" ) - # The correct target has already been added - ELSEIF( ${tmp} STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/${EXEFILE}" ) - # 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() + IF ( CURRENT_LIBRARY ) + IF ( NOT TARGET ${CURRENT_LIBRARY}-test ) + ADD_CUSTOM_TARGET( ${CURRENT_LIBRARY}-test ) + ENDIF() + ADD_DEPENDENCIES( ${CURRENT_LIBRARY}-test ${EXEFILE} ) + ENDIF() + ELSEIF ( NOT ${EXEFILE-BINDIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR} ) # 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( FATAL_ERROR "Trying to add 2 different tests with the same name" ) ENDIF() + SET( LAST_TEST ${EXEFILE} PARENT_SCOPE ) ENDFUNCTION() FUNCTION( 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( ADD_RESOURCE_LOCK TESTNAME EXEFILE ${ARGN} ) - IF ( NOT ARGN ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) - ELSE() - FOREACH( tmp ${ARGN} ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${tmp} ) - ENDFOREACH() + IF ( NOT DISABLE_RESOURCE_LOCK ) + IF ( NOT ARGN ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) + ELSE() + FOREACH( tmp ${ARGN} ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${tmp} ) + ENDFOREACH() + ENDIF() ENDIF() ENDFUNCTION() @@ -716,12 +903,11 @@ FUNCTION( ADD_${PROJ}_TEST EXEFILE ${ARGN} ) # Add the provisional test ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) CREATE_TEST_NAME( ${EXEFILE} ${ARGN} ) - GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION) - STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" ) 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 $ ${ARGN} ) + SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none ) ELSE() - ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) + ADD_TEST( NAME ${TESTNAME} COMMAND $ ${ARGN} ) ENDIF() SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) @@ -737,8 +923,6 @@ FUNCTION( ADD_${PROJ}_WEEKLY_TEST EXEFILE PROCS ${ARGN} ) ENDIF() # Add the provisional test ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) - GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION) - STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" ) IF( ${PROCS} STREQUAL "1" ) CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} ) 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" ) CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} ) 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 $ ${ARGN} ) + SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none ) ELSE() - ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) + ADD_TEST( NAME ${TESTNAME} COMMAND $ ${ARGN} ) ENDIF() SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ELSEIF( (USE_MPI OR USE_EXT_MPI) AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) 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} $ ${ARGN} ) 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} ) ENDIF() ENDFUNCTION() @@ -773,15 +959,14 @@ FUNCTION( ADD_${PROJ}_TEST_PARALLEL EXEFILE PROCS ${ARGN} ) ENDIF() # Add the provisional test 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} ) IF ( NOT ( USE_MPI OR USE_EXT_MPI ) ) MESSAGE("Disabling test ${TESTNAME} (configured without MPI)") ELSEIF ( ${PROCS} GREATER ${TEST_MAX_PROCS} ) MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS})") ELSE() - ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) + ADD_TEST( NAME ${TESTNAME} COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} $ ${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} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ENDIF() @@ -792,18 +977,17 @@ ENDFUNCTION() # This allows us to correctly compute the number of processors used by the test MACRO( ADD_${PROJ}_TEST_THREAD_MPI EXEFILE PROCS THREADS ${ARGN} ) 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} ) MATH( EXPR TOT_PROCS "${PROCS} * ${THREADS}" ) 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 ) - ADD_TEST ( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) + ADD_TEST( NAME ${TESTNAME} COMMAND $ ${ARGN} ) SET_TESTS_PROPERTIES ( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) 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} $ ${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} ) ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ENDIF() @@ -829,19 +1013,17 @@ FUNCTION( ADD_${PROJ}_EXAMPLE EXEFILE PROCS ${ARGN} ) ENDIF() # Add the provisional test ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) - GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION) - STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" ) ADD_DEPENDENCIES( build-examples ${EXEFILE} ) - GET_TARGET_PROPERTY(EXE2 ${EXEFILE} LOCATION) ADD_CUSTOM_COMMAND( TARGET ${EXEFILE} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy ${EXE2} "${EXAMPLE_INSTALL_DIR}/${EXEFILE}" + COMMAND ${CMAKE_COMMAND} -E copy $ "${EXAMPLE_INSTALL_DIR}/${EXEFILE}" ) IF( ${PROCS} STREQUAL "1" AND (NOT USE_MPI_FOR_SERIAL_TESTS) ) CREATE_TEST_NAME( "example--${EXEFILE}" ${ARGN} ) - ADD_TEST( ${TESTNAME} ${EXE} ${ARGN} ) + ADD_TEST( NAME ${TESTNAME} COMMAND $ ${ARGN} ) ELSEIF ( USE_EXT_MPI AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) 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} $ ${ARGN} ) + SET_PROPERTY( TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT OMPI_MCA_hwloc_base_binding_policy=none ) ENDIF() SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) @@ -874,9 +1056,9 @@ MACRO( CHECK_ENABLE_FLAG FLAG DEFAULT ) SET( ${FLAG} ${DEFAULT} ) ELSEIF( ${FLAG} STREQUAL "" ) 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 ) - 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 ) ELSE() MESSAGE( "Bad value for ${FLAG} (${${FLAG}}); use true or false" ) @@ -909,27 +1091,30 @@ ENDMACRO() FUNCTION( ADD_MATLAB_MEX MEXFILE ) # Set the MEX compiler and default link flags IF ( USING_MSVC ) - SET( MEX "\"${MATLAB_DIRECTORY}/bin/mex.bat\"" ) SET( MEX_LDFLAGS ${MEX_LDFLAGS} -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() - 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} ) IF ( NOT USING_MSVC ) FOREACH( rpath ${CMAKE_INSTALL_RPATH} ) SET( MEX_LDFLAGS ${MEX_LDFLAGS} "-Wl,-rpath,${rpath},--no-undefined" ) ENDFOREACH() 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 STRING(REGEX REPLACE "[.]cpp" "" TARGET ${MEXFILE}) STRING(REGEX REPLACE "[.]c" "" TARGET ${TARGET}) FILE(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}" ) IF ( USING_MSVC ) 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}" "${COMPFLAGS}" "\"" "\" " ) APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_INCLUDE}" "\"" "\" " ) @@ -940,7 +1125,7 @@ FUNCTION( ADD_MATLAB_MEX MEXFILE ) ELSE() STRING(REPLACE " " ";" MEX_CFLAGS "$$CFLAGS ${CMAKE_C_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} CFLAGS="${MEX_CFLAGS}" CXXFLAGS="${MEX_CXXFLAGS}" @@ -952,7 +1137,7 @@ FUNCTION( ADD_MATLAB_MEX MEXFILE ) OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION} 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}" "${${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} 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_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} ) - 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() # Add a matlab test 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 ) CREATE_TEST_NAME( MATLAB ${EXEFILE} ${ARGN} ) IF ( USING_MSVC ) - SET( MATLAB_OPTIONS "-nodisplay" "-nodesktop" "-wait" "-logfile" "log_${EXEFILE}" ) - ELSE() - SET( MATLAB_OPTIONS "-nojvm -nosplash -nodisplay" ) + SET( MATLAB_OPTIONS "-logfile" "log_${EXEFILE}" ) 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 ) IF ( MATLAB_DEBUGGER ) SET( MATLAB_DEBUGGER_OPTIONS -D${MATLAB_DEBUGGER} ) STRING(REPLACE "\"" "" MATLAB_DEBUGGER_OPTIONS "${MATLAB_DEBUGGER_OPTIONS}") ENDIF() - IF ( USING_MSVC ) - 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() + ADD_TEST( NAME ${TESTNAME} COMMAND "${MATLAB_EXE}" ${MATLAB_OPTIONS} -r "${MATLAB_COMMAND}" ${MATLAB_DEBUGGER_OPTIONS} ) 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} ) 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 FUNCTION( APPEND_LIST FILENAME VARS PREFIX POSTFIX ) FOREACH( tmp ${VARS} ) @@ -1040,6 +1287,8 @@ MACRO( ADD_DISTCLEAN ${ARGN} ) #tmp# bin cmake + cppclean + compile_commands.json ${ARGN} ) ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution) @@ -1097,3 +1346,32 @@ FUNCTION( WRITE_REPO_VERSION FILENAME ) 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)