mirror of
https://github.com/saymrwulf/onnxruntime.git
synced 2026-05-24 22:17:32 +00:00
09c9caab2d
* don't include dml stuff in cpu builds * tests that link the image lib also need the telemetry lib now
488 lines
23 KiB
CMake
488 lines
23 KiB
CMake
# Copyright (c) Microsoft Corporation. All rights reserved.
|
|
# Licensed under the MIT License.
|
|
|
|
include(precompiled_header.cmake)
|
|
include(winml_sdk_helpers.cmake)
|
|
include(winml_cppwinrt.cmake)
|
|
|
|
# get the current nuget sdk kit directory
|
|
get_sdk(sdk_folder sdk_version)
|
|
set(target_folder ONNXRuntime/winml)
|
|
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_adapter_dir ${REPO_ROOT}/winml/adapter)
|
|
set(winml_lib_api_image_dir ${REPO_ROOT}/winml/lib/api.image)
|
|
set(winml_lib_common_dir ${REPO_ROOT}/winml/lib/common)
|
|
set(winml_lib_telemetry_dir ${REPO_ROOT}/winml/lib/telemetry)
|
|
|
|
# Version parts for Windows.AI.MachineLearning.dll.
|
|
set(WINML_VERSION_MAJOR_PART 0 CACHE STRING "First part of numeric file/product version.")
|
|
set(WINML_VERSION_MINOR_PART 0 CACHE STRING "Second part of numeric file/product version.")
|
|
set(WINML_VERSION_BUILD_PART 0 CACHE STRING "Third part of numeric file/product version.")
|
|
set(WINML_VERSION_PRIVATE_PART 0 CACHE STRING "Fourth part of numeric file/product version.")
|
|
set(WINML_VERSION_STRING "Internal Build" CACHE STRING "String representation of file/product version.")
|
|
|
|
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(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)
|
|
|
|
# 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
|
|
)
|
|
|
|
# generate winml headers from idl
|
|
target_cppwinrt(winml_api
|
|
${winrt_idl} # winml winrt idl to compile
|
|
${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
|
|
)
|
|
|
|
target_midl(winml_api_native
|
|
${idl_native} # winml native idl to compile
|
|
${sdk_folder} # location of sdk folder
|
|
${sdk_version} # sdk version
|
|
${target_folder} # the folder this target will be placed under
|
|
)
|
|
|
|
target_midl(winml_api_native_internal
|
|
${idl_native_internal} # winml internal native idl to compile
|
|
${sdk_folder} # location of sdk folder
|
|
${sdk_version} # sdk version
|
|
${target_folder}) # the folder this target will be placed under
|
|
|
|
###########################
|
|
# Add winml_lib_telemetry
|
|
###########################
|
|
|
|
# Add static library that will be archived/linked for both static/dynamic library
|
|
add_library(winml_lib_telemetry STATIC
|
|
${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 PLATFORM_WINDOWS)
|
|
target_compile_definitions(winml_lib_telemetry PRIVATE _SCL_SECURE_NO_WARNINGS) # remove warnings about unchecked iterators
|
|
|
|
# Specify the usage of a precompiled header
|
|
target_precompiled_header(winml_lib_telemetry pch.h)
|
|
|
|
# Includes
|
|
target_include_directories(winml_lib_telemetry PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include)
|
|
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)
|
|
|
|
# Properties
|
|
set_target_properties(winml_lib_telemetry
|
|
PROPERTIES
|
|
FOLDER
|
|
${target_folder})
|
|
|
|
# Link libraries
|
|
target_link_libraries(winml_lib_telemetry PRIVATE wil)
|
|
|
|
###########################
|
|
# Add winml_adapter
|
|
###########################
|
|
|
|
list(APPEND winml_adapter_files
|
|
${winml_adapter_dir}/CpuOrtSessionBuilder.cpp
|
|
${winml_adapter_dir}/CpuOrtSessionBuilder.h
|
|
${winml_adapter_dir}/CustomRegistryHelper.h
|
|
${winml_adapter_dir}/FeatureDescriptorFactory.cpp
|
|
${winml_adapter_dir}/FeatureDescriptorFactory.h
|
|
${winml_adapter_dir}/LotusEnvironment.cpp
|
|
${winml_adapter_dir}/LotusEnvironment.h
|
|
${winml_adapter_dir}/pch.h
|
|
${winml_adapter_dir}/WinMLAdapter.cpp
|
|
${winml_adapter_dir}/WinMLAdapter.h
|
|
${winml_adapter_dir}/ZeroCopyInputStreamWrapper.cpp
|
|
${winml_adapter_dir}/ZeroCopyInputStreamWrapper.h
|
|
)
|
|
|
|
if (onnxruntime_USE_DML)
|
|
list(APPEND winml_adapter_files
|
|
${winml_adapter_dir}/AbiCustomRegistryImpl.cpp
|
|
${winml_adapter_dir}/AbiCustomRegistryImpl.h
|
|
${winml_adapter_dir}/DmlOrtSessionBuilder.cpp
|
|
${winml_adapter_dir}/DmlOrtSessionBuilder.h
|
|
)
|
|
endif(onnxruntime_USE_DML)
|
|
|
|
add_library(winml_adapter ${winml_adapter_files})
|
|
|
|
# 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::libprotobuf)
|
|
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 pch.h)
|
|
|
|
# Includes
|
|
target_include_directories(winml_adapter PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api) # windows machine learning generated component headers
|
|
target_include_directories(winml_adapter PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated) # windows machine learning generated component headers
|
|
target_include_directories(winml_adapter PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/winml/sdk/cppwinrt/include) # sdk cppwinrt headers
|
|
target_include_directories(winml_adapter PRIVATE ${winml_lib_api_dir}) # needed for generated headers
|
|
target_include_directories(winml_adapter PRIVATE ${winml_lib_dir})
|
|
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})
|
|
|
|
# Add deps
|
|
add_dependencies(winml_adapter winml_sdk_cppwinrt)
|
|
add_dependencies(winml_adapter winml_api)
|
|
add_dependencies(winml_adapter winml_api_native)
|
|
add_dependencies(winml_adapter winml_api_native_internal)
|
|
|
|
# Link libraries
|
|
target_link_libraries(winml_adapter PRIVATE wil)
|
|
if (onnxruntime_USE_DML)
|
|
target_link_libraries(winml_adapter PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/packages/DirectML.0.0.1/build/DirectML.targets)
|
|
endif(onnxruntime_USE_DML)
|
|
|
|
# add it to the onnxruntime shared library
|
|
set(onnxruntime_winml windowsapp.lib -WHOLEARCHIVE:$<TARGET_FILE: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
|
|
add_library(winml_lib_image STATIC
|
|
${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/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}/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}/ImageConversionHelpers.cpp
|
|
${winml_lib_api_image_dir}/ImageConverter.cpp
|
|
${winml_lib_api_image_dir}/TensorToVideoFrameConverter.cpp
|
|
${winml_lib_api_image_dir}/VideoFrameToTensorConverter.cpp
|
|
)
|
|
|
|
# Compiler options
|
|
target_compile_features(winml_lib_image PRIVATE cxx_std_17)
|
|
target_compile_options(winml_lib_image PRIVATE /GR- /await /wd4238)
|
|
|
|
# Compiler flags
|
|
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 pch.h)
|
|
|
|
# Includes
|
|
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
|
|
target_include_directories(winml_lib_image PRIVATE ${REPO_ROOT}/cmake/external/gsl/include)
|
|
target_include_directories(winml_lib_image PRIVATE ${REPO_ROOT}/cmake/external/onnx)
|
|
target_include_directories(winml_lib_image PRIVATE ${REPO_ROOT}/cmake/external/protobuf/src)
|
|
|
|
# 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 wil)
|
|
if (onnxruntime_USE_DML)
|
|
target_link_libraries(winml_lib_image PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/packages/DirectML.0.0.1/build/DirectML.targets)
|
|
endif(onnxruntime_USE_DML)
|
|
|
|
|
|
###########################
|
|
# Add winml_lib_api
|
|
###########################
|
|
|
|
# Add static library that will be archived/linked for both static/dynamic library
|
|
add_library(winml_lib_api STATIC
|
|
${winml_lib_api_dir}/impl/FeatureCompatibility.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/SequenceBase.h
|
|
${winml_lib_api_dir}/impl/Tensor.h
|
|
${winml_lib_api_dir}/impl/TensorBase.h
|
|
${winml_lib_api_dir}/impl/TensorBuffer.h
|
|
${winml_lib_api_dir}/impl/TensorKindFrom.h
|
|
${winml_lib_api_dir}/impl/TensorMemoryBufferReference.h
|
|
${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}/TensorFeatureDescriptor.cpp
|
|
${winml_lib_api_dir}/TensorFeatureDescriptor.h
|
|
${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)
|
|
|
|
# Compiler flags
|
|
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 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_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 ${CMAKE_CURRENT_BINARY_DIR}/external/date/include)
|
|
target_include_directories(winml_lib_api PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/external/gsl/include)
|
|
target_include_directories(winml_lib_api PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/external/onnx)
|
|
|
|
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}/cmake/external/eigen)
|
|
target_include_directories(winml_lib_api PRIVATE ${REPO_ROOT}/cmake/external/onnx)
|
|
target_include_directories(winml_lib_api PRIVATE ${REPO_ROOT}/cmake/external/protobuf/src)
|
|
target_include_directories(winml_lib_api PRIVATE ${REPO_ROOT}/cmake/external/gsl/include)
|
|
|
|
# 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)
|
|
if (onnxruntime_USE_DML)
|
|
target_link_libraries(winml_lib_api PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/packages/DirectML.0.0.1/build/DirectML.targets)
|
|
endif(onnxruntime_USE_DML)
|
|
|
|
|
|
###########################
|
|
# Add winml_dll
|
|
###########################
|
|
|
|
set_source_files_properties(
|
|
${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated/module.g.excl.cpp
|
|
PROPERTIES
|
|
GENERATED
|
|
TRUE)
|
|
|
|
# Add library
|
|
add_library(winml_dll SHARED
|
|
${CMAKE_CURRENT_BINARY_DIR}/winml_api/comp_generated/module.g.excl.cpp
|
|
${winml_dll_dir}/windows.ai.machinelearning.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 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=${WINML_VERSION_MAJOR_PART})
|
|
target_compile_definitions(winml_dll PRIVATE VER_MINOR=${WINML_VERSION_MINOR_PART})
|
|
target_compile_definitions(winml_dll PRIVATE VER_BUILD=${WINML_VERSION_BUILD_PART})
|
|
target_compile_definitions(winml_dll PRIVATE VER_PRIVATE=${WINML_VERSION_PRIVATE_PART})
|
|
target_compile_definitions(winml_dll PRIVATE VER_STRING=\"${WINML_VERSION_STRING}\")
|
|
|
|
# Specify the usage of a precompiled header
|
|
target_precompiled_header(winml_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/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)
|
|
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 ${CMAKE_CURRENT_BINARY_DIR}/external/date/include)
|
|
target_include_directories(winml_dll PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/external/gsl/include)
|
|
target_include_directories(winml_dll PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/external/onnx)
|
|
|
|
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 ${REPO_ROOT}/cmake/external/onnx)
|
|
target_include_directories(winml_dll PRIVATE ${REPO_ROOT}/cmake/external/protobuf/src)
|
|
target_include_directories(winml_dll PRIVATE ${REPO_ROOT}/cmake/external/gsl/include)
|
|
target_include_directories(winml_dll PRIVATE ${REPO_ROOT}/cmake/external/eigen)
|
|
|
|
# Properties
|
|
set_target_properties(winml_dll
|
|
PROPERTIES
|
|
OUTPUT_NAME windows.ai.machinelearning)
|
|
|
|
if (onnxruntime_USE_DML)
|
|
set(delayload_dml "/DELAYLOAD:directml.dll")
|
|
endif(onnxruntime_USE_DML)
|
|
|
|
set_target_properties(winml_dll
|
|
PROPERTIES
|
|
LINK_FLAGS
|
|
"/DEF:${WINML_DIR}/windows.ai.machinelearning.def ${os_component_link_flags} /DELAYLOAD:d3d12.dll /DELAYLOAD:d3d11.dll /DELAYLOAD:dxgi.dll ${delayload_dml}")
|
|
|
|
|
|
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)
|
|
|
|
# Any project that links in debug_alloc.obj needs this lib.
|
|
# unresolved external symbol __imp_SymSetOptions
|
|
# ... __imp_SymGetLineFromAddr64
|
|
# ... __imp_SymInitialize
|
|
# ... __imp_SymFromAddr
|
|
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
|
|
set(DBGHELP dbghelp.lib)
|
|
endif("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
|
|
|
|
# Link libraries
|
|
target_link_libraries(winml_dll PRIVATE onnxruntime)
|
|
target_link_libraries(winml_dll PRIVATE re2)
|
|
target_link_libraries(winml_dll PRIVATE wil)
|
|
#target_link_libraries(winml_dll PRIVATE windowsapp.lib)
|
|
target_link_libraries(winml_dll PRIVATE winml_lib_api)
|
|
target_link_libraries(winml_dll PRIVATE winml_lib_image)
|
|
target_link_libraries(winml_dll PRIVATE winml_lib_telemetry)
|
|
target_link_libraries(winml_dll PRIVATE onecoreuap_apiset.lib)
|
|
target_link_libraries(winml_dll PRIVATE ${DBGHELP})
|
|
|
|
# 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")
|
|
|
|
if (onnxruntime_BUILD_WINML_TESTS)
|
|
include(winml_unittests.cmake)
|
|
endif()
|