Home | History | Annotate | Download | only in cmake 
      1 
      2 macro(ei_add_property prop value)
      3   get_property(previous GLOBAL PROPERTY ${prop})
      4   if ((NOT previous) OR (previous STREQUAL ""))
      5     set_property(GLOBAL PROPERTY ${prop} "${value}")
      6   else()
      7     set_property(GLOBAL PROPERTY ${prop} "${previous} ${value}")
      8   endif()
      9 endmacro(ei_add_property)
     10 
     11 #internal. See documentation of ei_add_test for details.
     12 macro(ei_add_test_internal testname testname_with_suffix)
     13   set(targetname ${testname_with_suffix})
     14 
     15   if(EIGEN_ADD_TEST_FILENAME_EXTENSION)
     16     set(filename ${testname}.${EIGEN_ADD_TEST_FILENAME_EXTENSION})
     17   else()
     18     set(filename ${testname}.cpp)
     19   endif()
     20 
     21   if(EIGEN_ADD_TEST_FILENAME_EXTENSION STREQUAL cu)
     22     if(EIGEN_TEST_CUDA_CLANG)
     23       set_source_files_properties(${filename} PROPERTIES LANGUAGE CXX)
     24       if(CUDA_64_BIT_DEVICE_CODE)
     25         link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
     26       else()
     27         link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib")
     28       endif()
     29       if (${ARGC} GREATER 2)
     30         add_executable(${targetname} ${filename})
     31       else()
     32         add_executable(${targetname} ${filename} OPTIONS ${ARGV2})
     33       endif()
     34       target_link_libraries(${targetname} "cudart_static" "cuda" "dl" "rt" "pthread")
     35     else()
     36       if (${ARGC} GREATER 2)
     37         cuda_add_executable(${targetname} ${filename} OPTIONS ${ARGV2})
     38       else()
     39         cuda_add_executable(${targetname} ${filename})
     40       endif()
     41     endif()
     42   else()
     43     add_executable(${targetname} ${filename})
     44   endif()
     45 
     46   if (targetname MATCHES "^eigen2_")
     47     add_dependencies(eigen2_buildtests ${targetname})
     48   else()
     49     add_dependencies(buildtests ${targetname})
     50   endif()
     51 
     52   if(EIGEN_NO_ASSERTION_CHECKING)
     53     ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_NO_ASSERTION_CHECKING=1")
     54   else(EIGEN_NO_ASSERTION_CHECKING)
     55     if(EIGEN_DEBUG_ASSERTS)
     56       ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_DEBUG_ASSERTS=1")
     57     endif(EIGEN_DEBUG_ASSERTS)
     58   endif(EIGEN_NO_ASSERTION_CHECKING)
     59 
     60   ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE}")
     61 
     62   ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_TEST_FUNC=${testname}")
     63 
     64   if(MSVC)
     65     ei_add_target_property(${targetname} COMPILE_FLAGS "/bigobj")
     66   endif()
     67 
     68   # let the user pass flags.
     69   if(${ARGC} GREATER 2)
     70     ei_add_target_property(${targetname} COMPILE_FLAGS "${ARGV2}")
     71   endif(${ARGC} GREATER 2)
     72 
     73   if(EIGEN_TEST_CUSTOM_CXX_FLAGS)
     74     ei_add_target_property(${targetname} COMPILE_FLAGS "${EIGEN_TEST_CUSTOM_CXX_FLAGS}")
     75   endif()
     76 
     77   if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
     78     target_link_libraries(${targetname} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
     79   endif()
     80   if(EXTERNAL_LIBS)
     81     target_link_libraries(${targetname} ${EXTERNAL_LIBS})
     82   endif()
     83   if(EIGEN_TEST_CUSTOM_LINKER_FLAGS)
     84     target_link_libraries(${targetname} ${EIGEN_TEST_CUSTOM_LINKER_FLAGS})
     85   endif()
     86 
     87   if(${ARGC} GREATER 3)
     88     set(libs_to_link ${ARGV3})
     89     # it could be that some cmake module provides a bad library string " "  (just spaces),
     90     # and that severely breaks target_link_libraries ("can't link to -l-lstdc++" errors).
     91     # so we check for strings containing only spaces.
     92     string(STRIP "${libs_to_link}" libs_to_link_stripped)
     93     string(LENGTH "${libs_to_link_stripped}" libs_to_link_stripped_length)
     94     if(${libs_to_link_stripped_length} GREATER 0)
     95       # notice: no double quotes around ${libs_to_link} here. It may be a list.
     96       target_link_libraries(${targetname} ${libs_to_link})
     97     endif()
     98   endif()
     99 
    100   add_test(${testname_with_suffix} "${targetname}")
    101 
    102   # Specify target and test labels accoirding to EIGEN_CURRENT_SUBPROJECT
    103   get_property(current_subproject GLOBAL PROPERTY EIGEN_CURRENT_SUBPROJECT)
    104   if ((current_subproject) AND (NOT (current_subproject STREQUAL "")))
    105     set_property(TARGET ${targetname} PROPERTY LABELS "Build${current_subproject}")
    106     add_dependencies("Build${current_subproject}" ${targetname})
    107     set_property(TEST ${testname_with_suffix} PROPERTY LABELS "${current_subproject}")
    108   endif()
    109 
    110 endmacro(ei_add_test_internal)
    111 
    112 # SYCL
    113 macro(ei_add_test_internal_sycl testname testname_with_suffix)
    114   include_directories( SYSTEM ${COMPUTECPP_PACKAGE_ROOT_DIR}/include)
    115   set(targetname ${testname_with_suffix})
    116 
    117   if(EIGEN_ADD_TEST_FILENAME_EXTENSION)
    118     set(filename ${testname}.${EIGEN_ADD_TEST_FILENAME_EXTENSION})
    119   else()
    120     set(filename ${testname}.cpp)
    121   endif()
    122 
    123   set( include_file ${CMAKE_CURRENT_BINARY_DIR}/inc_${filename})
    124   set( bc_file ${CMAKE_CURRENT_BINARY_DIR}/${filename})
    125   set( host_file ${CMAKE_CURRENT_SOURCE_DIR}/${filename})
    126 
    127   ADD_CUSTOM_COMMAND(
    128     OUTPUT ${include_file}
    129     COMMAND ${CMAKE_COMMAND} -E echo "\\#include \\\"${host_file}\\\"" > ${include_file}
    130     COMMAND ${CMAKE_COMMAND} -E echo "\\#include \\\"${bc_file}.sycl\\\"" >> ${include_file}
    131     DEPENDS ${filename} ${bc_file}.sycl
    132     COMMENT "Building ComputeCpp integration header file ${include_file}"
    133   )
    134   # Add a custom target for the generated integration header
    135   add_custom_target(${testname}_integration_header_sycl DEPENDS ${include_file})
    136 
    137   add_executable(${targetname} ${include_file})
    138   add_dependencies(${targetname} ${testname}_integration_header_sycl)
    139   add_sycl_to_target(${targetname} ${filename} ${CMAKE_CURRENT_BINARY_DIR})
    140 
    141   if (targetname MATCHES "^eigen2_")
    142     add_dependencies(eigen2_buildtests ${targetname})
    143   else()
    144     add_dependencies(buildtests ${targetname})
    145   endif()
    146 
    147   if(EIGEN_NO_ASSERTION_CHECKING)
    148     ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_NO_ASSERTION_CHECKING=1")
    149   else(EIGEN_NO_ASSERTION_CHECKING)
    150     if(EIGEN_DEBUG_ASSERTS)
    151       ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_DEBUG_ASSERTS=1")
    152     endif(EIGEN_DEBUG_ASSERTS)
    153   endif(EIGEN_NO_ASSERTION_CHECKING)
    154 
    155   ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE}")
    156 
    157   ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_TEST_FUNC=${testname}")
    158 
    159   if(MSVC AND NOT EIGEN_SPLIT_LARGE_TESTS)
    160     ei_add_target_property(${targetname} COMPILE_FLAGS "/bigobj")
    161   endif()
    162 
    163   # let the user pass flags.
    164   if(${ARGC} GREATER 2)
    165     ei_add_target_property(${targetname} COMPILE_FLAGS "${ARGV2}")
    166   endif(${ARGC} GREATER 2)
    167 
    168   if(EIGEN_TEST_CUSTOM_CXX_FLAGS)
    169     ei_add_target_property(${targetname} COMPILE_FLAGS "${EIGEN_TEST_CUSTOM_CXX_FLAGS}")
    170   endif()
    171 
    172   if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
    173     target_link_libraries(${targetname} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
    174   endif()
    175   if(EXTERNAL_LIBS)
    176     target_link_libraries(${targetname} ${EXTERNAL_LIBS})
    177   endif()
    178   if(EIGEN_TEST_CUSTOM_LINKER_FLAGS)
    179     target_link_libraries(${targetname} ${EIGEN_TEST_CUSTOM_LINKER_FLAGS})
    180   endif()
    181 
    182   if(${ARGC} GREATER 3)
    183     set(libs_to_link ${ARGV3})
    184     # it could be that some cmake module provides a bad library string " "  (just spaces),
    185     # and that severely breaks target_link_libraries ("can't link to -l-lstdc++" errors).
    186     # so we check for strings containing only spaces.
    187     string(STRIP "${libs_to_link}" libs_to_link_stripped)
    188     string(LENGTH "${libs_to_link_stripped}" libs_to_link_stripped_length)
    189     if(${libs_to_link_stripped_length} GREATER 0)
    190       # notice: no double quotes around ${libs_to_link} here. It may be a list.
    191       target_link_libraries(${targetname} ${libs_to_link})
    192     endif()
    193   endif()
    194 
    195   add_test(${testname_with_suffix} "${targetname}")
    196 
    197   # Specify target and test labels according to EIGEN_CURRENT_SUBPROJECT
    198   get_property(current_subproject GLOBAL PROPERTY EIGEN_CURRENT_SUBPROJECT)
    199   if ((current_subproject) AND (NOT (current_subproject STREQUAL "")))
    200     set_property(TARGET ${targetname} PROPERTY LABELS "Build${current_subproject}")
    201     add_dependencies("Build${current_subproject}" ${targetname})
    202     set_property(TEST ${testname_with_suffix} PROPERTY LABELS "${current_subproject}")
    203   endif()
    204 
    205 
    206 endmacro(ei_add_test_internal_sycl)
    207 
    208 
    209 # Macro to add a test
    210 #
    211 # the unique mandatory parameter testname must correspond to a file
    212 # <testname>.cpp which follows this pattern:
    213 #
    214 # #include "main.h"
    215 # void test_<testname>() { ... }
    216 #
    217 # Depending on the contents of that file, this macro can have 2 behaviors,
    218 # see below.
    219 #
    220 # The optional 2nd parameter is libraries to link to.
    221 #
    222 # A. Default behavior
    223 #
    224 # this macro adds an executable <testname> as well as a ctest test
    225 # named <testname> too.
    226 #
    227 # On platforms with bash simply run:
    228 #   "ctest -V" or "ctest -V -R <testname>"
    229 # On other platform use ctest as usual
    230 #
    231 # B. Multi-part behavior
    232 #
    233 # If the source file matches the regexp
    234 #    CALL_SUBTEST_[0-9]+|EIGEN_TEST_PART_[0-9]+
    235 # then it is interpreted as a multi-part test. The behavior then depends on the
    236 # CMake option EIGEN_SPLIT_LARGE_TESTS, which is ON by default.
    237 #
    238 # If EIGEN_SPLIT_LARGE_TESTS is OFF, the behavior is the same as in A (the multi-part
    239 # aspect is ignored).
    240 #
    241 # If EIGEN_SPLIT_LARGE_TESTS is ON, the test is split into multiple executables
    242 #   test_<testname>_<N>
    243 # where N runs from 1 to the greatest occurence found in the source file. Each of these
    244 # executables is built passing -DEIGEN_TEST_PART_N. This allows to split large tests
    245 # into smaller executables.
    246 #
    247 # Moreover, targets <testname> are still generated, they
    248 # have the effect of building all the parts of the test.
    249 #
    250 # Again, ctest -R allows to run all matching tests.
    251 macro(ei_add_test testname)
    252   get_property(EIGEN_TESTS_LIST GLOBAL PROPERTY EIGEN_TESTS_LIST)
    253   set(EIGEN_TESTS_LIST "${EIGEN_TESTS_LIST}${testname}\n")
    254   set_property(GLOBAL PROPERTY EIGEN_TESTS_LIST "${EIGEN_TESTS_LIST}")
    255 
    256   if(EIGEN_ADD_TEST_FILENAME_EXTENSION)
    257     set(filename ${testname}.${EIGEN_ADD_TEST_FILENAME_EXTENSION})
    258   else()
    259     set(filename ${testname}.cpp)
    260   endif()
    261 
    262   file(READ "${filename}" test_source)
    263   set(parts 0)
    264   string(REGEX MATCHALL "CALL_SUBTEST_[0-9]+|EIGEN_TEST_PART_[0-9]+|EIGEN_SUFFIXES(;[0-9]+)+"
    265          occurences "${test_source}")
    266   string(REGEX REPLACE "CALL_SUBTEST_|EIGEN_TEST_PART_|EIGEN_SUFFIXES" "" suffixes "${occurences}")
    267   list(REMOVE_DUPLICATES suffixes)
    268   if(EIGEN_SPLIT_LARGE_TESTS AND suffixes)
    269     add_custom_target(${testname})
    270     foreach(suffix ${suffixes})
    271       ei_add_test_internal(${testname} ${testname}_${suffix}
    272         "${ARGV1} -DEIGEN_TEST_PART_${suffix}=1" "${ARGV2}")
    273       add_dependencies(${testname} ${testname}_${suffix})
    274     endforeach(suffix)
    275   else(EIGEN_SPLIT_LARGE_TESTS AND suffixes)
    276     set(symbols_to_enable_all_parts "")
    277     foreach(suffix ${suffixes})
    278       set(symbols_to_enable_all_parts
    279         "${symbols_to_enable_all_parts} -DEIGEN_TEST_PART_${suffix}=1")
    280     endforeach(suffix)
    281     ei_add_test_internal(${testname} ${testname} "${ARGV1} ${symbols_to_enable_all_parts}" "${ARGV2}")
    282   endif(EIGEN_SPLIT_LARGE_TESTS AND suffixes)
    283 endmacro(ei_add_test)
    284 
    285 macro(ei_add_test_sycl testname)
    286   get_property(EIGEN_TESTS_LIST GLOBAL PROPERTY EIGEN_TESTS_LIST)
    287   set(EIGEN_TESTS_LIST "${EIGEN_TESTS_LIST}${testname}\n")
    288   set_property(GLOBAL PROPERTY EIGEN_TESTS_LIST "${EIGEN_TESTS_LIST}")
    289 
    290   if(EIGEN_ADD_TEST_FILENAME_EXTENSION)
    291     set(filename ${testname}.${EIGEN_ADD_TEST_FILENAME_EXTENSION})
    292   else()
    293     set(filename ${testname}.cpp)
    294   endif()
    295 
    296   file(READ "${filename}" test_source)
    297   set(parts 0)
    298   string(REGEX MATCHALL "CALL_SUBTEST_[0-9]+|EIGEN_TEST_PART_[0-9]+|EIGEN_SUFFIXES(;[0-9]+)+"
    299          occurences "${test_source}")
    300   string(REGEX REPLACE "CALL_SUBTEST_|EIGEN_TEST_PART_|EIGEN_SUFFIXES" "" suffixes "${occurences}")
    301   list(REMOVE_DUPLICATES suffixes)
    302   if(EIGEN_SPLIT_LARGE_TESTS AND suffixes)
    303     add_custom_target(${testname})
    304     foreach(suffix ${suffixes})
    305       ei_add_test_internal_sycl(${testname} ${testname}_${suffix}
    306         "${ARGV1} -DEIGEN_TEST_PART_${suffix}=1" "${ARGV2}")
    307       add_dependencies(${testname} ${testname}_${suffix})
    308     endforeach(suffix)
    309   else(EIGEN_SPLIT_LARGE_TESTS AND suffixes)
    310     set(symbols_to_enable_all_parts "")
    311     foreach(suffix ${suffixes})
    312       set(symbols_to_enable_all_parts
    313         "${symbols_to_enable_all_parts} -DEIGEN_TEST_PART_${suffix}=1")
    314     endforeach(suffix)
    315     ei_add_test_internal_sycl(${testname} ${testname} "${ARGV1} ${symbols_to_enable_all_parts}" "${ARGV2}")
    316   endif(EIGEN_SPLIT_LARGE_TESTS AND suffixes)
    317 endmacro(ei_add_test_sycl)
    318 
    319 # adds a failtest, i.e. a test that succeed if the program fails to compile
    320 # note that the test runner for these is CMake itself, when passed -DEIGEN_FAILTEST=ON
    321 # so here we're just running CMake commands immediately, we're not adding any targets.
    322 macro(ei_add_failtest testname)
    323   get_property(EIGEN_FAILTEST_FAILURE_COUNT GLOBAL PROPERTY EIGEN_FAILTEST_FAILURE_COUNT)
    324   get_property(EIGEN_FAILTEST_COUNT GLOBAL PROPERTY EIGEN_FAILTEST_COUNT)
    325 
    326   message(STATUS "Checking failtest: ${testname}")
    327   set(filename "${testname}.cpp")
    328   file(READ "${filename}" test_source)
    329 
    330   try_compile(succeeds_when_it_should_fail
    331               "${CMAKE_CURRENT_BINARY_DIR}"
    332               "${CMAKE_CURRENT_SOURCE_DIR}/${filename}"
    333               COMPILE_DEFINITIONS "-DEIGEN_SHOULD_FAIL_TO_BUILD")
    334   if (succeeds_when_it_should_fail)
    335     message(STATUS "FAILED: ${testname} build succeeded when it should have failed")
    336   endif()
    337 
    338   try_compile(succeeds_when_it_should_succeed
    339               "${CMAKE_CURRENT_BINARY_DIR}"
    340               "${CMAKE_CURRENT_SOURCE_DIR}/${filename}"
    341               COMPILE_DEFINITIONS)
    342   if (NOT succeeds_when_it_should_succeed)
    343     message(STATUS "FAILED: ${testname} build failed when it should have succeeded")
    344   endif()
    345 
    346   if (succeeds_when_it_should_fail OR NOT succeeds_when_it_should_succeed)
    347     math(EXPR EIGEN_FAILTEST_FAILURE_COUNT ${EIGEN_FAILTEST_FAILURE_COUNT}+1)
    348   endif()
    349 
    350   math(EXPR EIGEN_FAILTEST_COUNT ${EIGEN_FAILTEST_COUNT}+1)
    351 
    352   set_property(GLOBAL PROPERTY EIGEN_FAILTEST_FAILURE_COUNT ${EIGEN_FAILTEST_FAILURE_COUNT})
    353   set_property(GLOBAL PROPERTY EIGEN_FAILTEST_COUNT ${EIGEN_FAILTEST_COUNT})
    354 endmacro(ei_add_failtest)
    355 
    356 # print a summary of the different options
    357 macro(ei_testing_print_summary)
    358   message(STATUS "************************************************************")
    359   message(STATUS "***    Eigen's unit tests configuration summary          ***")
    360   message(STATUS "************************************************************")
    361   message(STATUS "")
    362   message(STATUS "Build type:        ${CMAKE_BUILD_TYPE}")
    363   message(STATUS "Build site:        ${SITE}")
    364   message(STATUS "Build string:      ${BUILDNAME}")
    365   get_property(EIGEN_TESTING_SUMMARY GLOBAL PROPERTY EIGEN_TESTING_SUMMARY)
    366   get_property(EIGEN_TESTED_BACKENDS GLOBAL PROPERTY EIGEN_TESTED_BACKENDS)
    367   get_property(EIGEN_MISSING_BACKENDS GLOBAL PROPERTY EIGEN_MISSING_BACKENDS)
    368   message(STATUS "Enabled backends:  ${EIGEN_TESTED_BACKENDS}")
    369   message(STATUS "Disabled backends: ${EIGEN_MISSING_BACKENDS}")
    370 
    371   if(EIGEN_DEFAULT_TO_ROW_MAJOR)
    372     message(STATUS "Default order:     Row-major")
    373   else()
    374     message(STATUS "Default order:     Column-major")
    375   endif()
    376 
    377   if(EIGEN_TEST_NO_EXPLICIT_ALIGNMENT)
    378     message(STATUS "Explicit alignment (hence vectorization) disabled")
    379   elseif(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION)
    380     message(STATUS "Explicit vectorization disabled (alignment kept enabled)")
    381   else()
    382 
    383   message(STATUS "Maximal matrix/vector size: ${EIGEN_TEST_MAX_SIZE}")
    384 
    385     if(EIGEN_TEST_SSE2)
    386       message(STATUS "SSE2:              ON")
    387     else()
    388       message(STATUS "SSE2:              Using architecture defaults")
    389     endif()
    390 
    391     if(EIGEN_TEST_SSE3)
    392       message(STATUS "SSE3:              ON")
    393     else()
    394       message(STATUS "SSE3:              Using architecture defaults")
    395     endif()
    396 
    397     if(EIGEN_TEST_SSSE3)
    398       message(STATUS "SSSE3:             ON")
    399     else()
    400       message(STATUS "SSSE3:             Using architecture defaults")
    401     endif()
    402 
    403     if(EIGEN_TEST_SSE4_1)
    404       message(STATUS "SSE4.1:            ON")
    405     else()
    406       message(STATUS "SSE4.1:            Using architecture defaults")
    407     endif()
    408 
    409     if(EIGEN_TEST_SSE4_2)
    410       message(STATUS "SSE4.2:            ON")
    411     else()
    412       message(STATUS "SSE4.2:            Using architecture defaults")
    413     endif()
    414 
    415     if(EIGEN_TEST_AVX)
    416       message(STATUS "AVX:               ON")
    417     else()
    418       message(STATUS "AVX:               Using architecture defaults")
    419     endif()
    420 
    421     if(EIGEN_TEST_FMA)
    422       message(STATUS "FMA:               ON")
    423     else()
    424       message(STATUS "FMA:               Using architecture defaults")
    425     endif()
    426 
    427     if(EIGEN_TEST_AVX512)
    428       message(STATUS "AVX512:            ON")
    429     else()
    430       message(STATUS "AVX512:            Using architecture defaults")
    431     endif()
    432 
    433     if(EIGEN_TEST_ALTIVEC)
    434       message(STATUS "Altivec:           ON")
    435     else()
    436       message(STATUS "Altivec:           Using architecture defaults")
    437     endif()
    438 
    439     if(EIGEN_TEST_VSX)
    440       message(STATUS "VSX:               ON")
    441     else()
    442       message(STATUS "VSX:               Using architecture defaults")
    443     endif()
    444 
    445     if(EIGEN_TEST_NEON)
    446       message(STATUS "ARM NEON:          ON")
    447     else()
    448       message(STATUS "ARM NEON:          Using architecture defaults")
    449     endif()
    450 
    451     if(EIGEN_TEST_NEON64)
    452       message(STATUS "ARMv8 NEON:        ON")
    453     else()
    454       message(STATUS "ARMv8 NEON:        Using architecture defaults")
    455     endif()
    456 
    457     if(EIGEN_TEST_ZVECTOR)
    458       message(STATUS "S390X ZVECTOR:     ON")
    459     else()
    460       message(STATUS "S390X ZVECTOR:     Using architecture defaults")
    461     endif()
    462 
    463     if(EIGEN_TEST_CXX11)
    464       message(STATUS "C++11:             ON")
    465     else()
    466       message(STATUS "C++11:             OFF")
    467     endif()
    468 
    469     if(EIGEN_TEST_SYCL)
    470       message(STATUS "SYCL:              ON")
    471     else()
    472       message(STATUS "SYCL:              OFF")
    473     endif()
    474     if(EIGEN_TEST_CUDA)
    475       if(EIGEN_TEST_CUDA_CLANG)
    476         message(STATUS "CUDA:              ON (using clang)")
    477       else()
    478         message(STATUS "CUDA:              ON (using nvcc)")
    479       endif()
    480     else()
    481       message(STATUS "CUDA:              OFF")
    482     endif()
    483 
    484   endif() # vectorization / alignment options
    485 
    486   message(STATUS "\n${EIGEN_TESTING_SUMMARY}")
    487 
    488   message(STATUS "************************************************************")
    489 endmacro(ei_testing_print_summary)
    490 
    491 macro(ei_init_testing)
    492   define_property(GLOBAL PROPERTY EIGEN_CURRENT_SUBPROJECT BRIEF_DOCS " " FULL_DOCS " ")
    493   define_property(GLOBAL PROPERTY EIGEN_TESTED_BACKENDS BRIEF_DOCS " " FULL_DOCS " ")
    494   define_property(GLOBAL PROPERTY EIGEN_MISSING_BACKENDS BRIEF_DOCS " " FULL_DOCS " ")
    495   define_property(GLOBAL PROPERTY EIGEN_TESTING_SUMMARY BRIEF_DOCS " " FULL_DOCS " ")
    496   define_property(GLOBAL PROPERTY EIGEN_TESTS_LIST BRIEF_DOCS " " FULL_DOCS " ")
    497 
    498   set_property(GLOBAL PROPERTY EIGEN_TESTED_BACKENDS "")
    499   set_property(GLOBAL PROPERTY EIGEN_MISSING_BACKENDS "")
    500   set_property(GLOBAL PROPERTY EIGEN_TESTING_SUMMARY "")
    501   set_property(GLOBAL PROPERTY EIGEN_TESTS_LIST "")
    502 
    503   define_property(GLOBAL PROPERTY EIGEN_FAILTEST_FAILURE_COUNT BRIEF_DOCS " " FULL_DOCS " ")
    504   define_property(GLOBAL PROPERTY EIGEN_FAILTEST_COUNT BRIEF_DOCS " " FULL_DOCS " ")
    505 
    506   set_property(GLOBAL PROPERTY EIGEN_FAILTEST_FAILURE_COUNT "0")
    507   set_property(GLOBAL PROPERTY EIGEN_FAILTEST_COUNT "0")
    508 
    509   # uncomment anytime you change the ei_get_compilerver_from_cxx_version_string macro
    510   # ei_test_get_compilerver_from_cxx_version_string()
    511 endmacro(ei_init_testing)
    512 
    513 macro(ei_set_sitename)
    514   # if the sitename is not yet set, try to set it
    515   if(NOT ${SITE} OR ${SITE} STREQUAL "")
    516     set(eigen_computername $ENV{COMPUTERNAME})
    517     set(eigen_hostname $ENV{HOSTNAME})
    518     if(eigen_hostname)
    519       set(SITE ${eigen_hostname})
    520     elseif(eigen_computername)
    521       set(SITE ${eigen_computername})
    522     endif()
    523   endif()
    524   # in case it is already set, enforce lower case
    525   if(SITE)
    526     string(TOLOWER ${SITE} SITE)
    527   endif()
    528 endmacro(ei_set_sitename)
    529 
    530 macro(ei_get_compilerver VAR)
    531     if(MSVC)
    532       # on windows system, we use a modified CMake script
    533       include(EigenDetermineVSServicePack)
    534       EigenDetermineVSServicePack( my_service_pack )
    535 
    536       if( my_service_pack )
    537         set(${VAR} ${my_service_pack})
    538       else()
    539         set(${VAR} "na")
    540       endif()
    541     else()
    542     # on all other system we rely on ${CMAKE_CXX_COMPILER}
    543     # supporting a "--version" or "/version" flag
    544 
    545     if(WIN32 AND ${CMAKE_CXX_COMPILER_ID} EQUAL "Intel")
    546       set(EIGEN_CXX_FLAG_VERSION "/version")
    547     else()
    548       set(EIGEN_CXX_FLAG_VERSION "--version")
    549     endif()
    550 
    551     execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${EIGEN_CXX_FLAG_VERSION}
    552                     OUTPUT_VARIABLE eigen_cxx_compiler_version_string OUTPUT_STRIP_TRAILING_WHITESPACE)
    553     string(REGEX REPLACE "[\n\r].*"  ""  eigen_cxx_compiler_version_string  ${eigen_cxx_compiler_version_string})
    554 
    555     ei_get_compilerver_from_cxx_version_string("${eigen_cxx_compiler_version_string}" CNAME CVER)
    556     set(${VAR} "${CNAME}-${CVER}")
    557 
    558   endif()
    559 endmacro(ei_get_compilerver)
    560 
    561 # Extract compiler name and version from a raw version string
    562 # WARNING: if you edit thid macro, then please test it by  uncommenting
    563 # the testing macro call in ei_init_testing() of the EigenTesting.cmake file.
    564 # See also the ei_test_get_compilerver_from_cxx_version_string macro at the end of the file
    565 macro(ei_get_compilerver_from_cxx_version_string VERSTRING CNAME CVER)
    566   # extract possible compiler names
    567   string(REGEX MATCH "g\\+\\+"      ei_has_gpp    ${VERSTRING})
    568   string(REGEX MATCH "llvm|LLVM"    ei_has_llvm   ${VERSTRING})
    569   string(REGEX MATCH "gcc|GCC"      ei_has_gcc    ${VERSTRING})
    570   string(REGEX MATCH "icpc|ICC"     ei_has_icpc   ${VERSTRING})
    571   string(REGEX MATCH "clang|CLANG"  ei_has_clang  ${VERSTRING})
    572 
    573   # combine them
    574   if((ei_has_llvm) AND (ei_has_gpp OR ei_has_gcc))
    575     set(${CNAME} "llvm-g++")
    576   elseif((ei_has_llvm) AND (ei_has_clang))
    577     set(${CNAME} "llvm-clang++")
    578   elseif(ei_has_clang)
    579     set(${CNAME} "clang++")
    580   elseif(ei_has_icpc)
    581     set(${CNAME} "icpc")
    582   elseif(ei_has_gpp OR ei_has_gcc)
    583     set(${CNAME} "g++")
    584   else()
    585     set(${CNAME} "_")
    586   endif()
    587 
    588   # extract possible version numbers
    589   # first try to extract 3 isolated numbers:
    590   string(REGEX MATCH " [0-9]+\\.[0-9]+\\.[0-9]+" eicver ${VERSTRING})
    591   if(NOT eicver)
    592     # try to extract 2 isolated ones:
    593     string(REGEX MATCH " [0-9]+\\.[0-9]+" eicver ${VERSTRING})
    594     if(NOT eicver)
    595       # try to extract 3:
    596       string(REGEX MATCH "[^0-9][0-9]+\\.[0-9]+\\.[0-9]+" eicver ${VERSTRING})
    597       if(NOT eicver)
    598         # try to extract 2:
    599         string(REGEX MATCH "[^0-9][0-9]+\\.[0-9]+" eicver ${VERSTRING})
    600       else()
    601         set(eicver " _")
    602       endif()
    603     endif()
    604   endif()
    605 
    606   string(REGEX REPLACE ".(.*)" "\\1" ${CVER} ${eicver})
    607 
    608 endmacro(ei_get_compilerver_from_cxx_version_string)
    609 
    610 macro(ei_get_cxxflags VAR)
    611   set(${VAR} "")
    612   ei_is_64bit_env(IS_64BIT_ENV)
    613   if(EIGEN_TEST_NEON)
    614     set(${VAR} NEON)
    615   elseif(EIGEN_TEST_NEON64)
    616     set(${VAR} NEON)
    617   elseif(EIGEN_TEST_ZVECTOR)
    618     set(${VAR} ZVECTOR)
    619   elseif(EIGEN_TEST_VSX)
    620     set(${VAR} VSX)
    621   elseif(EIGEN_TEST_ALTIVEC)
    622     set(${VAR} ALVEC)
    623   elseif(EIGEN_TEST_FMA)
    624     set(${VAR} FMA)
    625   elseif(EIGEN_TEST_AVX)
    626     set(${VAR} AVX)
    627   elseif(EIGEN_TEST_SSE4_2)
    628     set(${VAR} SSE42)
    629   elseif(EIGEN_TEST_SSE4_1)
    630     set(${VAR} SSE41)
    631   elseif(EIGEN_TEST_SSSE3)
    632     set(${VAR} SSSE3)
    633   elseif(EIGEN_TEST_SSE3)
    634     set(${VAR} SSE3)
    635   elseif(EIGEN_TEST_SSE2 OR IS_64BIT_ENV)
    636     set(${VAR} SSE2)
    637   endif()
    638 
    639   if(EIGEN_TEST_OPENMP)
    640     if (${VAR} STREQUAL "")
    641       set(${VAR} OMP)
    642     else()
    643       set(${VAR} ${${VAR}}-OMP)
    644     endif()
    645   endif()
    646 
    647   if(EIGEN_DEFAULT_TO_ROW_MAJOR)
    648     if (${VAR} STREQUAL "")
    649       set(${VAR} ROW)
    650     else()
    651       set(${VAR} ${${VAR}}-ROWMAJ)
    652     endif()
    653   endif()
    654 endmacro(ei_get_cxxflags)
    655 
    656 macro(ei_set_build_string)
    657   ei_get_compilerver(LOCAL_COMPILER_VERSION)
    658   ei_get_cxxflags(LOCAL_COMPILER_FLAGS)
    659 
    660   include(EigenDetermineOSVersion)
    661   DetermineOSVersion(OS_VERSION)
    662 
    663   set(TMP_BUILD_STRING ${OS_VERSION}-${LOCAL_COMPILER_VERSION})
    664 
    665   if (NOT ${LOCAL_COMPILER_FLAGS} STREQUAL  "")
    666     set(TMP_BUILD_STRING ${TMP_BUILD_STRING}-${LOCAL_COMPILER_FLAGS})
    667   endif()
    668 
    669   ei_is_64bit_env(IS_64BIT_ENV)
    670   if(NOT IS_64BIT_ENV)
    671     set(TMP_BUILD_STRING ${TMP_BUILD_STRING}-32bit)
    672   else()
    673     set(TMP_BUILD_STRING ${TMP_BUILD_STRING}-64bit)
    674   endif()
    675 
    676   if(EIGEN_TEST_CXX11)
    677     set(TMP_BUILD_STRING ${TMP_BUILD_STRING}-cxx11)
    678   endif()
    679 
    680   if(EIGEN_BUILD_STRING_SUFFIX)
    681     set(TMP_BUILD_STRING ${TMP_BUILD_STRING}-${EIGEN_BUILD_STRING_SUFFIX})
    682   endif()
    683 
    684   string(TOLOWER ${TMP_BUILD_STRING} BUILDNAME)
    685 endmacro(ei_set_build_string)
    686 
    687 macro(ei_is_64bit_env VAR)
    688   if(CMAKE_SIZEOF_VOID_P EQUAL 8)
    689     set(${VAR} 1)
    690   elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
    691     set(${VAR} 0)
    692   else()
    693     message(WARNING "Unsupported pointer size. Please contact the authors.")
    694   endif()
    695 endmacro(ei_is_64bit_env)
    696 
    697 
    698 # helper macro for testing ei_get_compilerver_from_cxx_version_string
    699 # STR: raw version string
    700 # REFNAME: expected compiler name
    701 # REFVER: expected compiler version
    702 macro(ei_test1_get_compilerver_from_cxx_version_string STR REFNAME REFVER)
    703   ei_get_compilerver_from_cxx_version_string(${STR} CNAME CVER)
    704   if((NOT ${REFNAME} STREQUAL ${CNAME}) OR (NOT ${REFVER} STREQUAL ${CVER}))
    705     message("STATUS ei_get_compilerver_from_cxx_version_string error:")
    706     message("Expected \"${REFNAME}-${REFVER}\", got \"${CNAME}-${CVER}\"")
    707   endif()
    708 endmacro(ei_test1_get_compilerver_from_cxx_version_string)
    709 
    710 # macro for testing ei_get_compilerver_from_cxx_version_string
    711 # feel free to add more version strings
    712 macro(ei_test_get_compilerver_from_cxx_version_string)
    713   ei_test1_get_compilerver_from_cxx_version_string("g++ (SUSE Linux) 4.5.3 20110428 [gcc-4_5-branch revision 173117]" "g++" "4.5.3")
    714   ei_test1_get_compilerver_from_cxx_version_string("c++ (GCC) 4.5.1 20100924 (Red Hat 4.5.1-4)" "g++" "4.5.1")
    715   ei_test1_get_compilerver_from_cxx_version_string("icpc (ICC) 11.0 20081105" "icpc" "11.0")
    716   ei_test1_get_compilerver_from_cxx_version_string("g++-3.4 (GCC) 3.4.6" "g++" "3.4.6")
    717   ei_test1_get_compilerver_from_cxx_version_string("SUSE Linux clang version 3.0 (branches/release_30 145598) (based on LLVM 3.0)" "llvm-clang++" "3.0")
    718   ei_test1_get_compilerver_from_cxx_version_string("icpc (ICC) 12.0.5 20110719" "icpc" "12.0.5")
    719   ei_test1_get_compilerver_from_cxx_version_string("Apple clang version 2.1 (tags/Apple/clang-163.7.1) (based on LLVM 3.0svn)" "llvm-clang++" "2.1")
    720   ei_test1_get_compilerver_from_cxx_version_string("i686-apple-darwin11-llvm-g++-4.2 (GCC) 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2335.15.00)" "llvm-g++" "4.2.1")
    721   ei_test1_get_compilerver_from_cxx_version_string("g++-mp-4.4 (GCC) 4.4.6" "g++" "4.4.6")
    722   ei_test1_get_compilerver_from_cxx_version_string("g++-mp-4.4 (GCC) 2011" "g++" "4.4")
    723 endmacro(ei_test_get_compilerver_from_cxx_version_string)
    724