dmlc--dgl
Quan (Andy) Gan
196 行
6.7 KiB
CMake
196 行
6.7 KiB
CMake
cmake_minimum_required(VERSION 3.5)
|
|
########################################
|
|
# Borrowed and adapted from TVM project
|
|
########################################
|
|
project(dgl C CXX)
|
|
message(STATUS "Start configuring project ${PROJECT_NAME}")
|
|
|
|
# cmake utils
|
|
include(cmake/util/Util.cmake)
|
|
include(cmake/util/MshadowUtil.cmake)
|
|
include(cmake/util/FindCUDA.cmake)
|
|
|
|
if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/config.cmake)
|
|
include(${CMAKE_CURRENT_BINARY_DIR}/config.cmake)
|
|
else()
|
|
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/config.cmake)
|
|
include(${CMAKE_CURRENT_SOURCE_DIR}/config.cmake)
|
|
endif()
|
|
endif()
|
|
|
|
# NOTE: do not modify this file to change option values.
|
|
# You can create a config.cmake at build folder
|
|
# and add set(OPTION VALUE) to override these build options.
|
|
# Alernatively, use cmake -DOPTION=VALUE through command-line.
|
|
dgl_option(USE_CUDA "Build with CUDA" OFF)
|
|
dgl_option(USE_OPENMP "Build with OpenMP" ON)
|
|
dgl_option(BUILD_CPP_TEST "Build cpp unittest executables" OFF)
|
|
dgl_option(LIBCXX_ENABLE_PARALLEL_ALGORITHMS "Enable the parallel algorithms library. This requires the PSTL to be available." OFF)
|
|
dgl_option(USE_S3 "Build with S3 support" OFF)
|
|
dgl_option(USE_HDFS "Build with HDFS support" OFF) # Set env HADOOP_HDFS_HOME if needed
|
|
|
|
# Set debug compile option for gdb, only happens when -DCMAKE_BUILD_TYPE=DEBUG
|
|
if (NOT MSVC)
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g3 -ggdb")
|
|
endif(NOT MSVC)
|
|
|
|
if(USE_CUDA)
|
|
message(STATUS "Build with CUDA support")
|
|
project(dgl C CXX)
|
|
include(cmake/modules/CUDA.cmake)
|
|
if ((CUDA_VERSION_MAJOR LESS 11) OR
|
|
((CUDA_VERSION_MAJOR EQUAL 11) AND (CUDA_VERSION_MINOR EQUAL 0)))
|
|
# For cuda<11, use external CUB/Thrust library because CUB is not part of CUDA.
|
|
# For cuda==11.0, use external CUB/Thrust library because there is a bug in the
|
|
# official CUB library which causes invalid device ordinal error for DGL. The bug
|
|
# is fixed by https://github.com/NVIDIA/cub/commit/9143e47e048641aa0e6ddfd645bcd54ff1059939
|
|
# in 11.1.
|
|
message(STATUS "Detected CUDA of version ${CUDA_VERSION}. Use external CUB/Thrust library.")
|
|
cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/thrust")
|
|
cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/cub")
|
|
endif()
|
|
endif(USE_CUDA)
|
|
|
|
# include directories
|
|
include_directories("include")
|
|
include_directories("third_party/dlpack/include")
|
|
include_directories("third_party/METIS/include/")
|
|
include_directories("third_party/dmlc-core/include")
|
|
include_directories("third_party/minigun/minigun")
|
|
include_directories("third_party/minigun/third_party/moderngpu/src")
|
|
include_directories("third_party/phmap/")
|
|
include_directories("third_party/xbyak/")
|
|
|
|
# initial variables
|
|
set(DGL_LINKER_LIBS "")
|
|
if(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
|
|
set(DGL_RUNTIME_LINKER_LIBS "")
|
|
else(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
|
|
set(DGL_RUNTIME_LINKER_LIBS "rt")
|
|
endif(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
|
|
|
|
# Generic compilation options
|
|
if(MSVC)
|
|
add_definitions(-DWIN32_LEAN_AND_MEAN)
|
|
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
|
|
add_definitions(-D_SCL_SECURE_NO_WARNINGS)
|
|
add_definitions(-DNOMINMAX)
|
|
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS 1)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj")
|
|
if(USE_MSVC_MT)
|
|
foreach(flag_var
|
|
CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
|
|
CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
|
|
if(${flag_var} MATCHES "/MD")
|
|
string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
|
|
endif(${flag_var} MATCHES "/MD")
|
|
endforeach(flag_var)
|
|
endif()
|
|
else(MSVC)
|
|
include(CheckCXXCompilerFlag)
|
|
check_cxx_compiler_flag("-std=c++11" SUPPORT_CXX11)
|
|
set(CMAKE_C_FLAGS "-O2 -Wall -fPIC ${CMAKE_C_FLAGS}")
|
|
# We still use c++11 flag in CPU build because gcc5.4 (our default compiler) is
|
|
# not fully compatible with c++14 feature.
|
|
set(CMAKE_CXX_FLAGS "-O2 -Wall -fPIC -std=c++11 ${CMAKE_CXX_FLAGS}")
|
|
if(NOT APPLE)
|
|
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--warn-common ${CMAKE_SHARED_LINKER_FLAGS}")
|
|
endif(NOT APPLE)
|
|
endif(MSVC)
|
|
|
|
if(USE_OPENMP)
|
|
include(FindOpenMP)
|
|
if(OPENMP_FOUND)
|
|
set(CMAKE_C_FLAGS "${OpenMP_C_FLAGS} ${CMAKE_C_FLAGS}")
|
|
set(CMAKE_CXX_FLAGS "${OpenMP_CXX_FLAGS} ${CMAKE_CXX_FLAGS}")
|
|
endif(OPENMP_FOUND)
|
|
endif(USE_OPENMP)
|
|
|
|
# To compile METIS correct for DGL.
|
|
if(MSVC)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /DIDXTYPEWIDTH=64 /DREALTYPEWIDTH=32")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DIDXTYPEWIDTH=64 /DREALTYPEWIDTH=32")
|
|
else(MSVC)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DIDXTYPEWIDTH=64 -DREALTYPEWIDTH=32")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DIDXTYPEWIDTH=64 -DREALTYPEWIDTH=32")
|
|
endif(MSVC)
|
|
|
|
# configure minigun
|
|
add_definitions(-DENABLE_PARTIAL_FRONTIER=0) # disable minigun partial frontier compile
|
|
# Source file lists
|
|
file(GLOB DGL_SRC
|
|
src/*.cc
|
|
src/array/*.cc
|
|
src/array/cpu/*.cc
|
|
src/random/*.cc
|
|
src/random/cpu/*.cc
|
|
src/kernel/*.cc
|
|
src/kernel/cpu/*.cc
|
|
src/runtime/*.cc
|
|
src/geometry/*.cc
|
|
src/geometry/cpu/*.cc
|
|
)
|
|
|
|
file(GLOB_RECURSE DGL_SRC_1
|
|
src/api/*.cc
|
|
src/graph/*.cc
|
|
src/scheduler/*.cc
|
|
src/rpc/*.cc
|
|
)
|
|
|
|
list(APPEND DGL_SRC ${DGL_SRC_1})
|
|
|
|
# Configure cuda
|
|
if(USE_CUDA)
|
|
dgl_config_cuda(DGL_CUDA_SRC)
|
|
list(APPEND DGL_SRC ${DGL_CUDA_SRC})
|
|
endif(USE_CUDA)
|
|
|
|
if(USE_CUDA)
|
|
cuda_add_library(dgl SHARED ${DGL_SRC})
|
|
else(USE_CUDA)
|
|
add_library(dgl SHARED ${DGL_SRC})
|
|
endif(USE_CUDA)
|
|
|
|
# For serialization
|
|
if (USE_HDFS)
|
|
option(DMLC_HDFS_SHARED "dgl has to build with dynamic hdfs library" ON)
|
|
endif()
|
|
add_subdirectory("third_party/dmlc-core")
|
|
list(APPEND DGL_LINKER_LIBS dmlc)
|
|
set(GOOGLE_TEST 0) # Turn off dmlc-core test
|
|
|
|
# Compile METIS
|
|
if(NOT MSVC)
|
|
set(GKLIB_PATH "${CMAKE_SOURCE_DIR}/third_party/METIS/GKlib")
|
|
include(${GKLIB_PATH}/GKlibSystem.cmake)
|
|
include_directories(${GKLIB_PATH})
|
|
add_subdirectory("third_party/METIS/libmetis/")
|
|
list(APPEND DGL_LINKER_LIBS metis)
|
|
endif(NOT MSVC)
|
|
|
|
# support PARALLEL_ALGORITHMS
|
|
if (LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
|
|
add_definitions(-DPARALLEL_ALGORITHMS)
|
|
endif(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
|
|
|
|
target_link_libraries(dgl ${DGL_LINKER_LIBS} ${DGL_RUNTIME_LINKER_LIBS})
|
|
|
|
# Installation rules
|
|
install(TARGETS dgl DESTINATION lib${LIB_SUFFIX})
|
|
|
|
# Testing
|
|
if(BUILD_CPP_TEST)
|
|
message(STATUS "Build with unittest")
|
|
add_subdirectory(./third_party/googletest)
|
|
enable_testing()
|
|
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
|
|
file(GLOB_RECURSE TEST_SRC_FILES ${PROJECT_SOURCE_DIR}/tests/cpp/*.cc)
|
|
add_executable(runUnitTests ${TEST_SRC_FILES})
|
|
target_link_libraries(runUnitTests gtest gtest_main)
|
|
target_link_libraries(runUnitTests dgl)
|
|
add_test(UnitTests runUnitTests)
|
|
endif(BUILD_CPP_TEST)
|