Make use of CMake 3.22 features (halide#6919)

* Remove AddCudaToTarget.cmake
* Remove MakeShellPath.cmake
* Use CheckLinkerFlag in TargetExportScript
* Use DEPFILE for all generators
* Use REQUIRED with find_program, where applicable
* Use REQUIRED with find_library, where applicable
* Use CMake 3.21 cache behavior in HalideTargetHelpers.cmake
* Replace uses of get_filename_component with cmake_path
* Rework BLAS detection in linear_algebra app
* Drive-by: fix autotune_loop.sh install rule.
* Fix CBLAS header in linear_algebra test_halide_blas

Author: alexreinking

CMakeLists.txt

@@ -13,7 +13,6 @@ enable_testing()
 # Make our custom helpers available throughout the project via include().
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
 include(HalideGeneratorHelpers)
-include(MakeShellPath)
 include(CMakeDependentOption)
 
 # Build Halide as a shared lib by default, but still honor command-line settings.
@@ -50,22 +49,22 @@ endif()
 # Build Halide with ccache if the package is present
 option(Halide_CCACHE_BUILD "Set to ON for a ccache enabled build" OFF)
 mark_as_advanced(Halide_CCACHE_BUILD)
+
 if (Halide_CCACHE_BUILD)
-    find_program(CCACHE_PROGRAM ccache)
-    if (CCACHE_PROGRAM)
-        # TODO: ccache recommends setting CCACHE_SLOPPINESS=pch_defines,time_macros to
-        # enable precompiled header caching. Our timing found it slightly faster with
-        # just CCACHE_SLOPPINESS=pch_defines, so that's what we're using. Maybe revisit
-        # if issues occur (but we don't use any of the time macros so should be irrelevant).
-        set(Halide_CCACHE_PARAMS CCACHE_CPP2=yes CCACHE_HASHDIR=yes CCACHE_SLOPPINESS=pch_defines
-            CACHE STRING "Parameters to pass through to ccache")
-        mark_as_advanced(Halide_CCACHE_PARAMS)
-        set(CMAKE_C_COMPILER_LAUNCHER ${CMAKE_COMMAND} -E env ${Halide_CCACHE_PARAMS} ${CCACHE_PROGRAM})
-        set(CMAKE_CXX_COMPILER_LAUNCHER ${CMAKE_COMMAND} -E env ${Halide_CCACHE_PARAMS} ${CCACHE_PROGRAM})
-        message(STATUS "Enabling ccache usage for building.")
-    else ()
-        message(FATAL_ERROR "Unable to find the program ccache. Set Halide_CCACHE_BUILD to OFF")
-    endif ()
+    find_program(CCACHE_PROGRAM ccache REQUIRED)
+
+    # TODO: ccache recommends setting CCACHE_SLOPPINESS=pch_defines,time_macros to
+    # enable precompiled header caching. Our timing found it slightly faster with
+    # just CCACHE_SLOPPINESS=pch_defines, so that's what we're using. Maybe revisit
+    # if issues occur (but we don't use any of the time macros so should be irrelevant).
+    set(Halide_CCACHE_PARAMS CCACHE_CPP2=yes CCACHE_HASHDIR=yes CCACHE_SLOPPINESS=pch_defines
+        CACHE STRING "Parameters to pass through to ccache")
+    mark_as_advanced(Halide_CCACHE_PARAMS)
+
+    set(CMAKE_C_COMPILER_LAUNCHER ${CMAKE_COMMAND} -E env ${Halide_CCACHE_PARAMS} ${CCACHE_PROGRAM})
+    set(CMAKE_CXX_COMPILER_LAUNCHER ${CMAKE_COMMAND} -E env ${Halide_CCACHE_PARAMS} ${CCACHE_PROGRAM})
+
+    message(STATUS "Enabling ccache usage for building.")
 endif ()
 
 # Enable the SPIR-V target if requested (must declare before processing dependencies)

apps/HelloWasm/CMakeLists.txt

@@ -10,10 +10,7 @@ set(CMAKE_CXX_EXTENSIONS NO)
 find_package(Halide REQUIRED)
 set(halide_includes "$<TARGET_PROPERTY:Halide::Runtime,INTERFACE_INCLUDE_DIRECTORIES>")
 
-find_program(EMCC emcc HINTS "$ENV{EMSDK}/upstream/emscripten")
-if (NOT EMCC)
-    message(FATAL_ERROR "Could not find emscripten/emcc!")
-endif ()
+find_program(EMCC emcc REQUIRED HINTS "$ENV{EMSDK}/upstream/emscripten")
 
 configure_file(index.html index.html COPYONLY)
 

apps/linear_algebra/CMakeLists.txt

@@ -12,42 +12,47 @@ set(CMAKE_CXX_EXTENSIONS NO)
 find_package(Halide REQUIRED)
 
 # Find BLAS-es
-set(DEFAULT_BLAS "")
-set(BLAS_TARGETS "")
-set(BLAS_VENDORS OpenBLAS ATLAS Apple Generic)
-
-# ATLAS is weird and has extra requirements
-find_library(CBLAS_LIBRARY cblas)
-set(ATLAS_EXTRA_LIBS ${CBLAS_LIBRARY})
+set(found_blases "")
+set(known_vendors OpenBLAS ATLAS Apple Intel10_64_dyn Generic)
 
 message(STATUS "Checking for available CBLAS implementations")
-foreach (BLA_VENDOR IN LISTS BLAS_VENDORS)
+foreach (BLA_VENDOR IN LISTS known_vendors)
     find_package(BLAS QUIET)
-    if (NOT BLAS_FOUND
-        OR ("${BLA_VENDOR}" STREQUAL "ATLAS" AND NOT CBLAS_LIBRARY)
-        OR ("${BLA_VENDOR}" STREQUAL "Generic" AND BLAS_TARGETS))
-        message(STATUS "${BLA_VENDOR}: Missing")
-    else ()
-        list(APPEND BLAS_LIBRARIES ${${BLA_VENDOR}_EXTRA_LIBS})
-
-        message(STATUS "${BLA_VENDOR}: Found ${BLAS_LIBRARIES}")
-        add_library(BLAS_${BLA_VENDOR} INTERFACE)
-        add_library(${BLA_VENDOR}::${BLA_VENDOR} ALIAS BLAS_${BLA_VENDOR})
 
-        target_link_libraries(BLAS_${BLA_VENDOR} INTERFACE ${BLAS_LIBRARIES})
-        target_link_options(BLAS_${BLA_VENDOR} INTERFACE ${BLAS_LINKER_FLAGS})
-        target_include_directories(BLAS_${BLA_VENDOR} SYSTEM INTERFACE include) # Use CBlas header in our own tree.
+    # Fail early if not found
+    if (NOT BLAS_FOUND)
+        message(STATUS "${BLA_VENDOR}: Missing")
+        continue()
+    endif ()
 
-        if (NOT DEFAULT_BLAS)
-            set(DEFAULT_BLAS ${BLA_VENDOR}::${BLA_VENDOR})
+    # ATLAS is weird and has extra requirements
+    if (BLA_VENDOR STREQUAL "ATLAS")
+        find_library(CBLAS_LIBRARY cblas)
+        if (NOT CBLAS_LIBRARY)
+            message(STATUS "${BLA_VENDOR}: Missing dependency on CBLAS (hint: set CBLAS_LIBRARY)")
+            continue()
         endif ()
+        list(APPEND BLAS_LIBRARIES "${CBLAS_LIBRARY}")
+    endif ()
 
-        list(APPEND BLAS_TARGETS ${BLA_VENDOR})
+    # Don't use "Generic" BLAS if any good BLAS is available.
+    if (BLA_VENDOR STREQUAL "Generic" AND found_blases)
+        message(STATUS "${BLA_VENDOR}: Not considered")
+        continue()
     endif ()
+
+    message(STATUS "${BLA_VENDOR}: Found ${BLAS_LIBRARIES}")
+
+    add_library(BLAS::${BLA_VENDOR} INTERFACE IMPORTED)
+    target_link_libraries(BLAS::${BLA_VENDOR} INTERFACE ${BLAS_LIBRARIES})
+    target_link_options(BLAS::${BLA_VENDOR} INTERFACE ${BLAS_LINKER_FLAGS})
+    target_include_directories(BLAS::${BLA_VENDOR} INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include") # Use CBlas header in our own tree.
+
+    list(APPEND found_blases ${BLA_VENDOR})
 endforeach ()
 
-if (NOT BLAS_TARGETS)
-    message(FATAL_ERROR "Could not find any BLAS libraries! Searched among ${BLAS_VENDORS}")
+if (NOT found_blases)
+    message(FATAL_ERROR "Could not find any BLAS libraries! Searched among ${known_vendors}")
 endif ()
 
 # Load in the rest of the project.

apps/linear_algebra/benchmarks/CMakeLists.txt

@@ -1,7 +1,7 @@
 add_executable(halide_benchmarks halide_benchmarks.cpp)
 target_compile_definitions(halide_benchmarks PRIVATE ENABLE_FTZ_DAZ)
 target_link_libraries(halide_benchmarks PRIVATE halide_blas Halide::Tools)
-set(BENCHMARK_TARGETS halide_benchmarks)
+set(benchmark_targets halide_benchmarks)
 
 find_package(Eigen3 QUIET)
 set(Eigen3 Eigen3::Eigen)
@@ -18,39 +18,41 @@ if (TARGET ${Eigen3})
     add_executable(eigen_benchmarks eigen_benchmarks.cpp)
     target_compile_definitions(eigen_benchmarks PRIVATE EIGEN_DONT_PARALLELIZE ENABLE_FTZ_DAZ)
     target_link_libraries(eigen_benchmarks PRIVATE ${Eigen3} Halide::Tools)
-    list(APPEND BENCHMARK_TARGETS eigen_benchmarks)
+    list(APPEND benchmark_targets eigen_benchmarks)
     message(STATUS "Eigen3: Found")
 else ()
     message(STATUS "Eigen3: Missing")
 endif ()
 
-foreach (BLAS_TARGET IN LISTS BLAS_TARGETS)
-    set(TARGET ${BLAS_TARGET}_benchmarks)
-    add_executable(${TARGET} cblas_benchmarks.cpp)
-    target_compile_definitions(${TARGET} PRIVATE "BLAS_NAME=\"${BLAS_TARGET}\"")
-    target_link_libraries(${TARGET} PRIVATE ${BLAS_TARGET}::${BLAS_TARGET} Halide::Tools)
-    list(APPEND BENCHMARK_TARGETS ${TARGET})
+foreach (blas IN LISTS FOUND_BLASES)
+    set(blas_benchmarks "${blas}_benchmarks")
+    add_executable(${blas_benchmarks} cblas_benchmarks.cpp)
+    target_compile_definitions(${blas_benchmarks} PRIVATE "BLAS_NAME=\"${blas}\"")
+    target_link_libraries(${blas_benchmarks} PRIVATE BLAS::${blas} Halide::Tools)
+    list(APPEND benchmark_targets ${blas_benchmarks})
 endforeach ()
 
 # Large powers of two are a pathological case for the cache, so avoid
 # them for the benchmarks.
-set(BLAS_LEVELS L1 L2 L3)
-list(APPEND BENCHMARK_SIZES 64 128 256 512 1280 2560)
-list(APPEND L1_BENCHMARKS scopy dcopy sscal dscal saxpy daxpy sdot ddot sasum dasum)
-list(APPEND L2_BENCHMARKS sgemv_notrans dgemv_notrans sgemv_trans dgemv_trans sger dger)
-list(APPEND L3_BENCHMARKS sgemm_notrans dgemm_notrans sgemm_transA dgemm_transA sgemm_transB dgemm_transB sgemm_transAB dgemm_transAB)
-
-foreach (TARGET IN LISTS BENCHMARK_TARGETS)
-    string(REPLACE "_benchmarks" "" BLA_VENDOR "${TARGET}")
-    foreach (LEVEL IN LISTS BLAS_LEVELS)
-        foreach (FUNC IN LISTS ${LEVEL}_BENCHMARKS)
-            foreach (SIZE IN LISTS BENCHMARK_SIZES)
-                set(TEST_NAME ${BLA_VENDOR}_${FUNC}_${SIZE})
-                add_test(NAME ${TEST_NAME}
-                         COMMAND ${TARGET} ${FUNC} ${SIZE})
-                set_tests_properties("${TEST_NAME}" PROPERTIES
-                                     LABELS "linear_algebra;${BLA_VENDOR};${LEVEL};slow_tests"
-                                     PASS_REGULAR_EXPRESSION "${FUNC}[ \t]+${SIZE}"
+set(blas_levels L1 L2 L3)
+list(APPEND benchmark_sizes 64 128 256 512 1280 2560)
+list(APPEND L1_functions scopy dcopy sscal dscal saxpy daxpy sdot ddot sasum dasum)
+list(APPEND L2_functions sgemv_notrans dgemv_notrans sgemv_trans dgemv_trans sger dger)
+list(APPEND L3_functions sgemm_notrans dgemm_notrans sgemm_transA dgemm_transA sgemm_transB dgemm_transB sgemm_transAB dgemm_transAB)
+
+foreach (benchmark IN LISTS benchmark_targets)
+    string(REPLACE "_benchmarks" "" vendor "${benchmark}")
+    foreach (level IN LISTS blas_levels)
+        foreach (func IN LISTS ${level}_functions)
+            foreach (size IN LISTS benchmark_sizes)
+                set(test_name ${vendor}_${func}_${size})
+
+                add_test(NAME ${test_name}
+                         COMMAND ${benchmark} ${func} ${size})
+
+                set_tests_properties("${test_name}" PROPERTIES
+                                     LABELS "linear_algebra;${vendor};${level};slow_tests"
+                                     PASS_REGULAR_EXPRESSION "${func}[ \t]+${size}"
                                      SKIP_REGULAR_EXPRESSION "\\[SKIP\\]")
             endforeach ()
         endforeach ()

apps/linear_algebra/tests/CMakeLists.txt

@@ -1,5 +1,7 @@
 add_executable(test_halide_blas test_halide_blas.cpp)
-target_link_libraries(test_halide_blas PRIVATE ${DEFAULT_BLAS} halide_blas)
+target_link_libraries(test_halide_blas PRIVATE BLAS::BLAS halide_blas)
+target_include_directories(test_halide_blas PRIVATE "${linear_algebra_SOURCE_DIR}/include")
+
 add_test(NAME test_halide_blas COMMAND test_halide_blas)
 set_tests_properties(test_halide_blas PROPERTIES
                      LABELS linear_algebra

cmake/AddCudaToTarget.cmake

@@ -149,7 +149,7 @@ function(transfer_locations)
 
         get_property(lib TARGET ${ARG_FROM} PROPERTY "IMPORTED_LOCATION${cfg}")
         if (lib)
-            get_filename_component(stage "${lib}" NAME_WE)
+            cmake_path(GET lib STEM stage)
             set(stage "${CMAKE_CURRENT_BINARY_DIR}/${stage}.obj")
 
             if (NOT EXISTS "${stage}")

cmake/BundleStatic.cmake

@@ -488,19 +488,9 @@ function(_Halide_target_link_gpu_libs TARGET VISIBILITY)
     endif ()
 
     if ("${ARGN}" MATCHES "metal")
-        find_library(METAL_LIBRARY Metal)
-        if (NOT METAL_LIBRARY)
-            message(AUTHOR_WARNING "Metal framework dependency not found on system.")
-        else ()
-            target_link_libraries(${TARGET} ${VISIBILITY} "${METAL_LIBRARY}")
-        endif ()
-
-        find_library(FOUNDATION_LIBRARY Foundation)
-        if (NOT FOUNDATION_LIBRARY)
-            message(AUTHOR_WARNING "Foundation framework dependency not found on system.")
-        else ()
-            target_link_libraries(${TARGET} ${VISIBILITY} "${FOUNDATION_LIBRARY}")
-        endif ()
+        find_library(FOUNDATION_LIBRARY Foundation REQUIRED)
+        find_library(METAL_LIBRARY Metal REQUIRED)
+        target_link_libraries(${TARGET} ${VISIBILITY} "${FOUNDATION_LIBRARY}" "${METAL_LIBRARY}")
     endif ()
 endfunction()
 

cmake/HalideGeneratorHelpers.cmake

@@ -1,3 +1,5 @@
+cmake_minimum_required(VERSION 3.22)
+
 ##
 # Utilities for manipulating Halide target triples
 ##
@@ -27,22 +29,16 @@ function(_Halide_cmake_target OUTVAR)
     set(${OUTVAR} "${arch}-${bits}-${os}" PARENT_SCOPE)
 endfunction()
 
-function(_Halide_cache var val doc)
-    if (DEFINED ${var})
-        set(${var} "${${var}}" CACHE STRING "${doc}")
-    else ()
-        set(${var} "${val}" CACHE STRING "${doc}")
-    endif ()
-endfunction()
-
 ##
 # Set Halide `host` and `cmake` meta-target values
 ##
 
 _Halide_cmake_target(_active_triple)
 
-_Halide_cache(Halide_HOST_TARGET "${_active_triple}" "Halide target triple matching the Halide library")
-_Halide_cache(Halide_CMAKE_TARGET "${_active_triple}" "Halide target triple matching the CMake target")
+set(Halide_HOST_TARGET "${_active_triple}"
+    CACHE STRING "Halide target triple matching the Halide library")
+set(Halide_CMAKE_TARGET "${_active_triple}"
+    CACHE STRING "Halide target triple matching the CMake target")
 
 unset(_active_triple)
 
@@ -58,7 +54,8 @@ else ()
     set(_default_target "${Halide_CMAKE_TARGET}")
 endif ()
 
-_Halide_cache(Halide_TARGET "${_default_target}" "The default target to use when AOT compiling")
+set(Halide_TARGET "${_default_target}"
+    CACHE STRING "The default target to use when AOT compiling")
 
 unset(_default_target)
 

cmake/HalideTargetHelpers.cmake

@@ -81,7 +81,7 @@ function(tests)
 
     set(TEST_NAMES "")
     foreach (file IN LISTS args_SOURCES)
-        get_filename_component(name "${file}" NAME_WE)
+        cmake_path(GET file STEM name)
         set(TARGET "${PRIMARY_GROUP}_${name}")
 
         list(APPEND TEST_NAMES "${TARGET}")