add config module

cmake/MMDeploy.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+
+function (mmdeploy_export_impl NAME)
+    set(_LIB_DIR lib)
+    if (MSVC)
+        set(_LIB_DIR bin)
+    endif ()
+    install(TARGETS ${NAME}
+            EXPORT MMDeployTargets
+            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION ${_LIB_DIR}
+            RUNTIME DESTINATION bin)
+endfunction ()
+
+function (mmdeploy_add_rpath NAME)
+    if (MSVC)
+        return()
+    elseif(APPLE)
+        set_target_properties(${NAME} PROPERTIES
+                INSTALL_RPATH "@loader_path"
+                BUILD_RPATH "@loader_path")
+    else ()
+        set_target_properties(${NAME} PROPERTIES
+                INSTALL_RPATH "\$ORIGIN"
+                BUILD_RPATH "\$ORIGIN")
+        target_link_libraries(${NAME} PRIVATE -Wl,--disable-new-dtags)
+    endif ()
+endfunction ()
+
+macro(mmdeploy_add_net NAME)
+    if (MMDEPLOY_DYNAMIC_BACKEND)
+        mmdeploy_add_library(${NAME} SHARED ${ARGN})
+        mmdeploy_add_rpath(${NAME})
+        # DYNAMIC_BACKEND implies BUILD_SDK_MONOLITHIC
+        mmdeploy_export_impl(${NAME})
+        target_link_libraries(${PROJECT_NAME} PRIVATE mmdeploy)
+        set(BACKEND_LIB_NAMES ${BACKEND_LIB_NAMES} ${PROJECT_NAME} PARENT_SCOPE)
+    else ()
+        mmdeploy_add_module(${NAME} ${ARGN})
+    endif ()
+endmacro()
+
+function (mmdeploy_export NAME)
+    if (NOT MMDEPLOY_BUILD_SDK_MONOLITHIC)
+        mmdeploy_export_impl(${NAME})
+    endif ()
+endfunction ()
+
+
+function (mmdeploy_add_library NAME)
+    # EXCLUDE: exclude from registering & exporting
+    cmake_parse_arguments(_MMDEPLOY "EXCLUDE" "" "" ${ARGN})
+    # search for add_library keywords
+    cmake_parse_arguments(_TYPE "STATIC;SHARED;MODULE" "" "" ${_MMDEPLOY_UNPARSED_ARGUMENTS})
+    set(_MAYBE_TYPE)
+    if (NOT (_TYPE_STATIC OR _TYPE_SHARED OR _TYPE_MODULE))
+        set(_MAYBE_TYPE ${MMDEPLOY_LIB_TYPE})
+    endif ()
+    add_library(${NAME} ${_MAYBE_TYPE} ${_MMDEPLOY_UNPARSED_ARGUMENTS})
+    if (NOT MSVC)
+        target_compile_options(${NAME} PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fvisibility=hidden>)
+    endif ()
+    target_compile_definitions(${NAME} PRIVATE -DMMDEPLOY_API_EXPORTS=1)
+    get_target_property(_TYPE ${NAME} TYPE)
+    if (_TYPE STREQUAL STATIC_LIBRARY)
+        set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE 1)
+    elseif (_TYPE STREQUAL SHARED_LIBRARY)
+    else ()
+        message(FATAL_ERROR "unsupported type: ${_TYPE}")
+    endif ()
+    if (NOT _MMDEPLOY_EXCLUDE)
+        target_link_libraries(MMDeployLibs INTERFACE ${NAME})
+        mmdeploy_export(${NAME})
+    endif ()
+endfunction ()
+
+
+function (mmdeploy_add_module NAME)
+    # EXCLUDE: exclude from registering & exporting as SDK module
+    # LIBRARY: the module is also a library (add_libray with SHARED instead of MODULE)
+    cmake_parse_arguments(_MMDEPLOY "EXCLUDE;LIBRARY" "" "" ${ARGN})
+    # search for add_library keywords
+    cmake_parse_arguments(_TYPE "STATIC;SHARED;MODULE" "" "" ${_MMDEPLOY_UNPARSED_ARGUMENTS})
+
+    set(_MAYBE_TYPE)
+    # no library type specified
+    if (NOT (_TYPE_STATIC OR _TYPE_SHARED OR _TYPE_MODULE))
+        # shared but not marked as a library, build module library so that no .lib dependency
+        # will be generated for MSVC
+        if (MSVC AND MMDEPLOY_SHARED_LIBS AND NOT _MMDEPLOY_LIBRARY)
+            set(_MAYBE_TYPE MODULE)
+        else ()
+            set(_MAYBE_TYPE ${MMDEPLOY_LIB_TYPE})
+        endif ()
+    endif ()
+
+    add_library(${NAME} ${_MAYBE_TYPE} ${_MMDEPLOY_UNPARSED_ARGUMENTS})
+
+    if (NOT MSVC)
+        target_compile_options(${NAME} PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fvisibility=hidden>)
+    endif ()
+
+    # automatically link mmdeploy::core if exists
+    if (TARGET mmdeploy::core)
+        target_link_libraries(${NAME} PRIVATE mmdeploy::core)
+    endif ()
+
+    # export public symbols when marked as a library
+    if (_MMDEPLOY_LIBRARY)
+        target_compile_definitions(${NAME} PRIVATE -DMMDEPLOY_API_EXPORTS=1)
+    endif ()
+
+    get_target_property(_TYPE ${NAME} TYPE)
+    if (_TYPE STREQUAL STATIC_LIBRARY)
+        set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE 1)
+        if (MSVC)
+            target_link_options(${NAME} INTERFACE "/WHOLEARCHIVE:${NAME}")
+        endif ()
+        # register static modules
+        if (NOT _MMDEPLOY_EXCLUDE)
+            target_link_libraries(MMDeployStaticModules INTERFACE ${NAME})
+        endif ()
+    elseif (_TYPE STREQUAL SHARED_LIBRARY OR _TYPE STREQUAL MODULE_LIBRARY)
+        # register dynamic modules
+        if (NOT _MMDEPLOY_EXCLUDE)
+            target_link_libraries(MMDeployDynamicModules INTERFACE ${NAME})
+        endif ()
+    else ()
+        message(FATAL_ERROR "unsupported type: ${_TYPE}")
+    endif ()
+    if (NOT _MMDEPLOY_EXCLUDE)
+        mmdeploy_export(${NAME})
+    endif ()
+endfunction ()
+
+
+function (_mmdeploy_flatten_modules RETVAL)
+    set(_RETVAL)
+    foreach (ARG IN LISTS ARGN)
+        get_target_property(TYPE ${ARG} TYPE)
+        if (TYPE STREQUAL "INTERFACE_LIBRARY")
+            get_target_property(LIBS ${ARG} INTERFACE_LINK_LIBRARIES)
+            if (LIBS)
+                # pattern for 3.17+
+                list(FILTER LIBS EXCLUDE REGEX "^::@")
+                # pattern for 3.13-3.16
+                list(TRANSFORM LIBS REPLACE "(.+)::@.*" "\\1")
+                list(APPEND _RETVAL ${LIBS})
+            endif ()
+        else ()
+            list(APPEND _RETVAL ${ARG})
+        endif ()
+    endforeach ()
+    set(${RETVAL} ${_RETVAL} PARENT_SCOPE)
+endfunction ()
+
+
+function (mmdeploy_load_static NAME)
+    if (MSVC)
+        target_link_libraries(${NAME} PRIVATE ${ARGN})
+    else ()
+        _mmdeploy_flatten_modules(_MODULE_LIST ${ARGN})
+        if (APPLE)
+            foreach (module IN LISTS _MODULE_LIST)
+                target_link_libraries(${NAME} PRIVATE -force_load ${module})
+            endforeach ()
+        else ()
+            target_link_libraries(${NAME} PRIVATE
+                    -Wl,--whole-archive
+                    ${_MODULE_LIST}
+                    -Wl,--no-whole-archive)
+        endif ()
+    endif ()
+endfunction ()
+
+function (mmdeploy_load_dynamic NAME)
+    _mmdeploy_flatten_modules(_MODULE_LIST ${ARGN})
+    if (MSVC)
+        if (NOT _MODULE_LIST)
+            return ()
+        endif ()
+        # MSVC has nothing like "-Wl,--no-as-needed ... -Wl,--as-needed", as a
+        # workaround we build a static module which loads the dynamic modules
+        set(_MODULE_STR ${_MODULE_LIST})
+        list(TRANSFORM _MODULE_STR REPLACE "(.+)" "\"\\1\"")
+        string(JOIN ",\n        " _MODULE_STR ${_MODULE_STR})
+        set(_MMDEPLOY_DYNAMIC_MODULES ${_MODULE_STR})
+
+        set(_LOADER_NAME ${NAME}_loader)
+
+        add_dependencies(${NAME} ${_MODULE_LIST})
+
+        set(_LOADER_PATH ${CMAKE_BINARY_DIR}/${_LOADER_NAME}.cpp)
+        # ! CMAKE_CURRENT_FUNCTION_LIST_DIR requires cmake 3.17+
+        configure_file(
+                ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/loader.cpp.in
+                ${_LOADER_PATH})
+
+        mmdeploy_add_module(${_LOADER_NAME} STATIC EXCLUDE ${_LOADER_PATH})
+        mmdeploy_load_static(${NAME} ${_LOADER_NAME})
+    elseif (APPLE)
+        target_link_libraries(${NAME} PRIVATE ${_MODULE_LIST})
+    else ()
+        target_link_libraries(${NAME} PRIVATE
+                -Wl,--no-as-needed
+                ${_MODULE_LIST}
+                -Wl,--as-needed)
+    endif ()
+endfunction ()
+
+macro(mmdeploy_add_deps backend)
+    set(multiValueArgs BACKENDS DEPS)
+    cmake_parse_arguments(INFO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    set(has_backend OFF)
+    if (${backend} IN_LIST INFO_BACKENDS)
+        foreach(pkg IN LISTS INFO_DEPS)
+            set(${pkg}_DEPENDENCY "find_package(${pkg} REQUIRED)")
+        endforeach()
+    endif()
+endmacro()

cmake/MMDeployConfig.cmake.in

+@PACKAGE_INIT@
+
+cmake_minimum_required(VERSION 3.14)
+
+include("${CMAKE_CURRENT_LIST_DIR}/MMDeployTargets.cmake")
+
+set(MMDEPLOY_CODEBASES @MMDEPLOY_CODEBASES@)
+set(MMDEPLOY_TASKS @MMDEPLOY_TASKS@)
+set(MMDEPLOY_TARGET_DEVICES @MMDEPLOY_TARGET_DEVICES@)
+set(MMDEPLOY_TARGET_BACKENDS @MMDEPLOY_TARGET_BACKENDS@)
+set(MMDEPLOY_BUILD_TYPE @CMAKE_BUILD_TYPE@)
+set(MMDEPLOY_BUILD_SHARED @MMDEPLOY_SHARED_LIBS@)
+set(MMDEPLOY_BUILD_SDK_MONOLITHIC @MMDEPLOY_BUILD_SDK_MONOLITHIC@)
+set(MMDEPLOY_VERSION_MAJOR @MMDEPLOY_VERSION_MAJOR@)
+set(MMDEPLOY_VERSION_MINOR @MMDEPLOY_VERSION_MINOR@)
+set(MMDEPLOY_VERSION_PATCH @MMDEPLOY_VERSION_PATCH@)
+
+if (NOT MMDEPLOY_BUILD_SHARED AND NOT MMDEPLOY_BUILD_SDK_MONOLITHIC)
+    if ("cuda" IN_LIST MMDEPLOY_TARGET_DEVICES)
+        find_package(CUDA REQUIRED)
+        if(MSVC)
+            set(CMAKE_CUDA_COMPILER ${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc.exe)
+        else()
+            set(CMAKE_CUDA_COMPILER ${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc)
+        endif()
+        set(CMAKE_CUDA_RUNTIME_LIBRARY Shared)
+        enable_language(CUDA)
+        find_package(pplcv REQUIRED)
+    endif ()
+endif ()
+
+set(MMDEPLOY_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/modules")
+list(APPEND CMAKE_MODULE_PATH ${MMDEPLOY_MODULE_PATH})
+@SPDLOG_DEPENDENCY@
+@TENSORRT_DEPENDENCY@
+@CUDNN_DEPENDENCY@
+@ONNXRUNTIME_DEPENDENCY@
+@ncnn_DEPENDENCY@
+@InferenceEngine_DEPENDENCY@
+@pplnn_DEPENDENCY@
+list(REMOVE_ITEM CMAKE_MODULE_PATH ${MMDEPLOY_MODULE_PATH})
+
+find_package(OpenCV REQUIRED)
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+include("${CMAKE_CURRENT_LIST_DIR}/MMDeploy.cmake")

cmake/cuda.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+
+if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.18.0")
+    # suppress 'CMAKE_CUDA_ARCHITECTURES' warning
+    cmake_policy(SET CMP0104 OLD)
+endif ()
+
+if (MSVC OR (NOT DEFINED CMAKE_CUDA_RUNTIME_LIBRARY))
+    # use shared, on windows, python api can't build with static lib.
+    set(CMAKE_CUDA_RUNTIME_LIBRARY Shared)
+    set(CUDA_USE_STATIC_CUDA_RUNTIME OFF)
+endif ()
+
+if (MSVC)
+    # no plugin in BuildCustomizations and no specify cuda toolset
+    if (NOT CMAKE_VS_PLATFORM_TOOLSET_CUDA)
+        message(FATAL_ERROR "Please install CUDA MSBuildExtensions")
+    endif ()
+
+    if (CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR)
+        # find_package(CUDA) required ENV{CUDA_PATH}
+        set(ENV{CUDA_PATH} ${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR})
+    else ()
+        # we use CUDA_PATH and ignore nvcc.exe
+        # cmake will import highest cuda props version, which may not equal to CUDA_PATH
+        if (NOT (DEFINED ENV{CUDA_PATH}))
+            message(FATAL_ERROR "Please set CUDA_PATH environment variable")
+        endif ()
+
+        string(REGEX REPLACE ".*v([0-9]+)\\..*" "\\1" _MAJOR $ENV{CUDA_PATH})
+        string(REGEX REPLACE ".*v[0-9]+\\.([0-9]+).*" "\\1" _MINOR $ENV{CUDA_PATH})
+        if (NOT (${CMAKE_VS_PLATFORM_TOOLSET_CUDA} STREQUAL "${_MAJOR}.${_MINOR}"))
+            message(FATAL_ERROR "Auto detected cuda version ${CMAKE_VS_PLATFORM_TOOLSET_CUDA}"
+                " is mismatch with ENV{CUDA_PATH} $ENV{CUDA_PATH}. Please modify CUDA_PATH"
+                " to match ${CMAKE_VS_PLATFORM_TOOLSET_CUDA} or specify cuda toolset by"
+                " cmake -T cuda=/path/to/cuda ..")
+        endif ()
+
+        if (NOT (DEFINED ENV{CUDA_PATH_V${_MAJOR}_${_MINOR}}))
+            message(FATAL_ERROR "Please set CUDA_PATH_V${_MAJOR}_${_MINOR} environment variable")
+        endif ()
+    endif ()
+endif ()
+
+# nvcc compiler settings
+find_package(CUDA REQUIRED)
+
+if (MSVC)
+    set(CMAKE_CUDA_COMPILER ${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc.exe)
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=/wd4819,/wd4828")
+    if (HAVE_CXX_FLAG_UTF_8)
+        set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=/utf-8")
+    endif ()
+else ()
+    set(CMAKE_CUDA_COMPILER ${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc)
+    # Explicitly set the cuda host compiler. Because the default host compiler #
+    # selected by cmake maybe wrong.
+    set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+    set(CMAKE_CUDA_FLAGS
+            "${CMAKE_CUDA_FLAGS} -Xcompiler=-fPIC,-Wall,-fvisibility=hidden")
+    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+        set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=-fno-gnu-unique")
+    endif ()
+endif ()
+
+enable_language(CUDA)
+
+# set virtual compute architecture and real ones
+set(_NVCC_FLAGS)
+if (NOT CMAKE_CUDA_ARCHITECTURES)
+    set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_52,code=sm_52")
+    set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_53,code=sm_53")
+    if (CUDA_VERSION_MAJOR VERSION_GREATER_EQUAL "8")
+        set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_60,code=sm_60")
+        set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_61,code=sm_61")
+        set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_62,code=sm_62")
+    endif ()
+    if (CUDA_VERSION_MAJOR VERSION_GREATER_EQUAL "9")
+        set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_70,code=sm_70")
+    endif ()
+    if (CUDA_VERSION_MAJOR VERSION_GREATER_EQUAL "10")
+        set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_72,code=sm_72")
+        set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_75,code=sm_75")
+    endif ()
+    if (CUDA_VERSION_MAJOR VERSION_GREATER_EQUAL "11")
+        set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_80,code=sm_80")
+        if (CUDA_VERSION_MINOR VERSION_GREATER_EQUAL "1")
+            # cuda doesn't support `sm_86` until version 11.1
+            set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_86,code=sm_86")
+        endif ()
+        if (CUDA_VERSION_MINOR VERSION_GREATER_EQUAL "4")
+            set(_NVCC_FLAGS "${_NVCC_FLAGS} -gencode arch=compute_87,code=sm_87")
+        endif ()
+    endif ()
+endif ()
+
+set(CMAKE_CUDA_FLAGS_DEBUG "-g -O0")
+set(CMAKE_CUDA_FLAGS_RELEASE "-O3")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMMDEPLOY_USE_CUDA=1")
+
+if (NOT MSVC)
+    set(CMAKE_CUDA_STANDARD 14)
+endif ()
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${_NVCC_FLAGS}")
+
+if (MSVC AND MMDEPLOY_USE_MSCV_STATIC)
+    string(REPLACE -MD -MT CMAKE_CUDA_FLAGS_DEBUG "${CMAKE_CUDA_FLAGS_DEBUG}")
+    string(REPLACE -MD -MT CMAKE_CUDA_FLAGS_RELEASE "${CMAKE_CUDA_FLAGS_RELEASE}")
+endif ()

cmake/filesystem.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/pybind/pybind11/blob/master/tests/CMakeLists.txt
+
+if (MSVC)
+    set(STD_FS_NO_LIB_NEEDED TRUE)
+else ()
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+            "#include <filesystem>\nint main(int,char**argv){return std::filesystem::path(argv[0]).string().length();}")
+    try_compile(HAS_INC_FS ${CMAKE_CURRENT_BINARY_DIR}
+            SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+            COMPILE_DEFINITIONS -std=c++17 -c)
+
+    if (NOT HAS_INC_FS)
+        file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+                "#include <experimental/filesystem>\nint main(int,char**argv){return std::experimental::filesystem::path(argv[0]).string().length();}")
+    endif ()
+
+    try_compile(
+            STD_FS_NO_LIB_NEEDED ${CMAKE_CURRENT_BINARY_DIR}
+            SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+            COMPILE_DEFINITIONS -std=c++17)
+    try_compile(
+            STD_FS_NEEDS_STDCXXFS ${CMAKE_CURRENT_BINARY_DIR}
+            SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+            COMPILE_DEFINITIONS -std=c++17
+            LINK_LIBRARIES stdc++fs)
+    try_compile(
+            STD_FS_NEEDS_CXXFS ${CMAKE_CURRENT_BINARY_DIR}
+            SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+            COMPILE_DEFINITIONS -std=c++17
+            LINK_LIBRARIES c++fs)
+endif ()
+
+if (${STD_FS_NO_LIB_NEEDED})
+    set(STD_FS_LIB "")
+elseif (${STD_FS_NEEDS_STDCXXFS})
+    set(STD_FS_LIB stdc++fs)
+elseif (${STD_FS_NEEDS_CXXFS})
+    set(STD_FS_LIB c++fs)
+else ()
+    message(WARNING "Unknown C++17 compiler - not passing -lstdc++fs")
+    set(STD_FS_LIB "")
+endif ()

cmake/loader.cpp.in

+// Copyright (c) OpenMMLab. All rights reserved.
+
+#include <string>
+#include <cstdio>
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+#ifdef _WIN32
+#define LIBPREFIX ""
+#define LIBSUFFIX ".dll"
+#elif defined(__APPLE__)
+#define LIBPREFIX "lib"
+#define LIBSUFFIX ".dylib"
+#else
+#define LIBPREFIX "lib"
+#define LIBSUFFIX ".so"
+#endif
+
+namespace mmdeploy {
+namespace {
+
+#ifdef _WIN32
+inline static const std::wstring GetDllPath() {
+    HMODULE hm = NULL;
+    GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+      (LPWSTR)&GetDllPath, &hm);
+    std::wstring ret;
+    ret.resize(MAX_PATH);
+    GetModuleFileNameW(hm, &ret[0], ret.size());
+    ret = ret.substr(0, ret.find_last_of(L"/\\"));
+    return ret;
+}
+#endif
+
+void* mmdeploy_load_library(const char* name) {
+  fprintf(stderr, "loading %s ...\n", name);
+
+#ifdef _WIN32
+  auto handle = LoadLibraryExA(name, NULL, LOAD_LIBRARY_SEARCH_USER_DIRS);
+  if (handle == NULL) {
+    handle = LoadLibraryExA(name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+  }
+#else
+  auto handle = dlopen(name, RTLD_NOW | RTLD_GLOBAL);
+#endif
+
+  if (!handle) {
+    fprintf(stderr, "failed to load library %s\n", name);
+    return nullptr;
+  }
+  return handle;
+}
+
+// clang-format off
+
+class Loader {
+ public:
+  Loader() {
+#ifdef _WIN32
+    AddDllDirectory(GetDllPath().c_str());
+#endif
+    const char* modules[] = {
+        @_MMDEPLOY_DYNAMIC_MODULES@
+    };
+    for (const auto name : modules) {
+      std::string libname = std::string{} + LIBPREFIX + name + LIBSUFFIX;
+      mmdeploy_load_library(libname.c_str());
+    }
+  }
+};
+
+// clang-format on
+
+static Loader loader;
+
+}  // namespace
+}  // namespace mmdeploy

cmake/modules/FindCUDNN.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+
+if (NOT DEFINED CUDNN_DIR)
+    set(CUDNN_DIR $ENV{CUDNN_DIR})
+endif ()
+
+find_path(
+    CUDNN_INCLUDE_DIR cudnn.h
+    HINTS ${CUDNN_DIR} ${CUDA_TOOLKIT_ROOT_DIR}
+    PATH_SUFFIXES include)
+
+find_library(
+    CUDNN_LIBRARY_CUDNN_PATH cudnn
+    HINTS ${CUDNN_DIR} ${CUDA_TOOLKIT_ROOT_DIR}
+    PATH_SUFFIXES lib lib64 lib/x64)
+
+if (NOT (CUDNN_INCLUDE_DIR AND CUDNN_LIBRARY_CUDNN_PATH))
+    message(FATAL_ERROR "Couldn't find cuDNN in CUDNN_DIR: ${CUDNN_DIR}, "
+        "or in CUDA_TOOLKIT_ROOT_DIR: ${CUDA_TOOLKIT_ROOT_DIR}, "
+        "please check if the path is correct.")
+endif()
+
+add_library(cudnn SHARED IMPORTED)
+set_property(TARGET cudnn APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+if (MSVC)
+    set_target_properties(cudnn PROPERTIES
+        IMPORTED_IMPLIB_RELEASE ${CUDNN_LIBRARY_CUDNN_PATH}
+        INTERFACE_INCLUDE_DIRECTORIES ${CUDNN_INCLUDE_DIR}
+    )
+
+else()
+    set_target_properties(cudnn PROPERTIES
+        IMPORTED_LOCATION_RELEASE ${CUDNN_LIBRARY_CUDNN_PATH}
+        INTERFACE_INCLUDE_DIRECTORIES ${CUDNN_INCLUDE_DIR}
+    )
+endif()

cmake/modules/FindONNXRUNTIME.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+
+if (NOT DEFINED ONNXRUNTIME_DIR)
+    set(ONNXRUNTIME_DIR $ENV{ONNXRUNTIME_DIR})
+endif ()
+if (NOT ONNXRUNTIME_DIR)
+    message(FATAL_ERROR "Please set ONNXRUNTIME_DIR with cmake -D option.")
+endif()
+
+find_path(
+    ONNXRUNTIME_INCLUDE_DIR onnxruntime_cxx_api.h
+    HINTS ${ONNXRUNTIME_DIR}
+    PATH_SUFFIXES include)
+find_library(
+    ONNXRUNTIME_LIBRARY_ONNXRUNTIME_PATH onnxruntime
+    HINTS ${ONNXRUNTIME_DIR}
+    PATH_SUFFIXES lib lib64 lib/x64)
+if (NOT (ONNXRUNTIME_INCLUDE_DIR AND ONNXRUNTIME_LIBRARY_ONNXRUNTIME_PATH))
+    message(FATAL_ERROR "Couldn't find onnxruntime in ONNXRUNTIME_DIR: "
+        "${ONNXRUNTIME_DIR}, please check if the path is correct.")
+endif()
+
+add_library(onnxruntime SHARED IMPORTED)
+set_property(TARGET onnxruntime APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+if (MSVC)
+    set_target_properties(onnxruntime PROPERTIES
+        IMPORTED_IMPLIB_RELEASE ${ONNXRUNTIME_LIBRARY_ONNXRUNTIME_PATH}
+        INTERFACE_INCLUDE_DIRECTORIES ${ONNXRUNTIME_INCLUDE_DIR}
+    )
+
+else()
+    set_target_properties(onnxruntime PROPERTIES
+        IMPORTED_LOCATION_RELEASE ${ONNXRUNTIME_LIBRARY_ONNXRUNTIME_PATH}
+        INTERFACE_INCLUDE_DIRECTORIES ${ONNXRUNTIME_INCLUDE_DIR}
+    )
+endif()

cmake/modules/FindTENSORRT.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+
+if (NOT DEFINED TENSORRT_DIR)
+    set(TENSORRT_DIR $ENV{TENSORRT_DIR})
+endif ()
+if (NOT TENSORRT_DIR)
+    message(FATAL_ERROR "Please set TENSORRT_DIR with cmake -D option.")
+endif()
+
+find_path(
+    TENSORRT_INCLUDE_DIR NvInfer.h
+    HINTS ${TENSORRT_DIR} ${CUDA_TOOLKIT_ROOT_DIR}
+    PATH_SUFFIXES include)
+
+if (NOT TENSORRT_INCLUDE_DIR)
+    message(FATAL_ERROR "Cannot find TensorRT header NvInfer.h "
+        "in TENSORRT_DIR: ${TENSORRT_DIR} or in CUDA_TOOLKIT_ROOT_DIR: "
+        "${CUDA_TOOLKIT_ROOT_DIR}, please check if the path is correct.")
+endif ()
+
+set(__TENSORRT_LIB_COMPONENTS nvinfer;nvinfer_plugin)
+foreach(__component ${__TENSORRT_LIB_COMPONENTS})
+    find_library(
+        __component_path ${__component}
+        HINTS ${TENSORRT_DIR} ${CUDA_TOOLKIT_ROOT_DIR}
+        PATH_SUFFIXES lib lib64 lib/x64)
+    if (NOT __component_path)
+        message(FATAL_ERROR "Cannot find TensorRT lib ${__component} in "
+            "TENSORRT_DIR: ${TENSORRT_DIR} or CUDA_TOOLKIT_ROOT_DIR: ${CUDA_TOOLKIT_ROOT_DIR}, "
+            "please check if the path is correct")
+    endif()
+
+    add_library(${__component} SHARED IMPORTED)
+    set_property(TARGET ${__component} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+    if (MSVC)
+        set_target_properties(
+            ${__component} PROPERTIES
+            IMPORTED_IMPLIB_RELEASE ${__component_path}
+            INTERFACE_INCLUDE_DIRECTORIES ${TENSORRT_INCLUDE_DIR}
+        )
+    else()
+        set_target_properties(
+            ${__component} PROPERTIES
+            IMPORTED_LOCATION_RELEASE ${__component_path}
+            INTERFACE_INCLUDE_DIRECTORIES ${TENSORRT_INCLUDE_DIR}
+        )
+    endif()
+    unset(__component_path CACHE)
+endforeach()
+
+set(TENSORRT_LIBS ${__TENSORRT_LIB_COMPONENTS})

cmake/modules/FindTVM.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+
+if (NOT DEFINED TVM_DIR)
+    set(TVM_DIR $ENV{TVM_DIR})
+endif ()
+if (NOT TVM_DIR)
+    message(FATAL_ERROR "Please set TVM_DIR with cmake -D option.")
+endif()
+
+find_path(
+    TVM_INCLUDE_DIR tvm/runtime/c_runtime_api.h
+    HINTS ${TVM_DIR}
+    PATH_SUFFIXES include)
+
+find_path(
+    DMLC_CORE_INCLUDE_DIR  dmlc/io.h
+    HINTS ${TVM_DIR}/3rdparty/dmlc-core
+    PATH_SUFFIXES include)
+
+find_path(
+    DLPACK_INCLUDE_DIR dlpack/dlpack.h
+    HINTS ${TVM_DIR}/3rdparty/dlpack
+    PATH_SUFFIXES include)
+
+find_library(
+    TVM_LIBRARY_PATH tvm_runtime
+    HINTS ${TVM_DIR}
+    PATH_SUFFIXES build lib build/${CMAKE_BUILD_TYPE})
+if (NOT (TVM_INCLUDE_DIR AND DMLC_CORE_INCLUDE_DIR AND DLPACK_INCLUDE_DIR AND TVM_LIBRARY_PATH))
+    message(FATAL_ERROR "Couldn't find tvm in TVM_DIR: "
+        "${TVM_DIR}, please check if the path is correct.")
+endif()
+
+add_library(tvm_runtime SHARED IMPORTED)
+set_property(TARGET tvm_runtime APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+if (MSVC)
+    set_target_properties(tvm_runtime PROPERTIES
+        IMPORTED_IMPLIB_RELEASE ${TVM_LIBRARY_PATH}
+        INTERFACE_INCLUDE_DIRECTORIES ${TVM_INCLUDE_DIR} ${DMLC_CORE_INCLUDE_DIR} ${DLPACK_INCLUDE_DIR}
+    )
+
+else()
+    set_target_properties(tvm_runtime PROPERTIES
+        IMPORTED_LOCATION_RELEASE ${TVM_LIBRARY_PATH}
+        INTERFACE_INCLUDE_DIRECTORIES ${TVM_INCLUDE_DIR} ${DMLC_CORE_INCLUDE_DIR} ${DLPACK_INCLUDE_DIR}
+    )
+endif()

cmake/opencv.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+find_package(OpenCV REQUIRED)

cmake/post-install.cmake

+
+
+set(_TARGETS_PATH ${CMAKE_INSTALL_PREFIX}/lib/cmake/MMDeploy/MMDeployTargets.cmake)
+
+file(READ ${_TARGETS_PATH} _MMDEPLOY_TARGETS)
+
+string(REGEX REPLACE "::@<0x[a-z0-9]+>" ""
+        _MMDEPLOY_TARGETS_FIXED "${_MMDEPLOY_TARGETS}")
+
+file(WRITE ${_TARGETS_PATH} "${_MMDEPLOY_TARGETS_FIXED}")

cmake/stacktrace.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+find_package(Boost 1.65 COMPONENTS stacktrace_backtrace)
+if (Boost_FOUND)
+    target_link_libraries(mmdeploy_core PUBLIC Boost::stacktrace_backtrace)
+    target_compile_definitions(mmdeploy_core PUBLIC -DMMDEPLOY_STATUS_USE_STACKTRACE=1)
+endif()

cmake/tensorrt.cmake

+# Copyright (c) OpenMMLab. All rights reserved.
+
+include(${CMAKE_SOURCE_DIR}/cmake/modules/FindTENSORRT.cmake)
+include(${CMAKE_SOURCE_DIR}/cmake/modules/FindCUDNN.cmake)
+find_path(
+        TENSORRT_INCLUDE_DIR NvInfer.h
+        HINTS ${TENSORRT_DIR} ${CUDA_TOOLKIT_ROOT_DIR}
+        PATH_SUFFIXES include)
+if (TENSORRT_INCLUDE_DIR)
+    message(STATUS "Found TensorRT headers at ${TENSORRT_INCLUDE_DIR}")
+else ()
+    message(ERROR "Cannot find TensorRT headers")
+endif ()
+
+find_library(
+        TENSORRT_LIBRARY_INFER nvinfer
+        HINTS ${TENSORRT_DIR} ${TENSORRT_BUILD} ${CUDA_TOOLKIT_ROOT_DIR}
+        PATH_SUFFIXES lib lib64 lib/x64)
+find_library(
+        TENSORRT_LIBRARY_INFER_PLUGIN nvinfer_plugin
+        HINTS ${TENSORRT_DIR} ${TENSORRT_BUILD} ${CUDA_TOOLKIT_ROOT_DIR}
+        PATH_SUFFIXES lib lib64 lib/x64)
+set(TENSORRT_LIBRARY ${TENSORRT_LIBRARY_INFER}
+        ${TENSORRT_LIBRARY_INFER_PLUGIN})
+if (TENSORRT_LIBRARY_INFER
+        AND TENSORRT_LIBRARY_INFER_PLUGIN)
+    message(STATUS "Found TensorRT libs at ${TENSORRT_LIBRARY}")
+else ()
+    message(FATAL_ERROR "Cannot find TensorRT libs")
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(TENSORRT DEFAULT_MSG TENSORRT_INCLUDE_DIR
+        TENSORRT_LIBRARY)
+if (NOT TENSORRT_FOUND)
+    message(ERROR "Cannot find TensorRT library.")
+endif ()

cmake/toolchains/aarch64-linux-gnu.cmake

+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+set(CMAKE_C_COMPILER "aarch64-linux-gnu-gcc")
+set(CMAKE_CXX_COMPILER "aarch64-linux-gnu-g++")
+set(CMAKE_LINKER "aarch64-linux-gnu-ld")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(CMAKE_C_FLAGS "-march=armv8-a")
+set(CMAKE_CXX_FLAGS "-march=armv8-a")
+
+# cache flags
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags")

cmake/toolchains/arm-linux-gnueabihf.cmake

+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR arm)
+
+set(CMAKE_C_COMPILER "arm-linux-gnueabihf-gcc")
+set(CMAKE_CXX_COMPILER "arm-linux-gnueabihf-g++")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(CMAKE_C_FLAGS "-march=armv7-a -mfloat-abi=hard -mfpu=neon")
+set(CMAKE_CXX_FLAGS "-march=armv7-a -mfloat-abi=hard -mfpu=neon")
+
+# cache flags
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags")

cmake/toolchains/riscv64-linux-gnu.cmake

+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv)
+
+set(CMAKE_C_COMPILER "riscv64-linux-gnu-gcc")
+set(CMAKE_CXX_COMPILER "riscv64-linux-gnu-g++")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+set(CMAKE_C_FLAGS "-march=rv64gc")
+set(CMAKE_CXX_FLAGS "-march=rv64gc")
+
+# cache flags
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags")

cmake/toolchains/riscv64-unknown-linux-gnu.cmake

+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv)
+
+if(DEFINED ENV{RISCV_ROOT_PATH})
+    file(TO_CMAKE_PATH $ENV{RISCV_ROOT_PATH} RISCV_ROOT_PATH)
+else()
+    message(FATAL_ERROR "RISCV_ROOT_PATH env must be defined")
+endif()
+
+set(CMAKE_C_COMPILER ${RISCV_ROOT_PATH}/bin/riscv64-unknown-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER ${RISCV_ROOT_PATH}/bin/riscv64-unknown-linux-gnu-g++)
+
+set(CMAKE_SYSROOT "${RISCV_ROOT_PATH}/sysroot" CACHE PATH "riscv sysroot")
+set(CMAKE_FIND_ROOT_PATH ${RISCV_ROOT_PATH}/riscv64-unknown-linux-gnu)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+set(CMAKE_C_FLAGS "-march=rv64gc")
+set(CMAKE_CXX_FLAGS "-march=rv64gc")
+
+# cache flags
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags")

cmake/toolchains/rknpu2-linux-gnu.cmake

+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR rockchip)
+
+if(DEFINED ENV{RKNN_TOOL_CHAIN})
+    file(TO_CMAKE_PATH $ENV{RKNN_TOOL_CHAIN} RKNN_TOOL_CHAIN)
+else()
+    message(FATAL_ERROR "RKNN_TOOL_CHAIN env must be defined")
+endif()
+
+set(CMAKE_C_COMPILER ${RKNN_TOOL_CHAIN}/bin/aarch64-rockchip-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER ${RKNN_TOOL_CHAIN}/bin/aarch64-rockchip-linux-gnu-g++)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+set(CMAKE_C_FLAGS "-Wl,--allow-shlib-undefined")
+set(CMAKE_CXX_FLAGS "-Wl,--allow-shlib-undefined")
+
+# cache flags
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags")

configs/_base_/backends/ascend.py

+backend_config = dict(type='ascend')

configs/_base_/backends/coreml.py

+backend_config = dict(type='coreml', convert_to='mlprogram')