This is an automated email from the ASF dual-hosted git repository.
tqchen pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tvm.git
The following commit(s) were added to refs/heads/main by this push:
new 55c8b72b91 [REFACTOR] Simplify TIRx CMake and package installation
(#20751)
55c8b72b91 is described below
commit 55c8b72b91fb197cfe2f4b851ff275487ce78aed
Author: Tianqi Chen <[email protected]>
AuthorDate: Thu Oct 15 19:41:04 2026 -0400
[REFACTOR] Simplify TIRx CMake and package installation (#20751)
Give TVM and TIRx fixed install components so each package owns its
headers, libraries, and support files in standalone and embedded builds.
Each wheel selects its package component, and the parent no longer
duplicates TIRx installation rules.
Scope TIRx compilation policy to its core and backend object/library
targets, preserving embedding-project and bundled-FFI settings. Attach
thread-pool requirements directly to runtime targets, retain GNU and
Intel OpenMP selection, and isolate LLVM signature detection from parent
compilation defaults.
Use typed native option declarations, explicit module includes, a
shared-script source pattern, documented installation sections, and only
the parent exports with consumers. Keep the installed package's
shared-library interface and explicit FFI linkage.
---
CMakeLists.txt | 50 +++++------
cmake/modules/RuntimeExtra.cmake | 3 +-
cmake/utils/Library.cmake | 4 +-
pyproject.toml | 1 +
tirx/CMakeLists.txt | 172 ++++++++++++++++++------------------
tirx/cmake/modules/CUDA.cmake | 4 +-
tirx/cmake/modules/Metal.cmake | 4 +-
tirx/cmake/modules/OpenCL.cmake | 4 +-
tirx/cmake/modules/OpenMP.cmake | 49 +++++-----
tirx/cmake/modules/ROCM.cmake | 4 +-
tirx/cmake/modules/Vulkan.cmake | 4 +-
tirx/cmake/modules/contrib/Z3.cmake | 2 +-
tirx/cmake/utils/FindLLVM.cmake | 49 +++++-----
tirx/cmake/utils/Library.cmake | 12 ++-
tirx/pyproject.toml | 1 +
15 files changed, 177 insertions(+), 186 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index df54344dec..101c1507bd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -359,40 +359,32 @@ endif()
if(USE_IOS_RPC)
add_subdirectory(apps/ios_rpc)
endif()
-# The parent owns installation of the core when it embeds the source build.
-if(NOT TVM_USE_INSTALLED_TIRX)
- set(_core_install_targets tvm_tirx tvm_runtime tvm_runtime_static)
- foreach(_backend cuda opencl vulkan metal rocm)
- if(TARGET tvm_runtime_${_backend})
- list(APPEND _core_install_targets tvm_runtime_${_backend})
- endif()
- endforeach()
- install(TARGETS ${_core_install_targets}
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
- LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
- RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
- install(DIRECTORY tirx/include/ DESTINATION include FILES_MATCHING PATTERN
"*.h")
- install(FILES tirx/cmake/tvm_tirx-config.cmake tirx/python/tvm_tirx/config.py
- DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx")
- install(DIRECTORY tirx/cmake/utils/
- DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx/utils" FILES_MATCHING
PATTERN "Find*.cmake")
-endif()
install(TARGETS tvm_compiler tvm_runtime_extra
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
- LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
- RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
FILES_MATCHING PATTERN "*.h")
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+ RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm)
+if(TVM_TIRX_USE_CUDA AND USE_CUTLASS)
+ install(TARGETS fpA_intB_gemm flash_attn
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+ RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm)
+endif()
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+ COMPONENT tvm FILES_MATCHING PATTERN "*.h")
# Parent minRPC compilation retains its own source and private header closure.
-install(DIRECTORY src/runtime/rpc/ DESTINATION src/runtime/rpc FILES_MATCHING
PATTERN "*.h" PATTERN "*.cc")
-install(DIRECTORY src/support/ DESTINATION src/support FILES_MATCHING PATTERN
"*.h")
-install(DIRECTORY src/runtime/extra/ DESTINATION src/runtime/extra
FILES_MATCHING PATTERN "*.h" PATTERN "*.cuh")
+install(DIRECTORY src/runtime/rpc/ DESTINATION src/runtime/rpc
+ COMPONENT tvm FILES_MATCHING PATTERN "*.h" PATTERN "*.cc")
+install(DIRECTORY src/support/ DESTINATION src/support
+ COMPONENT tvm FILES_MATCHING PATTERN "*.h")
+install(DIRECTORY src/runtime/extra/ DESTINATION src/runtime/extra
+ COMPONENT tvm FILES_MATCHING PATTERN "*.h" PATTERN "*.cuh")
if(TVM_BUILD_PYTHON_MODULE)
- install(DIRECTORY web/ DESTINATION web)
- install(DIRECTORY licenses/ DESTINATION licenses)
- install(FILES LICENSE NOTICE DESTINATION .)
+ install(DIRECTORY web/ DESTINATION web COMPONENT tvm)
+ install(DIRECTORY licenses/ DESTINATION licenses COMPONENT tvm)
+ install(FILES LICENSE NOTICE DESTINATION . COMPONENT tvm)
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/cutlass/include")
install(DIRECTORY 3rdparty/cutlass/include/ DESTINATION
3rdparty/cutlass/include
- FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")
+ COMPONENT tvm FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")
endif()
endif()
find_and_set_linker(${USE_ALTERNATIVE_LINKER})
diff --git a/cmake/modules/RuntimeExtra.cmake b/cmake/modules/RuntimeExtra.cmake
index b2d726cdb5..e3057ebe0b 100644
--- a/cmake/modules/RuntimeExtra.cmake
+++ b/cmake/modules/RuntimeExtra.cmake
@@ -98,4 +98,5 @@ if(TVM_VISIBILITY_FLAG)
set_property(TARGET tvm_runtime_extra APPEND PROPERTY LINK_OPTIONS
"${TVM_VISIBILITY_FLAG}")
endif()
-tvm_configure_target_library(tvm_runtime_extra RUNTIME_MODULE)
+# The root registers the package-owned installation alongside tvm_compiler.
+tvm_configure_target_library(tvm_runtime_extra)
diff --git a/cmake/utils/Library.cmake b/cmake/utils/Library.cmake
index 4b4d9f6605..f1ec6be620 100644
--- a/cmake/utils/Library.cmake
+++ b/cmake/utils/Library.cmake
@@ -78,9 +78,9 @@ function(tvm_configure_target_library target_name)
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
)
- install(TARGETS ${target_name} DESTINATION lib${LIB_SUFFIX})
+ install(TARGETS ${target_name} DESTINATION lib${LIB_SUFFIX} COMPONENT tvm)
if(TVM_BUILD_PYTHON_MODULE)
- install(TARGETS ${target_name} DESTINATION "lib")
+ install(TARGETS ${target_name} DESTINATION "lib" COMPONENT tvm)
endif()
endif()
endfunction()
diff --git a/pyproject.toml b/pyproject.toml
index cff0e474b3..8305d6dd88 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -89,6 +89,7 @@ wheel.py-api = "py3"
build-dir = "build"
# Wheel configuration
+install.components = ["tvm"]
wheel.packages = ["python/tvm"]
wheel.install-dir = "tvm"
diff --git a/tirx/CMakeLists.txt b/tirx/CMakeLists.txt
index 510d708c5b..c3397d5736 100644
--- a/tirx/CMakeLists.txt
+++ b/tirx/CMakeLists.txt
@@ -21,49 +21,61 @@ if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR AND
NOT DEFINED CMAKE_EXPO
endif()
project(tvm_tirx LANGUAGES C CXX)
+# Declare native boolean switches and typed cache settings uniformly.
+function(tvm_tirx_option variable type default description)
+ if(type STREQUAL "BOOL")
+ option(${variable} "${description}" "${default}")
+ else()
+ set(${variable} "${default}" CACHE ${type} "${description}")
+ endif()
+endfunction()
+
# ######### Common options ##########
set(TVM_TIRX_VERSION "0.1.0a0")
if(PROJECT_IS_TOP_LEVEL)
- option(TVM_TIRX_BUILD_TESTS "Build C++ tests" OFF)
- option(TVM_TIRX_BUILD_PYTHON_MODULE "Build the Python package with
scikit-build-core" OFF)
+ tvm_tirx_option(TVM_TIRX_BUILD_TESTS BOOL OFF "Build C++ tests")
+ tvm_tirx_option(TVM_TIRX_BUILD_PYTHON_MODULE BOOL OFF "Build the Python
package with scikit-build-core")
endif()
-option(TVM_TIRX_USE_THREADS "Build with thread support" ON)
-option(TVM_TIRX_USE_CUSTOM_LOGGING "Use user-defined logging implementations"
OFF)
-set(TVM_TIRX_USE_OPENMP OFF CACHE STRING "OpenMP thread pool implementation
(OFF, gnu, intel)")
-set_property(CACHE TVM_TIRX_USE_OPENMP PROPERTY STRINGS OFF gnu intel)
+tvm_tirx_option(TVM_TIRX_USE_THREADS BOOL ON "Build with thread support")
+tvm_tirx_option(TVM_TIRX_USE_CUSTOM_LOGGING BOOL OFF "Use user-defined logging
implementations")
# ######### LLVM ##########
-set(TVM_TIRX_USE_LLVM OFF CACHE STRING "Build with LLVM (OFF, ON, or
llvm-config command)")
+tvm_tirx_option(TVM_TIRX_USE_LLVM STRING OFF "Build with LLVM (OFF, ON, or
llvm-config command)")
# ######### Z3 ##########
-set(TVM_TIRX_USE_Z3 AUTO CACHE STRING "Build with Z3 SMT solver support (OFF,
ON, AUTO)")
+tvm_tirx_option(TVM_TIRX_USE_Z3 STRING AUTO "Build with Z3 SMT solver support
(OFF, ON, AUTO)")
set_property(CACHE TVM_TIRX_USE_Z3 PROPERTY STRINGS OFF ON AUTO)
# ######### CUDA ##########
-set(TVM_TIRX_USE_CUDA OFF CACHE STRING "Build with CUDA (OFF, ON, or SDK
path)")
+tvm_tirx_option(TVM_TIRX_USE_CUDA STRING OFF "Build with CUDA (OFF, ON, or SDK
path)")
# ######### Other device runtimes ##########
# OpenCL
-set(TVM_TIRX_USE_OPENCL OFF CACHE STRING "Build with OpenCL (OFF, ON, or SDK
path)")
-option(TVM_TIRX_USE_OPENCL_ENABLE_HOST_PTR "Enable OpenCL memory object access
to host" OFF)
-option(TVM_TIRX_USE_OPENCL_EXTN_QCOM "Enable Qualcomm OpenCL extensions" OFF)
+tvm_tirx_option(TVM_TIRX_USE_OPENCL STRING OFF "Build with OpenCL (OFF, ON, or
SDK path)")
+tvm_tirx_option(TVM_TIRX_USE_OPENCL_ENABLE_HOST_PTR BOOL OFF "Enable OpenCL
memory object access to host")
+tvm_tirx_option(TVM_TIRX_USE_OPENCL_EXTN_QCOM BOOL OFF "Enable Qualcomm OpenCL
extensions")
# Vulkan
-set(TVM_TIRX_USE_VULKAN OFF CACHE STRING "Build with Vulkan (OFF, ON, or SDK
path)")
-set(TVM_TIRX_USE_KHRONOS_SPIRV OFF CACHE STRING "Use Khronos SPIR-V tools (OFF
or install path)")
-option(TVM_TIRX_USE_SPIRV_KHR_INTEGER_DOT_PRODUCT "Enable SPIR-V integer dot
product" OFF)
+tvm_tirx_option(TVM_TIRX_USE_VULKAN STRING OFF "Build with Vulkan (OFF, ON, or
SDK path)")
+tvm_tirx_option(TVM_TIRX_USE_KHRONOS_SPIRV STRING OFF "Use Khronos SPIR-V
tools (OFF or install path)")
+tvm_tirx_option(TVM_TIRX_USE_SPIRV_KHR_INTEGER_DOT_PRODUCT BOOL OFF "Enable
SPIR-V integer dot product")
# ROCm
-set(TVM_TIRX_ROCM_PATH /opt/rocm CACHE PATH "Default ROCm SDK location")
-set(TVM_TIRX_USE_ROCM OFF CACHE STRING "Build with ROCm (OFF, ON, or SDK
path)")
+tvm_tirx_option(TVM_TIRX_ROCM_PATH PATH /opt/rocm "Default ROCm SDK location")
+tvm_tirx_option(TVM_TIRX_USE_ROCM STRING OFF "Build with ROCm (OFF, ON, or SDK
path)")
# Metal
-option(TVM_TIRX_USE_METAL "Build with Metal" OFF)
+tvm_tirx_option(TVM_TIRX_USE_METAL BOOL OFF "Build with Metal")
+
+# ######### OpenMP ##########
+
+tvm_tirx_option(TVM_TIRX_USE_OPENMP STRING OFF "OpenMP thread pool
implementation (OFF, gnu, intel)")
+set_property(CACHE TVM_TIRX_USE_OPENMP PROPERTY STRINGS OFF gnu intel)
# ######### Dependencies ##########
@@ -83,17 +95,8 @@ endif()
# ######### TIRx build settings ##########
-# Apply these after the FFI subdirectory so its own settings remain
independent.
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CUDA_STANDARD 20)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_VISIBILITY_PRESET hidden)
-set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+include(GNUInstallDirs)
if(PROJECT_IS_TOP_LEVEL)
- include(GNUInstallDirs)
if(TVM_TIRX_BUILD_PYTHON_MODULE)
set(CMAKE_INSTALL_LIBDIR lib)
endif()
@@ -135,7 +138,6 @@ target_link_libraries(tvm_tirx_header INTERFACE
tvm_ffi::header)
# ######### Sources and backends ##########
set(TVM_LINKER_LIBS "")
-set(TVM_RUNTIME_LINKER_LIBS "${CMAKE_DL_LIBS}")
set(TVM_RUNTIME_BACKEND_LIBS "")
set(BUILD_FOR_ANDROID "${ANDROID}")
# Source file lists
@@ -145,25 +147,7 @@ file(GLOB_RECURSE COMPILER_SRCS CONFIGURE_DEPENDS
src/sym/*.cc
src/tirx/*.cc
src/support/*.cc
- # Shared printer and TVMScript IR builder. Per-dialect printer/builder
pieces
- # live under src/<dialect>/script/. List shared files explicitly so a
dialect
- # implementation cannot be silently included through a recursive glob.
- src/script/ir_builder/base.cc
- src/script/ir_builder/ir.cc
- src/script/ir_builder/frame.cc
- src/script/printer/config.cc
- src/script/printer/doc.cc
- src/script/printer/doc_translator.cc
- src/script/printer/ir/call.cc
- src/script/printer/ir/utils.cc
- src/script/printer/ir/ir.cc
- src/script/printer/ir/misc.cc
- src/script/printer/ir/prim_type.cc
- src/script/printer/ir/prim_expr.cc
- src/script/printer/ir/stmt.cc
- src/script/printer/printer.cc
- src/script/printer/doc_printer.cc
- src/script/printer/script_printer.cc
+ src/script/*.cc
)
file(GLOB CODEGEN_SRCS CONFIGURE_DEPENDS
@@ -198,10 +182,6 @@ list(APPEND COMPILER_SRCS ${CODEGEN_SRCS})
file(GLOB RUNTIME_SRCS CONFIGURE_DEPENDS
src/runtime/*.cc
)
-set(TVM_RUNTIME_EXT_OBJS "")
-
-# The core runtime's thread pool implementation supplies its link dependencies.
-include(cmake/modules/OpenMP.cmake)
# ######### Targets: `tvm_runtime`, `tvm_runtime_static` ##########
@@ -211,10 +191,10 @@ if(MSVC)
target_compile_definitions(tvm_runtime_objs PRIVATE TVM_RUNTIME_EXPORTS
TVM_FFI_EXPORTS)
endif()
-add_library(tvm_runtime SHARED $<TARGET_OBJECTS:tvm_runtime_objs>
${TVM_RUNTIME_EXT_OBJS})
+add_library(tvm_runtime SHARED $<TARGET_OBJECTS:tvm_runtime_objs>)
add_library(tvm_runtime::shared ALIAS tvm_runtime)
target_link_libraries(tvm_runtime PUBLIC tvm_tirx_header tvm_ffi::shared)
-add_library(tvm_runtime_static STATIC $<TARGET_OBJECTS:tvm_runtime_objs>
${TVM_RUNTIME_EXT_OBJS})
+add_library(tvm_runtime_static STATIC $<TARGET_OBJECTS:tvm_runtime_objs>)
target_link_libraries(tvm_runtime_static PUBLIC tvm_tirx_header
tvm_ffi::static)
# Static consumers retain registration objects from both archives, with
# tvm_ffi::static before tvm_runtime_static in their whole-archive link group.
@@ -223,19 +203,27 @@ if(MSVC)
TVM_RUNTIME_DLL= TVM_RUNTIME_DLL_EXPORT= TVM_FFI_DLL= TVM_FFI_DLL_EXPORT=)
endif()
foreach(_target tvm_runtime tvm_runtime_static)
- target_link_libraries(${_target} PRIVATE ${TVM_RUNTIME_LINKER_LIBS})
+ target_link_libraries(${_target} PRIVATE ${CMAKE_DL_LIBS})
if(TVM_TIRX_USE_THREADS)
target_link_libraries(${_target} PUBLIC Threads::Threads)
endif()
endforeach()
+# The core runtime owns the selected thread pool and its link dependencies.
+include(cmake/modules/OpenMP.cmake)
+
# ######### Device runtimes and compiler backends ##########
# The core runtime exists before device runtimes link to it. Compiler backend
# contributions are collected before the compiler object target is created.
-foreach(_module CUDA OpenCL Vulkan Metal ROCM LLVM contrib/Z3 Git)
- include(cmake/modules/${_module}.cmake)
-endforeach()
+include(cmake/modules/CUDA.cmake)
+include(cmake/modules/OpenCL.cmake)
+include(cmake/modules/Vulkan.cmake)
+include(cmake/modules/Metal.cmake)
+include(cmake/modules/ROCM.cmake)
+include(cmake/modules/LLVM.cmake)
+include(cmake/modules/contrib/Z3.cmake)
+include(cmake/modules/Git.cmake)
# ######### Target: `tvm_tirx` ##########
add_library(tvm_tirx_objs OBJECT ${COMPILER_SRCS})
@@ -249,7 +237,7 @@ endif()
add_library(tvm_tirx SHARED $<TARGET_OBJECTS:tvm_tirx_objs>)
add_library(tvm_tirx::shared ALIAS tvm_tirx)
target_link_libraries(tvm_tirx PUBLIC tvm_runtime tvm_tirx_header)
-target_link_libraries(tvm_tirx PRIVATE ${TVM_LINKER_LIBS}
${TVM_RUNTIME_LINKER_LIBS})
+target_link_libraries(tvm_tirx PRIVATE ${TVM_LINKER_LIBS})
# Avoid GNU ld relaxation of LLVM's GOT calls into incorrect direct calls.
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT "${TVM_TIRX_USE_LLVM}" MATCHES
${IS_FALSE_PATTERN})
@@ -261,6 +249,7 @@ include(cmake/modules/ClangFlags.cmake)
# ######### Library configuration ##########
foreach(_target tvm_runtime_objs tvm_tirx_objs tvm_runtime tvm_runtime_static
tvm_tirx)
+ tvm_tirx_configure_target(${_target})
tvm_ffi_add_prefix_map(${_target} "${CMAKE_CURRENT_SOURCE_DIR}")
endforeach()
foreach(_target IN LISTS TVM_RUNTIME_BACKEND_LIBS)
@@ -268,7 +257,6 @@ foreach(_target IN LISTS TVM_RUNTIME_BACKEND_LIBS)
tvm_ffi_add_prefix_map(${_target} "${CMAKE_CURRENT_SOURCE_DIR}")
endforeach()
foreach(_target tvm_runtime tvm_tirx ${TVM_RUNTIME_BACKEND_LIBS})
- tvm_tirx_configure_target(${_target})
if(APPLE)
target_link_options(${_target} PRIVATE "-Wl,-undefined,error")
elseif(UNIX)
@@ -280,31 +268,40 @@ endforeach()
# ######### Installation ##########
-if(PROJECT_IS_TOP_LEVEL)
- file(GLOB_RECURSE _headers CONFIGURE_DEPENDS RELATIVE
- "${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")
- foreach(_header IN LISTS _headers)
- get_filename_component(_directory "${_header}" DIRECTORY)
- install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/${_header}" DESTINATION
"include/${_directory}")
+# Public headers
+file(GLOB_RECURSE _headers CONFIGURE_DEPENDS RELATIVE
+ "${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")
+foreach(_header IN LISTS _headers)
+ get_filename_component(_directory "${_header}" DIRECTORY)
+ install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/${_header}"
+ DESTINATION "include/${_directory}" COMPONENT tvm_tirx)
+endforeach()
+
+# Libraries
+install(TARGETS tvm_tirx_header tvm_tirx tvm_runtime tvm_runtime_static
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx
+ RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx)
+
+# CMake package and dependency helpers
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/tvm_tirx-config.cmake"
+ "${CMAKE_CURRENT_SOURCE_DIR}/python/tvm_tirx/config.py"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx" COMPONENT tvm_tirx)
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/utils/"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx/utils"
+ COMPONENT tvm_tirx FILES_MATCHING PATTERN "Find*.cmake")
+
+# Python package artifacts and licenses
+if(TVM_TIRX_BUILD_PYTHON_MODULE)
+ foreach(_extra_lib IN LISTS TVM_TIRX_PACKAGE_EXTRA_LIBS)
+ if(NOT EXISTS "${_extra_lib}")
+ message(FATAL_ERROR "TVM_TIRX_PACKAGE_EXTRA_LIBS entry does not exist:
${_extra_lib}")
+ endif()
+ install(FILES "${_extra_lib}" DESTINATION lib COMPONENT tvm_tirx)
endforeach()
- install(TARGETS tvm_tirx_header tvm_tirx tvm_runtime tvm_runtime_static
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
- LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
- RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
- install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/tvm_tirx-config.cmake"
- "${CMAKE_CURRENT_SOURCE_DIR}/python/tvm_tirx/config.py" DESTINATION
"${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx")
- install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/utils/"
- DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx/utils" FILES_MATCHING
PATTERN "Find*.cmake")
- if(TVM_TIRX_BUILD_PYTHON_MODULE)
- foreach(_extra_lib IN LISTS TVM_TIRX_PACKAGE_EXTRA_LIBS)
- if(NOT EXISTS "${_extra_lib}")
- message(FATAL_ERROR "TVM_TIRX_PACKAGE_EXTRA_LIBS entry does not exist:
${_extra_lib}")
- endif()
- install(FILES "${_extra_lib}" DESTINATION lib)
- endforeach()
- install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/licenses/" DESTINATION
licenses)
- install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
"${CMAKE_CURRENT_SOURCE_DIR}/NOTICE" DESTINATION .)
- endif()
+ install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/licenses/" DESTINATION
licenses COMPONENT tvm_tirx)
+ install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
"${CMAKE_CURRENT_SOURCE_DIR}/NOTICE"
+ DESTINATION . COMPONENT tvm_tirx)
endif()
# ######### C++ tests ##########
@@ -316,10 +313,9 @@ endif()
set(TVM_TIRX_CMAKE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
if(NOT PROJECT_IS_TOP_LEVEL)
- foreach(_variable TVM_TIRX_VERSION TVM_TIRX_CMAKE_DIR TVM_TIRX_USE_CUDA
TVM_TIRX_USE_ROCM)
- set(${_variable} "${${_variable}}" PARENT_SCOPE)
- endforeach()
- set(TVM_TIRX_BUILD_FOR_ANDROID "${BUILD_FOR_ANDROID}" PARENT_SCOPE)
+ # The parent checks the core version and reuses its dependency finders.
+ set(TVM_TIRX_VERSION "${TVM_TIRX_VERSION}" PARENT_SCOPE)
+ set(TVM_TIRX_CMAKE_DIR "${TVM_TIRX_CMAKE_DIR}" PARENT_SCOPE)
return()
endif()
diff --git a/tirx/cmake/modules/CUDA.cmake b/tirx/cmake/modules/CUDA.cmake
index 9093c3fb33..68525b7d87 100644
--- a/tirx/cmake/modules/CUDA.cmake
+++ b/tirx/cmake/modules/CUDA.cmake
@@ -77,9 +77,7 @@ if(TVM_TIRX_USE_CUDA)
target_compile_definitions(tvm_runtime_cuda_objs PRIVATE TVM_RUNTIME_EXPORTS
TVM_FFI_EXPORTS)
set_target_properties(tvm_runtime_cuda_objs PROPERTIES
POSITION_INDEPENDENT_CODE ON)
add_library(tvm_runtime_cuda SHARED $<TARGET_OBJECTS:tvm_runtime_cuda_objs>)
- if(PROJECT_IS_TOP_LEVEL)
- install(TARGETS tvm_runtime_cuda DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
+ install(TARGETS tvm_runtime_cuda DESTINATION ${CMAKE_INSTALL_LIBDIR}
COMPONENT tvm_tirx)
list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_cuda)
target_link_libraries(tvm_runtime_cuda PUBLIC tvm_runtime PRIVATE
${CUDA_CUDART_LIBRARY} ${CUDA_CUDA_LIBRARY})
tvm_tirx_configure_target(tvm_runtime_cuda_objs)
diff --git a/tirx/cmake/modules/Metal.cmake b/tirx/cmake/modules/Metal.cmake
index c733344c25..53d62c8320 100644
--- a/tirx/cmake/modules/Metal.cmake
+++ b/tirx/cmake/modules/Metal.cmake
@@ -25,9 +25,7 @@ if(TVM_TIRX_USE_METAL)
target_link_libraries(tvm_runtime_metal_objs PUBLIC tvm_tirx_header)
set_target_properties(tvm_runtime_metal_objs PROPERTIES
POSITION_INDEPENDENT_CODE ON)
add_library(tvm_runtime_metal SHARED
$<TARGET_OBJECTS:tvm_runtime_metal_objs>)
- if(PROJECT_IS_TOP_LEVEL)
- install(TARGETS tvm_runtime_metal DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
+ install(TARGETS tvm_runtime_metal DESTINATION ${CMAKE_INSTALL_LIBDIR}
COMPONENT tvm_tirx)
list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_metal)
target_link_libraries(tvm_runtime_metal PUBLIC tvm_runtime PRIVATE
${METAL_LIB} ${FOUNDATION_LIB})
tvm_tirx_configure_target(tvm_runtime_metal_objs)
diff --git a/tirx/cmake/modules/OpenCL.cmake b/tirx/cmake/modules/OpenCL.cmake
index 168977b508..a1d4aa3eb8 100644
--- a/tirx/cmake/modules/OpenCL.cmake
+++ b/tirx/cmake/modules/OpenCL.cmake
@@ -53,9 +53,7 @@ if(TVM_TIRX_USE_OPENCL)
target_compile_definitions(tvm_runtime_opencl_objs PRIVATE
"TVM_OPENCL_DLL=${_opencl_export}")
set_target_properties(tvm_runtime_opencl_objs PROPERTIES
POSITION_INDEPENDENT_CODE ON)
add_library(tvm_runtime_opencl SHARED
$<TARGET_OBJECTS:tvm_runtime_opencl_objs>)
- if(PROJECT_IS_TOP_LEVEL)
- install(TARGETS tvm_runtime_opencl DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
+ install(TARGETS tvm_runtime_opencl DESTINATION ${CMAKE_INSTALL_LIBDIR}
COMPONENT tvm_tirx)
list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_opencl)
target_link_libraries(tvm_runtime_opencl PUBLIC tvm_runtime PRIVATE
${_opencl_libs})
target_compile_definitions(tvm_runtime_opencl INTERFACE
"TVM_OPENCL_DLL=${_opencl_import}")
diff --git a/tirx/cmake/modules/OpenMP.cmake b/tirx/cmake/modules/OpenMP.cmake
index 3eb4d31590..a92376fb40 100644
--- a/tirx/cmake/modules/OpenMP.cmake
+++ b/tirx/cmake/modules/OpenMP.cmake
@@ -15,34 +15,35 @@
# specific language governing permissions and limitations
# under the License.
-# OpenMP Module
-if(TVM_TIRX_USE_OPENMP STREQUAL "gnu")
- find_package(OpenMP)
- if(OPENMP_FOUND)
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
- list(APPEND TVM_RUNTIME_LINKER_LIBS ${OpenMP_CXX_LIBRARIES})
- add_definitions(-DTVM_THREADPOOL_USE_OPENMP=1)
- message(STATUS "Build with OpenMP ${OpenMP_CXX_LIBRARIES}")
- else()
- add_definitions(-DTVM_THREADPOOL_USE_OPENMP=0)
- message(WARNING "OpenMP cannot be found, use TVM threadpool instead.")
- endif()
-elseif(TVM_TIRX_USE_OPENMP STREQUAL "intel")
- find_package(OpenMP)
- if(OPENMP_FOUND)
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
- if (MSVC)
- find_library(OMP_LIBRARY NAMES libiomp5md)
+# OpenMP implements only the core runtime's thread pool.
+if(TVM_TIRX_USE_OPENMP STREQUAL "gnu" OR TVM_TIRX_USE_OPENMP STREQUAL "intel")
+ find_package(OpenMP COMPONENTS CXX)
+ if(OpenMP_CXX_FOUND)
+ target_compile_definitions(tvm_runtime_objs PRIVATE
TVM_THREADPOOL_USE_OPENMP=1)
+ if(TVM_TIRX_USE_OPENMP STREQUAL "gnu")
+ target_link_libraries(tvm_runtime_objs PRIVATE OpenMP::OpenMP_CXX)
+ target_link_libraries(tvm_runtime PRIVATE OpenMP::OpenMP_CXX)
+ target_link_libraries(tvm_runtime_static PRIVATE OpenMP::OpenMP_CXX)
+ message(STATUS "Build with OpenMP ${OpenMP_CXX_LIBRARIES}")
else()
- find_library(OMP_LIBRARY NAMES iomp5)
+ # Keep Intel's runtime even when the compiler's default OpenMP runtime
is GNU.
+ if(MSVC)
+ find_library(OMP_LIBRARY NAMES libiomp5md)
+ else()
+ find_library(OMP_LIBRARY NAMES iomp5)
+ endif()
+ separate_arguments(_openmp_flags NATIVE_COMMAND "${OpenMP_CXX_FLAGS}")
+ target_compile_options(tvm_runtime_objs PRIVATE
+ "$<$<COMPILE_LANGUAGE:CXX>:${_openmp_flags}>")
+ target_include_directories(tvm_runtime_objs PRIVATE
${OpenMP_CXX_INCLUDE_DIRS})
+ target_link_libraries(tvm_runtime PRIVATE ${OMP_LIBRARY})
+ target_link_libraries(tvm_runtime_static PRIVATE ${OMP_LIBRARY})
+ message(STATUS "Build with OpenMP ${OMP_LIBRARY}")
endif()
- list(APPEND TVM_RUNTIME_LINKER_LIBS ${OMP_LIBRARY})
- add_definitions(-DTVM_THREADPOOL_USE_OPENMP=1)
- message(STATUS "Build with OpenMP " ${OMP_LIBRARY})
else()
- add_definitions(-DTVM_THREADPOOL_USE_OPENMP=0)
+ target_compile_definitions(tvm_runtime_objs PRIVATE
TVM_THREADPOOL_USE_OPENMP=0)
message(WARNING "OpenMP cannot be found, use TVM threadpool instead.")
endif()
else()
- add_definitions(-DTVM_THREADPOOL_USE_OPENMP=0)
+ target_compile_definitions(tvm_runtime_objs PRIVATE
TVM_THREADPOOL_USE_OPENMP=0)
endif()
diff --git a/tirx/cmake/modules/ROCM.cmake b/tirx/cmake/modules/ROCM.cmake
index a1be778dd8..b51b1fbca6 100644
--- a/tirx/cmake/modules/ROCM.cmake
+++ b/tirx/cmake/modules/ROCM.cmake
@@ -47,9 +47,7 @@ if(TVM_TIRX_USE_ROCM)
target_link_libraries(tvm_runtime_rocm_objs PUBLIC tvm_tirx_header)
set_target_properties(tvm_runtime_rocm_objs PROPERTIES
POSITION_INDEPENDENT_CODE ON)
add_library(tvm_runtime_rocm SHARED $<TARGET_OBJECTS:tvm_runtime_rocm_objs>)
- if(PROJECT_IS_TOP_LEVEL)
- install(TARGETS tvm_runtime_rocm DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
+ install(TARGETS tvm_runtime_rocm DESTINATION ${CMAKE_INSTALL_LIBDIR}
COMPONENT tvm_tirx)
list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_rocm)
target_link_libraries(tvm_runtime_rocm PUBLIC tvm_runtime PRIVATE
${_rocm_libs})
tvm_tirx_configure_target(tvm_runtime_rocm_objs)
diff --git a/tirx/cmake/modules/Vulkan.cmake b/tirx/cmake/modules/Vulkan.cmake
index de6bbfec33..88025bf03d 100644
--- a/tirx/cmake/modules/Vulkan.cmake
+++ b/tirx/cmake/modules/Vulkan.cmake
@@ -49,9 +49,7 @@ if(TVM_TIRX_USE_VULKAN)
target_link_libraries(tvm_runtime_vulkan_objs PUBLIC tvm_tirx_header)
set_target_properties(tvm_runtime_vulkan_objs PROPERTIES
POSITION_INDEPENDENT_CODE ON)
add_library(tvm_runtime_vulkan SHARED
$<TARGET_OBJECTS:tvm_runtime_vulkan_objs>)
- if(PROJECT_IS_TOP_LEVEL)
- install(TARGETS tvm_runtime_vulkan DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
+ install(TARGETS tvm_runtime_vulkan DESTINATION ${CMAKE_INSTALL_LIBDIR}
COMPONENT tvm_tirx)
list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_vulkan)
target_link_libraries(tvm_runtime_vulkan PUBLIC tvm_runtime PRIVATE
${Vulkan_LIBRARY})
tvm_tirx_configure_target(tvm_runtime_vulkan_objs)
diff --git a/tirx/cmake/modules/contrib/Z3.cmake
b/tirx/cmake/modules/contrib/Z3.cmake
index 4543e46909..37c37f74cb 100644
--- a/tirx/cmake/modules/contrib/Z3.cmake
+++ b/tirx/cmake/modules/contrib/Z3.cmake
@@ -103,7 +103,7 @@ if(TVM_TIRX_BUILD_PYTHON_MODULE AND Z3_TARGET)
"import importlib.util; from pathlib import Path;
s=importlib.util.find_spec('mlc_z3_static'); print((Path(s.origin).parent /
'licenses/LICENSE-Z3.txt').as_posix() if s else '')"
OUTPUT_VARIABLE _z3_license OUTPUT_STRIP_TRAILING_WHITESPACE)
if(EXISTS "${_z3_license}")
- install(FILES "${_z3_license}" DESTINATION licenses)
+ install(FILES "${_z3_license}" DESTINATION licenses COMPONENT tvm_tirx)
endif()
endif()
endif()
diff --git a/tirx/cmake/utils/FindLLVM.cmake b/tirx/cmake/utils/FindLLVM.cmake
index fc6796a361..e249de8b01 100644
--- a/tirx/cmake/utils/FindLLVM.cmake
+++ b/tirx/cmake/utils/FindLLVM.cmake
@@ -15,6 +15,29 @@
# specific language governing permissions and limitations
# under the License.
+# Isolate the signature probe from an embedding project's compilation defaults.
+function(_tvm_llvm_check_dibuilder)
+ include(CheckCXXSourceCompiles)
+ include(CMakePushCheckState)
+ cmake_push_check_state(RESET)
+ set(CMAKE_REQUIRED_INCLUDES ${LLVM_INCLUDE_DIRS})
+ # Probe the headers with the same standard as the TIRx compilation targets.
+ set(CMAKE_CXX_STANDARD 20)
+ set(CMAKE_CXX_STANDARD_REQUIRED ON)
+ set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+ check_cxx_source_compiles("
+ #include <llvm/IR/DIBuilder.h>
+ #include <llvm/IR/Instructions.h>
+ void f(llvm::DIBuilder* b, llvm::Value* v, llvm::DILocalVariable* var,
+ llvm::DIExpression* e, const llvm::DILocation* dl,
+ llvm::Instruction* i) {
+ b->insertDeclare(v, var, e, dl, llvm::BasicBlock::iterator(i));
+ b->insertDbgValueIntrinsic(v, var, e, dl, llvm::BasicBlock::iterator(i));
+ }
+ " TVM_LLVM_DIBUILDER_USES_ITERATOR)
+ cmake_pop_check_state()
+endfunction()
+
#######################################################
# Enhanced version of find llvm.
#
@@ -233,31 +256,7 @@ macro(find_llvm use_llvm)
# (upstream LLVM 20+) vs Instruction* (pre-LLVM 20 and ROCm-bundled LLVM 20,
# which reports version 200 but retains the legacy Instruction* overload).
if (${TVM_LLVM_VERSION} GREATER_EQUAL 200)
- include(CheckCXXSourceCompiles)
- include(CMakePushCheckState)
- cmake_push_check_state(RESET)
- set(CMAKE_REQUIRED_INCLUDES ${LLVM_INCLUDE_DIRS})
- # Only force -std= when the outer project hasn't already selected a
- # standard; signature-only probe does not need -fno-rtti. Use the
- # compiler-appropriate form so the probe works under MSVC as well.
- if(NOT CMAKE_CXX_STANDARD)
- if(MSVC)
- set(CMAKE_REQUIRED_FLAGS "/std:c++20")
- else()
- set(CMAKE_REQUIRED_FLAGS "-std=c++20")
- endif()
- endif()
- check_cxx_source_compiles("
- #include <llvm/IR/DIBuilder.h>
- #include <llvm/IR/Instructions.h>
- void f(llvm::DIBuilder* b, llvm::Value* v, llvm::DILocalVariable* var,
- llvm::DIExpression* e, const llvm::DILocation* dl,
- llvm::Instruction* i) {
- b->insertDeclare(v, var, e, dl, llvm::BasicBlock::iterator(i));
- b->insertDbgValueIntrinsic(v, var, e, dl,
llvm::BasicBlock::iterator(i));
- }
- " TVM_LLVM_DIBUILDER_USES_ITERATOR)
- cmake_pop_check_state()
+ _tvm_llvm_check_dibuilder()
if(TVM_LLVM_DIBUILDER_USES_ITERATOR)
add_definitions(-DTVM_LLVM_DIBUILDER_USES_ITERATOR=1)
message(STATUS "LLVM DIBuilder insertion APIs use BasicBlock::iterator")
diff --git a/tirx/cmake/utils/Library.cmake b/tirx/cmake/utils/Library.cmake
index ee26447a80..a37a8a97f9 100644
--- a/tirx/cmake/utils/Library.cmake
+++ b/tirx/cmake/utils/Library.cmake
@@ -15,8 +15,18 @@
# specific language governing permissions and limitations
# under the License.
-# Keep shared libraries relocatable within their installation directory.
+# Apply compilation policy only to TIRx targets, including their object
libraries.
function(tvm_tirx_configure_target target)
+ set_property(TARGET ${target} PROPERTY POSITION_INDEPENDENT_CODE ON)
+ set_property(TARGET ${target} PROPERTY CXX_STANDARD 20)
+ set_property(TARGET ${target} PROPERTY CXX_STANDARD_REQUIRED ON)
+ set_property(TARGET ${target} PROPERTY CUDA_STANDARD 20)
+ set_property(TARGET ${target} PROPERTY CUDA_STANDARD_REQUIRED ON)
+ set_property(TARGET ${target} PROPERTY CXX_EXTENSIONS OFF)
+ set_property(TARGET ${target} PROPERTY CXX_VISIBILITY_PRESET hidden)
+ set_property(TARGET ${target} PROPERTY VISIBILITY_INLINES_HIDDEN ON)
+
+ # Keep shared libraries relocatable within their installation directory.
if(APPLE)
set_target_properties(${target} PROPERTIES BUILD_RPATH "@loader_path"
INSTALL_RPATH "@loader_path")
elseif(UNIX)
diff --git a/tirx/pyproject.toml b/tirx/pyproject.toml
index 5b232d8495..98afc68828 100644
--- a/tirx/pyproject.toml
+++ b/tirx/pyproject.toml
@@ -89,6 +89,7 @@ wheel.py-api = "py3"
build-dir = "build"
# Wheel configuration
+install.components = ["tvm_tirx"]
wheel.packages = ["python/tvm_tirx"]
wheel.install-dir = "tvm_tirx"
