diff --git a/CMakeLists.txt b/CMakeLists.txt index aee59ae2..12282d39 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,11 +1,14 @@ -cmake_minimum_required(VERSION 3.9.0) -project(MegEngine) +cmake_minimum_required(VERSION 3.13.0) + +include (cmake/FetchMegBrainVersion.cmake) +project(MegEngine LANGUAGES C CXX VERSION ${MGB_VER_STRING}) set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) +set(CMAKE_POLICY_DEFAULT_CMP0048 NEW) if(NOT MSVC AND NOT APPLE AND NOT WIN32) set(CMAKE_CXX_ARCHIVE_CREATE " Dqc ") @@ -13,6 +16,7 @@ if(NOT MSVC AND NOT APPLE AND NOT WIN32) set(CMAKE_CXX_ARCHIVE_FINISH " -D ") endif() +include(GNUInstallDirs) include(CheckCXXCompilerFlag) CHECK_CXX_COMPILER_FLAG(-Wclass-memaccess CXX_SUPPORT_WCLASS_MEMACCESS) @@ -22,6 +26,7 @@ set_property(CACHE MGE_ARCH PROPERTY STRINGS AUTO armv7 aarch64 naive fallback ) +set (MGE_EXPORT_TARGETS MegEngine-targets) option(MGE_WITH_JIT "Build MegEngine with JIT." ON) option(MGE_WITH_HALIDE "Build MegEngine with Halide JIT" ON) @@ -33,6 +38,15 @@ option(MGE_CUDA_USE_STATIC "Enable MegEngine CUDA static linking." ON) option(MGE_WITH_TRT "Build MegEngine with TensorRT." ON) option(MGE_USE_SYSTEM_LIB "Build MegEngine with system libraries." OFF) option(MGB_WITH_FLATBUFFERS "Build MegBrain with FlatBuffers serialization support." ON) +option(BUILD_SHARED_LIBS "Build shared libraries" ON) + +if (MGE_USE_SYSTEM_LIB) + set (MGE_CUDA_USE_STATIC OFF) +endif() + +if (MGB_WITH_FLATBUFFERS) + set(MGB_ENABLE_FBS_SERIALIZATION ON) +endif() if(CMAKE_TOOLCHAIN_FILE) message("We are cross compiling.") @@ -509,7 +523,7 @@ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MARCH}") # Write out megbrain_build_config.h # It defines macros needed by both megbrain and dnn configure_file(src/megbrain_build_config.h.in ${CMAKE_CURRENT_BINARY_DIR}/genfiles/megbrain_build_config.h) -install(FILES ${CMAKE_CURRENT_BINARY_DIR}/genfiles/megbrain_build_config.h DESTINATION include) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/genfiles/megbrain_build_config.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) add_subdirectory(dnn) @@ -531,13 +545,18 @@ list(APPEND MGB_OPR_PARAM_DEFS_OUTS ${MGB_OPR_PARAM_DEFS_OUT_DIR}/megbrain/opr/param_defs.h ) -install(FILES ${MGB_OPR_PARAM_DEFS_OUTS} DESTINATION include/megbrain/opr/) +install(FILES ${MGB_OPR_PARAM_DEFS_OUTS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/megbrain/opr/) list(APPEND MGB_OPR_PARAM_DEFS_INC ${MGB_OPR_PARAM_DEFS_OUT_DIR}) add_custom_target(_mgb_opr_param_defs DEPENDS ${MGB_OPR_PARAM_DEFS_OUTS}) add_library(mgb_opr_param_defs INTERFACE) -target_include_directories(mgb_opr_param_defs INTERFACE ${MGB_OPR_PARAM_DEFS_INC}) +target_include_directories(mgb_opr_param_defs + INTERFACE + $ + $ +) add_dependencies(mgb_opr_param_defs _mgb_opr_param_defs) +install(TARGETS mgb_opr_param_defs EXPORT ${MGE_EXPORT_TARGETS}) if(MGE_WITH_DISTRIBUTED) add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/MegRay) @@ -554,12 +573,12 @@ if(MGE_WITH_TEST AND MGE_ENABLE_RTTI) add_subdirectory(test) endif() -if(TARGET _mgb) +if(TARGET mgb) add_custom_target( develop COMMAND ${CMAKE_COMMAND} -E create_symlink - ${CMAKE_CURRENT_BINARY_DIR}/python_module/megengine/_internal/$ - ${CMAKE_CURRENT_SOURCE_DIR}/python_module/megengine/_internal/$ + ${CMAKE_CURRENT_BINARY_DIR}/python_module/megengine/_internal/$ + ${CMAKE_CURRENT_SOURCE_DIR}/python_module/megengine/_internal/$ COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_BINARY_DIR}/python_module/megengine/_internal/mgb.py ${CMAKE_CURRENT_SOURCE_DIR}/python_module/megengine/_internal/mgb.py @@ -572,7 +591,7 @@ if(TARGET _mgb) COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_BINARY_DIR}/python_module/megengine/_internal/include ${CMAKE_CURRENT_SOURCE_DIR}/python_module/megengine/_internal/include - DEPENDS _mgb + DEPENDS mgb VERBATIM ) endif() @@ -584,3 +603,38 @@ IF(APPLE) set(CMAKE_USE_PTHREADS_INIT 1) set(THREADS_PREFER_PTHREAD_FLAG ON) ENDIF() + +# Configure and install pkg-config. +# Note that unlike the Config.cmake modules, this is not relocatable (and not +# really portable) because we have two dependencies without pkg-config +# descriptions: FlatBuffers and MKL-DNN +if (MGE_USE_SYSTEM_MKLDNN) + set (MGE_PKGCONFIG_LIBS_PRIVATE "-ldnnl") +endif() +if (MGE_USE_SYSTEM_OPENBLAS) + set (MGE_PKGCONFIG_LIBS_PRIVATE "${MGE_PKGCONFIG_LIBS_PRIVATE} -lopenblas") +endif() +configure_file(cmake/megengine.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/megengine.pc + @ONLY) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/megengine.pc + DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) + +# Do not export targets if MGE_WITH_DISTRIBUTED is on. MegRay is not ready. +if (NOT MGE_WITH_DISTRIBUTED) + include(CMakePackageConfigHelpers) + set (MGE_INSTALL_CMAKEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/MegEngine) + configure_package_config_file(cmake/MegEngineConfig.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/MegEngineConfig.cmake + INSTALL_DESTINATION ${MGE_INSTALL_CMAKEDIR} + ) + write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/MegEngineConfigVersion.cmake + VERSION ${MGB_VER_MAJOR}.${MGB_VER_MINOR}.${MGB_VER_PATCH} + COMPATIBILITY SameMajorVersion) + + install(EXPORT ${MGE_EXPORT_TARGETS} DESTINATION ${MGE_INSTALL_CMAKEDIR}) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/MegEngineConfig.cmake + ${CMAKE_CURRENT_BINARY_DIR}/MegEngineConfigVersion.cmake + DESTINATION ${MGE_INSTALL_CMAKEDIR}) +endif() diff --git a/cmake/BuildFlatBuffers.cmake b/cmake/BuildFlatBuffers.cmake new file mode 100644 index 00000000..91cf5f97 --- /dev/null +++ b/cmake/BuildFlatBuffers.cmake @@ -0,0 +1,152 @@ +# Copyright 2015 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# General function to create FlatBuffer build rules for the given list of +# schemas. +# +# flatbuffers_schemas: A list of flatbuffer schema files to process. +# +# schema_include_dirs: A list of schema file include directories, which will be +# passed to flatc via the -I parameter. +# +# custom_target_name: The generated files will be added as dependencies for a +# new custom target with this name. You should add that target as a dependency +# for your main target to ensure these files are built. You can also retrieve +# various properties from this target, such as GENERATED_INCLUDES_DIR, +# BINARY_SCHEMAS_DIR, and COPY_TEXT_SCHEMAS_DIR. +# +# additional_dependencies: A list of additional dependencies that you'd like +# all generated files to depend on. Pass in a blank string if you have none. +# +# generated_includes_dir: Where to generate the C++ header files for these +# schemas. The generated includes directory will automatically be added to +# CMake's include directories, and will be where generated header files are +# placed. This parameter is optional; pass in empty string if you don't want to +# generate include files for these schemas. +# +# binary_schemas_dir: If you specify an optional binary schema directory, binary +# schemas will be generated for these schemas as well, and placed into the given +# directory. +# +# copy_text_schemas_dir: If you want all text schemas (including schemas from +# all schema include directories) copied into a directory (for example, if you +# need them within your project to build JSON files), you can specify that +# folder here. All text schemas will be copied to that folder. +# +# IMPORTANT: Make sure you quote all list arguments you pass to this function! +# Otherwise CMake will only pass in the first element. +# Example: build_flatbuffers("${fb_files}" "${include_dirs}" target_name ...) +function(build_flatbuffers flatbuffers_schemas + schema_include_dirs + custom_target_name + additional_dependencies + generated_includes_dir + binary_schemas_dir + copy_text_schemas_dir) + + # Test if including from FindFlatBuffers + if(FLATBUFFERS_FLATC_EXECUTABLE) + set(FLATC_TARGET "") + set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE}) + else() + set(FLATC_TARGET flatbuffers::flatc) + set(FLATC flatc) + endif() + set(FLATC_SCHEMA_ARGS --gen-mutable) + if(FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS) + set(FLATC_SCHEMA_ARGS + ${FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS} + ${FLATC_SCHEMA_ARGS} + ) + endif() + + set(working_dir "${CMAKE_CURRENT_SOURCE_DIR}") + + set(schema_glob "*.fbs") + # Generate the include files parameters. + set(include_params "") + set(all_generated_files "") + foreach (include_dir ${schema_include_dirs}) + set(include_params -I ${include_dir} ${include_params}) + if (NOT ${copy_text_schemas_dir} STREQUAL "") + # Copy text schemas from dependent folders. + file(GLOB_RECURSE dependent_schemas ${include_dir}/${schema_glob}) + foreach (dependent_schema ${dependent_schemas}) + file(COPY ${dependent_schema} DESTINATION ${copy_text_schemas_dir}) + endforeach() + endif() + endforeach() + + foreach(schema ${flatbuffers_schemas}) + get_filename_component(filename ${schema} NAME_WE) + # For each schema, do the things we requested. + if (NOT ${generated_includes_dir} STREQUAL "") + set(generated_include ${generated_includes_dir}/${filename}_generated.h) + add_custom_command( + OUTPUT ${generated_include} + COMMAND ${FLATC} ${FLATC_SCHEMA_ARGS} + -o ${generated_includes_dir} + ${include_params} + -c ${schema} + DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies} + WORKING_DIRECTORY "${working_dir}") + list(APPEND all_generated_files ${generated_include}) + endif() + + if (NOT ${binary_schemas_dir} STREQUAL "") + set(binary_schema ${binary_schemas_dir}/${filename}.bfbs) + add_custom_command( + OUTPUT ${binary_schema} + COMMAND ${FLATC} -b --schema + -o ${binary_schemas_dir} + ${include_params} + ${schema} + DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies} + WORKING_DIRECTORY "${working_dir}") + list(APPEND all_generated_files ${binary_schema}) + endif() + + if (NOT ${copy_text_schemas_dir} STREQUAL "") + file(COPY ${schema} DESTINATION ${copy_text_schemas_dir}) + endif() + endforeach() + + # Create a custom target that depends on all the generated files. + # This is the target that you can depend on to trigger all these + # to be built. + add_custom_target(${custom_target_name} + DEPENDS ${all_generated_files} ${additional_dependencies}) + + # Register the include directory we are using. + if (NOT ${generated_includes_dir} STREQUAL "") + include_directories(${generated_includes_dir}) + set_property(TARGET ${custom_target_name} + PROPERTY GENERATED_INCLUDES_DIR + ${generated_includes_dir}) + endif() + + # Register the binary schemas dir we are using. + if (NOT ${binary_schemas_dir} STREQUAL "") + set_property(TARGET ${custom_target_name} + PROPERTY BINARY_SCHEMAS_DIR + ${binary_schemas_dir}) + endif() + + # Register the text schema copy dir we are using. + if (NOT ${copy_text_schemas_dir} STREQUAL "") + set_property(TARGET ${custom_target_name} + PROPERTY COPY_TEXT_SCHEMAS_DIR + ${copy_text_schemas_dir}) + endif() +endfunction() diff --git a/cmake/FetchMegBrainVersion.cmake b/cmake/FetchMegBrainVersion.cmake new file mode 100644 index 00000000..2a3f8d41 --- /dev/null +++ b/cmake/FetchMegBrainVersion.cmake @@ -0,0 +1,33 @@ +# Parses the version set in src/core/include/megbrain/version.h +# Exports the following variables: +# MGB_VER_MAJOR: Major version +# MGB_VER_MINOR: Minor version +# MGB_VER_PATCH: Patch version +# MGB_IS_DEV: Is development version +# MGB_VER_STRING: Version string +option(MGB_FORCE_DEV_VERSION "Force -dev tag in version stamp" OFF) + +file (READ "${CMAKE_SOURCE_DIR}/src/core/include/megbrain/version.h" content) + +string (REGEX MATCH "MGB_MAJOR +([0-9]+)" _ ${content}) +set (MGB_VER_MAJOR ${CMAKE_MATCH_1}) + +string (REGEX MATCH "MGB_MINOR +([0-9]+)" _ ${content}) +set (MGB_VER_MINOR ${CMAKE_MATCH_1}) + +string (REGEX MATCH "MGB_PATCH *([0-9]+)" _ ${content}) +set (MGB_VER_PATCH ${CMAKE_MATCH_1}) + +if (MGB_FORCE_DEV_VERSION) + set (MGB_IS_DEV 1) +else() + string (REGEX MATCH "MGB_IS_DEV +([01])" _ ${content}) + set (MGB_IS_DEV ${CMAKE_MATCH_1}) +endif() + +set (MGB_VER_STRING "${MGB_VER_MAJOR}.${MGB_VER_MINOR}.${MGB_VER_PATCH}") +if (MGB_IS_DEV) + set (MGB_VER_STRING "${MGB_VER_STRING}-dev") +endif() + +message("-- Building MegBrain ${MGB_VER_STRING}") diff --git a/cmake/MKL_DNN.cmake b/cmake/MKL_DNN.cmake index 7bf370ed..d85db4ae 100644 --- a/cmake/MKL_DNN.cmake +++ b/cmake/MKL_DNN.cmake @@ -1,25 +1,25 @@ +if (MGE_USE_SYSTEM_LIB) + find_package(dnnl) + if (dnnl_FOUND) + message("Using system provided MKL-DNN.") + set (MGE_USE_SYSTEM_MKLDNN ON) + return() + endif() +endif() option(DNNL_BUILD_TESTS "" OFF) option(DNNL_BUILD_EXAMPLES "" OFF) -set(DNNL_LIBRARY_TYPE STATIC CACHE STRING "config dnnl to STATIC") # we do not want to use OMP now, so config to CPU mode # if set to OMP, some dnnl algo will be more fast set(DNNL_CPU_RUNTIME DNNL_RUNTIME_SEQ CACHE STRING "config dnnl to DNNL_RUNTIME_SEQ") if(MGE_BLAS STREQUAL "MKL") option(_DNNL_USE_MKL "" ON) set(MKLROOT ${MKL_ROOT_DIR} CACHE STRING "MKL ROOT FOR DNNL") - if (WIN32) - set(MKLLIB "mkl_core" CACHE STRING "MKLLIB NAME FOR DNNL") - else() - set(MKLLIB "libmkl_core.a" CACHE STRING "MKLLIB NAME FOR DNNL") - endif() - # workround for DNNL link failed, we do not want to modify - # dnnl MKL.cmake of intel-mkl-dnn when include intel-mkl-dnn - # via add_subdirectory api - link_directories(${MKL_ROOT_DIR}/lib) + set(MKLLIB libmkl) else() option(_DNNL_USE_MKL "" OFF) endif() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-parameter -Wno-extra") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-extra") +set(DNNL_LIBRARY_TYPE STATIC CACHE STRING "config dnnl to STATIC") add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/intel-mkl-dnn) diff --git a/cmake/MegEngineConfig.cmake.in b/cmake/MegEngineConfig.cmake.in new file mode 100644 index 00000000..19c9fb35 --- /dev/null +++ b/cmake/MegEngineConfig.cmake.in @@ -0,0 +1,13 @@ +@PACKAGE_INIT@ + +find_package(Flatbuffers REQUIRED) + +if (@MGE_WITH_MKLDNN@) + find_package(dnnl REQUIRED) +endif() + +list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}) +if (NOT TARGET megengine) + include ("${CMAKE_CURRENT_LIST_DIR}/@MGE_EXPORT_TARGETS@.cmake") + check_required_components("megengine") +endif () diff --git a/cmake/Modules/FindNumpy.cmake b/cmake/Modules/FindNumPy.cmake similarity index 100% rename from cmake/Modules/FindNumpy.cmake rename to cmake/Modules/FindNumPy.cmake diff --git a/cmake/OpenBLAS.cmake b/cmake/OpenBLAS.cmake index 37fbfa65..66c11b9a 100644 --- a/cmake/OpenBLAS.cmake +++ b/cmake/OpenBLAS.cmake @@ -1,3 +1,17 @@ +if (MGE_USE_SYSTEM_LIB) + find_package(OpenBLAS) + set (MGE_USE_SYSTEM_OPENBLAS ON) + + message("Using system provided OpenBLAS ${OpenBLAS_VERSION}") + add_library(libopenblas IMPORTED GLOBAL) + set_target_properties( + libopenblas PROPERTIES + IMPORTED_LOCATION ${OpenBLAS_LIBRARIES} + INTERFACE_INCLUDE_DIRECTORIES ${OpenBLAS_INCLUDE_DIRS} + ) + return() +endif() + include(ExternalProject) include(GNUInstallDirs) diff --git a/cmake/flatbuffers.cmake b/cmake/flatbuffers.cmake index b64e3948..5005c1ea 100644 --- a/cmake/flatbuffers.cmake +++ b/cmake/flatbuffers.cmake @@ -1,5 +1,7 @@ if (MGE_USE_SYSTEM_LIB) - find_package(FlatBuffers REQUIRED) + find_package(Flatbuffers REQUIRED) + message("Using system provided Flatbuffers ${Flatbuffers_VERSION}") + include(cmake/BuildFlatBuffers.cmake) return() endif() if(MSVC OR WIN32) @@ -21,5 +23,5 @@ endif() option(FLATBUFFERS_BUILD_TESTS "" OFF) add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/flatbuffers - ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers - EXCLUDE_FROM_ALL) + ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers) +add_library(flatbuffers::flatbuffers ALIAS flatbuffers) diff --git a/cmake/megengine.pc.in b/cmake/megengine.pc.in new file mode 100644 index 00000000..46f2deb7 --- /dev/null +++ b/cmake/megengine.pc.in @@ -0,0 +1,11 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +libdir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@ +includedir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_INCLUDEDIR@ + +Name: MegEngine +Description: A deep learning framework +Version: @MGB_VER_STRING@ +URL: https://github.com/MegEngine/MegEngine +Cflags: -I${includedir} +Libs: -L${libdir} -lmegengine -pthread +Libs.private: @MGE_PKGCONFIG_LIBS_PRIVATE@ diff --git a/cmake/mkl.cmake b/cmake/mkl.cmake index 391c5693..68f1686e 100644 --- a/cmake/mkl.cmake +++ b/cmake/mkl.cmake @@ -42,11 +42,11 @@ if(MGE_MKL_USE_STATIC) PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/) endif() - add_library(libmkl INTERFACE) - if(APPLE) - target_link_libraries(libmkl INTERFACE ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY} ${MKL_IPL_LIBRARY}) - else() + add_library(libmkl INTERFACE IMPORTED) + if(UNIX AND NOT APPLE) target_link_libraries(libmkl INTERFACE -Wl,--start-group ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY} ${MKL_IPL_LIBRARY} -Wl,--end-group) + else() + target_link_libraries(libmkl INTERFACE ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY} ${MKL_IPL_LIBRARY}) endif() target_include_directories(libmkl INTERFACE ${MKL_INCLUDE_DIR}) else() diff --git a/dnn/CMakeLists.txt b/dnn/CMakeLists.txt index 0bc22e63..61c28297 100644 --- a/dnn/CMakeLists.txt +++ b/dnn/CMakeLists.txt @@ -1,4 +1,3 @@ - list(APPEND OPR_PARAM_DEFS_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/scripts/opr_param_defs.py) set(OPR_PARAM_DEFS_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/scripts/gen_param_defs.py) @@ -40,14 +39,22 @@ list(APPEND OPR_PARAM_DEFS_OUTS list(APPEND OPR_PARAM_DEFS_INC ${OPR_PARAM_DEFS_OUT_DIR}) -install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/megdnn DESTINATION include FILES_MATCHING PATTERN "*.h") +install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/megdnn DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h") add_custom_target(_opr_param_defs DEPENDS ${OPR_PARAM_DEFS_OUTS}) add_library(opr_param_defs INTERFACE) -target_include_directories(opr_param_defs INTERFACE ${OPR_PARAM_DEFS_INC}) -add_dependencies(opr_param_defs _opr_param_defs) - +target_include_directories(opr_param_defs + INTERFACE + $ +) +foreach (INCPATH IN LISTS OPR_PARAM_DEFS_INC) + target_include_directories(opr_param_defs + INTERFACE $ + ) +endforeach() +add_dependencies(opr_param_defs _opr_param_defs) +install(TARGETS opr_param_defs EXPORT ${MGE_EXPORT_TARGETS}) @@ -56,3 +63,5 @@ if(MGE_WITH_TEST) endif() add_subdirectory(src) + +# install(TARGETS megdnn opr_param_defs libmkl EXPORT ${MGE_EXPORT_TARGETS}) diff --git a/dnn/cuda-stub/CMakeLists.txt b/dnn/cuda-stub/CMakeLists.txt index 090e8509..2bd634a2 100644 --- a/dnn/cuda-stub/CMakeLists.txt +++ b/dnn/cuda-stub/CMakeLists.txt @@ -4,3 +4,4 @@ add_library (cuda-stub SHARED ${SOURCES}) set_target_properties(cuda-stub PROPERTIES OUTPUT_NAME cuda) target_compile_definitions(cuda-stub PRIVATE __CUDA_API_VERSION_INTERNAL) target_link_libraries(cuda-stub PRIVATE dl -Wl,--no-undefined) +install (TARGETS cuda-stub EXPORT ${MGE_EXPORT_TARGETS}) diff --git a/dnn/src/CMakeLists.txt b/dnn/src/CMakeLists.txt index da359706..93411e16 100644 --- a/dnn/src/CMakeLists.txt +++ b/dnn/src/CMakeLists.txt @@ -48,11 +48,18 @@ endif() add_definitions(${LIBMEGDNN_DEF}) -add_library(megdnn EXCLUDE_FROM_ALL STATIC ${SOURCES}) +add_library(megdnn EXCLUDE_FROM_ALL OBJECT ${SOURCES}) -target_link_libraries(megdnn opr_param_defs) -target_include_directories(megdnn PUBLIC ${PROJECT_BINARY_DIR}/genfiles ${PROJECT_SOURCE_DIR}/dnn/include) -target_include_directories(megdnn PRIVATE ${PROJECT_SOURCE_DIR}/dnn ${PROJECT_SOURCE_DIR}/third_party/midout/src) +target_link_libraries(megdnn PUBLIC opr_param_defs) +target_include_directories(megdnn + PUBLIC + $ + $ + $ + PRIVATE + ${PROJECT_SOURCE_DIR}/dnn + ${PROJECT_SOURCE_DIR}/third_party/midout/src +) install(DIRECTORY ${PROJECT_SOURCE_DIR}/dnn/include DESTINATION . FILES_MATCHING PATTERN "*.h*") @@ -67,10 +74,20 @@ endif() target_compile_definitions(megdnn INTERFACE ${LIBMEGDNN_DEF}) if(MGE_WITH_MKLDNN AND ${MGE_ARCH} STREQUAL "x86_64") - target_link_libraries(megdnn dnnl) + if (BUILD_SHARED_LIBS) + target_link_libraries(megdnn PRIVATE $) + else() + target_link_libraries(megdnn PRIVATE dnnl) + endif() +endif() +target_link_libraries(megdnn PRIVATE ${MGE_CUDA_LIBS}) +if (BUILD_SHARED_LIBS) + target_link_libraries(megdnn PRIVATE $) +else() + target_link_libraries(megdnn PRIVATE ${MGE_BLAS_LIBS}) endif() -target_link_libraries(megdnn ${MGE_CUDA_LIBS}) -target_link_libraries(megdnn ${MGE_BLAS_LIBS}) if(CMAKE_THREAD_LIBS_INIT) - target_link_libraries(megdnn Threads::Threads) + target_link_libraries(megdnn PRIVATE Threads::Threads) endif() + +install(TARGETS megdnn EXPORT ${MGE_EXPORT_TARGETS}) diff --git a/dnn/test/CMakeLists.txt b/dnn/test/CMakeLists.txt index c1f40a41..e4c881fc 100644 --- a/dnn/test/CMakeLists.txt +++ b/dnn/test/CMakeLists.txt @@ -29,7 +29,7 @@ endif() add_executable(megdnn_test ${SOURCES}) target_link_libraries(megdnn_test gtest) -target_link_libraries(megdnn_test megdnn) +target_link_libraries(megdnn_test megdnn ${MGE_BLAS_LIBS}) if(UNIX) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++") @@ -42,5 +42,3 @@ endif() if(UNIX) target_link_libraries(megdnn_test dl rt) endif() - -install(TARGETS megdnn_test RUNTIME DESTINATION test) diff --git a/python_module/CMakeLists.txt b/python_module/CMakeLists.txt index a02f8282..3d9dbecb 100644 --- a/python_module/CMakeLists.txt +++ b/python_module/CMakeLists.txt @@ -1,3 +1,5 @@ +cmake_policy(SET CMP0086 NEW) + find_package(PythonLibs ${PYTHON_VERSION_STRING} EXACT REQUIRED) find_package(Git) @@ -5,7 +7,7 @@ if(GIT_FOUND) message("git found: ${GIT_EXECUTABLE}") endif() -find_package(Numpy REQUIRED) +find_package(NumPy REQUIRED) find_package(SWIG REQUIRED) set(SWIG_SRC src/swig/mgb.i) @@ -63,15 +65,19 @@ swig_add_library(mgb LANGUAGE python SOURCES ${SWIG_SRC} ${SRCS}) set(VERSION_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/src/version.ld) add_custom_target(version_ld SOURCES ${VERSION_SCRIPT}) -set_target_properties(_mgb PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/megengine/_internal) -target_link_libraries(_mgb megbrain -Wl,--version-script=${VERSION_SCRIPT}) -target_include_directories(_mgb PRIVATE ${PYTHON_INCLUDE_DIRS} src/cpp ${CMAKE_CURRENT_BINARY_DIR} ${NUMPY_INCLUDE_DIR}) -target_link_libraries(_mgb ${PYTHON_LIBRARIES}) +set_target_properties(mgb PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/megengine/_internal) +target_link_libraries(mgb megbrain megdnn -Wl,--version-script=${VERSION_SCRIPT}) +target_include_directories(mgb PRIVATE ${PYTHON_INCLUDE_DIRS} src/cpp ${CMAKE_CURRENT_BINARY_DIR} ${NUMPY_INCLUDE_DIR}) +target_link_libraries(mgb ${PYTHON_LIBRARIES}) + +if (MGE_WITH_DISTRIBUTED) + target_link_libraries(mgb megray) +endif() -add_dependencies(_mgb mgb_opr_py version_ld) +add_dependencies(mgb mgb_opr_py version_ld) add_custom_command( - TARGET _mgb POST_BUILD + TARGET mgb POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/LICENSE ${PROJECT_SOURCE_DIR}/ACKNOWLEDGMENTS ${PROJECT_BINARY_DIR} COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/megengine ${CMAKE_CURRENT_BINARY_DIR}/megengine COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/test ${CMAKE_CURRENT_BINARY_DIR}/test diff --git a/python_module/src/version.ld b/python_module/src/version.ld index 1338a910..ac6e0802 100644 --- a/python_module/src/version.ld +++ b/python_module/src/version.ld @@ -8,7 +8,9 @@ global: *mgb::*; *megdnn::*; *megcore::*; + megcore*; }; + megcore*; local: *; diff --git a/sdk/load-and-run/CMakeLists.txt b/sdk/load-and-run/CMakeLists.txt index 1479a2de..486c0572 100755 --- a/sdk/load-and-run/CMakeLists.txt +++ b/sdk/load-and-run/CMakeLists.txt @@ -2,10 +2,15 @@ include_directories(src) file (GLOB_RECURSE SOURCES src/*.cpp main.cpp) add_executable (load_and_run ${SOURCES}) -target_link_libraries (load_and_run megbrain) -install (TARGETS load_and_run RUNTIME DESTINATION bin) +if (WIN32) + # Windows does not support implicitly importing data members from DLL. + target_link_libraries(load_and_run megbrain megdnn) +else() + target_link_libraries (load_and_run megengine) +endif() +install (TARGETS load_and_run EXPORT ${MGE_EXPORT_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) if(MGE_WITH_TEST) add_executable(json_loader_test test/json_loader_test.cpp src/json_loader.h src/json_loader.cpp) - target_link_libraries (json_loader_test megbrain) + target_link_libraries (json_loader_test megengine) endif() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 6b68f2bc..20ddcbbc 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,5 +1,3 @@ - - file(GLOB_RECURSE SOURCES core/impl/*.cpp gopt/impl/*.cpp opr/impl/*.cpp plugin/impl/*.cpp serialization/impl/*.cpp core/impl/*.inl gopt/impl/*.inl opr/impl/*.inl plugin/impl/*.inl serialization/impl/*.inl) if(MGE_WITH_JIT) @@ -16,29 +14,36 @@ if(MGE_WITH_DISTRIBUTED) list(APPEND SOURCES ${GRPC_SRCS}) endif() -set(MGB_INC ${PROJECT_BINARY_DIR}/genfiles core/include gopt/include opr/include plugin/include serialization/include) +set(MGB_INC ${PROJECT_BINARY_DIR}/genfiles ${CMAKE_CURRENT_LIST_DIR}/core/include ${CMAKE_CURRENT_LIST_DIR}/gopt/include ${CMAKE_CURRENT_LIST_DIR}/opr/include ${CMAKE_CURRENT_LIST_DIR}/plugin/include ${CMAKE_CURRENT_LIST_DIR}/serialization/include) if(MGE_WITH_JIT) - list(APPEND MGB_INC jit/include) + list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/jit/include) if(MGE_WITH_CUDA) - list(APPEND MGB_INC jit/impl/cuda) + list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/jit/impl/cuda) endif() endif() if(MGE_WITH_DISTRIBUTED) - list(APPEND MGB_INC opr-mm/include) + list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/opr-mm/include) endif() if(MGE_WITH_CUDA AND MGE_WITH_TRT) - list(APPEND MGB_INC tensorrt/include) + list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/tensorrt/include) file(GLOB_RECURSE SOURCES_ tensorrt/impl/*.cpp tensorrt/impl/*.inl) list(APPEND SOURCES ${SOURCES_}) endif() -add_library(megbrain STATIC EXCLUDE_FROM_ALL ${SOURCES}) -target_link_libraries(megbrain mgb_opr_param_defs) -target_include_directories(megbrain PUBLIC ${MGB_INC}) +add_library(megbrain OBJECT EXCLUDE_FROM_ALL ${SOURCES}) +target_link_libraries(megbrain PUBLIC mgb_opr_param_defs) +target_include_directories(megbrain + PUBLIC $ +) +foreach (INCPATH IN LISTS MGB_INC) + target_include_directories(megbrain + PUBLIC $ + ) +endforeach() if(MGE_WITH_CUDA) target_compile_options(megbrain PRIVATE "$<$:-Xcompiler=-Wno-unused-parameter>" @@ -54,19 +59,19 @@ if(CXX_SUPPORT_WCLASS_MEMACCESS) target_compile_options(megbrain PRIVATE "-Wno-class-memaccess") endif() endif() -target_link_libraries(megbrain megdnn) +target_link_libraries(megbrain PUBLIC megdnn) if(MGE_WITH_DISTRIBUTED) add_dependencies(megbrain mgb_proto_target) - target_link_libraries (megbrain libprotobuf libzmq) + target_link_libraries (megbrain PRIVATE libprotobuf libzmq) set(CPPZMQ_INC ${PROJECT_SOURCE_DIR}/third_party/cppzmq) # FIXME: add CMAKE_CURRENT_BINARY_DIR for including mm_handler.pb.h target_include_directories(megbrain PRIVATE ${CPPZMQ_INC} ${CMAKE_CURRENT_BINARY_DIR}) - target_link_libraries (megbrain megray) + target_link_libraries (megbrain PRIVATE megray) endif() -target_link_libraries(megbrain ${MGE_CUDA_LIBS}) +target_link_libraries(megbrain PRIVATE ${MGE_CUDA_LIBS}) if(MGE_WITH_JIT AND MGE_WITH_HALIDE) - target_link_libraries(megbrain libhalide) - target_link_libraries(megbrain ${HALIDE_LLVM_LIBS}) + target_link_libraries(megbrain PRIVATE libhalide) + target_link_libraries(megbrain PRIVATE ${HALIDE_LLVM_LIBS}) endif() if (MGB_WITH_FLATBUFFERS) set (GEN_FLATBUFFERS_SCHEMA_PY ${PROJECT_SOURCE_DIR}/dnn/scripts/gen_flatbuffers_schema.py) @@ -113,7 +118,7 @@ if (MGB_WITH_FLATBUFFERS) add_dependencies(megbrain mgb_serialization_schema_fbs) target_include_directories(megbrain PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/serialization/include) target_compile_definitions(megbrain PUBLIC MGB_ENABLE_FBS_SERIALIZATION=1) - target_link_libraries(megbrain flatbuffers) + target_link_libraries(megbrain PUBLIC flatbuffers) set (GENERATED_FLATBUFFERS_CONVERTER_PATH ${CMAKE_CURRENT_BINARY_DIR}/genfiles) set (GEN_FLATBUFFERS_CONVERTER_PY ${PROJECT_SOURCE_DIR}/dnn/scripts/gen_flatbuffers_converter.py) @@ -139,27 +144,34 @@ if (MGB_WITH_FLATBUFFERS) target_include_directories(megbrain PRIVATE ${GENERATED_FLATBUFFERS_CONVERTER_PATH}) endif() if(UNIX AND NOT ANDROID AND NOT APPLE) - target_link_libraries(megbrain dl rt atomic) + target_link_libraries(megbrain PUBLIC dl rt atomic) endif() if(ANDROID) - target_link_libraries(megbrain log) + target_link_libraries(megbrain PUBLIC log) endif() -add_library(megengine SHARED $) -if(MGB_WITH_FLATBUFFERS) - add_dependencies(megengine mgb_serialization_schema_fbs) +# Build as SHARED or STATIC depending on BUILD_SHARED_LIBS=ON/OFF +add_library(megengine) +target_link_libraries(megengine PUBLIC megbrain megdnn) +if (UNIX AND NOT APPLE) + # TODO: Use target_link_options after upgrading to CMake 3.13 + target_link_options(megengine PRIVATE -Wl,--no-undefined -Wl,--version-script=${PROJECT_SOURCE_DIR}/python_module/src/version.ld) endif() -target_include_directories(megengine PRIVATE $) -target_compile_definitions(megengine PUBLIC $) -target_compile_options(megengine PUBLIC $) -if(APPLE) - target_link_libraries(megengine PRIVATE $) +set_target_properties(megengine PROPERTIES CXX_VISIBILITY_PRESET default) +set_target_properties(megengine PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE) +if (MGE_WITH_DISTRIBUTED) + # Do not export targets if MGE_WITH_DISTRIBUTED is on. MegRay is not ready + # for this. + install(TARGETS megengine + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) else() - target_link_libraries(megengine PRIVATE $ -Wl,--no-undefined -Wl,--version-script=${PROJECT_SOURCE_DIR}/python_module/src/version.ld) + install(TARGETS megengine megbrain + EXPORT ${MGE_EXPORT_TARGETS} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) endif() -set_target_properties(megengine PROPERTIES CXX_VISIBILITY_PRESET default) -install(TARGETS megengine LIBRARY DESTINATION lib64) foreach(_PATH ${MGB_INC}) - install(DIRECTORY ${_PATH}/megbrain DESTINATION include FILES_MATCHING PATTERN "*.h") + install(DIRECTORY ${_PATH}/megbrain DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h") endforeach() diff --git a/src/core/include/megbrain/version.h b/src/core/include/megbrain/version.h index dfdbe50e..739ecf2b 100644 --- a/src/core/include/megbrain/version.h +++ b/src/core/include/megbrain/version.h @@ -15,7 +15,9 @@ #define MGB_MINOR 4 #define MGB_PATCH 1 //! whether it is development version +#ifndef MGB_IS_DEV #define MGB_IS_DEV 0 +#endif // MGB_IS_DEV namespace mgb { struct Version { diff --git a/src/megbrain_build_config.h.in b/src/megbrain_build_config.h.in index 6b853b68..9eb19797 100644 --- a/src/megbrain_build_config.h.in +++ b/src/megbrain_build_config.h.in @@ -26,7 +26,8 @@ #cmakedefine01 MGB_ENABLE_JSON #cmakedefine01 MGB_HAVE_THREAD #cmakedefine01 MGB_ENABLE_OPR_MM -#cmakedefine01 MEGDNN_ENABLE_MANGLING +#cmakedefine01 MGB_ENABLE_FBS_SERIALIZATION +#cmakedefine01 MGB_IS_DEV // DNN related flags // Platform macro's @@ -41,7 +42,7 @@ #cmakedefine01 MEGDNN_X86_WITH_MKL_DNN #cmakedefine01 MEGDNN_ENABLE_RTTI #cmakedefine01 MEGDNN_ENABLE_LOGGING -#cmakedefine01 MEGDNN_ENABLE_LOGGING +#cmakedefine01 MEGDNN_ENABLE_MANGLING #cmakedefine01 MEGDNN_ENABLE_EXCEPTIONS #cmakedefine01 MEGDNN_NAIVE #cmakedefine01 MEGDNN_X86 diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index bf45728d..4559e991 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -17,7 +17,7 @@ endif() add_executable(megbrain_test ${SOURCES}) target_link_libraries(megbrain_test gtest) -target_link_libraries(megbrain_test megbrain) +target_link_libraries(megbrain_test megengine) if(CXX_SUPPORT_WCLASS_MEMACCESS) if(MGE_WITH_CUDA) target_compile_options(megbrain_test PRIVATE "$<$:-Xcompiler=-Wno-class-memaccess>" @@ -31,4 +31,6 @@ if(UNIX) target_link_libraries(megbrain_test dl rt) endif() -install(TARGETS megbrain_test RUNTIME DESTINATION test) +if (MGE_WITH_DISTRIBUTED) + target_link_libraries(megbrain_test megray) +endif()