Skip to content

GitLab

"vscode:/vscode.git/clone" did not exist on "781cacd2e60ffbf358aaeeeee315a9b9d69c43a6"
Commit 21d47d0e authored by yuguo's avatar yuguo
Browse files

Oneflow 0.8 for DCU

parents
Hide whitespace changes
Inline Side-by-side
Showing with 2228 additions and 0 deletions
cmake/caches/international/cuda.cmake 0 → 100644
View file @ 21d47d0e
set(BUILD_CUDA YES CACHE BOOL "")
set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "")
cmake/cuda.cmake 0 → 100644
View file @ 21d47d0e
option(CUDA_STATIC "" ON)
if(BUILD_CUDA)
if((NOT CUDA_STATIC) OR BUILD_SHARED_LIBS)
set(OF_CUDA_LINK_DYNAMIC_LIBRARY ON)
else()
set(OF_CUDA_LINK_DYNAMIC_LIBRARY OFF)
endif()
if(DEFINED CUDA_TOOLKIT_ROOT_DIR)
message(WARNING "CUDA_TOOLKIT_ROOT_DIR is deprecated, use CUDAToolkit_ROOT instead")
set(CUDAToolkit_ROOT ${CUDA_TOOLKIT_ROOT_DIR})
endif(DEFINED CUDA_TOOLKIT_ROOT_DIR)
find_package(CUDAToolkit REQUIRED)
message(STATUS "CUDAToolkit_FOUND: ${CUDAToolkit_FOUND}")
message(STATUS "CUDAToolkit_VERSION: ${CUDAToolkit_VERSION}")
message(STATUS "CUDAToolkit_VERSION_MAJOR: ${CUDAToolkit_VERSION_MAJOR}")
message(STATUS "CUDAToolkit_VERSION_MINOR: ${CUDAToolkit_VERSION_MINOR}")
message(STATUS "CUDAToolkit_VERSION_PATCH: ${CUDAToolkit_VERSION_PATCH}")
message(STATUS "CUDAToolkit_BIN_DIR: ${CUDAToolkit_BIN_DIR}")
message(STATUS "CUDAToolkit_INCLUDE_DIRS: ${CUDAToolkit_INCLUDE_DIRS}")
message(STATUS "CUDAToolkit_LIBRARY_DIR: ${CUDAToolkit_LIBRARY_DIR}")
message(STATUS "CUDAToolkit_LIBRARY_ROOT: ${CUDAToolkit_LIBRARY_ROOT}")
message(STATUS "CUDAToolkit_TARGET_DIR: ${CUDAToolkit_TARGET_DIR}")
message(STATUS "CUDAToolkit_NVCC_EXECUTABLE: ${CUDAToolkit_NVCC_EXECUTABLE}")
if(CUDA_NVCC_GENCODES)
message(FATAL_ERROR "CUDA_NVCC_GENCODES is deprecated, use CMAKE_CUDA_ARCHITECTURES instead")
endif()
add_definitions(-DWITH_CUDA)
# NOTE: For some unknown reason, CUDAToolkit_VERSION may become empty when running cmake again
set(CUDA_VERSION ${CUDAToolkit_VERSION} CACHE STRING "")
if(NOT CUDA_VERSION)
message(FATAL_ERROR "CUDA_VERSION empty")
endif()
message(STATUS "CUDA_VERSION: ${CUDA_VERSION}")
if(OF_CUDA_LINK_DYNAMIC_LIBRARY)
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::cublas)
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::curand)
if(CUDA_VERSION VERSION_GREATER_EQUAL "10.1")
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::cublasLt)
endif()
if(CUDA_VERSION VERSION_GREATER_EQUAL "10.2")
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::nvjpeg)
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::nppc)
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::nppig)
endif()
else()
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::cublas_static)
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::curand_static)
if(CUDA_VERSION VERSION_GREATER_EQUAL "10.1")
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::cublasLt_static)
endif()
if(CUDA_VERSION VERSION_GREATER_EQUAL "10.2")
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::nvjpeg_static)
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::nppig_static)
# Must put nppc_static after nppig_static in CUDA 10.2
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::nppc_static)
list(APPEND VENDOR_CUDA_LIBRARIES CUDA::culibos)
endif()
endif()
message(STATUS "VENDOR_CUDA_LIBRARIES: ${VENDOR_CUDA_LIBRARIES}")
# add a cache entry if want to use a ccache/sccache wrapped nvcc
set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE} CACHE STRING "")
message(STATUS "CMAKE_CUDA_COMPILER: ${CMAKE_CUDA_COMPILER}")
set(CMAKE_CUDA_STANDARD 14)
find_package(CUDNN REQUIRED)
endif()
cmake/functional.cmake 0 → 100644
View file @ 21d47d0e
function(GENERATE_FUNCTIONAL_API_AND_PYBIND11_CPP SRCS HDRS PYBIND_SRCS ROOT_DIR)
set(YAML_FILE ${PROJECT_SOURCE_DIR}/oneflow/core/functional/functional_api.yaml)
set(GENERATED_API_DIR oneflow/core/functional)
list(APPEND SRCS ${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/functional_api.yaml.cpp)
list(APPEND HDRS ${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/functional_api.yaml.h)
if(BUILD_PYTHON)
set(GENERATED_PYBIND_DIR oneflow/api/python/functional)
list(APPEND PYBIND_SRCS
${PROJECT_BINARY_DIR}/${GENERATED_PYBIND_DIR}/functional_api.yaml.pybind.cpp)
endif(BUILD_PYTHON)
if(BUILD_PYTHON)
add_custom_command(
OUTPUT "${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/functional_api.yaml.cpp"
"${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/functional_api.yaml.h"
"${PROJECT_BINARY_DIR}/${GENERATED_PYBIND_DIR}/functional_api.yaml.pybind.cpp"
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_API_DIR}
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_PYBIND_DIR}
COMMAND ${CODEGEN_PYTHON_EXECUTABLE} ARGS
${PROJECT_SOURCE_DIR}/tools/functional/generate_functional_api.py --project_source_dir
${PROJECT_SOURCE_DIR} --export_pybind
DEPENDS ${CODEGEN_PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/tools/functional/generate_functional_api.py
${PROJECT_SOURCE_DIR}/tools/functional/generator.py ${YAML_FILE}
VERBATIM)
else() # build_python
add_custom_command(
OUTPUT "${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/functional_api.yaml.cpp"
"${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/functional_api.yaml.h"
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_API_DIR}
COMMAND ${CODEGEN_PYTHON_EXECUTABLE} ARGS
${PROJECT_SOURCE_DIR}/tools/functional/generate_functional_api.py --project_source_dir
${PROJECT_SOURCE_DIR}
DEPENDS ${CODEGEN_PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/tools/functional/generate_functional_api.py
${PROJECT_SOURCE_DIR}/tools/functional/generator.py ${YAML_FILE}
VERBATIM)
endif(BUILD_PYTHON)
set_source_files_properties(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
set(${SRCS} ${${SRCS}} PARENT_SCOPE)
set(${HDRS} ${${HDRS}} PARENT_SCOPE)
if(BUILD_PYTHON)
set_source_files_properties(${${PYBIND_SRCS}} PROPERTIES GENERATED TRUE)
set(${PYBIND_SRCS} ${${PYBIND_SRCS}} PARENT_SCOPE)
endif(BUILD_PYTHON)
endfunction()
function(GENERATE_FUNCTIONAL_TENSOR_API_AND_PYBIND11_CPP SRCS HDRS PYBIND_SRCS ROOT_DIR)
set(YAML_FILE ${PROJECT_SOURCE_DIR}/oneflow/api/python/functional/tensor_api.yaml)
set(GENERATED_API_DIR oneflow/api/python/functional)
set(GENERATED_PYBIND_DIR oneflow/api/python/functional)
list(APPEND SRCS ${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/tensor_api.yaml.cpp)
list(APPEND HDRS ${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/tensor_api.yaml.h)
list(APPEND PYBIND_SRCS ${PROJECT_BINARY_DIR}/${GENERATED_PYBIND_DIR}/tensor_api.yaml.pybind.cpp)
add_custom_command(
OUTPUT "${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/tensor_api.yaml.cpp"
"${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/tensor_api.yaml.h"
"${PROJECT_BINARY_DIR}/${GENERATED_PYBIND_DIR}/tensor_api.yaml.pybind.cpp"
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_API_DIR}
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_PYBIND_DIR}
COMMAND ${CODEGEN_PYTHON_EXECUTABLE} ARGS
${PROJECT_SOURCE_DIR}/tools/functional/generate_tensor_api.py --project_source_dir
${PROJECT_SOURCE_DIR}
DEPENDS ${CODEGEN_PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/tools/functional/generate_tensor_api.py
${PROJECT_SOURCE_DIR}/tools/functional/generator.py ${YAML_FILE}
VERBATIM)
set_source_files_properties(${${SRCS}} ${${HDRS}} ${${PYBIND_SRCS}} PROPERTIES GENERATED TRUE)
set(${SRCS} ${${SRCS}} PARENT_SCOPE)
set(${HDRS} ${${HDRS}} PARENT_SCOPE)
set(${PYBIND_SRCS} ${${PYBIND_SRCS}} PARENT_SCOPE)
endfunction()
function(GENERATE_FUNCTIONAL_DISPATCH_STATEFUL_OPS_AND_PYBIND11_CPP SRCS HDRS PYBIND_SRCS ROOT_DIR)
set(YAML_FILE ${PROJECT_SOURCE_DIR}/oneflow/api/python/functional/dispatch_stateful_ops.yaml)
set(GENERATED_API_DIR oneflow/api/python/functional)
set(GENERATED_PYBIND_DIR oneflow/api/python/functional)
list(APPEND SRCS ${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/dispatch_stateful_ops.yaml.cpp)
list(APPEND HDRS ${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/dispatch_stateful_ops.yaml.h)
list(APPEND PYBIND_SRCS
${PROJECT_BINARY_DIR}/${GENERATED_PYBIND_DIR}/dispatch_stateful_ops.yaml.pybind.cpp)
add_custom_command(
OUTPUT "${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/dispatch_stateful_ops.yaml.cpp"
"${PROJECT_BINARY_DIR}/${GENERATED_API_DIR}/dispatch_stateful_ops.yaml.h"
"${PROJECT_BINARY_DIR}/${GENERATED_PYBIND_DIR}/dispatch_stateful_ops.yaml.pybind.cpp"
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_API_DIR}
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_PYBIND_DIR}
COMMAND ${CODEGEN_PYTHON_EXECUTABLE} ARGS
${PROJECT_SOURCE_DIR}/tools/functional/generate_dispatch_stateful_ops.py
--project_source_dir ${PROJECT_SOURCE_DIR}
DEPENDS ${CODEGEN_PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/tools/functional/generate_dispatch_stateful_ops.py
${PROJECT_SOURCE_DIR}/tools/functional/generator.py ${YAML_FILE}
VERBATIM)
set_source_files_properties(${${SRCS}} ${${HDRS}} ${${PYBIND_SRCS}} PROPERTIES GENERATED TRUE)
set(${SRCS} ${${SRCS}} PARENT_SCOPE)
set(${HDRS} ${${HDRS}} PARENT_SCOPE)
set(${PYBIND_SRCS} ${${PYBIND_SRCS}} PARENT_SCOPE)
endfunction()
cmake/git_version.cmake 0 → 100644
View file @ 21d47d0e
cmake_minimum_required(VERSION 3.5)
execute_process(
COMMAND git describe --tags --always --dirty=-snapshot
WORKING_DIRECTORY ${OF_GIT_VERSION_ROOT}
OUTPUT_VARIABLE GIT_REV
ERROR_QUIET)
if(("${GIT_REV}" STREQUAL "") OR (NOT BUILD_GIT_VERSION))
set(GIT_REV "N/A")
else()
string(STRIP "${GIT_REV}" GIT_REV)
endif()
set(VERSION_FILE_CONTENT
"namespace oneflow {\n\
\n\
const char* GetOneFlowGitVersion() {\n\
return \"${GIT_REV}\";\n\
}\n\
\n\
}\n")
if(EXISTS ${OF_GIT_VERSION_FILE})
file(READ ${OF_GIT_VERSION_FILE} VERSION_FILE_CONTENT_)
else()
set(VERSION_FILE_CONTENT_ "")
endif()
if(NOT "${VERSION_FILE_CONTENT}" STREQUAL "${VERSION_FILE_CONTENT_}")
file(WRITE ${OF_GIT_VERSION_FILE} "${VERSION_FILE_CONTENT}")
endif()
cmake/oneflow-config.cmake 0 → 100644
View file @ 21d47d0e
if(DEFINED ENV{ONEFLOW_INSTALL_PREFIX})
set(ONEFLOW_INSTALL_PREFIX $ENV{ONEFLOW_INSTALL_PREFIX})
else()
get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
get_filename_component(ONEFLOW_INSTALL_PREFIX "${CMAKE_CURRENT_LIST_DIR}/../" ABSOLUTE)
endif()
set(ONEFLOW_INCLUDE_DIRS ${ONEFLOW_INSTALL_PREFIX}/include)
find_library(ONEFLOW_LIBRARY NAMES oneflow_cpp PATHS ${ONEFLOW_INSTALL_PREFIX}/lib REQUIRED)
if(NOT TARGET OneFlow::liboneflow)
add_library(OneFlow::liboneflow INTERFACE IMPORTED)
set_property(TARGET OneFlow::liboneflow PROPERTY INTERFACE_LINK_LIBRARIES ${ONEFLOW_LIBRARY})
set_property(TARGET OneFlow::liboneflow PROPERTY INTERFACE_INCLUDE_DIRECTORIES
${ONEFLOW_INCLUDE_DIRS})
endif()
cmake/oneflow.cmake 0 → 100644
View file @ 21d47d0e
include(python)
function(oneflow_add_executable)
add_executable(${ARGV})
set_compile_options_to_oneflow_target(${ARGV0})
endfunction()
function(oneflow_add_library)
add_library(${ARGV})
set_compile_options_to_oneflow_target(${ARGV0})
endfunction()
# source_group
if(WIN32)
set(oneflow_platform "windows")
list(APPEND oneflow_platform_excludes "linux")
else()
set(oneflow_platform "linux")
list(APPEND oneflow_platform_excludes "windows")
endif()
file(GLOB_RECURSE oneflow_all_hdr_to_be_expanded "${PROJECT_SOURCE_DIR}/oneflow/core/*.e.h"
"${PROJECT_SOURCE_DIR}/oneflow/python/*.e.h")
foreach(oneflow_hdr_to_be_expanded ${oneflow_all_hdr_to_be_expanded})
file(RELATIVE_PATH of_ehdr_rel_path ${PROJECT_SOURCE_DIR} ${oneflow_hdr_to_be_expanded})
set(of_e_h_expanded "${PROJECT_BINARY_DIR}/${of_ehdr_rel_path}.expanded.h")
if(WIN32)
error("Expanding macro in WIN32 is not supported yet")
else()
add_custom_command(
OUTPUT ${of_e_h_expanded}
COMMAND ${CMAKE_C_COMPILER} ARGS -E -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}" -o
"${of_e_h_expanded}" "${oneflow_hdr_to_be_expanded}"
DEPENDS ${oneflow_hdr_to_be_expanded}
COMMENT "Expanding macros in ${oneflow_hdr_to_be_expanded}")
list(APPEND oneflow_all_hdr_expanded "${of_e_h_expanded}")
endif()
set_source_files_properties(${oneflow_all_hdr_expanded} PROPERTIES GENERATED TRUE)
endforeach()
file(
GLOB_RECURSE
oneflow_all_src
"${PROJECT_SOURCE_DIR}/oneflow/core/*.*"
"${PROJECT_SOURCE_DIR}/oneflow/user/*.*"
"${PROJECT_SOURCE_DIR}/oneflow/api/*.*"
"${PROJECT_SOURCE_DIR}/oneflow/maybe/*.*"
"${PROJECT_SOURCE_DIR}/oneflow/extension/python/*.*")
foreach(oneflow_single_file ${oneflow_all_src})
# Verify whether this file is for other platforms
set(exclude_this OFF)
set(group_this OFF)
foreach(oneflow_platform_exclude ${oneflow_platform_excludes})
string(FIND ${oneflow_single_file} ${oneflow_platform_exclude} platform_found)
if(NOT ${platform_found} EQUAL -1) # the ${oneflow_single_file} is for other platforms
set(exclude_this ON)
endif()
endforeach()
# If this file is for other platforms, just exclude it from current project
if(exclude_this)
continue()
endif()
if("${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/(core|user|maybe)/.*\\.(h|hpp)$")
if((NOT RPC_BACKEND MATCHES "GRPC") AND "${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/core/control/.*")
# skip if GRPC not enabled
elseif(APPLE AND "${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/core/comm_network/(epoll|ibverbs)/.*")
# skip if macOS
else()
list(APPEND of_all_obj_cc ${oneflow_single_file})
set(group_this ON)
endif()
endif()
if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user)/.*\\.(cuh|cu)$")
if(BUILD_CUDA)
list(APPEND of_all_obj_cc ${oneflow_single_file})
endif()
set(group_this ON)
endif()
if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user)/.*\\.proto$")
list(APPEND of_all_proto ${oneflow_single_file})
#list(APPEND of_all_obj_cc ${oneflow_single_file}) # include the proto file in the project
set(group_this ON)
endif()
if(BUILD_PYTHON)
if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/api/python/.*\\.(h|cpp)$")
list(APPEND of_pybind_obj_cc ${oneflow_single_file})
set(group_this ON)
endif()
if("${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/extension/python/.*\\.(h|cpp)$")
list(APPEND of_pyext_obj_cc ${oneflow_single_file})
set(group_this ON)
endif()
endif(BUILD_PYTHON)
if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user|maybe)/.*\\.cpp$")
if("${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/(core|user|maybe)/.*_test\\.cpp$")
# test file
list(APPEND of_all_test_cc ${oneflow_single_file})
elseif(APPLE AND "${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/core/comm_network/(epoll|ibverbs)/.*")
# skip if macOS
elseif(APPLE AND "${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/core/transport/.*")
# skip if macOS
elseif((NOT RPC_BACKEND MATCHES "GRPC") AND "${oneflow_single_file}" MATCHES
"^${PROJECT_SOURCE_DIR}/oneflow/core/control.*")
# skip if GRPC not enabled
else()
list(APPEND of_all_obj_cc ${oneflow_single_file})
endif()
set(group_this ON)
endif()
if(group_this)
file(RELATIVE_PATH oneflow_relative_file ${PROJECT_SOURCE_DIR}/oneflow/core/
${oneflow_single_file})
get_filename_component(oneflow_relative_path ${oneflow_relative_file} PATH)
string(REPLACE "/" "\\" group_name ${oneflow_relative_path})
source_group("${group_name}" FILES ${oneflow_single_file})
endif()
endforeach()
# clang format
add_custom_target(
of_format
COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ci/check/run_license_format.py -i
${CMAKE_CURRENT_SOURCE_DIR}/oneflow --fix
COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ci/check/run_license_format.py -i
${ONEFLOW_PYTHON_DIR} --fix --exclude="oneflow/include" --exclude="oneflow/core"
COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ci/check/run_clang_format.py --source_dir
${CMAKE_CURRENT_SOURCE_DIR}/oneflow --fix --quiet
COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ci/check/run_py_format.py --source_dir
${CMAKE_CURRENT_SOURCE_DIR}/python --fix
COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ci/check/run_clang_format.py
--source_dir ${CMAKE_CURRENT_SOURCE_DIR}/tools/oneflow-tblgen --fix --quiet)
# clang tidy
set(RUN_CLANG_TIDY_ARGS --build_dir ${CMAKE_BINARY_DIR})
if(MAYBE_NEED_ERROR_MSG_CHECK)
list(APPEND RUN_CLANG_TIDY_ARGS --check-error-msg)
endif()
message(STATUS "RUN_CLANG_TIDY_ARGS: ${RUN_CLANG_TIDY_ARGS}")
add_custom_target(
of_tidy COMMAND ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/ci/check/run_clang_tidy.py
${RUN_CLANG_TIDY_ARGS} DEPENDS of_git_version oneflow_deps of_functional_obj
of_functional_tensor_obj)
# generate version
set(OF_GIT_VERSION_DIR ${CMAKE_CURRENT_BINARY_DIR}/of_git_version)
set(OF_GIT_VERSION_FILE ${OF_GIT_VERSION_DIR}/version.cpp)
set(OF_GIT_VERSION_DUMMY_FILE ${OF_GIT_VERSION_DIR}/_version.cpp)
add_custom_target(of_git_version_create_dir COMMAND ${CMAKE_COMMAND} -E make_directory
${OF_GIT_VERSION_DIR})
add_custom_command(
OUTPUT ${OF_GIT_VERSION_DUMMY_FILE}
COMMAND ${CMAKE_COMMAND} -DOF_GIT_VERSION_FILE=${OF_GIT_VERSION_FILE}
-DOF_GIT_VERSION_ROOT=${PROJECT_SOURCE_DIR} -DBUILD_GIT_VERSION=${BUILD_GIT_VERSION} -P
${CMAKE_CURRENT_SOURCE_DIR}/cmake/git_version.cmake
DEPENDS of_git_version_create_dir)
add_custom_target(of_git_version DEPENDS ${OF_GIT_VERSION_DUMMY_FILE})
set_source_files_properties(${OF_GIT_VERSION_FILE} PROPERTIES GENERATED TRUE)
list(APPEND of_all_obj_cc ${OF_GIT_VERSION_FILE})
set(of_proto_python_dir "${PROJECT_BINARY_DIR}/of_proto_python")
# proto obj lib
add_custom_target(make_pyproto_dir ALL COMMAND ${CMAKE_COMMAND} -E make_directory
${of_proto_python_dir})
foreach(proto_name ${of_all_proto})
file(RELATIVE_PATH proto_rel_name ${PROJECT_SOURCE_DIR} ${proto_name})
list(APPEND of_all_rel_protos ${proto_rel_name})
endforeach()
relative_protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS ${PROJECT_SOURCE_DIR} ${of_all_rel_protos})
oneflow_add_library(of_protoobj SHARED ${PROTO_SRCS} ${PROTO_HDRS})
add_dependencies(of_protoobj make_pyproto_dir protobuf)
target_link_libraries(of_protoobj protobuf_imported)
include(functional)
generate_functional_api_and_pybind11_cpp(FUNCTIONAL_GENERATED_SRCS FUNCTIONAL_GENERATED_HRCS
FUNCTIONAL_PYBIND11_SRCS ${PROJECT_SOURCE_DIR})
oneflow_add_library(of_functional_obj STATIC ${FUNCTIONAL_GENERATED_SRCS}
${FUNCTIONAL_GENERATED_HRCS})
target_link_libraries(of_functional_obj LLVMSupportWithHeader glog::glog)
add_dependencies(of_functional_obj prepare_oneflow_third_party)
if(BUILD_PYTHON)
generate_functional_tensor_api_and_pybind11_cpp(
FUNCTIONAL_TENSOR_GENERATED_SRCS FUNCTIONAL_TENSOR_GENERATED_HRCS
FUNCTIONAL_TENSOR_PYBIND11_SRCS ${PROJECT_SOURCE_DIR})
generate_functional_dispatch_stateful_ops_and_pybind11_cpp(
FUNCTIONAL_OPS_GENERATED_SRCS FUNCTIONAL_OPS_GENERATED_HRCS FUNCTIONAL_OPS_PYBIND11_SRCS
${PROJECT_SOURCE_DIR})
oneflow_add_library(
of_functional_tensor_obj STATIC ${FUNCTIONAL_TENSOR_GENERATED_SRCS}
${FUNCTIONAL_TENSOR_GENERATED_HRCS} ${FUNCTIONAL_OPS_GENERATED_SRCS}
${FUNCTIONAL_OPS_GENERATED_HRCS})
target_link_libraries(of_functional_tensor_obj LLVMSupportWithHeader glog::glog)
add_dependencies(of_functional_tensor_obj prepare_oneflow_third_party)
target_include_directories(of_functional_tensor_obj PRIVATE ${Python_INCLUDE_DIRS}
${Python_NumPy_INCLUDE_DIRS})
set(PYBIND11_SRCS ${FUNCTIONAL_PYBIND11_SRCS} ${FUNCTIONAL_TENSOR_PYBIND11_SRCS}
${FUNCTIONAL_OPS_PYBIND11_SRCS})
endif(BUILD_PYTHON)
include_directories(${PROJECT_SOURCE_DIR}) # TO FIND: third_party/eigen3/..
include_directories(${PROJECT_BINARY_DIR})
# cc obj lib
oneflow_add_library(oneflow SHARED ${of_all_obj_cc})
add_dependencies(oneflow of_protoobj)
add_dependencies(oneflow of_functional_obj)
add_dependencies(oneflow of_op_schema)
add_dependencies(oneflow of_git_version)
if(USE_CLANG_FORMAT)
add_dependencies(oneflow of_format)
endif()
if(USE_CLANG_TIDY)
add_dependencies(oneflow of_tidy)
endif()
target_compile_definitions(oneflow PRIVATE GOOGLE_LOGGING)
set(ONEFLOW_TOOLS_DIR "${PROJECT_BINARY_DIR}/tools"
CACHE STRING "dir to put binary for debugging and development")
# clean cache for last LLVM version
if("${LLVM_MONO_REPO_URL}" STREQUAL
"https://github.com/llvm/llvm-project/archive/c63522e6ba7782c335043893ae7cbd37eca24fe5.zip"
OR "${LLVM_MONO_REPO_URL}" STREQUAL
"https://github.com/llvm/llvm-project/archive/a0595f8c99a253c65f30a151337e7aadc19ee3a1.zip"
OR "${LLVM_MONO_REPO_URL}" STREQUAL
"https://github.com/llvm/llvm-project/archive/7eaa84eac3ba935d13f4267d3d533a6c3e1283ed.zip"
OR "${LLVM_MONO_REPO_URL}" STREQUAL
"https://github.com/llvm/llvm-project/archive/35e60f5de180aea55ed478298f4b40f04dcc57d1.zip"
OR "${LLVM_MONO_REPO_URL}" STREQUAL
"https://github.com/llvm/llvm-project/archive/6a9bbd9f20dcd700e28738788bb63a160c6c088c.zip"
OR "${LLVM_MONO_REPO_URL}" STREQUAL
"https://github.com/llvm/llvm-project/archive/32805e60c9de1f82887cd2af30d247dcabd2e1d3.zip"
OR "${LLVM_MONO_REPO_MD5}" STREQUAL "f2f17229cf21049663b8ef4f2b6b8062"
OR "${LLVM_MONO_REPO_MD5}" STREQUAL "6b7c6506d5922de9632c8ff012b2f945"
OR "${LLVM_MONO_REPO_MD5}" STREQUAL "e0ea669a9f0872d35bffda5ec6c5ac6f"
OR "${LLVM_MONO_REPO_MD5}" STREQUAL "241a333828bba1efa35aff4c4fc2ce87"
OR "${LLVM_MONO_REPO_MD5}" STREQUAL "075fbfdf06cb3f02373ea44971af7b03"
OR "${LLVM_MONO_REPO_MD5}" STREQUAL "e412dc61159b5e929b0c94e44b11feb2")
unset(LLVM_MONO_REPO_URL CACHE)
unset(LLVM_MONO_REPO_MD5 CACHE)
endif()
set(LLVM_MONO_REPO_URL
"https://github.com/llvm/llvm-project/archive/6d6268dcbf0f48e43f6f9fe46b3a28c29ba63c7d.zip"
CACHE STRING "")
use_mirror(VARIABLE LLVM_MONO_REPO_URL URL ${LLVM_MONO_REPO_URL})
set(LLVM_MONO_REPO_MD5 "334997b4879aba15d9323a732356cf2a" CACHE STRING "")
set(ONEFLOW_BUILD_ROOT_DIR "${PROJECT_BINARY_DIR}")
add_subdirectory(${PROJECT_SOURCE_DIR}/oneflow/ir)
if(WITH_MLIR)
set(ONEFLOW_MLIR_LIBS -Wl,--no-as-needed MLIROneFlowExtension -Wl,--as-needed)
endif()
if("${LLVM_PROVIDER}" STREQUAL "install")
get_property(LLVM_INSTALL_DIR GLOBAL PROPERTY LLVM_INSTALL_DIR)
check_variable_defined(LLVM_INSTALL_DIR)
find_library(LLVMSupportLib LLVMSupport PATHS ${LLVM_INSTALL_DIR}/lib REQUIRED)
add_library(LLVMSupportWithHeader UNKNOWN IMPORTED)
set_property(TARGET LLVMSupportWithHeader PROPERTY IMPORTED_LOCATION ${LLVMSupportLib})
else()
add_library(LLVMSupportWithHeader INTERFACE IMPORTED)
target_link_libraries(LLVMSupportWithHeader INTERFACE LLVMSupport)
endif()
check_variable_defined(LLVM_INCLUDE_DIRS)
set_property(TARGET LLVMSupportWithHeader PROPERTY INTERFACE_INCLUDE_DIRECTORIES
${LLVM_INCLUDE_DIRS})
list(APPEND oneflow_third_party_libs LLVMSupportWithHeader)
include(op_schema)
get_property(EXTERNAL_TARGETS GLOBAL PROPERTY EXTERNAL_TARGETS)
if(APPLE)
set(of_libs -Wl,-force_load oneflow of_op_schema)
target_link_libraries(oneflow of_protoobj of_functional_obj ${oneflow_third_party_libs})
elseif(UNIX)
set(of_libs -Wl,--whole-archive oneflow of_op_schema -Wl,--no-whole-archive -ldl -lrt)
target_link_libraries(
oneflow
of_protoobj
of_functional_obj
${oneflow_third_party_libs}
${EXTERNAL_TARGETS}
-Wl,--no-whole-archive
-ldl
-lrt
-Wl,--version-script ${PROJECT_SOURCE_DIR}/version_script.lds)
if(BUILD_CUDA)
target_link_libraries(oneflow CUDA::cudart_static)
endif()
elseif(WIN32)
set(of_libs oneflow of_protoobj of_functional_obj of_op_schema)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /WHOLEARCHIVE:oneflow")
endif()
# oneflow api common
if(BUILD_PYTHON OR BUILD_CPP_API)
file(GLOB_RECURSE of_api_common_files ${PROJECT_SOURCE_DIR}/oneflow/api/common/*.h
${PROJECT_SOURCE_DIR}/oneflow/api/common/*.cpp)
oneflow_add_library(of_api_common OBJECT ${of_api_common_files})
target_link_libraries(of_api_common oneflow)
if(WITH_MLIR)
target_link_libraries(of_api_common ${ONEFLOW_MLIR_LIBS})
endif()
endif()
if(BUILD_PYTHON)
# py ext lib
# This library should be static to make sure all python symbols are included in the final ext shared lib,
# so that it is safe to do wheel audits of multiple pythons version in parallel.
oneflow_add_library(of_pyext_obj STATIC ${of_pyext_obj_cc})
target_include_directories(of_pyext_obj PRIVATE ${Python_INCLUDE_DIRS}
${Python_NumPy_INCLUDE_DIRS})
target_link_libraries(of_pyext_obj oneflow pybind11::headers)
if(BUILD_SHARED_LIBS AND APPLE)
target_link_libraries(of_pyext_obj ${Python3_LIBRARIES})
endif()
add_dependencies(of_pyext_obj oneflow)
pybind11_add_module(oneflow_internal ${PYBIND11_SRCS} ${of_pybind_obj_cc} ${PYBIND_REGISTRY_CC})
set_compile_options_to_oneflow_target(oneflow_internal)
set_property(TARGET oneflow_internal PROPERTY CXX_VISIBILITY_PRESET "default")
add_dependencies(oneflow_internal of_functional_obj of_functional_tensor_obj of_op_schema)
set_target_properties(oneflow_internal PROPERTIES PREFIX "_")
set_target_properties(oneflow_internal PROPERTIES LIBRARY_OUTPUT_DIRECTORY
"${ONEFLOW_PYTHON_DIR}/oneflow")
target_link_libraries(
oneflow_internal PRIVATE ${of_libs} of_functional_tensor_obj of_api_common
${oneflow_third_party_libs} of_pyext_obj glog::glog)
target_include_directories(oneflow_internal PRIVATE ${Python_INCLUDE_DIRS}
${Python_NumPy_INCLUDE_DIRS})
target_compile_definitions(oneflow_internal PRIVATE ONEFLOW_CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE})
if(WITH_MLIR)
add_dependencies(check-oneflow oneflow_internal)
endif(WITH_MLIR)
set(gen_pip_args "")
if(BUILD_CUDA)
list(APPEND gen_pip_args --cuda=${CUDA_VERSION})
endif()
if(BUILD_ROCM)
list(APPEND gen_pip_args --rocm="DCU_Toolkits")
endif()
add_custom_target(
of_pyscript_copy ALL
COMMAND ${CMAKE_COMMAND} -E touch "${of_proto_python_dir}/oneflow/core/__init__.py"
COMMAND ${CMAKE_COMMAND} -E create_symlink "${of_proto_python_dir}/oneflow/core"
"${ONEFLOW_PYTHON_DIR}/oneflow/core"
COMMAND
${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/tools/generate_pip_version.py ${gen_pip_args}
--src=${PROJECT_SOURCE_DIR} --cmake_project_binary_dir=${PROJECT_BINARY_DIR}
--out=${ONEFLOW_PYTHON_DIR}/oneflow/version.py)
# source this file to add oneflow in PYTHONPATH
file(WRITE "${PROJECT_BINARY_DIR}/source.sh"
"export PYTHONPATH=${ONEFLOW_PYTHON_DIR}:$PYTHONPATH")
add_dependencies(of_pyscript_copy of_protoobj)
endif(BUILD_PYTHON)
if(BUILD_CPP_API)
file(GLOB_RECURSE of_cpp_api_files ${PROJECT_SOURCE_DIR}/oneflow/api/cpp/*.cpp
${PROJECT_SOURCE_DIR}/oneflow/api/cpp/*.h)
list(FILTER of_cpp_api_files EXCLUDE REGEX "oneflow/api/cpp/tests")
oneflow_add_library(oneflow_cpp SHARED ${of_cpp_api_files})
set_target_properties(oneflow_cpp PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${LIBONEFLOW_LIBRARY_DIR}"
LIBRARY_OUTPUT_DIRECTORY "${LIBONEFLOW_LIBRARY_DIR}")
target_link_libraries(oneflow_cpp PRIVATE ${of_libs} of_api_common ${oneflow_third_party_libs})
endif()
file(RELATIVE_PATH PROJECT_BINARY_DIR_RELATIVE ${PROJECT_SOURCE_DIR} ${PROJECT_BINARY_DIR})
function(oneflow_add_test target_name)
cmake_parse_arguments(arg "" "TEST_NAME;WORKING_DIRECTORY" "SRCS" ${ARGN})
oneflow_add_executable(${target_name} ${arg_SRCS})
if(BUILD_CUDA)
target_link_libraries(${target_name} CUDA::cudart_static)
endif()
set_target_properties(${target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY
"${PROJECT_BINARY_DIR}/bin")
add_test(NAME ${arg_TEST_NAME} COMMAND ${target_name} WORKING_DIRECTORY ${arg_WORKING_DIRECTORY})
set_tests_properties(
${arg_TEST_NAME} PROPERTIES ENVIRONMENT
"HTTP_PROXY='';HTTPS_PROXY='';http_proxy='';https_proxy='';")
endfunction()
# build test
if(BUILD_TESTING)
if(of_all_test_cc)
oneflow_add_test(oneflow_testexe SRCS ${of_all_test_cc} TEST_NAME oneflow_test)
target_link_libraries(oneflow_testexe ${of_libs} ${oneflow_third_party_libs} glog::glog
${oneflow_test_libs})
endif()
if(BUILD_CPP_API)
file(GLOB_RECURSE cpp_api_test_files ${PROJECT_SOURCE_DIR}/oneflow/api/cpp/tests/*.cpp)
oneflow_add_test(
oneflow_cpp_api_testexe
SRCS
${cpp_api_test_files}
TEST_NAME
oneflow_cpp_api_test
WORKING_DIRECTORY
${PROJECT_SOURCE_DIR})
find_package(Threads REQUIRED)
target_link_libraries(oneflow_cpp_api_testexe oneflow_cpp ${oneflow_third_party_libs}
${oneflow_test_libs} Threads::Threads)
endif()
endif()
# build include
add_custom_target(of_include_copy ALL)
if(BUILD_PYTHON)
add_dependencies(of_include_copy oneflow_internal of_pyscript_copy)
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/oneflow/core
DESTINATION ${ONEFLOW_INCLUDE_DIR}/oneflow
COMPONENT oneflow_py_include
EXCLUDE_FROM_ALL FILES_MATCHING
PATTERN *.h
PATTERN *.hpp)
install(
DIRECTORY ${CMAKE_SOURCE_DIR}/oneflow
DESTINATION ${ONEFLOW_INCLUDE_DIR}
COMPONENT oneflow_py_include
EXCLUDE_FROM_ALL FILES_MATCHING
REGEX "oneflow/core/common/.+(h|hpp)$"
REGEX "oneflow/core/device/.+(h|hpp)$"
REGEX "oneflow/core/framework/.+(h|hpp)$"
REGEX "oneflow/core/kernel/util/.+(h|hpp)$"
REGEX "oneflow/core/persistence/.+(h|hpp)$"
REGEX "oneflow/core/ep/include/.+(h|hpp)$"
REGEX "oneflow/core/ep/cuda/.+(h|hpp)$"
REGEX "oneflow/core/job/.+(h|hpp)$"
REGEX "oneflow/core/.+(proto)$"
PATTERN "oneflow/core/kernel/new_kernel_util.h"
PATTERN "oneflow/core/kernel/kernel_context.h"
PATTERN "oneflow/core/kernel/kernel_observer.h"
PATTERN "oneflow/core/kernel/kernel_util.cuh"
PATTERN "oneflow/core/common/symbol.h"
PATTERN "oneflow/core/autograd/autograd_meta.h"
PATTERN "oneflow/core/register/blob_desc.h"
PATTERN "oneflow/core/operator/operator.h"
PATTERN "oneflow/core/operator/op_conf_util.h"
PATTERN "oneflow/core/graph/graph.h"
PATTERN "oneflow/core/graph/node.h"
PATTERN "oneflow/core/graph/op_graph.h"
PATTERN "oneflow/core/graph/task_id.h"
PATTERN "oneflow/core/graph/task_id_generator.h"
PATTERN "oneflow/core/graph/stream_id.h"
PATTERN "oneflow/core/vm/vm_sync.h"
PATTERN "oneflow/api" EXCLUDE
PATTERN "oneflow/user" EXCLUDE
PATTERN "oneflow/extension" EXCLUDE
PATTERN "oneflow/maybe" EXCLUDE
PATTERN "oneflow/core/lazy" EXCLUDE
PATTERN "oneflow/core/graph_impl" EXCLUDE
PATTERN "oneflow/core/job_rewriter" EXCLUDE
PATTERN "oneflow/core/hardware" EXCLUDE
PATTERN "oneflow/core/intrusive" EXCLUDE
PATTERN "oneflow/core/stream" EXCLUDE
PATTERN "oneflow/core/functional" EXCLUDE
PATTERN "oneflow/core/platform" EXCLUDE
PATTERN "oneflow/core/boxing" EXCLUDE
PATTERN "oneflow/core/rpc" EXCLUDE
PATTERN "oneflow/core/profiler" EXCLUDE
PATTERN "oneflow/core/transport" EXCLUDE
PATTERN "oneflow/core/comm_network" EXCLUDE
PATTERN "oneflow/ir" EXCLUDE)
add_custom_target(
install_oneflow_py_include
COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=oneflow_py_include -P
"${CMAKE_BINARY_DIR}/cmake_install.cmake" DEPENDS oneflow_internal)
add_custom_target(oneflow_py ALL)
add_dependencies(oneflow_py of_include_copy install_oneflow_py_include)
endif(BUILD_PYTHON)
if(BUILD_CPP_API)
set(LIBONEFLOW_DIR ${PROJECT_BINARY_DIR}/liboneflow_cpp)
install(
DIRECTORY oneflow/api/cpp/
COMPONENT oneflow_cpp_all
DESTINATION include/oneflow
FILES_MATCHING
PATTERN "*.h"
PATTERN "tests" EXCLUDE)
set(LIBONEFLOW_THIRD_PARTY_DIRS)
checkdirandappendslash(DIR ${PROTOBUF_LIBRARY_DIR} OUTPUT PROTOBUF_LIBRARY_DIR_APPENDED)
list(APPEND LIBONEFLOW_THIRD_PARTY_DIRS ${PROTOBUF_LIBRARY_DIR_APPENDED})
if(BUILD_CUDA)
checkdirandappendslash(DIR ${NCCL_LIBRARY_DIR} OUTPUT NCCL_LIBRARY_DIR_APPENDED)
list(APPEND LIBONEFLOW_THIRD_PARTY_DIRS ${NCCL_LIBRARY_DIR_APPENDED})
endif()
install(
DIRECTORY ${LIBONEFLOW_THIRD_PARTY_DIRS}
COMPONENT oneflow_cpp_all
DESTINATION lib
FILES_MATCHING
PATTERN "*.so*"
PATTERN "*.a" EXCLUDE
PATTERN "libprotobuf-lite.so*" EXCLUDE
PATTERN "libprotoc.so*" EXCLUDE
PATTERN "cmake" EXCLUDE
PATTERN "pkgconfig" EXCLUDE)
install(FILES ${PROJECT_SOURCE_DIR}/cmake/oneflow-config.cmake COMPONENT oneflow_cpp_all
DESTINATION share)
get_property(MLIR_RELATED_TARGETS GLOBAL PROPERTY MLIR_EXPORTS)
get_property(LLVM_RELATED_TARGETS GLOBAL PROPERTY LLVM_EXPORTS)
list(
REMOVE_ITEM
LLVM_RELATED_TARGETS
count
not
FileCheck
lli-child-target
llvm-jitlink-executor
llvm-PerfectShuffle
llvm-tblgen
mlir-tblgen
obj2yaml
oneflow_tblgen
yaml-bench
yaml2obj)
set(LIBONEFLOW_TARGETS)
list(
APPEND
LIBONEFLOW_TARGETS
oneflow_cpp
oneflow
of_protoobj
glog
${MLIR_RELATED_TARGETS}
${LLVM_RELATED_TARGETS}
${EXTERNAL_TARGETS})
if(BUILD_TESTING AND BUILD_SHARED_LIBS)
list(APPEND LIBONEFLOW_TARGETS gtest_main gtest)
endif()
if(BUILD_TESTING)
list(APPEND LIBONEFLOW_TARGETS oneflow_cpp_api_testexe)
list(APPEND LIBONEFLOW_TARGETS oneflow_testexe)
endif(BUILD_TESTING)
install(
TARGETS ${LIBONEFLOW_TARGETS}
COMPONENT oneflow_cpp_all
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
RUNTIME DESTINATION bin)
add_custom_target(
install_oneflow_cpp
COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=oneflow_cpp_all
-DCMAKE_INSTALL_PREFIX="${LIBONEFLOW_DIR}" -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
DEPENDS oneflow_cpp)
if(BUILD_TESTING)
add_dependencies(install_oneflow_cpp oneflow_cpp_api_testexe oneflow_testexe)
endif(BUILD_TESTING)
add_dependencies(of_include_copy install_oneflow_cpp)
string(TOLOWER ${CMAKE_SYSTEM_NAME} CPACK_SYSTEM_NAME)
set(CPACK_GENERATOR ZIP)
set(CPACK_PACKAGE_DIRECTORY ${PROJECT_BINARY_DIR}/cpack)
set(CPACK_PACKAGE_NAME liboneflow)
# TODO: by Shenghang, unify python and c++ version genenerating and getting
set(CPACK_PACKAGE_VERSION ${ONEFLOW_CURRENT_VERSION})
set(CPACK_INSTALL_CMAKE_PROJECTS ${PROJECT_BINARY_DIR};oneflow;oneflow_cpp_all;/)
include(CPack)
endif(BUILD_CPP_API)
cmake/op_schema.cmake 0 → 100644
View file @ 21d47d0e
get_property(LLVM_INSTALL_DIR GLOBAL PROPERTY LLVM_INSTALL_DIR)
set(LLVM_INSTALL_DIR ${THIRD_PARTY_DIR}/llvm)
set(LLVM_DIR ${LLVM_INSTALL_DIR}/lib/cmake/llvm)
set(ONEFLOW_OP_GROUPS
"ASSIGN"
"BINARY"
"BROADCAST"
"CONV"
"CROSS_ENTROPY"
"CUDA"
"DATASET"
"DETECTION"
"EAGER"
"FUSED"
"IDEMPOTENT"
"IDENTITY"
"IMAGE"
"INDICES"
"INVOLUTION"
"LOSS"
"MATH"
"MATMUL"
"MISC"
"NCCL"
"NORMALIZATION"
"OPTIMIZER"
"PADDING"
"PARALLEL_CAST"
"POOL"
"QUANTIZATION"
"REDUCE"
"RESHAPE"
"SCALAR"
"SOFTMAX"
"SUMMARY"
"TENSOR_BUFFER"
"TEST"
"TRIGONOMETRIC"
"UNARY"
"UPSAMPLE"
"ONE_EMBEDDING")
foreach(OP_GROUP_NAME IN LISTS ONEFLOW_OP_GROUPS)
list(APPEND ONEFLOW_SCHEMA_TABLEGEN_FLAGS "-DGET_ONEFLOW_${OP_GROUP_NAME}_OP_DEFINITIONS")
endforeach()
list(APPEND ONEFLOW_SCHEMA_TABLEGEN_FLAGS "-DREMOVE_ONEFLOW_MLIR_ONLY_OP_DEFINITIONS")
set(GENERATED_OP_SCHEMA_DIR oneflow/core/framework)
set(GENERATED_IR_INCLUDE_DIR oneflow/ir/include)
set(SOURCE_IR_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/oneflow/ir/include)
set(ONEFLOW_ODS ${SOURCE_IR_INCLUDE_DIR}/OneFlow/OneFlowOps.td)
list(APPEND ONEFLOW_SCHEMA_TABLEGEN_FLAGS "-I${GENERATED_IR_INCLUDE_DIR}")
list(APPEND ONEFLOW_SCHEMA_TABLEGEN_FLAGS "-I${SOURCE_IR_INCLUDE_DIR}")
list(APPEND ONEFLOW_SCHEMA_TABLEGEN_FLAGS "-I${LLVM_INSTALL_DIR}/include")
set(GENERATED_OP_SCHEMA_H "${GENERATED_OP_SCHEMA_DIR}/op_generated.h")
set(GENERATED_OP_SCHEMA_CPP "${GENERATED_OP_SCHEMA_DIR}/op_generated.cpp")
set(ONEFLOW_TABLE_GEN_EXE ${LLVM_INSTALL_DIR}/bin/oneflow_tblgen)
if(LLVM_PROVIDER STREQUAL "in-tree")
set(ONEFLOW_TABLE_GEN_TARGET oneflow_tblgen install-oneflow-tblgen install-mlir-headers)
elseif(LLVM_PROVIDER STREQUAL "install")
set(ONEFLOW_TABLE_GEN_TARGET ${ONEFLOW_TABLE_GEN_EXE})
endif()
file(GLOB_RECURSE ODS_FILES LIST_DIRECTORIES false "${SOURCE_IR_INCLUDE_DIR}/*.td")
if(NOT ODS_FILES)
message(FATAL_ERROR "ODS_FILES not found: ${ODS_FILES}")
endif()
add_custom_command(
OUTPUT ${GENERATED_OP_SCHEMA_H} ${GENERATED_OP_SCHEMA_CPP}
COMMAND ${CMAKE_COMMAND} ARGS -E make_directory ${GENERATED_OP_SCHEMA_DIR}
COMMAND ${ONEFLOW_TABLE_GEN_EXE} ARGS --gen-op-schema-h ${ONEFLOW_ODS}
${ONEFLOW_SCHEMA_TABLEGEN_FLAGS} -o ${GENERATED_OP_SCHEMA_H}
COMMAND ${ONEFLOW_TABLE_GEN_EXE} ARGS --gen-op-schema-cpp ${ONEFLOW_ODS}
${ONEFLOW_SCHEMA_TABLEGEN_FLAGS} --op-include ${GENERATED_OP_SCHEMA_H} -o
${GENERATED_OP_SCHEMA_CPP}
DEPENDS ${ONEFLOW_TABLE_GEN_TARGET} ${ODS_FILES}
VERBATIM)
set_source_files_properties(${GENERATED_OP_SCHEMA_H} ${GENERATED_OP_SCHEMA_CPP} PROPERTIES GENERATED
TRUE)
oneflow_add_library(of_op_schema OBJECT ${GENERATED_OP_SCHEMA_H} ${GENERATED_OP_SCHEMA_CPP})
target_link_libraries(of_op_schema LLVMSupportWithHeader glog::glog)
add_dependencies(of_op_schema prepare_oneflow_third_party)
cmake/proto2cpp.cmake 0 → 100644
View file @ 21d47d0e
function(RELATIVE_PROTOBUF_GENERATE_CPP SRCS HDRS ROOT_DIR)
if(NOT ARGN)
message(SEND_ERROR "Error: RELATIVE_PROTOBUF_GENERATE_CPP() called without any proto files")
return()
endif()
set(${SRCS})
set(${HDRS})
foreach(FIL ${ARGN})
set(ABS_FIL ${ROOT_DIR}/${FIL})
get_filename_component(FIL_WE ${FIL} NAME_WE)
get_filename_component(FIL_DIR ${ABS_FIL} PATH)
file(RELATIVE_PATH REL_DIR ${ROOT_DIR} ${FIL_DIR})
list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${REL_DIR}/${FIL_WE}.pb.cc")
list(APPEND ${HDRS} "${CMAKE_CURRENT_BINARY_DIR}/${REL_DIR}/${FIL_WE}.pb.h")
add_custom_command(
OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${REL_DIR}/${FIL_WE}.pb.cc"
"${CMAKE_CURRENT_BINARY_DIR}/${REL_DIR}/${FIL_WE}.pb.h"
"${of_proto_python_dir}/${REL_DIR}/${FIL_WE}_pb2.py"
COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} ARGS --cpp_out ${CMAKE_CURRENT_BINARY_DIR} -I
${ROOT_DIR} ${ABS_FIL} -I ${PROTOBUF_INCLUDE_DIR}
COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} ARGS --python_out ${of_proto_python_dir} -I ${ROOT_DIR}
${ABS_FIL} -I ${PROTOBUF_INCLUDE_DIR}
COMMAND ${CMAKE_COMMAND} ARGS -E touch ${of_proto_python_dir}/${REL_DIR}/__init__.py
DEPENDS ${ABS_FIL} protobuf
COMMENT "Running Protocol Buffer Compiler on ${FIL}"
VERBATIM)
endforeach()
set_source_files_properties(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
set(${SRCS} ${${SRCS}} PARENT_SCOPE)
set(${HDRS} ${${HDRS}} PARENT_SCOPE)
endfunction()
cmake/pybind11.cmake 0 → 100644
View file @ 21d47d0e
include(FetchContent)
set_mirror_url_with_hash(PYBIND11_URL https://github.com/pybind/pybind11/archive/v2.7.0.zip
267807f790ef598ef912a79aceefdc10)
FetchContent_Declare(pybind11 URL ${PYBIND11_URL} URL_HASH MD5=${PYBIND11_URL_HASH})
FetchContent_MakeAvailable(pybind11)
cmake/python.cmake 0 → 100644
View file @ 21d47d0e
if(NOT DEFINED Python3_EXECUTABLE)
execute_process(
COMMAND which python3
RESULT_VARIABLE STATUS
OUTPUT_VARIABLE OUTPUT
ERROR_QUIET)
if(STATUS EQUAL 0)
string(STRIP ${OUTPUT} STRIPPED)
message(STATUS "Using Python3 from 'which python3': ${STRIPPED}")
set(Python3_EXECUTABLE ${STRIPPED})
endif()
endif()
find_package(Python3 COMPONENTS Interpreter REQUIRED)
message(STATUS "Python3 specified. Version found: " ${Python3_VERSION})
set(Python_EXECUTABLE ${Python3_EXECUTABLE})
message(STATUS "Using Python executable: " ${Python_EXECUTABLE})
message(STATUS "Installing necessary Python packages...")
set(requirements_txt ${PROJECT_SOURCE_DIR}/dev-requirements.txt)
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${requirements_txt})
message(STATUS "PIP_INDEX_MIRROR: ${PIP_INDEX_MIRROR}")
if(PIP_INDEX_MIRROR)
set(extra_index_arg "-i")
endif()
function(install_py_dev_deps)
execute_process(COMMAND ${ARGV0} -m pip install ${extra_index_arg} ${PIP_INDEX_MIRROR} -r
${requirements_txt} --user RESULT_VARIABLE PIP_INSTALL_STATUS)
if(NOT PIP_INSTALL_STATUS EQUAL 0)
message(FATAL_ERROR "fail to install pip packages")
endif()
message(STATUS "Python packages are installed.")
endfunction(install_py_dev_deps)
install_py_dev_deps(${Python_EXECUTABLE})
find_package(Python3 COMPONENTS Development NumPy)
if(Python3_Development_FOUND AND Python3_INCLUDE_DIRS)
set(Python_INCLUDE_DIRS ${Python3_INCLUDE_DIRS})
endif()
if(Python3_NumPy_FOUND AND Python3_NumPy_INCLUDE_DIRS)
set(Python_NumPy_INCLUDE_DIRS ${Python3_NumPy_INCLUDE_DIRS})
endif()
if(NOT Python_INCLUDE_DIRS)
message(STATUS "Getting python include directory from sysconfig..")
execute_process(
COMMAND ${Python_EXECUTABLE} -c "import sysconfig; print(sysconfig.get_paths()['include'])"
OUTPUT_VARIABLE Python_INCLUDE_DIRS RESULT_VARIABLE ret_code)
string(STRIP "${Python_INCLUDE_DIRS}" Python_INCLUDE_DIRS)
if((NOT (ret_code EQUAL "0")) OR (NOT IS_DIRECTORY ${Python_INCLUDE_DIRS})
OR (NOT EXISTS ${Python_INCLUDE_DIRS}/Python.h))
set(Python_INCLUDE_DIRS "")
endif()
endif()
if(NOT Python_INCLUDE_DIRS)
message(FATAL_ERROR "Cannot find python include directory")
endif()
message(STATUS "Found python include directory ${Python_INCLUDE_DIRS}")
if(NOT Python_NumPy_INCLUDE_DIRS)
message(STATUS "Getting numpy include directory by numpy.get_include()..")
execute_process(COMMAND ${Python_EXECUTABLE} -c "import numpy; print(numpy.get_include())"
OUTPUT_VARIABLE Python_NumPy_INCLUDE_DIRS RESULT_VARIABLE ret_code)
string(STRIP "${Python_NumPy_INCLUDE_DIRS}" Python_NumPy_INCLUDE_DIRS)
if((NOT ret_code EQUAL 0) OR (NOT IS_DIRECTORY ${Python_NumPy_INCLUDE_DIRS})
OR (NOT EXISTS ${Python_NumPy_INCLUDE_DIRS}/numpy/arrayobject.h))
set(Python_NumPy_INCLUDE_DIRS "")
endif()
endif()
if(NOT Python_NumPy_INCLUDE_DIRS)
message(FATAL_ERROR "Cannot find numpy include directory")
endif()
message(STATUS "Found numpy include directory ${Python_NumPy_INCLUDE_DIRS}")
# PYTHON_EXECUTABLE will be used by pybind11
set(PYTHON_EXECUTABLE ${Python_EXECUTABLE})
include(pybind11)
set(CODEGEN_PYTHON_EXECUTABLE ${Python_EXECUTABLE}
CACHE STRING "Python executable to generate .cpp/.h files")
if(NOT "${CODEGEN_PYTHON_EXECUTABLE}" STREQUAL "${Python_EXECUTABLE}")
install_py_dev_deps(${CODEGEN_PYTHON_EXECUTABLE})
endif()
cmake/third_party.cmake 0 → 100644
View file @ 21d47d0e
cmake_policy(SET CMP0074 NEW)
if(NOT WIN32)
find_package(Threads)
endif()
if(WITH_ZLIB)
include(zlib)
endif()
include(protobuf)
include(googletest)
include(glog)
include(libjpeg-turbo)
include(opencv)
include(eigen)
if(WITH_COCOAPI)
include(cocoapi)
endif()
include(half)
include(re2)
include(json)
if(RPC_BACKEND MATCHES "GRPC")
include(absl)
include(cares)
include(openssl)
include(grpc)
endif()
include(flatbuffers)
include(lz4)
include(string_view)
include(hwloc)
include(liburing)
if(WITH_ONEDNN)
include(oneDNN)
endif()
set_mirror_url_with_hash(INJA_URL https://github.com/pantor/inja/archive/refs/tags/v3.3.0.zip
611e6b7206d0fb89728a3879f78b4775)
if(NOT WIN32)
set(BLA_STATIC ON)
set(BLA_VENDOR "Intel10_64lp_seq")
find_package(BLAS)
if(NOT BLAS_FOUND)
set(BLA_VENDOR "All")
find_package(BLAS)
endif()
else()
set(MKL_LIB_PATH
"C:/Program Files (x86)/IntelSWTools/compilers_and_libraries_2017/windows/mkl/lib/intel64_win"
)
set(BLAS_LIBRARIES ${MKL_LIB_PATH}/mkl_core_dll.lib ${MKL_LIB_PATH}/mkl_sequential_dll.lib
${MKL_LIB_PATH}/mkl_intel_lp64_dll.lib)
endif()
message(STATUS "Found Blas Lib: " ${BLAS_LIBRARIES})
set(oneflow_test_libs gtest_main)
set(oneflow_third_party_libs
protobuf_imported
${GRPC_STATIC_LIBRARIES}
${farmhash_STATIC_LIBRARIES}
${BLAS_LIBRARIES}
${OPENCV_STATIC_LIBRARIES}
${COCOAPI_STATIC_LIBRARIES}
${LIBJPEG_STATIC_LIBRARIES}
${ABSL_STATIC_LIBRARIES}
${OPENSSL_STATIC_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT}
${FLATBUFFERS_STATIC_LIBRARIES}
${LZ4_STATIC_LIBRARIES}
nlohmann_json::nlohmann_json
string-view-lite)
if(WITH_ONEDNN)
set(oneflow_third_party_libs ${oneflow_third_party_libs} ${ONEDNN_STATIC_LIBRARIES})
endif()
list(APPEND oneflow_third_party_libs ${RE2_LIBRARIES})
if(WITH_ZLIB)
list(APPEND oneflow_third_party_libs zlib_imported)
endif()
if(WIN32)
# static gflags lib requires "PathMatchSpecA" defined in "ShLwApi.Lib"
list(APPEND oneflow_third_party_libs "ShLwApi.Lib")
list(APPEND oneflow_third_party_libs "Ws2_32.lib")
endif()
set(oneflow_third_party_dependencies
protobuf
eigen
half_copy_headers_to_destination
re2
opencv
install_libpng_headers
flatbuffers
lz4_copy_libs_to_destination
lz4_copy_headers_to_destination)
if(WITH_ONEDNN)
list(APPEND oneflow_third_party_dependencies onednn)
endif()
if(WITH_ZLIB)
list(APPEND oneflow_third_party_dependencies zlib)
endif()
if(WITH_COCOAPI)
list(APPEND oneflow_third_party_dependencies cocoapi_copy_headers_to_destination)
list(APPEND oneflow_third_party_dependencies cocoapi_copy_libs_to_destination)
endif()
if(RPC_BACKEND MATCHES "GRPC")
list(APPEND oneflow_third_party_dependencies grpc)
endif()
list(
APPEND
ONEFLOW_THIRD_PARTY_INCLUDE_DIRS
${ZLIB_INCLUDE_DIR}
${PROTOBUF_INCLUDE_DIR}
${GRPC_INCLUDE_DIR}
${GLOG_INCLUDE_DIR}
${LIBJPEG_INCLUDE_DIR}
${OPENCV_INCLUDE_DIR}
${LIBPNG_INCLUDE_DIR}
${EIGEN_INCLUDE_DIR}
${COCOAPI_INCLUDE_DIR}
${HALF_INCLUDE_DIR}
${ABSL_INCLUDE_DIR}
${OPENSSL_INCLUDE_DIR}
${FLATBUFFERS_INCLUDE_DIR}
${LZ4_INCLUDE_DIR})
if(WITH_ONEDNN)
list(APPEND ONEFLOW_THIRD_PARTY_INCLUDE_DIRS ${ONEDNN_INCLUDE_DIR})
endif()
list(APPEND ONEFLOW_THIRD_PARTY_INCLUDE_DIRS ${RE2_INCLUDE_DIR})
if(BUILD_CUDA)
if(CUDA_VERSION VERSION_GREATER_EQUAL "11.0")
if(CMAKE_CXX_STANDARD LESS 14)
add_definitions(-DTHRUST_IGNORE_DEPRECATED_CPP_DIALECT)
add_definitions(-DCUB_IGNORE_DEPRECATED_CPP11)
endif()
if(CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.0")
add_definitions(-DCUB_IGNORE_DEPRECATED_COMPILER)
endif()
else()
include(cub)
list(APPEND oneflow_third_party_dependencies cub_copy_headers_to_destination)
endif()
include(nccl)
list(APPEND oneflow_third_party_libs ${NCCL_LIBRARIES})
list(APPEND oneflow_third_party_libs ${CUDNN_LIBRARIES})
list(APPEND oneflow_third_party_libs ${VENDOR_CUDA_LIBRARIES})
list(APPEND oneflow_third_party_dependencies nccl)
list(APPEND ONEFLOW_THIRD_PARTY_INCLUDE_DIRS ${CUDNN_INCLUDE_DIRS} ${CUB_INCLUDE_DIR}
${NCCL_INCLUDE_DIR})
endif()
if (BUILD_ROCM)
# Find rocm packages
find_package(hip)
find_package(hipblas)
find_package(hipcub)
find_package(hiprand)
find_package(rocrand)
find_package(miopen)
find_package(rccl)
add_definitions(-DWITH_ROCM)
add_definitions(-D__HIP_PLATFORM_HCC__)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__HIP_PLATFORM_HCC__ --gpu-max-threads-per-block=1024")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__HIP_PLATFORM_HCC__ --gpu-max-threads-per-block=1024")
list(APPEND oneflow_third_party_libs hip::device)
list(APPEND oneflow_third_party_libs roc::hipblas)
list(APPEND oneflow_third_party_libs hip::hipcub)
list(APPEND oneflow_third_party_libs roc::rocrand)
list(APPEND oneflow_third_party_libs hip::hiprand)
list(APPEND oneflow_third_party_libs MIOpen)
link_directories(${ROCM_PATH}/rccl/lib)
list(APPEND oneflow_third_party_libs rccl)
list(APPEND ONEFLOW_THIRD_PARTY_INCLUDE_DIRS ${HIP_INCLUDE_DIRS}
${HIPBLAS_INCLUDE_DIRS}
${HIPCUB_INCLUDE_DIRS}
"${ROCM_PATH}/hiprand/include"
"${ROCM_PATH}/rocrand/include"
${MIOPEN_INCLUDE_DIRS}
${RCCL_INCLUDE_DIRS})
message(STATUS "ONEFLOW_THIRD_PARTY_INCLUDE_DIRS: ${ONEFLOW_THIRD_PARTY_INCLUDE_DIRS}")
endif()
if(BUILD_RDMA)
if(UNIX)
include(CheckIncludeFiles)
include(CheckLibraryExists)
check_include_files(infiniband/verbs.h HAVE_VERBS_H)
if(HAVE_VERBS_H)
add_definitions(-DWITH_RDMA)
else()
message(FATAL_ERROR "RDMA head file not found")
endif()
else()
message(FATAL_ERROR "UNIMPLEMENTED")
endif()
endif()
if(BUILD_HWLOC)
list(APPEND oneflow_third_party_dependencies hwloc)
list(APPEND oneflow_third_party_libs ${ONEFLOW_HWLOC_STATIC_LIBRARIES})
list(APPEND oneflow_third_party_libs ${PCIACCESS_STATIC_LIBRARIES})
list(APPEND ONEFLOW_THIRD_PARTY_INCLUDE_DIRS ${HWLOC_INCLUDE_DIR})
add_definitions(-DWITH_HWLOC)
endif()
if(WITH_LIBURING)
list(APPEND oneflow_third_party_dependencies liburing)
list(APPEND oneflow_third_party_libs ${LIBURING_STATIC_LIBRARIES})
list(APPEND ONEFLOW_THIRD_PARTY_INCLUDE_DIRS ${LIBURING_INCLUDE_DIR})
add_definitions(-DWITH_LIBURING)
endif()
include_directories(SYSTEM ${ONEFLOW_THIRD_PARTY_INCLUDE_DIRS})
foreach(oneflow_third_party_lib IN LISTS oneflow_third_party_libs)
if(NOT "${oneflow_third_party_lib}" MATCHES "^-l.+"
AND NOT TARGET ${oneflow_third_party_lib}
AND "${oneflow_third_party_lib}" MATCHES "^\/.+"
AND NOT "${oneflow_third_party_lib}" MATCHES "^.+\.framework")
get_filename_component(IMPORTED_LIB_NAME ${oneflow_third_party_lib} NAME_WE)
set(IMPORTED_LIB_NAME "imported::${IMPORTED_LIB_NAME}")
message(STATUS "Creating imported lib: ${oneflow_third_party_lib} => ${IMPORTED_LIB_NAME}")
add_library(${IMPORTED_LIB_NAME} UNKNOWN IMPORTED)
set_property(TARGET ${IMPORTED_LIB_NAME} PROPERTY IMPORTED_LOCATION
"${oneflow_third_party_lib}")
list(APPEND ONEFLOW_THIRD_PARTY_LIBS_TO_LINK "${IMPORTED_LIB_NAME}")
else()
list(APPEND ONEFLOW_THIRD_PARTY_LIBS_TO_LINK "${oneflow_third_party_lib}")
endif()
endforeach()
set(oneflow_third_party_libs ${ONEFLOW_THIRD_PARTY_LIBS_TO_LINK})
message(STATUS "oneflow_third_party_libs: ${oneflow_third_party_libs}")
add_definitions(-DHALF_ENABLE_CPP11_USER_LITERALS=0)
if(THIRD_PARTY)
add_custom_target(prepare_oneflow_third_party ALL DEPENDS ${oneflow_third_party_dependencies})
if(BUILD_PYTHON)
if(NOT ONEFLOW_INCLUDE_DIR MATCHES "/include$")
message(
FATAL_ERROR
"ONEFLOW_INCLUDE_DIR must end with '/include', current value: ${ONEFLOW_INCLUDE_DIR}")
endif()
get_filename_component(ONEFLOW_INCLUDE_DIR_PARENT "${ONEFLOW_INCLUDE_DIR}" DIRECTORY)
foreach(of_include_src_dir ${ONEFLOW_THIRD_PARTY_INCLUDE_DIRS})
if(of_include_src_dir MATCHES "/include$")
# it requires two slashes, but in CMake doc it states only one slash is needed
set(of_include_src_dir "${of_include_src_dir}//")
endif()
install(
DIRECTORY ${of_include_src_dir}
DESTINATION ${ONEFLOW_INCLUDE_DIR}
COMPONENT oneflow_py_include
EXCLUDE_FROM_ALL)
endforeach()
endif(BUILD_PYTHON)
else()
add_custom_target(prepare_oneflow_third_party ALL)
endif()
cmake/third_party/FindBLAS.cmake 0 → 100644
View file @ 21d47d0e
#.rst:
# FindBLAS
# --------
#
# Find BLAS library
#
# This module finds an installed fortran library that implements the
# BLAS linear-algebra interface (see http://www.netlib.org/blas/). The
# list of libraries searched for is taken from the autoconf macro file,
# acx_blas.m4 (distributed at
# http://ac-archive.sourceforge.net/ac-archive/acx_blas.html).
#
# This module sets the following variables:
#
# ::
#
# BLAS_FOUND - set to true if a library implementing the BLAS interface
# is found
# BLAS_LINKER_FLAGS - uncached list of required linker flags (excluding -l
# and -L).
# BLAS_LIBRARIES - uncached list of libraries (using full path name) to
# link against to use BLAS
# BLAS95_LIBRARIES - uncached list of libraries (using full path name)
# to link against to use BLAS95 interface
# BLAS95_FOUND - set to true if a library implementing the BLAS f95 interface
# is found
# BLA_STATIC if set on this determines what kind of linkage we do (static)
# BLA_VENDOR if set checks only the specified vendor, if not set checks
# all the possibilities
# BLA_F95 if set on tries to find the f95 interfaces for BLAS/LAPACK
#
# ######### ## List of vendors (BLA_VENDOR) valid in this module #
# Goto,OpenBLAS,ATLAS PhiPACK,CXML,DXML,SunPerf,SCSL,SGIMATH,IBMESSL,
# Intel10_32 (intel mkl v10 32 bit),Intel10_64lp (intel mkl v10 64 bit,
# lp thread model, lp64 model), # Intel10_64lp_seq (intel mkl v10 64
# bit,sequential code, lp64 model), # Intel( older versions of mkl 32
# and 64 bit), ACML,ACML_MP,ACML_GPU,Apple, NAS, Generic C/CXX should be
# enabled to use Intel mkl
#=============================================================================
# Copyright 2007-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
set(CMAKE_REQUIRED_QUIET ${BLAS_FIND_QUIETLY})
set(_blas_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
# Check the language being used
if(NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED OR CMAKE_Fortran_COMPILER_LOADED))
if(BLAS_FIND_REQUIRED)
message(FATAL_ERROR "FindBLAS requires Fortran, C, or C++ to be enabled.")
else()
message(STATUS "Looking for BLAS... - NOT found (Unsupported languages)")
return()
endif()
endif()
macro(
Check_Fortran_Libraries
LIBRARIES
_prefix
_name
_flags
_list
_thread)
# This macro checks for the existence of the combination of fortran libraries
# given by _list. If the combination is found, this macro checks (using the
# Check_Fortran_Function_Exists macro) whether can link against that library
# combination using the name of a routine given by _name using the linker
# flags given by _flags. If the combination of libraries is found and passes
# the link test, LIBRARIES is set to the list of complete library paths that
# have been found. Otherwise, LIBRARIES is set to FALSE.
# N.B. _prefix is the prefix applied to the names of all cached variables that
# are generated internally and marked advanced by this macro.
set(_libdir ${ARGN})
set(_libraries_work TRUE)
set(${LIBRARIES})
set(_combined_name)
if(NOT _libdir)
if(WIN32)
set(_libdir ENV LIB)
elseif(APPLE)
set(_libdir ENV DYLD_LIBRARY_PATH)
else()
set(_libdir ENV LD_LIBRARY_PATH)
endif()
endif()
foreach(_library ${_list})
set(_combined_name ${_combined_name}_${_library})
if(_libraries_work)
if(BLA_STATIC)
if(WIN32)
set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
endif()
if(APPLE)
set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
else()
set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
endif()
else()
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
# for ubuntu's libblas3gf and liblapack3gf packages
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf)
endif()
endif()
find_library(${_prefix}_${_library}_LIBRARY NAMES ${_library} PATHS ${_libdir})
mark_as_advanced(${_prefix}_${_library}_LIBRARY)
set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY})
set(_libraries_work ${${_prefix}_${_library}_LIBRARY})
endif()
endforeach()
if(_libraries_work)
set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_thread})
set(CMAKE_REQUIRED_LIBRARIES)
mark_as_advanced(${_prefix}${_combined_name}_WORKS)
set(_libraries_work ${${_prefix}${_combined_name}_WORKS})
endif()
endmacro()
set(BLAS_LINKER_FLAGS)
set(BLAS_LIBRARIES)
set(BLAS95_LIBRARIES)
if(NOT $ENV{BLA_VENDOR} STREQUAL "")
set(BLA_VENDOR $ENV{BLA_VENDOR})
else()
if(NOT BLA_VENDOR)
set(BLA_VENDOR "All")
endif()
endif()
if(BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
# gotoblas (http://www.tacc.utexas.edu/tacc-projects/gotoblas2)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "goto2" "")
endif()
endif()
if(BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
# OpenBLAS (http://www.openblas.net)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "openblas" "")
endif()
endif()
if(BLA_VENDOR STREQUAL "ATLAS" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
# BLAS in ATLAS library? (http://math-atlas.sourceforge.net/)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS dgemm "" "f77blas;atlas" "")
endif()
endif()
# BLAS in PhiPACK libraries? (requires generic BLAS lib, too)
if(BLA_VENDOR STREQUAL "PhiPACK" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "sgemm;dgemm;blas" "")
endif()
endif()
# BLAS in Alpha CXML library?
if(BLA_VENDOR STREQUAL "CXML" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "cxml" "")
endif()
endif()
# BLAS in Alpha DXML library? (now called CXML, see above)
if(BLA_VENDOR STREQUAL "DXML" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "dxml" "")
endif()
endif()
# BLAS in Sun Performance library?
if(BLA_VENDOR STREQUAL "SunPerf" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "-xlic_lib=sunperf" "sunperf;sunmath" "")
if(BLAS_LIBRARIES)
set(BLAS_LINKER_FLAGS "-xlic_lib=sunperf")
endif()
endif()
endif()
# BLAS in SCSL library? (SGI/Cray Scientific Library)
if(BLA_VENDOR STREQUAL "SCSL" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "scsl" "")
endif()
endif()
# BLAS in SGIMATH library?
if(BLA_VENDOR STREQUAL "SGIMATH" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "complib.sgimath" "")
endif()
endif()
# BLAS in IBM ESSL library? (requires generic BLAS lib, too)
if(BLA_VENDOR STREQUAL "IBMESSL" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "essl;blas" "")
endif()
endif()
#BLAS in acml library?
if(BLA_VENDOR MATCHES "ACML" OR BLA_VENDOR STREQUAL "All")
if(((BLA_VENDOR STREQUAL "ACML") AND (NOT BLAS_ACML_LIB_DIRS))
OR ((BLA_VENDOR STREQUAL "ACML_MP") AND (NOT BLAS_ACML_MP_LIB_DIRS))
OR ((BLA_VENDOR STREQUAL "ACML_GPU") AND (NOT BLAS_ACML_GPU_LIB_DIRS)))
# try to find acml in "standard" paths
if(WIN32)
file(GLOB _ACML_ROOT "C:/AMD/acml*/ACML-EULA.txt")
else()
file(GLOB _ACML_ROOT "/opt/acml*/ACML-EULA.txt")
endif()
if(WIN32)
file(GLOB _ACML_GPU_ROOT "C:/AMD/acml*/GPGPUexamples")
else()
file(GLOB _ACML_GPU_ROOT "/opt/acml*/GPGPUexamples")
endif()
list(GET _ACML_ROOT 0 _ACML_ROOT)
list(GET _ACML_GPU_ROOT 0 _ACML_GPU_ROOT)
if(_ACML_ROOT)
get_filename_component(_ACML_ROOT ${_ACML_ROOT} PATH)
if(SIZEOF_INTEGER EQUAL 8)
set(_ACML_PATH_SUFFIX "_int64")
else()
set(_ACML_PATH_SUFFIX "")
endif()
if(CMAKE_Fortran_COMPILER_ID STREQUAL "Intel")
set(_ACML_COMPILER32 "ifort32")
set(_ACML_COMPILER64 "ifort64")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "SunPro")
set(_ACML_COMPILER32 "sun32")
set(_ACML_COMPILER64 "sun64")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "PGI")
set(_ACML_COMPILER32 "pgi32")
if(WIN32)
set(_ACML_COMPILER64 "win64")
else()
set(_ACML_COMPILER64 "pgi64")
endif()
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "Open64")
# 32 bit builds not supported on Open64 but for code simplicity
# We'll just use the same directory twice
set(_ACML_COMPILER32 "open64_64")
set(_ACML_COMPILER64 "open64_64")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "NAG")
set(_ACML_COMPILER32 "nag32")
set(_ACML_COMPILER64 "nag64")
else()
set(_ACML_COMPILER32 "gfortran32")
set(_ACML_COMPILER64 "gfortran64")
endif()
if(BLA_VENDOR STREQUAL "ACML_MP")
set(_ACML_MP_LIB_DIRS "${_ACML_ROOT}/${_ACML_COMPILER32}_mp${_ACML_PATH_SUFFIX}/lib"
"${_ACML_ROOT}/${_ACML_COMPILER64}_mp${_ACML_PATH_SUFFIX}/lib")
else()
set(_ACML_LIB_DIRS "${_ACML_ROOT}/${_ACML_COMPILER32}${_ACML_PATH_SUFFIX}/lib"
"${_ACML_ROOT}/${_ACML_COMPILER64}${_ACML_PATH_SUFFIX}/lib")
endif()
endif()
elseif(BLAS_${BLA_VENDOR}_LIB_DIRS)
set(_${BLA_VENDOR}_LIB_DIRS ${BLAS_${BLA_VENDOR}_LIB_DIRS})
endif()
if(BLA_VENDOR STREQUAL "ACML_MP")
foreach(BLAS_ACML_MP_LIB_DIRS ${_ACML_MP_LIB_DIRS})
Check_Fortran_Libraries(
BLAS_LIBRARIES
BLAS
sgemm
""
"acml_mp;acml_mv"
""
${BLAS_ACML_MP_LIB_DIRS})
if(BLAS_LIBRARIES)
break()
endif()
endforeach()
elseif(BLA_VENDOR STREQUAL "ACML_GPU")
foreach(BLAS_ACML_GPU_LIB_DIRS ${_ACML_GPU_LIB_DIRS})
Check_Fortran_Libraries(
BLAS_LIBRARIES
BLAS
sgemm
""
"acml;acml_mv;CALBLAS"
""
${BLAS_ACML_GPU_LIB_DIRS})
if(BLAS_LIBRARIES)
break()
endif()
endforeach()
else()
foreach(BLAS_ACML_LIB_DIRS ${_ACML_LIB_DIRS})
Check_Fortran_Libraries(
BLAS_LIBRARIES
BLAS
sgemm
""
"acml;acml_mv"
""
${BLAS_ACML_LIB_DIRS})
if(BLAS_LIBRARIES)
break()
endif()
endforeach()
endif()
# Either acml or acml_mp should be in LD_LIBRARY_PATH but not both
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "acml;acml_mv" "")
endif()
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "acml_mp;acml_mv" "")
endif()
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "acml;acml_mv;CALBLAS" "")
endif()
endif() # ACML
# Apple BLAS library?
if(BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS dgemm "" "Accelerate" "")
endif()
endif()
if(BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS dgemm "" "vecLib" "")
endif()
endif()
# Generic BLAS library?
if(BLA_VENDOR STREQUAL "Generic" OR BLA_VENDOR STREQUAL "All")
if(NOT BLAS_LIBRARIES)
Check_Fortran_Libraries(BLAS_LIBRARIES BLAS sgemm "" "blas" "")
endif()
endif()
#BLAS in intel mkl 10 library? (em64t 64bit)
if(BLA_VENDOR MATCHES "Intel" OR BLA_VENDOR STREQUAL "All")
if(NOT WIN32)
set(LM "-lm")
endif()
if(CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED)
if(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED)
find_package(Threads)
else()
find_package(Threads REQUIRED)
endif()
set(BLAS_SEARCH_LIBS "")
if(BLA_F95)
set(BLAS_mkl_SEARCH_SYMBOL SGEMM)
set(_LIBRARIES BLAS95_LIBRARIES)
if(WIN32)
if(BLA_STATIC)
set(BLAS_mkl_DLL_SUFFIX "")
else()
set(BLAS_mkl_DLL_SUFFIX "_dll")
endif()
# Find the main file (32-bit or 64-bit)
set(BLAS_SEARCH_LIBS_WIN_MAIN "")
if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN
"mkl_blas95${BLAS_mkl_DLL_SUFFIX} mkl_intel_c${BLAS_mkl_DLL_SUFFIX}")
endif()
if(BLA_VENDOR MATCHES "^Intel10_64lp" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN
"mkl_blas95_lp64${BLAS_mkl_DLL_SUFFIX} mkl_intel_lp64${BLAS_mkl_DLL_SUFFIX}")
endif()
# Add threading/sequential libs
set(BLAS_SEARCH_LIBS_WIN_THREAD "")
if(BLA_VENDOR MATCHES "_seq$" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD "mkl_sequential${BLAS_mkl_DLL_SUFFIX}")
endif()
if(NOT BLA_VENDOR MATCHES "_seq$" OR BLA_VENDOR STREQUAL "All")
# old version
list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD
"libguide40 mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}")
# mkl >= 10.3
list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD
"libiomp5md mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}")
endif()
# Cartesian product of the above
foreach(MAIN ${BLAS_SEARCH_LIBS_WIN_MAIN})
foreach(THREAD ${BLAS_SEARCH_LIBS_WIN_THREAD})
list(APPEND BLAS_SEARCH_LIBS "${MAIN} ${THREAD} mkl_core${BLAS_mkl_DLL_SUFFIX}")
endforeach()
endforeach()
else()
if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS "mkl_blas95 mkl_intel mkl_intel_thread mkl_core guide")
endif()
if(BLA_VENDOR STREQUAL "Intel10_64lp" OR BLA_VENDOR STREQUAL "All")
# old version
list(APPEND BLAS_SEARCH_LIBS "mkl_blas95 mkl_intel_lp64 mkl_intel_thread mkl_core guide")
# mkl >= 10.3
if(CMAKE_C_COMPILER MATCHES ".+gcc")
list(APPEND BLAS_SEARCH_LIBS
"mkl_blas95_lp64 mkl_intel_lp64 mkl_gnu_thread mkl_core gomp")
else()
list(APPEND BLAS_SEARCH_LIBS
"mkl_blas95_lp64 mkl_intel_lp64 mkl_intel_thread mkl_core iomp5")
endif()
endif()
if(BLA_VENDOR STREQUAL "Intel10_64lp_seq" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_sequential mkl_core")
endif()
endif()
else()
set(BLAS_mkl_SEARCH_SYMBOL sgemm)
set(_LIBRARIES BLAS_LIBRARIES)
if(WIN32)
if(BLA_STATIC)
set(BLAS_mkl_DLL_SUFFIX "")
else()
set(BLAS_mkl_DLL_SUFFIX "_dll")
endif()
# Find the main file (32-bit or 64-bit)
set(BLAS_SEARCH_LIBS_WIN_MAIN "")
if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN "mkl_intel_c${BLAS_mkl_DLL_SUFFIX}")
endif()
if(BLA_VENDOR MATCHES "^Intel10_64lp" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN "mkl_intel_lp64${BLAS_mkl_DLL_SUFFIX}")
endif()
# Add threading/sequential libs
set(BLAS_SEARCH_LIBS_WIN_THREAD "")
if(NOT BLA_VENDOR MATCHES "_seq$" OR BLA_VENDOR STREQUAL "All")
# old version
list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD
"libguide40 mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}")
# mkl >= 10.3
list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD
"libiomp5md mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}")
endif()
if(BLA_VENDOR MATCHES "_seq$" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD "mkl_sequential${BLAS_mkl_DLL_SUFFIX}")
endif()
# Cartesian product of the above
foreach(MAIN ${BLAS_SEARCH_LIBS_WIN_MAIN})
foreach(THREAD ${BLAS_SEARCH_LIBS_WIN_THREAD})
list(APPEND BLAS_SEARCH_LIBS "${MAIN} ${THREAD} mkl_core${BLAS_mkl_DLL_SUFFIX}")
endforeach()
endforeach()
else()
if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS "mkl_intel mkl_intel_thread mkl_core guide")
endif()
if(BLA_VENDOR STREQUAL "Intel10_64lp" OR BLA_VENDOR STREQUAL "All")
# old version
list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_intel_thread mkl_core guide")
# mkl >= 10.3
if(CMAKE_C_COMPILER MATCHES ".+gcc")
list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_gnu_thread mkl_core gomp")
else()
list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_intel_thread mkl_core iomp5")
endif()
endif()
if(BLA_VENDOR STREQUAL "Intel10_64lp_seq" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_sequential mkl_core")
endif()
#older vesions of intel mkl libs
if(BLA_VENDOR STREQUAL "Intel" OR BLA_VENDOR STREQUAL "All")
list(APPEND BLAS_SEARCH_LIBS "mkl")
list(APPEND BLAS_SEARCH_LIBS "mkl_ia32")
list(APPEND BLAS_SEARCH_LIBS "mkl_em64t")
endif()
endif()
endif()
foreach(IT ${BLAS_SEARCH_LIBS})
string(REPLACE " " ";" SEARCH_LIBS ${IT})
if(${_LIBRARIES})
else()
Check_Fortran_Libraries(${_LIBRARIES} BLAS ${BLAS_mkl_SEARCH_SYMBOL} "" "${SEARCH_LIBS}"
"${CMAKE_THREAD_LIBS_INIT};${LM}")
endif()
endforeach()
endif()
endif()
if(BLA_F95)
if(BLAS95_LIBRARIES)
set(BLAS95_FOUND TRUE)
else()
set(BLAS95_FOUND FALSE)
endif()
if(NOT BLAS_FIND_QUIETLY)
if(BLAS95_FOUND)
message(STATUS "A library with BLAS95 API found.")
else()
if(BLAS_FIND_REQUIRED)
message(
FATAL_ERROR
"A required library with BLAS95 API not found. Please specify library location.")
else()
message(STATUS "A library with BLAS95 API not found. Please specify library location.")
endif()
endif()
endif()
set(BLAS_FOUND TRUE)
set(BLAS_LIBRARIES "${BLAS95_LIBRARIES}")
else()
if(BLAS_LIBRARIES)
set(BLAS_FOUND TRUE)
else()
set(BLAS_FOUND FALSE)
endif()
if(NOT BLAS_FIND_QUIETLY)
if(BLAS_FOUND)
message(STATUS "A library with BLAS API found.")
else()
if(BLAS_FIND_REQUIRED)
message(
FATAL_ERROR "A required library with BLAS API not found. Please specify library location."
)
else()
message(STATUS "A library with BLAS API not found. Please specify library location.")
endif()
endif()
endif()
endif()
set(CMAKE_FIND_LIBRARY_SUFFIXES ${_blas_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
cmake/third_party/FindCUDNN.cmake 0 → 100644
View file @ 21d47d0e
# - Try to find cuDNN
#
# The following variables are optionally searched for defaults
# CUDNN_ROOT_DIR: Base directory where all cuDNN components are found
#
# The following are set after configuration is done:
# CUDNN_FOUND
# CUDNN_INCLUDE_DIRS
# CUDNN_LIBRARIES
# CUDNN_LIBRARY_DIRS
include(FindPackageHandleStandardArgs)
include(CMakeDependentOption)
set(CUDNN_ROOT_DIR "" CACHE PATH "Folder contains NVIDIA cuDNN")
if(CUDA_VERSION VERSION_LESS "11.0")
set(CUDA_VERSION_VERSION_LESS_11 TRUE)
endif()
cmake_dependent_option(CUDNN_STATIC "Look for static cuDNN" ON "CUDA_VERSION_VERSION_LESS_11" OFF)
if(OF_CUDA_LINK_DYNAMIC_LIBRARY)
set(CUDNN_STATIC OFF)
endif()
if(CUDNN_STATIC)
set(__cudnn_libname "libcudnn_static.a")
else()
set(__cudnn_libname "libcudnn.so")
endif()
find_path(CUDNN_INCLUDE_DIR cudnn.h HINTS ${CUDNN_ROOT_DIR} ${CUDAToolkit_INCLUDE_DIRS}
PATH_SUFFIXES cuda/include include)
unset(CUDNN_LIBRARY CACHE)
find_library(CUDNN_LIBRARY ${__cudnn_libname} HINTS ${CUDNN_ROOT_DIR} ${CUDAToolkit_LIBRARY_DIR}
PATH_SUFFIXES lib lib64 cuda/lib cuda/lib64 lib/x64)
find_package_handle_standard_args(CUDNN DEFAULT_MSG CUDNN_INCLUDE_DIR CUDNN_LIBRARY)
if(CUDNN_FOUND)
# get cuDNN version
if(EXISTS "${CUDNN_INCLUDE_DIR}/cudnn_version.h")
file(READ ${CUDNN_INCLUDE_DIR}/cudnn_version.h CUDNN_HEADER_CONTENTS)
else()
file(READ ${CUDNN_INCLUDE_DIR}/cudnn.h CUDNN_HEADER_CONTENTS)
endif()
string(REGEX MATCH "define CUDNN_MAJOR * +([0-9]+)" CUDNN_VERSION_MAJOR
"${CUDNN_HEADER_CONTENTS}")
string(REGEX REPLACE "define CUDNN_MAJOR * +([0-9]+)" "\\1" CUDNN_VERSION_MAJOR
"${CUDNN_VERSION_MAJOR}")
string(REGEX MATCH "define CUDNN_MINOR * +([0-9]+)" CUDNN_VERSION_MINOR
"${CUDNN_HEADER_CONTENTS}")
string(REGEX REPLACE "define CUDNN_MINOR * +([0-9]+)" "\\1" CUDNN_VERSION_MINOR
"${CUDNN_VERSION_MINOR}")
string(REGEX MATCH "define CUDNN_PATCHLEVEL * +([0-9]+)" CUDNN_VERSION_PATCH
"${CUDNN_HEADER_CONTENTS}")
string(REGEX REPLACE "define CUDNN_PATCHLEVEL * +([0-9]+)" "\\1" CUDNN_VERSION_PATCH
"${CUDNN_VERSION_PATCH}")
# Assemble cuDNN version
if(NOT CUDNN_VERSION_MAJOR)
set(CUDNN_VERSION "?")
else()
set(CUDNN_VERSION "${CUDNN_VERSION_MAJOR}.${CUDNN_VERSION_MINOR}.${CUDNN_VERSION_PATCH}")
endif()
set(CUDNN_INCLUDE_DIRS ${CUDNN_INCLUDE_DIR})
if(NOT CUDNN_STATIC AND CUDNN_VERSION_MAJOR GREATER_EQUAL 8)
# skipping: libcudnn_adv_infer.so libcudnn_adv_train.so
set(CUDNN_DYNAMIC_NAMES libcudnn_cnn_infer.so libcudnn_cnn_train.so libcudnn_ops_infer.so
libcudnn_ops_train.so)
get_filename_component(CUDNN_LIBRARY_DIRECTORY ${CUDNN_LIBRARY} DIRECTORY)
foreach(CUDNN_DYNAMIC_NAME ${CUDNN_DYNAMIC_NAMES})
list(APPEND CUDNN_LIBRARIES ${CUDNN_LIBRARY_DIRECTORY}/${CUDNN_DYNAMIC_NAME})
endforeach()
else()
set(CUDNN_LIBRARIES ${CUDNN_LIBRARY})
endif()
message(
STATUS
"Found cuDNN: v${CUDNN_VERSION} (include: ${CUDNN_INCLUDE_DIR}, library: ${CUDNN_LIBRARIES})"
)
mark_as_advanced(CUDNN_ROOT_DIR CUDNN_LIBRARY CUDNN_INCLUDE_DIR)
endif()
cmake/third_party/absl.cmake 0 → 100644
View file @ 21d47d0e
include(ExternalProject)
include(GNUInstallDirs)
set(ABSL_PROJECT absl)
set(ABSL_TAR_URL https://github.com/Oneflow-Inc/abseil-cpp/archive/refs/tags/d0.tar.gz)
use_mirror(VARIABLE ABSL_TAR_URL URL ${ABSL_TAR_URL})
set(ABSL_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/absl/src/absl)
set(ABSL_INSTALL ${THIRD_PARTY_DIR}/absl)
set(ABSL_INCLUDE_DIR ${THIRD_PARTY_DIR}/absl/include CACHE PATH "" FORCE)
set(ABSL_LIBRARY_DIR ${THIRD_PARTY_DIR}/absl/${CMAKE_INSTALL_LIBDIR} CACHE PATH "" FORCE)
if(WIN32)
set(ABSL_BUILD_LIBRARY_DIR ${ABSL_INSTALL}/${CMAKE_INSTALL_LIBDIR})
set(ABSL_LIBRARY_NAMES
absl_spinlock_wait.lib
absl_dynamic_annotations.lib
absl_malloc_internal.lib
absl_throw_delegate.lib
absl_int128.lib
absl_strings.lib
absl_str_format_internal.lib
absl_time.lib
absl_bad_optional_access.lib
absl_base.lib)
else()
set(ABSL_BUILD_LIBRARY_DIR ${ABSL_INSTALL}/${CMAKE_INSTALL_LIBDIR})
set(ABSL_LIBRARY_NAMES
libabsl_spinlock_wait.a
libabsl_dynamic_annotations.a
libabsl_malloc_internal.a
libabsl_throw_delegate.a
libabsl_int128.a
libabsl_strings.a
libabsl_str_format_internal.a
libabsl_time.a
libabsl_bad_optional_access.a
libabsl_base.a)
endif()
foreach(LIBRARY_NAME ${ABSL_LIBRARY_NAMES})
list(APPEND ABSL_STATIC_LIBRARIES ${ABSL_LIBRARY_DIR}/${LIBRARY_NAME})
list(APPEND ABSL_BUILD_STATIC_LIBRARIES ${ABSL_BUILD_LIBRARY_DIR}/${LIBRARY_NAME})
endforeach()
if(THIRD_PARTY)
ExternalProject_Add(
${ABSL_PROJECT}
PREFIX absl
URL ${ABSL_TAR_URL}
URL_MD5 20126998c9b17e5f7a93711972f03f79
UPDATE_COMMAND ""
BUILD_BYPRODUCTS ${ABSL_STATIC_LIBRARIES}
CMAKE_CACHE_ARGS
-DCMAKE_C_COMPILER_LAUNCHER:STRING=${CMAKE_C_COMPILER_LAUNCHER}
-DCMAKE_CXX_COMPILER_LAUNCHER:STRING=${CMAKE_CXX_COMPILER_LAUNCHER}
-DCMAKE_INSTALL_PREFIX:PATH=${ABSL_INSTALL}
-DCMAKE_INSTALL_LIBDIR:PATH=${ABSL_INSTALL}/${CMAKE_INSTALL_LIBDIR}
-DCMAKE_INSTALL_MESSAGE:STRING=${CMAKE_INSTALL_MESSAGE}
-DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE})
endif(THIRD_PARTY)
cmake/third_party/cares.cmake 0 → 100644
View file @ 21d47d0e
include(ExternalProject)
set(CARES_TAR_URL
https://github.com/c-ares/c-ares/releases/download/cares-1_15_0/c-ares-1.15.0.tar.gz)
use_mirror(VARIABLE CARES_TAR_URL URL ${CARES_TAR_URL})
set(CARES_URL_HASH d2391da274653f7643270623e822dff7)
set(CARES_INSTALL ${THIRD_PARTY_DIR}/cares)
set(CARES_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/cares/src/cares)
if(THIRD_PARTY)
ExternalProject_Add(
cares
PREFIX cares
URL ${CARES_TAR_URL}
URL_HASH MD5=${CARES_URL_HASH}
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND "")
endif()
cmake/third_party/cocoapi.cmake 0 → 100644
View file @ 21d47d0e
include(ExternalProject)
set(COCOAPI_INCLUDE_DIR ${THIRD_PARTY_DIR}/cocoapi/include)
set(COCOAPI_LIBRARY_DIR ${THIRD_PARTY_DIR}/cocoapi/lib)
set(COCOAPI_URL https://github.com/Oneflow-Inc/cocoapi/archive/refs/tags/ed842bf.tar.gz)
use_mirror(VARIABLE COCOAPI_URL URL ${COCOAPI_URL})
set(COCOAPI_URL_HASH e7e0504231e5614ffaa34f081773f7f1)
set(COCOAPI_BASE_DIR ${CMAKE_CURRENT_BINARY_DIR}/cocoapi/src/cocoapi)
set(COCOAPI_LIBRARY_NAME libcocoapi_static.a)
list(APPEND COCOAPI_STATIC_LIBRARIES ${COCOAPI_LIBRARY_DIR}/${COCOAPI_LIBRARY_NAME})
list(APPEND COCOAPI_BUILD_STATIC_LIBRARIES ${COCOAPI_BASE_DIR}/${COCOAPI_LIBRARY_NAME})
set(COCOAPI_HEADERS "${COCOAPI_BASE_DIR}/common/maskApi.h")
if(THIRD_PARTY)
ExternalProject_Add(
cocoapi
PREFIX cocoapi
URL ${COCOAPI_URL}
URL_HASH MD5=${COCOAPI_URL_HASH}
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_IN_SOURCE 1
BUILD_BYPRODUCTS ${COCOAPI_STATIC_LIBRARIES}
BUILD_COMMAND ${CMAKE_C_COMPILER} -fPIC -O3 -c common/maskApi.c -o maskApi.o && ${CMAKE_AR} rcs
${COCOAPI_LIBRARY_NAME} maskApi.o
INSTALL_COMMAND "")
add_custom_target(cocoapi_create_header_dir COMMAND ${CMAKE_COMMAND} -E make_directory
${COCOAPI_INCLUDE_DIR} DEPENDS cocoapi)
add_custom_target(cocoapi_copy_headers_to_destination DEPENDS cocoapi_create_header_dir)
foreach(header_file ${COCOAPI_HEADERS})
add_custom_command(
TARGET cocoapi_copy_headers_to_destination PRE_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${header_file} ${COCOAPI_INCLUDE_DIR})
endforeach()
add_custom_target(cocoapi_create_library_dir COMMAND ${CMAKE_COMMAND} -E make_directory
${COCOAPI_LIBRARY_DIR} DEPENDS cocoapi)
add_custom_target(
cocoapi_copy_libs_to_destination
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${COCOAPI_BUILD_STATIC_LIBRARIES}
${COCOAPI_LIBRARY_DIR} DEPENDS cocoapi_create_library_dir)
endif(THIRD_PARTY)
cmake/third_party/cub.cmake 0 → 100644
View file @ 21d47d0e
include(ExternalProject)
set(CUB_INCLUDE_DIR ${THIRD_PARTY_DIR}/cub/include)
set(CUB_BUILD_INCLUDE ${CMAKE_CURRENT_BINARY_DIR}/cub/src/cub/cub)
set(CUB_URL https://github.com/NVIDIA/cub/archive/refs/tags/1.11.0.tar.gz)
use_mirror(VARIABLE CUB_URL URL ${CUB_URL})
if(THIRD_PARTY)
ExternalProject_Add(
cub
PREFIX cub
URL ${CUB_URL}
URL_MD5 97196a885598e40592100e1caaf3d5ea
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND "")
add_copy_headers_target(
NAME
cub
SRC
${CUB_BUILD_INCLUDE}
DST
${CUB_INCLUDE_DIR}/cub
DEPS
cub
INDEX_FILE
"${oneflow_cmake_dir}/third_party/header_index/cub_headers.txt")
endif(THIRD_PARTY)
cmake/third_party/eigen.cmake 0 → 100644
View file @ 21d47d0e
include(ExternalProject)
set(EIGEN_INCLUDE_DIR ${THIRD_PARTY_DIR}/eigen/include/eigen3)
set(EIGEN_INSTALL_DIR ${THIRD_PARTY_DIR}/eigen)
set(EIGEN_URL https://github.com/Oneflow-Inc/eigen-git-mirror/archive/refs/tags/e9e95489a.tar.gz)
set(EIGEN_MD5 a23cb70e12d1bf9b09cb28af51bc26ae)
use_mirror(VARIABLE EIGEN_URL URL ${EIGEN_URL})
add_definitions(-DEIGEN_NO_AUTOMATIC_RESIZING)
if(BUILD_CUDA)
add_definitions(-DEIGEN_USE_GPU)
endif()
add_definitions(-DEIGEN_NO_MALLOC)
#add_definitions(-DEIGEN_NO_AUTOMATIC_RESIZING -DEIGEN_NO_MALLOC -DEIGEN_USE_GPU)
if(THIRD_PARTY)
ExternalProject_Add(
eigen
PREFIX eigen
URL ${EIGEN_URL}
URL_MD5 ${EIGEN_MD5}
UPDATE_COMMAND ""
INSTALL_DIR "${EIGEN_INSTALL_DIR}"
CMAKE_CACHE_ARGS
-DCMAKE_C_COMPILER_LAUNCHER:STRING=${CMAKE_C_COMPILER_LAUNCHER}
-DCMAKE_CXX_COMPILER_LAUNCHER:STRING=${CMAKE_CXX_COMPILER_LAUNCHER}
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF
-DCMAKE_INSTALL_PREFIX:STRING=${EIGEN_INSTALL_DIR}
-DCMAKE_INSTALL_MESSAGE:STRING=${CMAKE_INSTALL_MESSAGE}
-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
-DBUILD_TESTING:BOOL=OFF)
endif(THIRD_PARTY)
cmake/third_party/flatbuffers.cmake 0 → 100644
View file @ 21d47d0e
include(ExternalProject)
set(FLATBUFFERS_URL https://github.com/google/flatbuffers/archive/v1.12.0.tar.gz)
set(FLATBUFFERS_INSTALL_PREFIX ${THIRD_PARTY_DIR}/flatbuffers)
set(FLATBUFFERS_INSTALL_INCLUDEDIR include)
set(FLATBUFFERS_INSTALL_LIBDIR lib)
set(FLATBUFFERS_INSTALL_BINDIR bin)
use_mirror(VARIABLE FLATBUFFERS_URL URL ${FLATBUFFERS_URL})
set(FLATBUFFERS_INCLUDE_DIR ${FLATBUFFERS_INSTALL_PREFIX}/${FLATBUFFERS_INSTALL_INCLUDEDIR})
set(FLATBUFFERS_LIBRARY_DIR ${FLATBUFFERS_INSTALL_PREFIX}/${FLATBUFFERS_INSTALL_LIBDIR})
set(FLATBUFFERS_BINARY_DIR ${FLATBUFFERS_INSTALL_PREFIX}/${FLATBUFFERS_INSTALL_BINDIR})
set(FLATC_EXECUTABLE_NAME flatc)
set(FLATBUFFERS_FLATC_EXECUTABLE ${FLATBUFFERS_BINARY_DIR}/${FLATC_EXECUTABLE_NAME})
set(FLATBUFFERS_LIBRARY_NAMES libflatbuffers.a)
foreach(LIBRARY_NAME ${FLATBUFFERS_LIBRARY_NAMES})
list(APPEND FLATBUFFERS_STATIC_LIBRARIES ${FLATBUFFERS_LIBRARY_DIR}/${LIBRARY_NAME})
endforeach()
if(THIRD_PARTY)
ExternalProject_Add(
flatbuffers
PREFIX flatbuffers
URL ${FLATBUFFERS_URL}
URL_MD5 c62ffefb3d4548b127cca14ce047f16c
UPDATE_COMMAND bash -c "rm -f BUILD || true"
BUILD_IN_SOURCE 1
SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers/src/flatbuffers
BUILD_BYPRODUCTS ${FLATBUFFERS_STATIC_LIBRARIES}
CMAKE_ARGS -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-DCMAKE_INSTALL_PREFIX=${FLATBUFFERS_INSTALL_PREFIX}
-DCMAKE_INSTALL_INCLUDEDIR=${FLATBUFFERS_INSTALL_INCLUDEDIR}
-DCMAKE_INSTALL_LIBDIR=${FLATBUFFERS_INSTALL_LIBDIR}
-DCMAKE_INSTALL_BINDIR=${FLATBUFFERS_INSTALL_BINDIR}
-DCMAKE_INSTALL_MESSAGE:STRING=${CMAKE_INSTALL_MESSAGE}
-DFLATBUFFERS_BUILD_TESTS=OFF)
endif(THIRD_PARTY)
cmake/third_party/glog.cmake 0 → 100644
View file @ 21d47d0e
include(ExternalProject)
set_mirror_url_with_hash(glog_URL https://github.com/google/glog/archive/refs/tags/v0.5.0.tar.gz
2368e3e0a95cce8b5b35a133271b480f)
include(FetchContent)
FetchContent_Declare(glog URL ${glog_URL} URL_HASH MD5=${glog_URL_HASH})
set(WITH_GFLAGS OFF CACHE BOOL "")
set(BUILD_SHARED_LIBS OFF CACHE BOOL "")
set(WITH_GTEST OFF CACHE BOOL "")
FetchContent_MakeAvailable(glog)
# just for tensorflow, DO NOT USE IN OTHER PLACE
FetchContent_GetProperties(glog)
set(GLOG_INCLUDE_DIR ${glog_BINARY_DIR})
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment