saymrwulf/onnxruntime
1
0
Fork 0
mirror of https://github.com/saymrwulf/onnxruntime.git synced 2026-05-17 21:10:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
onnxruntime/cmake/winml.cmake
Changming Sun 04900f96c1
Improve dependency management (#13523) 
## Description
1. Convert some git submodules to cmake external projects
2. Update nsync from
[1.23.0](https://github.com/google/nsync/releases/tag/1.23.0) to
[1.25.0](https://github.com/google/nsync/releases/tag/1.25.0)
3. Update re2 from 2021-06-01 to 2022-06-01
4. Update wil from an old commit to 1.0.220914.1 tag
5. Update gtest to a newer commit so that it can optionally leverage
absl/re2 for parsing command line flags.

The following git submodules are deleted:

1. FP16
2. safeint
3. XNNPACK
4. cxxopts
5. dlpack
7. flatbuffers
8. googlebenchmark
9. json
10. mimalloc
11. mp11
12. pthreadpool

More will come.

## Motivation and Context
There are 3 ways of integrating 3rd party C/C++ libraries into ONNX
Runtime:
1. Install them to a system location, then use cmake's find_package
module to locate them.
2.  Use git submodules 
6.  Use cmake's external projects(externalproject_add). 

At first when this project was just started, we considered both option 2
and option 3. We preferred option 2 because:

1. It's easier to handle authentication. At first this project was not
open source, and it had some other non-public dependencies. If we use
git submodule, ADO will handle authentication smoothly. Otherwise we
need to manually pass tokens around and be very careful on not exposing
them in build logs.
2. At that time, cmake fetched dependencies after "cmake" finished
generating vcprojects/makefiles. So it was very difficult to make cflags
consistent. Since cmake 3.11, it has a new command: FetchContent, which
fetches dependencies when it generates vcprojects/makefiles just before
add_subdirectories, so the parent project's variables/settings can be
easily passed to the child projects.

And when the project went on,  we had some new concerns:
1. As we started to have more and more EPs and build configs, the number
of submodules grew quickly. For more developers, most ORT submodules are
not relevant to them. They shouldn't need to download all of them.
2. It is impossible to let two different build configs use two different
versions of the same dependency. For example, right now we have protobuf
3.18.3 in the submodules. Then every EP must use the same version.
Whenever we have a need to upgrade protobuf, we need to coordinate
across the whole team and many external developers. I can't manage it
anymore.
3. Some projects want to manage the dependencies in a different way,
either because of their preference or because of compliance
requirements. For example, some Microsoft teams want to use vcpkg, but
we don't want to force every user of onnxruntime using vcpkg.
7. Someone wants to dynamically link to protobuf, but our build script
only does static link.
8. Hard to handle security vulnerabilities. For example, whenever
protobuf has a security patch, we have a lot of things to do. But if we
allowed people to build ORT with a different version of protobuf without
changing ORT"s source code, the customer who build ORT from source will
be able to act on such things in a quicker way. They will not need to
wait ORT having a patch release.
9. Every time we do a release, github will also publish a source file
zip file and a source file tarball for us. But they are not usable,
because they miss submodules.
 
### New features

After this change, users will be able to:
1. Build the dependencies in the way they want, then install them to
somewhere(for example, /usr or a temp folder).
2. Or download the dependencies by using cmake commands from these
dependencies official website
3. Similar to the above, but use your private mirrors to migrate supply
chain risks.
4. Use different versions of the dependencies, as long as our source
code is compatible with them. For example, you may use you can't use
protobuf 3.20.x as they need code changes in ONNX Runtime.
6.  Only download the things the current build needs.
10. Avoid building external dependencies again and again in every build.

### Breaking change
The onnxruntime_PREFER_SYSTEM_LIB build option is removed you could think from now 
it is default ON. If you don't like the new behavior, you can set FETCHCONTENT_TRY_FIND_PACKAGE_MODE to NEVER.
Besides, for who relied on the onnxruntime_PREFER_SYSTEM_LIB build
option, please be aware that this PR will change find_package calls from
Module mode to Config mode. For example, in the past if you have
installed protobuf from apt-get from ubuntu 20.04's official repo,
find_package can find it and use it. But after this PR, it won't. This
is because that protobuf version provided by Ubuntu 20.04 is too old to
support the "config mode". It can be resolved by getting a newer version
of protobuf from somewhere.
2022-12-01 09:51:59 -08:00

843 lines
41 KiB
CMake
Raw Blame History

# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
if (CMAKE_CXX_STANDARD_LIBRARIES MATCHES kernel32.lib)
message(FATAL_ERROR "WinML is only supported on WCOS")
endif()
include(precompiled_header.cmake)
include(target_delayload.cmake)
include(winml_sdk_helpers.cmake)
include(winml_cppwinrt.cmake)
include(nuget_helpers.cmake)
# get the current nuget sdk kit directory
get_sdk(sdk_folder sdk_version)
get_sdk_include_folder(${sdk_folder} ${sdk_version} sdk_include_folder)
set(dxcore_header "${sdk_include_folder}/um/dxcore.h")
set(target_folder ONNXRuntime/winml)
set(winml_adapter_dir ${REPO_ROOT}/winml/adapter)
set(winml_api_root ${REPO_ROOT}/winml/api)
set(winml_dll_dir ${REPO_ROOT}/winml/dll)
set(winml_lib_dir ${REPO_ROOT}/winml/lib)
set(winml_lib_api_dir ${REPO_ROOT}/winml/lib/api)
set(winml_lib_api_experimental_dir ${REPO_ROOT}/winml/lib/api.experimental)
set(winml_lib_api_image_dir ${REPO_ROOT}/winml/lib/api.image)
set(winml_lib_api_ort_dir ${REPO_ROOT}/winml/lib/api.ort)
set(winml_lib_common_dir ${REPO_ROOT}/winml/lib/common)
set(winml_lib_telemetry_dir ${REPO_ROOT}/winml/lib/telemetry)
# Retrieve the version of cppwinrt nuget
package_version(
Microsoft.Windows.CppWinRT
CppWinRT_version
${PROJECT_SOURCE_DIR}/../packages.config
)
# Override and use the the cppwinrt from NuGet package as opposed to the one in the SDK.
set(winml_CPPWINRT_EXE_PATH_OVERRIDE ${CMAKE_CURRENT_BINARY_DIR}/../packages/Microsoft.Windows.CppWinRT.${CppWinRT_version}/bin/cppwinrt.exe)
# add custom target to fetch the nugets
add_fetch_nuget_target(
RESTORE_NUGET_PACKAGES # target name
winml_CPPWINRT_EXE_PATH_OVERRIDE # cppwinrt is the target package
)
set(winml_is_inbox OFF)
if (onnxruntime_WINML_NAMESPACE_OVERRIDE)
set(output_name "${onnxruntime_WINML_NAMESPACE_OVERRIDE}.AI.MachineLearning")
set(experimental_output_name "${onnxruntime_WINML_NAMESPACE_OVERRIDE}.AI.MachineLearning.Experimental")
set(idl_native_output_name "${onnxruntime_WINML_NAMESPACE_OVERRIDE}.AI.MachineLearning.Native")
set(idl_native_internal_output_name "${onnxruntime_WINML_NAMESPACE_OVERRIDE}.AI.MachineLearning.Native.Internal")
if (onnxruntime_WINML_NAMESPACE_OVERRIDE STREQUAL "Windows")
set(winml_midl_defines "/DBUILD_INBOX=1")
set(winml_is_inbox ON)
endif()
set(winml_root_ns "${onnxruntime_WINML_NAMESPACE_OVERRIDE}")
set(BINARY_NAME "${onnxruntime_WINML_NAMESPACE_OVERRIDE}.AI.MachineLearning.dll")
set(winml_api_use_ns_prefix false)
else()
set(output_name "Microsoft.AI.MachineLearning")
set(experimental_output_name "Microsoft.AI.MachineLearning.Experimental")
set(idl_native_output_name "Microsoft.AI.MachineLearning.Native")
set(idl_native_internal_output_name "Microsoft.AI.MachineLearning.Native.Internal")
set(winml_midl_defines "/DROOT_NS=Microsoft")
set(winml_root_ns "Microsoft")
set(BINARY_NAME "Microsoft.AI.MachineLearning.dll")
set(winml_api_use_ns_prefix true)
endif()
get_filename_component(exclusions "${winml_api_root}/exclusions.txt" ABSOLUTE)
convert_forward_slashes_to_back(${exclusions} CPPWINRT_COMPONENT_EXCLUSION_LIST)
# For winrt idl files:
# 1) the file name must match the casing of the file on disk.
# 2) for winrt idls the casing must match the namespaces within exactly (Window.AI.MachineLearning).
# target_cppwinrt will attempt to create a winmd with the name and same casing as the supplied
# idl file. If the name of the winmd file does not match the contained namespaces, cppwinrt.exe
# will generate component template files with fully qualified names, which will not match the existing
# generated component files.
#
# For native idl files there are no casing restrictions.
get_filename_component(winrt_idl "${winml_api_root}/Windows.AI.MachineLearning.idl" ABSOLUTE)
get_filename_component(winrt_experimental_idl "${winml_api_root}/Microsoft.AI.MachineLearning.Experimental.idl" ABSOLUTE)
get_filename_component(idl_native "${winml_api_root}/windows.ai.machineLearning.native.idl" ABSOLUTE)
get_filename_component(idl_native_internal "${winml_api_root}/windows.ai.machineLearning.native.internal.idl" ABSOLUTE)
get_filename_component(winrt_winmd "${CMAKE_CURRENT_BINARY_DIR}/${winml_root_ns}.AI.MachineLearning.winmd" ABSOLUTE)
# generate cppwinrt sdk
add_generate_cppwinrt_sdk_headers_target(
winml_sdk_cppwinrt # the target name
${sdk_folder} # location of sdk folder
${sdk_version} # sdk version
${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include # output folder relative to CMAKE_BINARY_DIR where the generated sdk will be placed in the
${target_folder} # folder where this target will be placed
)
add_dependencies(winml_sdk_cppwinrt RESTORE_NUGET_PACKAGES)
# generate winml headers from idl
target_cppwinrt(winml_api
${winrt_idl} # winml winrt idl to compile
${output_name} # outputs name
${winml_lib_api_dir} # location for cppwinrt generated component sources
${sdk_folder} # location of sdk folder
${sdk_version} # sdk version
${target_folder} # the folder this target will be placed under
"${winml_midl_defines}" # the midl compiler defines
${winml_api_use_ns_prefix} # set ns_prefix
"" # set additional cppwinrt ref path
)
add_dependencies(winml_api RESTORE_NUGET_PACKAGES)
# generate winml.experimental headers from idl
target_cppwinrt(winml_api_experimental
${winrt_experimental_idl} # winml winrt idl to compile
${experimental_output_name} # outputs name
${winml_lib_api_dir} # location for cppwinrt generated component sources
${sdk_folder} # location of sdk folder
${sdk_version} # sdk version
${target_folder} # the folder this target will be placed under
${winml_midl_defines} # the midl compiler defines
${winml_api_use_ns_prefix} # set ns_prefix
${winrt_winmd} # set additional cppwinrt ref path
)
add_dependencies(winml_api_experimental RESTORE_NUGET_PACKAGES)
add_dependencies(winml_api_experimental winml_api)
target_midl(winml_api_native
${idl_native} # winml native idl to compile
${idl_native_output_name} # outputs name
${sdk_folder} # location of sdk folder
${sdk_version} # sdk version
${target_folder} # the folder this target will be placed under
"${winml_midl_defines}" # the midl compiler defines
)
add_dependencies(winml_api_native RESTORE_NUGET_PACKAGES)
target_midl(winml_api_native_internal
${idl_native_internal} # winml internal native idl to compile
${idl_native_internal_output_name} # outputs name
${sdk_folder} # location of sdk folder
${sdk_version} # sdk version
${target_folder} # the folder this target will be placed under
"${winml_midl_defines}" # the midl compiler defines
)
add_dependencies(winml_api_native_internal RESTORE_NUGET_PACKAGES)
###########################
# Add winml_lib_telemetry
###########################
# Add static library that will be archived/linked for both static/dynamic library
onnxruntime_add_static_library(winml_lib_telemetry
${winml_lib_telemetry_dir}/inc/TelemetryEvent.h
${ONNXRUNTIME_INCLUDE_DIR}/core/platform/windows/TraceLoggingConfig.h
${winml_lib_common_dir}/inc/WinMLTelemetryHelper.h
${winml_lib_telemetry_dir}/Telemetry.cpp
${winml_lib_telemetry_dir}/TelemetryEvent.cpp
${winml_lib_telemetry_dir}/WinMLTelemetryHelper.cpp
${winml_lib_telemetry_dir}/pch.h
)
# Compiler options
target_compile_features(winml_lib_telemetry PRIVATE cxx_std_17)
target_compile_options(winml_lib_telemetry PRIVATE /GR- /await /wd4238)
if (onnxruntime_USE_TELEMETRY)
set_target_properties(winml_lib_telemetry PROPERTIES COMPILE_FLAGS "/FI${ONNXRUNTIME_INCLUDE_DIR}/core/platform/windows/TraceLoggingConfigPrivate.h")
endif()
# Compiler flags
target_compile_definitions(winml_lib_telemetry PRIVATE WINML_ROOT_NS=${winml_root_ns})
target_compile_definitions(winml_lib_telemetry PRIVATE PLATFORM_WINDOWS)
target_compile_definitions(winml_lib_telemetry PRIVATE _SCL_SECURE_NO_WARNINGS) # remove warnings about unchecked iterators
target_compile_definitions(winml_lib_telemetry PRIVATE BINARY_NAME=\"${BINARY_NAME}\")
# Specify the usage of a precompiled header
target_precompiled_header(winml_lib_telemetry lib/Telemetry/pch.h)
# Includes
target_include_directories(winml_lib_telemetry PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) # windows machine learning generated component headers
target_include_directories(winml_lib_telemetry PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
target_include_directories(winml_lib_telemetry PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_lib_telemetry PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
target_include_directories(winml_lib_telemetry PRIVATE ${CMAKE_SOURCE_DIR}/common/inc)
target_include_directories(winml_lib_telemetry PRIVATE ${winml_lib_telemetry_dir})
target_include_directories(winml_lib_telemetry PRIVATE ${winml_lib_common_dir}/inc)
target_include_directories(winml_lib_telemetry PRIVATE ${ONNXRUNTIME_INCLUDE_DIR}/core/platform/windows)
target_include_directories(winml_lib_telemetry PRIVATE ${REPO_ROOT}/winml)
target_include_directories(winml_lib_telemetry PRIVATE ${GSL_INCLUDE_DIR})
# Properties
set_target_properties(winml_lib_telemetry
PROPERTIES
FOLDER
${target_folder})
# Add deps
add_dependencies(winml_lib_telemetry winml_sdk_cppwinrt)
add_dependencies(winml_lib_telemetry winml_api)
add_dependencies(winml_lib_telemetry winml_api_native)
add_dependencies(winml_lib_telemetry winml_api_native_internal)
# Link libraries
target_link_libraries(winml_lib_telemetry PRIVATE WIL::WIL)
###########################
# Add winml_lib_ort
###########################
list(APPEND winml_lib_api_ort_files
${winml_lib_api_ort_dir}/inc/OnnxruntimeProvider.h
${winml_lib_api_ort_dir}/OnnxruntimeCpuSessionBuilder.h
${winml_lib_api_ort_dir}/OnnxruntimeCpuSessionBuilder.cpp
${winml_lib_api_ort_dir}/OnnxruntimeDescriptorConverter.h
${winml_lib_api_ort_dir}/OnnxruntimeDescriptorConverter.cpp
${winml_lib_api_ort_dir}/OnnxruntimeEngine.h
${winml_lib_api_ort_dir}/OnnxruntimeEngine.cpp
${winml_lib_api_ort_dir}/OnnxruntimeEngineBuilder.h
${winml_lib_api_ort_dir}/OnnxruntimeEngineBuilder.cpp
${winml_lib_api_ort_dir}/OnnxruntimeEnvironment.h
${winml_lib_api_ort_dir}/OnnxruntimeEnvironment.cpp
${winml_lib_api_ort_dir}/OnnxruntimeModel.h
${winml_lib_api_ort_dir}/OnnxruntimeModel.cpp
${winml_lib_api_ort_dir}/OnnxruntimeSessionBuilder.h
${winml_lib_api_ort_dir}/pch.h
)
if (onnxruntime_USE_DML)
list(APPEND winml_lib_api_ort_files
${winml_lib_api_ort_dir}/OnnxruntimeDmlSessionBuilder.h
${winml_lib_api_ort_dir}/OnnxruntimeDmlSessionBuilder.cpp
)
endif()
# Add static library that will be archived/linked for both static/dynamic library
onnxruntime_add_static_library(winml_lib_ort ${winml_lib_api_ort_files})
# Compiler options
target_compile_features(winml_lib_ort PRIVATE cxx_std_17)
target_compile_options(winml_lib_ort PRIVATE /GR- /await /wd4238)
# Compiler definitions
target_compile_definitions(winml_lib_ort PRIVATE WINML_ROOT_NS=${winml_root_ns})
target_compile_definitions(winml_lib_ort PRIVATE PLATFORM_WINDOWS)
target_compile_definitions(winml_lib_ort PRIVATE _SCL_SECURE_NO_WARNINGS) # remove warnings about unchecked iterators
if (onnxruntime_WINML_NAMESPACE_OVERRIDE STREQUAL "Windows")
target_compile_definitions(winml_lib_ort PRIVATE "BUILD_INBOX=1")
endif()
# Specify the usage of a precompiled header
target_precompiled_header(winml_lib_ort lib/Api.Ort/pch.h)
# Includes
target_include_directories(winml_lib_ort PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
target_include_directories(winml_lib_ort PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_lib_ort PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
target_include_directories(winml_lib_ort PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(winml_lib_ort PRIVATE ${REPO_ROOT}/winml)
target_include_directories(winml_lib_ort PRIVATE ${winml_lib_api_dir}) # needed for generated headers
target_include_directories(winml_lib_ort PRIVATE ${winml_lib_api_core_dir})
target_include_directories(winml_lib_ort PRIVATE ${winml_lib_api_ort_dir})
target_include_directories(winml_lib_ort PRIVATE ${winml_lib_common_dir}/inc)
target_include_directories(winml_lib_ort PRIVATE ${ONNXRUNTIME_INCLUDE_DIR})
target_include_directories(winml_lib_ort PRIVATE ${ONNXRUNTIME_ROOT})
target_include_directories(winml_lib_ort PRIVATE ${GSL_INCLUDE_DIR})
set_target_properties(winml_lib_ort
PROPERTIES
FOLDER
${target_folder})
# Add deps
add_dependencies(winml_lib_ort winml_sdk_cppwinrt)
add_dependencies(winml_lib_ort winml_api)
add_dependencies(winml_lib_ort winml_api_native)
add_dependencies(winml_lib_ort winml_api_native_internal)
# Link libraries
if (onnxruntime_USE_DML)
target_add_dml(winml_lib_ort)
endif()
target_link_libraries(winml_lib_ort PRIVATE WIL::WIL)
target_link_libraries(winml_lib_ort INTERFACE winml_lib_api)
target_link_libraries(winml_lib_ort INTERFACE winml_lib_telemetry)
###########################
# Add winml_adapter
###########################
list(APPEND winml_adapter_files
${winml_adapter_dir}/pch.h
${winml_adapter_dir}/winml_adapter_apis.h
${winml_adapter_dir}/winml_adapter_c_api.h
${winml_adapter_dir}/winml_adapter_c_api.cpp
${winml_adapter_dir}/winml_adapter_dml.cpp
${winml_adapter_dir}/winml_adapter_environment.cpp
${winml_adapter_dir}/winml_adapter_execution_provider.cpp
${winml_adapter_dir}/winml_adapter_model.cpp
${winml_adapter_dir}/winml_adapter_model.h
${winml_adapter_dir}/winml_adapter_session.cpp
)
if (onnxruntime_USE_DML)
list(APPEND winml_adapter_files
${winml_adapter_dir}/abi_custom_registry_impl.cpp
${winml_adapter_dir}/abi_custom_registry_impl.h
)
endif()
onnxruntime_add_static_library(winml_adapter ${winml_adapter_files})
if (onnxruntime_WINML_NAMESPACE_OVERRIDE STREQUAL "Windows")
target_compile_definitions(winml_adapter PRIVATE "BUILD_INBOX=1")
endif()
# wil requires C++17
set_target_properties(winml_adapter PROPERTIES CXX_STANDARD 17)
set_target_properties(winml_adapter PROPERTIES CXX_STANDARD_REQUIRED ON)
# Compiler definitions
onnxruntime_add_include_to_target(winml_adapter onnxruntime_common onnxruntime_framework onnx onnx_proto ${PROTOBUF_LIB} flatbuffers safeint_interface Boost::mp11)
target_include_directories(winml_adapter PRIVATE ${ONNXRUNTIME_ROOT} ${eigen_INCLUDE_DIRS})
add_dependencies(winml_adapter ${onnxruntime_EXTERNAL_DEPENDENCIES})
# Specify the usage of a precompiled header
target_precompiled_header(winml_adapter adapter/pch.h)
# Includes
target_include_directories(winml_adapter PRIVATE ${REPO_ROOT}/winml)
target_include_directories(winml_adapter PRIVATE ${winml_adapter_dir})
target_include_directories(winml_adapter PRIVATE ${winml_lib_common_dir}/inc)
set_target_properties(winml_adapter
PROPERTIES
FOLDER
${target_folder})
# Link libraries
target_link_libraries(winml_adapter PRIVATE WIL::WIL)
if (onnxruntime_USE_DML)
target_add_dml(winml_adapter)
endif()
# add it to the onnxruntime shared library
set(onnxruntime_winml winml_adapter)
list(APPEND onnxruntime_EXTERNAL_DEPENDENCIES winml_adapter)
###########################
# Add winml_lib_image
###########################
# Add static library that will be archived/linked for both static/dynamic library
onnxruntime_add_static_library(winml_lib_image
${winml_lib_api_image_dir}/inc/ConverterResourceStore.h
${winml_lib_api_image_dir}/inc/D3DDeviceCache.h
${winml_lib_api_image_dir}/inc/DeviceHelpers.h
${winml_lib_api_image_dir}/inc/DisjointBufferHelpers.h
${winml_lib_api_image_dir}/inc/ImageConversionHelpers.h
${winml_lib_api_image_dir}/inc/ImageConversionTypes.h
${winml_lib_api_image_dir}/inc/ImageConverter.h
${winml_lib_api_image_dir}/inc/TensorToVideoFrameConverter.h
${winml_lib_api_image_dir}/inc/VideoFrameToTensorConverter.h
${winml_lib_api_image_dir}/inc/NominalRangeConverter.h
${winml_lib_api_image_dir}/CpuDetensorizer.h
${winml_lib_api_image_dir}/CpuTensorizer.h
${winml_lib_api_image_dir}/pch.h
${winml_lib_api_image_dir}/ConverterResourceStore.cpp
${winml_lib_api_image_dir}/D3DDeviceCache.cpp
${winml_lib_api_image_dir}/DeviceHelpers.cpp
${winml_lib_api_image_dir}/DisjointBufferHelpers.cpp
${winml_lib_api_image_dir}/ImageConversionHelpers.cpp
${winml_lib_api_image_dir}/ImageConverter.cpp
${winml_lib_api_image_dir}/TensorToVideoFrameConverter.cpp
${winml_lib_api_image_dir}/VideoFrameToTensorConverter.cpp
${winml_lib_api_image_dir}/NominalRangeConverter.cpp
)
# Compiler options
target_compile_features(winml_lib_image PRIVATE cxx_std_17)
target_compile_options(winml_lib_image PRIVATE /GR- /await /wd4238 /wd5205)
# Compiler flags
target_compile_definitions(winml_lib_image PRIVATE WINML_ROOT_NS=${winml_root_ns})
target_compile_definitions(winml_lib_image PRIVATE ONNX_NAMESPACE=onnx)
target_compile_definitions(winml_lib_image PRIVATE ONNX_ML)
target_compile_definitions(winml_lib_image PRIVATE LOTUS_LOG_THRESHOLD=2)
target_compile_definitions(winml_lib_image PRIVATE LOTUS_ENABLE_STDERR_LOGGING)
target_compile_definitions(winml_lib_image PRIVATE PLATFORM_WINDOWS)
target_compile_definitions(winml_lib_image PRIVATE _SCL_SECURE_NO_WARNINGS) # remove warnings about unchecked iterators
# Specify the usage of a precompiled header
target_precompiled_header(winml_lib_image lib/Api.Image/pch.h)
# Includes
target_include_directories(winml_lib_image PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) # windows machine learning generated component headers
target_include_directories(winml_lib_image PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
target_include_directories(winml_lib_image PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_lib_image PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
target_include_directories(winml_lib_image PRIVATE ${ONNXRUNTIME_ROOT}/core/providers/dml/DmlExecutionProvider/src/External/D3DX12) # for d3dx12.h
target_include_directories(winml_lib_image PRIVATE ${winml_lib_api_dir}) # needed for generated headers
target_include_directories(winml_lib_image PRIVATE ${winml_lib_api_image_dir})
target_include_directories(winml_lib_image PRIVATE ${winml_lib_common_dir}/inc)
target_include_directories(winml_lib_image PRIVATE ${ONNXRUNTIME_ROOT})
target_include_directories(winml_lib_image PRIVATE ${ONNXRUNTIME_INCLUDE_DIR}) # for status.h
onnxruntime_add_include_to_target(winml_lib_image onnx onnx_proto ${PROTOBUF_LIB} re2::re2 flatbuffers Boost::mp11)
target_include_directories(winml_lib_image PRIVATE ${ONNXRUNTIME_INCLUDE_DIR}/core/platform/windows)
target_include_directories(winml_lib_image PRIVATE ${REPO_ROOT}/winml)
target_include_directories(winml_lib_image PRIVATE ${GSL_INCLUDE_DIR})
# Properties
set_target_properties(winml_lib_image
PROPERTIES
FOLDER
${target_folder})
# Add deps
add_dependencies(winml_lib_image winml_sdk_cppwinrt)
add_dependencies(winml_lib_image winml_api)
add_dependencies(winml_lib_image winml_api_native)
add_dependencies(winml_lib_image winml_api_native_internal)
# Link libraries
target_link_libraries(winml_lib_image PRIVATE dxgi d3d11 d3d12 WIL::WIL winml_lib_common)
get_target_property(winml_lib_image_include_directories winml_lib_image INCLUDE_DIRECTORIES)
if (onnxruntime_USE_DML)
target_add_dml(winml_lib_image)
endif(onnxruntime_USE_DML)
###########################
# Add winml_lib_api
###########################
# Add static library that will be archived/linked for both static/dynamic library
onnxruntime_add_static_library(winml_lib_api
${winml_lib_api_dir}/impl/FeatureCompatibility.h
${winml_lib_api_dir}/impl/IData.h
${winml_lib_api_dir}/impl/IMapFeatureValue.h
${winml_lib_api_dir}/impl/ISequenceFeatureValue.h
${winml_lib_api_dir}/impl/MapBase.h
${winml_lib_api_dir}/impl/NumericData.h
${winml_lib_api_dir}/impl/SequenceBase.h
${winml_lib_api_dir}/impl/StringData.h
${winml_lib_api_dir}/impl/Tensor.h
${winml_lib_api_dir}/impl/TensorBase.h
${winml_lib_api_dir}/impl/TensorKindFrom.h
${winml_lib_api_dir}/impl/TensorMemoryBufferReference.h
${winml_lib_api_dir}/NumericData.cpp
${winml_lib_api_dir}/ImageFeatureDescriptor.cpp
${winml_lib_api_dir}/ImageFeatureDescriptor.h
${winml_lib_api_dir}/ImageFeatureValue.cpp
${winml_lib_api_dir}/ImageFeatureValue.h
${winml_lib_api_dir}/LearningModel.cpp
${winml_lib_api_dir}/LearningModel.h
${winml_lib_api_dir}/LearningModelBinding.cpp
${winml_lib_api_dir}/LearningModelBinding.h
${winml_lib_api_dir}/LearningModelDevice.cpp
${winml_lib_api_dir}/LearningModelDevice.h
${winml_lib_api_dir}/LearningModelEvaluationResult.cpp
${winml_lib_api_dir}/LearningModelEvaluationResult.h
${winml_lib_api_dir}/LearningModelSession.cpp
${winml_lib_api_dir}/LearningModelSession.h
${winml_lib_api_dir}/LearningModelSessionOptions.cpp
${winml_lib_api_dir}/LearningModelSessionOptions.h
${winml_lib_api_dir}/MapFeatureDescriptor.cpp
${winml_lib_api_dir}/MapFeatureDescriptor.h
${winml_lib_api_dir}/SequenceFeatureDescriptor.cpp
${winml_lib_api_dir}/SequenceFeatureDescriptor.h
${winml_lib_api_dir}/StringData.cpp
${winml_lib_api_dir}/TensorFeatureDescriptor.cpp
${winml_lib_api_dir}/TensorFeatureDescriptor.h
${winml_lib_api_dir}/VectorBackedBuffer.h
${winml_lib_api_dir}/VectorBackedBuffer.cpp
${winml_lib_api_dir}/pch/pch.h
)
# Compiler options
target_compile_features(winml_lib_api PRIVATE cxx_std_17)
target_compile_options(winml_lib_api PRIVATE /GR- /await /bigobj /wd4238 /wd5205)
# Compiler flags
target_compile_definitions(winml_lib_api PRIVATE WINML_ROOT_NS=${winml_root_ns})
target_compile_definitions(winml_lib_api PRIVATE ONNX_NAMESPACE=onnx)
target_compile_definitions(winml_lib_api PRIVATE ONNX_ML)
target_compile_definitions(winml_lib_api PRIVATE LOTUS_LOG_THRESHOLD=2)
target_compile_definitions(winml_lib_api PRIVATE LOTUS_ENABLE_STDERR_LOGGING)
target_compile_definitions(winml_lib_api PRIVATE PLATFORM_WINDOWS)
target_compile_definitions(winml_lib_api PRIVATE _SCL_SECURE_NO_WARNINGS) # remove warnings about unchecked iterators
# Specify the usage of a precompiled header
target_precompiled_header(winml_lib_api lib/Api/pch/pch.h)
# Includes
target_include_directories(winml_lib_api PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
target_include_directories(winml_lib_api PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_lib_api PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
target_include_directories(winml_lib_api PRIVATE ${winml_lib_api_dir})
target_include_directories(winml_lib_api PRIVATE ${winml_lib_api_dir}/pch)
target_include_directories(winml_lib_api PRIVATE ${winml_adapter_dir})
target_include_directories(winml_lib_api PRIVATE ${winml_lib_api_image_dir}/inc)
target_include_directories(winml_lib_api PRIVATE ${winml_lib_api_ort_dir}/inc)
target_include_directories(winml_lib_api PRIVATE ${winml_lib_telemetry_dir}/inc)
target_include_directories(winml_lib_api PRIVATE ${winml_lib_common_dir}/inc)
target_include_directories(winml_lib_api PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(winml_lib_api PRIVATE ${ONNXRUNTIME_INCLUDE_DIR})
target_include_directories(winml_lib_api PRIVATE ${ONNXRUNTIME_INCLUDE_DIR}/core/graph)
target_include_directories(winml_lib_api PRIVATE ${ONNXRUNTIME_ROOT})
target_include_directories(winml_lib_api PRIVATE ${ONNXRUNTIME_ROOT}/core/graph)
target_include_directories(winml_lib_api PRIVATE ${REPO_ROOT}/winml)
target_include_directories(winml_lib_api PRIVATE ${eigen_INCLUDE_DIRS})
target_link_libraries(winml_lib_api PRIVATE ${GSL_TARGET} safeint_interface flatbuffers Boost::mp11 onnx onnx_proto)
# Properties
set_target_properties(winml_lib_api
PROPERTIES
FOLDER
${target_folder})
# Add deps
add_dependencies(winml_lib_api onnx)
add_dependencies(winml_lib_api winml_sdk_cppwinrt)
add_dependencies(winml_lib_api winml_api)
add_dependencies(winml_lib_api winml_api_native)
add_dependencies(winml_lib_api winml_api_native_internal)
# Link libraries
target_link_libraries(winml_lib_api PRIVATE WIL::WIL winml_lib_telemetry)
if (onnxruntime_USE_DML)
target_add_dml(winml_lib_api)
endif(onnxruntime_USE_DML)
###########################
# Add winml_lib_api_experimental_dir
###########################
# Add static library that will be archived/linked for both static/dynamic library
onnxruntime_add_static_library(winml_lib_api_experimental
${winml_lib_api_experimental_dir}/LearningModelBuilder.cpp
${winml_lib_api_experimental_dir}/LearningModelBuilder.h
${winml_lib_api_experimental_dir}/LearningModelExperimental.cpp
${winml_lib_api_experimental_dir}/LearningModelExperimental.h
${winml_lib_api_experimental_dir}/LearningModelInputs.cpp
${winml_lib_api_experimental_dir}/LearningModelInputs.h
${winml_lib_api_experimental_dir}/LearningModelJoinOptions.cpp
${winml_lib_api_experimental_dir}/LearningModelJoinOptions.h
${winml_lib_api_experimental_dir}/LearningModelOutputs.cpp
${winml_lib_api_experimental_dir}/LearningModelOutputs.h
${winml_lib_api_experimental_dir}/LearningModelOperator.cpp
${winml_lib_api_experimental_dir}/LearningModelOperator.h
${winml_lib_api_experimental_dir}/LearningModelOperatorSet.cpp
${winml_lib_api_experimental_dir}/LearningModelOperatorSet.h
${winml_lib_api_experimental_dir}/LearningModelSessionExperimental.cpp
${winml_lib_api_experimental_dir}/LearningModelSessionExperimental.h
${winml_lib_api_experimental_dir}/LearningModelSessionOptionsExperimental.cpp
${winml_lib_api_experimental_dir}/LearningModelSessionOptionsExperimental.h
)
# Compiler options
target_compile_features(winml_lib_api_experimental PRIVATE cxx_std_17)
target_compile_options(winml_lib_api_experimental PRIVATE /GR- /await /bigobj /wd4238)
# Compiler flags
target_compile_definitions(winml_lib_api_experimental PRIVATE WINML_ROOT_NS=${winml_root_ns})
target_compile_definitions(winml_lib_api_experimental PRIVATE ONNX_NAMESPACE=onnx)
target_compile_definitions(winml_lib_api_experimental PRIVATE ONNX_ML)
target_compile_definitions(winml_lib_api_experimental PRIVATE LOTUS_LOG_THRESHOLD=2)
target_compile_definitions(winml_lib_api_experimental PRIVATE LOTUS_ENABLE_STDERR_LOGGING)
target_compile_definitions(winml_lib_api_experimental PRIVATE PLATFORM_WINDOWS)
target_compile_definitions(winml_lib_api_experimental PRIVATE _SCL_SECURE_NO_WARNINGS) # remove warnings about unchecked iterators
# Specify the usage of a precompiled header
target_precompiled_header(winml_lib_api_experimental lib/Api.Experimental/pch/pch.h)
# Includes
target_include_directories(winml_lib_api_experimental PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
target_include_directories(winml_lib_api_experimental PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_lib_api_experimental PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api_experimental) # windows machine learning generated component headers
target_include_directories(winml_lib_api_experimental PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api_experimental/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_lib_api_experimental PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
target_include_directories(winml_lib_api_experimental PRIVATE ${winml_lib_api_dir})
target_include_directories(winml_lib_api_experimental PRIVATE ${winml_lib_api_dir}/pch)
target_include_directories(winml_lib_api_experimental PRIVATE ${winml_adapter_dir})
target_include_directories(winml_lib_api_experimental PRIVATE ${winml_lib_api_image_dir}/inc)
target_include_directories(winml_lib_api_experimental PRIVATE ${winml_lib_api_ort_dir}/inc)
target_include_directories(winml_lib_api_experimental PRIVATE ${winml_lib_telemetry_dir}/inc)
target_include_directories(winml_lib_api_experimental PRIVATE ${winml_lib_common_dir}/inc)
target_include_directories(winml_lib_api_experimental PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(winml_lib_api_experimental PRIVATE ${ONNXRUNTIME_INCLUDE_DIR})
target_include_directories(winml_lib_api_experimental PRIVATE ${ONNXRUNTIME_INCLUDE_DIR}/core/graph)
target_include_directories(winml_lib_api_experimental PRIVATE ${ONNXRUNTIME_ROOT})
target_include_directories(winml_lib_api_experimental PRIVATE ${ONNXRUNTIME_ROOT}/core/graph)
target_include_directories(winml_lib_api_experimental PRIVATE ${eigen_INCLUDE_DIRS})
target_include_directories(winml_lib_api_experimental PRIVATE ${REPO_ROOT}/winml)
onnxruntime_add_include_to_target(winml_lib_api_experimental PRIVATE ${PROTOBUF_LIB} safeint_interface flatbuffers Boost::mp11 onnx onnx_proto ${GSL_TARGET})
# Properties
set_target_properties(winml_lib_api_experimental
PROPERTIES
FOLDER
${target_folder})
# Add deps
add_dependencies(winml_lib_api_experimental onnx)
add_dependencies(winml_lib_api_experimental winml_sdk_cppwinrt)
add_dependencies(winml_lib_api_experimental winml_api)
add_dependencies(winml_lib_api_experimental winml_api_native)
add_dependencies(winml_lib_api_experimental winml_api_native_internal)
add_dependencies(winml_lib_api_experimental winml_api_experimental)
# Link libraries
target_link_libraries(winml_lib_api_experimental PRIVATE WIL::WIL winml_lib_telemetry)
if (onnxruntime_USE_DML)
target_add_dml(winml_lib_api_experimental)
endif(onnxruntime_USE_DML)
###########################
# Add winml_lib_common
###########################
onnxruntime_add_static_library(winml_lib_common
${winml_lib_common_dir}/inc/common.h
${winml_lib_common_dir}/inc/CommonDeviceHelpers.h
${winml_lib_common_dir}/inc/cppwinrt_onnx.h
${winml_lib_common_dir}/inc/dx.h
${winml_lib_common_dir}/inc/errors.h
${winml_lib_common_dir}/inc/iengine.h
${winml_lib_common_dir}/inc/NamespaceAliases.h
${winml_lib_common_dir}/inc/onnx.h
${winml_lib_common_dir}/inc/PheonixSingleton.h
${winml_lib_common_dir}/inc/StringHelpers.h
${winml_lib_common_dir}/inc/WinMLTelemetryHelper.h
${winml_lib_common_dir}/inc/WinML_Lock.h
${winml_lib_common_dir}/inc/winrt_headers.h
${winml_lib_common_dir}/CommonDeviceHelpers.cpp
)
set_target_properties(winml_lib_common PROPERTIES CXX_STANDARD 17)
set_target_properties(winml_lib_common PROPERTIES CXX_STANDARD_REQUIRED ON)
target_compile_options(winml_lib_common PRIVATE /GR- /await /bigobj /wd4238)
target_link_libraries(winml_lib_common PRIVATE WIL::WIL)
target_include_directories(winml_lib_common PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api)
# Compiler flags
target_compile_definitions(winml_lib_common PRIVATE BINARY_NAME=\"${BINARY_NAME}\")
target_compile_definitions(winml_lib_common PRIVATE WINML_ROOT_NS=${winml_root_ns})
target_compile_definitions(winml_lib_common PRIVATE ONNX_NAMESPACE=onnx)
target_compile_definitions(winml_lib_common PRIVATE ONNX_ML)
target_compile_definitions(winml_lib_common PRIVATE LOTUS_LOG_THRESHOLD=2)
target_compile_definitions(winml_lib_common PRIVATE LOTUS_ENABLE_STDERR_LOGGING)
target_compile_definitions(winml_lib_common PRIVATE PLATFORM_WINDOWS)
target_compile_definitions(winml_lib_common PRIVATE _SCL_SECURE_NO_WARNINGS)
add_dependencies(winml_lib_common winml_sdk_cppwinrt)
add_dependencies(winml_lib_common winml_api)
add_dependencies(winml_lib_common winml_api_native)
add_dependencies(winml_lib_common winml_api_native_internal)
target_include_directories(winml_lib_common PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
target_include_directories(winml_lib_common PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_lib_common PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
target_include_directories(winml_lib_common PRIVATE ${winml_lib_api_dir})
target_include_directories(winml_lib_common PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(winml_lib_common PRIVATE ${winml_lib_common_dir}/inc)
target_include_directories(winml_lib_common PRIVATE ${REPO_ROOT}/winml)
target_include_directories(winml_lib_common PRIVATE ${GSL_INCLUDE_DIR})
target_precompiled_header(winml_lib_common lib/Common/inc/pch.h)
# Properties
set_target_properties(winml_lib_common
PROPERTIES
FOLDER
${target_folder})
if (onnxruntime_USE_DML)
target_add_dml(winml_lib_common)
endif()
###########################
# Add winml_dll
###########################
set_source_files_properties(
${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated/module.g.excl.cpp
PROPERTIES
GENERATED
TRUE)
# Add library
onnxruntime_add_shared_library(winml_dll
${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated/module.g.excl.cpp
${winml_dll_dir}/winml.def
${winml_dll_dir}/winml.rc
${winml_dll_dir}/pch.h
${winml_dll_dir}/module.cpp
)
# Compiler options
target_compile_features(winml_dll PRIVATE cxx_std_17)
target_compile_options(winml_dll PRIVATE /GR- /await /bigobj /wd4238)
# Compiler definitions
target_compile_definitions(winml_dll PRIVATE WINML_ROOT_NS=${winml_root_ns})
target_compile_definitions(winml_dll PRIVATE ONNX_NAMESPACE=onnx)
target_compile_definitions(winml_dll PRIVATE ONNX_ML)
target_compile_definitions(winml_dll PRIVATE LOTUS_LOG_THRESHOLD=2)
target_compile_definitions(winml_dll PRIVATE LOTUS_ENABLE_STDERR_LOGGING)
target_compile_definitions(winml_dll PRIVATE PLATFORM_WINDOWS)
target_compile_definitions(winml_dll PRIVATE VER_MAJOR=${VERSION_MAJOR_PART})
target_compile_definitions(winml_dll PRIVATE VER_MINOR=${VERSION_MINOR_PART})
target_compile_definitions(winml_dll PRIVATE VER_BUILD=${VERSION_BUILD_PART})
target_compile_definitions(winml_dll PRIVATE VER_PRIVATE=${VERSION_PRIVATE_PART})
target_compile_definitions(winml_dll PRIVATE VER_STRING=\"${VERSION_STRING}\")
target_compile_definitions(winml_dll PRIVATE BINARY_NAME=\"${BINARY_NAME}\")
if (onnxruntime_WINML_NAMESPACE_OVERRIDE STREQUAL "Windows")
target_compile_definitions(winml_dll PRIVATE "BUILD_INBOX=1")
endif()
# Specify the usage of a precompiled header
target_precompiled_header(winml_dll dll/pch.h)
# Includes
target_include_directories(winml_dll PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
target_include_directories(winml_dll PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_dll PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api_experimental/comp_generated) # windows machine learning generated component headers
target_include_directories(winml_dll PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
target_include_directories(winml_dll PRIVATE ${winml_dll_dir})
target_include_directories(winml_dll PRIVATE ${winml_lib_api_dir})
target_include_directories(winml_dll PRIVATE ${winml_lib_api_dir}/impl)
if (NOT winml_is_inbox)
target_include_directories(winml_dll PRIVATE ${winml_lib_api_experimental_dir})
endif()
target_include_directories(winml_dll PRIVATE ${winml_lib_api_ort_dir}/inc)
target_include_directories(winml_dll PRIVATE ${winml_adapter_dir})
target_include_directories(winml_dll PRIVATE ${winml_lib_api_image_dir}/inc)
target_include_directories(winml_dll PRIVATE ${winml_lib_telemetry_dir}/inc)
target_include_directories(winml_dll PRIVATE ${winml_lib_common_dir}/inc)
target_include_directories(winml_dll PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(winml_dll PRIVATE ${ONNXRUNTIME_INCLUDE_DIR})
target_include_directories(winml_dll PRIVATE ${ONNXRUNTIME_INCLUDE_DIR}/core/graph)
target_include_directories(winml_dll PRIVATE ${ONNXRUNTIME_ROOT})
target_include_directories(winml_dll PRIVATE ${ONNXRUNTIME_ROOT}/core/graph)
target_include_directories(winml_dll PRIVATE ${eigen_INCLUDE_DIRS})
target_include_directories(winml_dll PRIVATE ${REPO_ROOT}/winml)
target_link_libraries(winml_dll PRIVATE onnx onnx_proto ${PROTOBUF_LIB} flatbuffers safeint_interface Boost::mp11 ${GSL_TARGET})
target_link_libraries(winml_dll PRIVATE debug Dbghelp)
# Properties
set_target_properties(winml_dll
PROPERTIES
OUTPUT_NAME ${output_name})
set(os_component_link_flags_list ${os_component_link_flags})
separate_arguments(os_component_link_flags_list)
target_link_options(winml_dll PRIVATE /DEF:${WINML_DIR}/winml.def ${os_component_link_flags_list})
target_delayload(winml_dll api-ms-win-core-libraryloader-l1-2-1.dll api-ms-win-core-threadpool-legacy-l1-1-0.dll api-ms-win-core-processtopology-obsolete-l1-1-0.dll api-ms-win-core-kernel32-legacy-l1-1-0.dll d3d12.dll d3d11.dll dxgi.dll directml.dll)
if (EXISTS ${dxcore_header})
target_delayload(winml_dll ext-ms-win-dxcore-l1-*.dll)
endif()
set_target_properties(winml_dll
PROPERTIES
FOLDER
${target_folder})
# Add deps
add_dependencies(winml_dll winml_sdk_cppwinrt)
add_dependencies(winml_dll winml_api_native)
add_dependencies(winml_dll winml_api_native_internal)
# Link libraries
target_link_libraries(winml_dll PRIVATE re2)
target_link_libraries(winml_dll PRIVATE WIL::WIL)
target_link_libraries(winml_dll PRIVATE winml_lib_api)
if (NOT winml_is_inbox)
target_link_libraries(winml_dll PRIVATE winml_lib_api_experimental)
endif()
target_link_libraries(winml_dll PRIVATE winml_lib_image)
target_link_libraries(winml_dll PRIVATE winml_lib_ort)
target_link_libraries(winml_dll PRIVATE winml_lib_telemetry)
target_link_libraries(winml_dll PRIVATE RuntimeObject.lib)
target_link_libraries(winml_dll PRIVATE windowsapp.lib)
# 1 of 3 projects that fail in link with 'failed to do memory mapped file I/O' (Only release)
# when using x86 hosted architecture. When using the LKG compiler this becomes a problem
# because it falls back to incorrectly using the public version of link.
# To avoid the scenario completely, this will tell cl/link to already start with x64 hosted,
# rather than waiting for it to fail and retry and resolve incorrectly.
if("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
set_target_properties(winml_dll PROPERTIES VS_GLOBAL_PreferredToolArchitecture "x64")
endif("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
option(onnxruntime_BUILD_WINML_TESTS "Build WinML tests" ON)
# This is needed to suppress warnings that complain that no imports are found for the delayloaded library cublas64*.lib
# When cuda is enabled in the pipeline, it sets CMAKE_SHARED_LINKER_FLAGS which affects all targets including winml_dll.
# However, there are no cuda imports in winml_dll, and the linker throws the 4199 warning.
# This is needed to allow winml_dll build with cuda enabled.
target_link_options(winml_dll PRIVATE /ignore:4199)
if (winml_is_inbox)
# Link *_x64/*_arm64 DLLs for the ARM64X forwarder
function(duplicate_shared_library target new_target)
get_target_property(sources ${target} SOURCES)
get_target_property(compile_definitions ${target} COMPILE_DEFINITIONS)
get_target_property(compile_options ${target} COMPILE_OPTIONS)
get_target_property(include_directories ${target} INCLUDE_DIRECTORIES)
get_target_property(link_libraries ${target} LINK_LIBRARIES)
get_target_property(link_options ${target} LINK_OPTIONS)
add_library(${new_target} SHARED ${sources})
add_dependencies(${target} ${new_target})
target_compile_definitions(${new_target} PRIVATE ${compile_definitions})
target_compile_options(${new_target} PRIVATE ${compile_options})
target_include_directories(${new_target} PRIVATE ${include_directories})
target_link_libraries(${new_target} PRIVATE ${link_libraries})
target_link_options(${new_target} PRIVATE ${link_options})
endfunction()
if (WAI_ARCH STREQUAL x64 OR WAI_ARCH STREQUAL arm64)
duplicate_shared_library(winml_dll Windows_AI_MachineLearning_${WAI_ARCH})
target_compile_features(Windows_AI_MachineLearning_${WAI_ARCH} PRIVATE cxx_std_17)
endif()
endif()
Reference in a new issue View git blame Copy permalink