CMakeLists.txt 16.1 KB
Newer Older
1
cmake_minimum_required(VERSION 3.5)
Minjie Wang's avatar
Minjie Wang committed
2
3
4
5
########################################
# Borrowed and adapted from TVM project
########################################
project(dgl C CXX)
6
7
8
9
10
11
message(STATUS "Start configuring project ${PROJECT_NAME}")

# cmake utils
include(cmake/util/Util.cmake)
include(cmake/util/MshadowUtil.cmake)
include(cmake/util/FindCUDA.cmake)
Minjie Wang's avatar
Minjie Wang committed
12
13
14
15
16
17
18
19
20

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()

21
22
23
24
25
# 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)
26
dgl_option(USE_OPENMP "Build with OpenMP" ON)
27
dgl_option(USE_LIBXSMM "Build with LIBXSMM library optimization" ON)
Zhi Lin's avatar
Zhi Lin committed
28
dgl_option(USE_TVM "Build with TVM kernels" OFF)
29
dgl_option(BUILD_CPP_TEST "Build cpp unittest executables" OFF)
30
dgl_option(LIBCXX_ENABLE_PARALLEL_ALGORITHMS "Enable the parallel algorithms library. This requires the PSTL to be available." OFF)
31
32
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
Jinjing Zhou's avatar
Jinjing Zhou committed
33
dgl_option(REBUILD_LIBXSMM "Clean LIBXSMM build cache at every build" OFF) # Set env HADOOP_HDFS_HOME if needed
34
dgl_option(USE_EPOLL "Build with epoll for socket communicator" ON)
35
dgl_option(TP_BUILD_LIBUV "Build libuv together with tensorpipe (only impacts Linux)" ON)
36
dgl_option(BUILD_TORCH "Build the PyTorch plugin" OFF)
37
dgl_option(BUILD_SPARSE "Build DGL sparse library" ON)
38
dgl_option(BUILD_GRAPHBOLT "Build Graphbolt library" OFF)
39
dgl_option(TORCH_PYTHON_INTERPS "Python interpreter used to build tensoradapter and DGL sparse library" python3)
40

VoVAllen's avatar
VoVAllen committed
41
42
# Set debug compile option for gdb, only happens when -DCMAKE_BUILD_TYPE=DEBUG
if (NOT MSVC)
43
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -O0 -g3 -ggdb")
VoVAllen's avatar
VoVAllen committed
44
endif(NOT MSVC)
45
46
47

if(USE_CUDA)
  message(STATUS "Build with CUDA support")
48
  project(dgl C CXX)
49
50
  # see https://github.com/NVIDIA/thrust/issues/1401
  add_definitions(-DTHRUST_CUB_WRAPPED_NAMESPACE=dgl)
51
  include(cmake/modules/CUDA.cmake)
52
53
  message(STATUS "Use external CUB/Thrust library for a consistent API and performance.")
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/thrust")
54
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/thrust/dependencies/cub")
55
56
endif(USE_CUDA)

Minjie Wang's avatar
Minjie Wang committed
57
# initial variables
58
59
60
61
if(NOT MSVC)
set(DGL_LINKER_LIBS "dl")
endif(NOT MSVC)

62
if(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
Minjie Wang's avatar
Minjie Wang committed
63
set(DGL_RUNTIME_LINKER_LIBS "")
64
65
66
else(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
set(DGL_RUNTIME_LINKER_LIBS "rt")
endif(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
Minjie Wang's avatar
Minjie Wang committed
67
68
69
70
71
72

# 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)
73
  add_definitions(-DNOMINMAX)
VoVAllen's avatar
VoVAllen committed
74
  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS 1)
Minjie Wang's avatar
Minjie Wang committed
75
76
77
78
79
80
81
82
83
84
85
86
87
88
  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)
89
90
  # tensorpipe's dependencies require C++14
  check_cxx_compiler_flag("-std=c++14"    SUPPORT_CXX14)
91
  set(CMAKE_C_FLAGS "-O2 -Wall -fPIC ${CMAKE_C_FLAGS}")
92
  set(CMAKE_CXX_FLAGS "-O2 -Wall -fPIC -std=c++14 ${CMAKE_CXX_FLAGS}")
93
94
95
  if(NOT APPLE)
    set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--warn-common ${CMAKE_SHARED_LINKER_FLAGS}")
  endif(NOT APPLE)
96
endif(MSVC)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
97

98
if(USE_OPENMP)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
99
100
101
102
103
  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)
104
  message(STATUS "Build with OpenMP.")
105
106
endif(USE_OPENMP)

107
108
109
110
111
if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
  message(STATUS "Disabling LIBXSMM on ${CMAKE_SYSTEM_PROCESSOR}.")
  set(USE_LIBXSMM OFF)
endif()

112
113
114
115
116
if(USE_LIBXSMM)
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_LIBXSMM -DDGL_CPU_LLC_SIZE=40000000")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_LIBXSMM -DDGL_CPU_LLC_SIZE=40000000")
  message(STATUS "Build with LIBXSMM optimization.")
endif(USE_LIBXSMM)
117

118
119
if ((NOT MSVC) AND USE_EPOLL)
  INCLUDE(CheckIncludeFile)
120
121
  check_include_file("sys/epoll.h" EPOLL_AVAILABLE)
  if (EPOLL_AVAILABLE)
122
123
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_EPOLL")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_EPOLL")
124
125
  else()
    message(WARNING "EPOLL is not available on this platform...")
126
127
128
  endif()
endif ()

129
# To compile METIS correct for DGL.
130
131
132
133
134
135
136
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)
137

138
139
# configure minigun
add_definitions(-DENABLE_PARTIAL_FRONTIER=0)  # disable minigun partial frontier compile
Minjie Wang's avatar
Minjie Wang committed
140
# Source file lists
141
142
file(GLOB DGL_SRC
  src/*.cc
143
144
  src/array/*.cc
  src/array/cpu/*.cc
145
146
  src/random/*.cc
  src/random/cpu/*.cc
147
  src/runtime/*.cc
148
149
  src/geometry/*.cc
  src/geometry/cpu/*.cc
150
  src/partition/*.cc
151
152
153
)

file(GLOB_RECURSE DGL_SRC_1
154
  src/api/*.cc
155
156
157
  src/graph/*.cc
  src/scheduler/*.cc
)
Minjie Wang's avatar
Minjie Wang committed
158

159
list(APPEND DGL_SRC ${DGL_SRC_1})
Minjie Wang's avatar
Minjie Wang committed
160

161
162
163
164
165
166
167
if (NOT MSVC)
  file(GLOB_RECURSE DGL_RPC_SRC src/rpc/*.cc)
else()
  file(GLOB_RECURSE DGL_RPC_SRC src/rpc/network/*.cc)
endif()
list(APPEND DGL_SRC ${DGL_RPC_SRC})

168
# Configure cuda
169
170
171
172
173
174
175
if(USE_CUDA)
  dgl_config_cuda(DGL_CUDA_SRC)
  list(APPEND DGL_SRC ${DGL_CUDA_SRC})
  cuda_add_library(dgl SHARED ${DGL_SRC})
else(USE_CUDA)
  add_library(dgl SHARED ${DGL_SRC})
endif(USE_CUDA)
Minjie Wang's avatar
Minjie Wang committed
176

177
178
set_property(TARGET dgl PROPERTY CXX_STANDARD 14)

Zhi Lin's avatar
Zhi Lin committed
179
180
181
182
183
184
185
# include directories
target_include_directories(dgl PRIVATE "include")
target_include_directories(dgl PRIVATE "third_party/dlpack/include")
target_include_directories(dgl PRIVATE "third_party/dmlc-core/include")
target_include_directories(dgl PRIVATE "third_party/phmap/")
target_include_directories(dgl PRIVATE "third_party/METIS/include/")
target_include_directories(dgl PRIVATE "tensoradapter/include")
186
target_include_directories(dgl PRIVATE "third_party/nanoflann/include")
187
target_include_directories(dgl PRIVATE "third_party/libxsmm/include")
188
target_include_directories(dgl PRIVATE "third_party/pcg/include")
189

VoVAllen's avatar
VoVAllen committed
190
# For serialization
191
192
193
if (USE_HDFS)
  option(DMLC_HDFS_SHARED "dgl has to build with dynamic hdfs library" ON)
endif()
VoVAllen's avatar
VoVAllen committed
194
195
196
197
add_subdirectory("third_party/dmlc-core")
list(APPEND DGL_LINKER_LIBS dmlc)
set(GOOGLE_TEST 0) # Turn off dmlc-core test

198
# Compile METIS
199
if(NOT MSVC)
200
  set(GKLIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/third_party/METIS/GKlib")
201
202
  include(${GKLIB_PATH}/GKlibSystem.cmake)
  include_directories(${GKLIB_PATH})
Zhi Lin's avatar
Zhi Lin committed
203
  include_directories("third_party/METIS/include/")
204
205
206
  add_subdirectory("third_party/METIS/libmetis/")
  list(APPEND DGL_LINKER_LIBS metis)
endif(NOT MSVC)
207

208
209
# Compile LIBXSMM
if((NOT MSVC) AND USE_LIBXSMM)
210
211
212
213
  set(LIBXSMM_COMPILER "${CMAKE_C_COMPILER}")
  if (APPLE)
    set(LIBXSMM_COMPILER "${CMAKE_C_COMPILER} -isysroot ${CMAKE_OSX_SYSROOT}")
  endif()
Jinjing Zhou's avatar
Jinjing Zhou committed
214
  if(REBUILD_LIBXSMM)
215
    add_custom_target(libxsmm COMMAND make realclean COMMAND make -j ECFLAGS="-Wno-error=deprecated-declarations" BLAS=0 CC=${LIBXSMM_COMPILER}
Jinjing Zhou's avatar
Jinjing Zhou committed
216
217
218
                      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/third_party/libxsmm
                      )
  else(REBUILD_LIBXSMM)
219
    add_custom_target(libxsmm COMMAND make -j ECFLAGS="-Wno-error=deprecated-declarations" BLAS=0 CC=${LIBXSMM_COMPILER}
Jinjing Zhou's avatar
Jinjing Zhou committed
220
221
222
                      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/third_party/libxsmm
                      )
  endif(REBUILD_LIBXSMM)
223
  add_dependencies(dgl libxsmm)
Andrzej Kotłowski's avatar
Andrzej Kotłowski committed
224
  list(APPEND DGL_LINKER_LIBS -L${CMAKE_SOURCE_DIR}/third_party/libxsmm/lib/ xsmm.a)
225
226
endif((NOT MSVC) AND USE_LIBXSMM)

227
228
229
if(NOT MSVC)
  # Only build tensorpipe on linux
  string(REPLACE "-pedantic" "" CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
230
231
232
  # Disable -Wall for third-party tensorpipe due to too many warnings
  string(REPLACE "-Wall" "" CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
  string(REPLACE "-Wall" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
bgawrych's avatar
bgawrych committed
233
234
235
236
237
238
  set(WNOERROR_FLAGS "-Wno-error=sign-compare")
  if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0)
      set(WNOERROR_FLAGS "${WNOERROR_FLAGS} -Wno-error=dangling-pointer")
  endif()
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WNOERROR_FLAGS}")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WNOERROR_FLAGS}")
239
240
241
242
  set(TP_STATIC_OR_SHARED STATIC)
  add_subdirectory(third_party/tensorpipe)
  list(APPEND DGL_LINKER_LIBS tensorpipe)
  target_include_directories(dgl PRIVATE third_party/tensorpipe)
243
244
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
bgawrych's avatar
bgawrych committed
245
246
247
  string(REPLACE "${WNOERROR_FLAGS}" "" CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
  string(REPLACE "${WNOERROR_FLAGS}" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})

czkkkkkk's avatar
czkkkkkk committed
248
  # Avoid exposing third-party symbols when using DGL as a library.
249
250
251
252
  if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,--exclude-libs,ALL")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--exclude-libs,ALL")
  endif()
253
254
endif(NOT MSVC)

Zhi Lin's avatar
Zhi Lin committed
255
256
257
258
259
260
261
262
263
264
# Compile TVM Runtime and Featgraph
# (NOTE) We compile a dynamic library called featgraph_runtime, which the DGL library links to.
# Kernels are packed in a separate dynamic library called featgraph_kernels, which DGL
# will load during runtime.
if(USE_TVM)
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_TVM")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_TVM")
  target_include_directories(dgl PRIVATE "featgraph/include")
  add_subdirectory("featgraph/")
  list(APPEND DGL_LINKER_LIBS featgraph_runtime)
265
  message(STATUS "Build with TVM runtime and featgraph kernels.")
Zhi Lin's avatar
Zhi Lin committed
266
267
endif(USE_TVM)

268
269
270
271
# support PARALLEL_ALGORITHMS
if (LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
  add_definitions(-DPARALLEL_ALGORITHMS)
endif(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
272

Minjie Wang's avatar
Minjie Wang committed
273
target_link_libraries(dgl ${DGL_LINKER_LIBS} ${DGL_RUNTIME_LINKER_LIBS})
274
275
276
if(MSVC)
  add_custom_command(
    TARGET dgl POST_BUILD COMMAND
277
    ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:dgl>" "$<TARGET_FILE_DIR:dgl>/..")
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
endif(MSVC)

# Tensor adapter libraries
# Linking against LibTorch involves linking against a bunch of other libraries
# returned by PyTorch's CMake (e.g. C10 or NVTools).  Because CMake caches
# the found libraries in find_library(), often times CMake will look into the libraries
# of the wrong version when I build everything in the same CMake process.  As
# a result, I (BarclayII) am launching an individual CMake build for every PyTorch version.
if(BUILD_TORCH)
  file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR} BINDIR)
  file(TO_NATIVE_PATH ${CMAKE_COMMAND} CMAKE_CMD)
  if(MSVC)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/tensoradapter/pytorch/build.bat BUILD_SCRIPT)
    add_custom_target(
      tensoradapter_pytorch
      ${CMAKE_COMMAND} -E env
      CMAKE_COMMAND=${CMAKE_CMD}
      CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
296
      USE_CUDA=${USE_CUDA}
297
298
299
300
301
302
303
304
305
306
307
      BINDIR=${BINDIR}
      cmd /e:on /c ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tensoradapter/pytorch)
  else(MSVC)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/tensoradapter/pytorch/build.sh BUILD_SCRIPT)
    add_custom_target(
      tensoradapter_pytorch
      ${CMAKE_COMMAND} -E env
      CMAKE_COMMAND=${CMAKE_CMD}
      CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
308
      USE_CUDA=${USE_CUDA}
309
310
311
312
313
314
315
      BINDIR=${CMAKE_CURRENT_BINARY_DIR}
      bash ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tensoradapter/pytorch)
  endif(MSVC)
  add_dependencies(dgl tensoradapter_pytorch)
endif(BUILD_TORCH)
Minjie Wang's avatar
Minjie Wang committed
316
317
318

# Installation rules
install(TARGETS dgl DESTINATION lib${LIB_SUFFIX})
VoVAllen's avatar
VoVAllen committed
319
320
321

# Testing
if(BUILD_CPP_TEST)
322
  message(STATUS "Build with unittest")
VoVAllen's avatar
VoVAllen committed
323
324
325
  add_subdirectory(./third_party/googletest)
  enable_testing()
  include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
Zhi Lin's avatar
Zhi Lin committed
326
327
328
  include_directories("include")
  include_directories("third_party/dlpack/include")
  include_directories("third_party/dmlc-core/include")
329
  include_directories("third_party/phmap")
330
  include_directories("third_party/libxsmm/include")
331
  include_directories("third_party/pcg/include")
VoVAllen's avatar
VoVAllen committed
332
333
334
335
336
  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)
337
338
339
340
341
342
343
344
345
346

  if(NOT MSVC)
    message(STATUS "Building dist/rpc tests")
    file(GLOB_RECURSE TEST_SRC_FILES ${PROJECT_SOURCE_DIR}/tests/dist/cpp/rpc_client.cc)
    add_executable(rpc_client ${TEST_SRC_FILES})
    target_link_libraries(rpc_client dgl)
    file(GLOB_RECURSE TEST_SRC_FILES ${PROJECT_SOURCE_DIR}/tests/dist/cpp/rpc_server.cc)
    add_executable(rpc_server ${TEST_SRC_FILES})
    target_link_libraries(rpc_server dgl)
  endif(NOT MSVC)
VoVAllen's avatar
VoVAllen committed
347
endif(BUILD_CPP_TEST)
czkkkkkk's avatar
czkkkkkk committed
348
349

if(BUILD_SPARSE)
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
  message(STATUS "Configuring DGL sparse library")
  file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR} BINDIR)
  file(TO_NATIVE_PATH ${CMAKE_COMMAND} CMAKE_CMD)
  get_target_property(DGL_INCLUDE_DIRS dgl INCLUDE_DIRECTORIES)
  message(STATUS "DGL include directories: ${DGL_INCLUDE_DIRS}")
  message(STATUS "DGL link directories: ${DGL_INCLUDE_DIRS}")
  if(MSVC)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/dgl_sparse/build.bat BUILD_SCRIPT)
    add_custom_target(
      dgl_sparse
      ALL
      ${CMAKE_COMMAND} -E env
      CMAKE_COMMAND=${CMAKE_CMD}
      CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
      USE_CUDA=${USE_CUDA}
      BINDIR=${BINDIR}
      INCLUDEDIR="${DGL_INCLUDE_DIRS}"
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
      LDFLAGS=${CMAKE_SHARED_LINKER_FLAGS}
      cmd /e:on /c ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/dgl_sparse)
  else(MSVC)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/dgl_sparse/build.sh BUILD_SCRIPT)
    add_custom_target(
      dgl_sparse
      ALL
      ${CMAKE_COMMAND} -E env
      CMAKE_COMMAND=${CMAKE_CMD}
      CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
      USE_CUDA=${USE_CUDA}
      BINDIR=${CMAKE_CURRENT_BINARY_DIR}
      INCLUDEDIR="${DGL_INCLUDE_DIRS}"
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
      LDFLAGS=${CMAKE_SHARED_LINKER_FLAGS}
      bash ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/dgl_sparse)
  endif(MSVC)
  add_dependencies(dgl_sparse dgl)
czkkkkkk's avatar
czkkkkkk committed
392
endif(BUILD_SPARSE)
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427

if(BUILD_GRAPHBOLT)
  message(STATUS "Configuring graphbolt library")
  file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR} BINDIR)
  file(TO_NATIVE_PATH ${CMAKE_COMMAND} CMAKE_CMD)
  if(MSVC)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/graphbolt/build.bat BUILD_SCRIPT)
    add_custom_target(
      graphbolt
      ALL
      ${CMAKE_COMMAND} -E env
      CMAKE_COMMAND=${CMAKE_CMD}
      BINDIR=${BINDIR}
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
      LDFLAGS=${CMAKE_SHARED_LINKER_FLAGS}
      cmd /e:on /c ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/graphbolt)
  else(MSVC)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/graphbolt/build.sh BUILD_SCRIPT)
    add_custom_target(
      graphbolt
      ALL
      ${CMAKE_COMMAND} -E env
      CMAKE_COMMAND=${CMAKE_CMD}
      BINDIR=${CMAKE_CURRENT_BINARY_DIR}
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
      LDFLAGS=${CMAKE_SHARED_LINKER_FLAGS}
      bash ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/graphbolt)
  endif(MSVC)
endif(BUILD_GRAPHBOLT)