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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
# TODO(#5475): Clean up the old flags after CI and regression framework adopt to the new setup.
if (NOT DEFINED BUILD_TYPE)
  dgl_option(USE_CUDA "Build with CUDA" OFF)
  dgl_option(USE_OPENMP "Build with OpenMP" ON)
  dgl_option(USE_LIBXSMM "Build with LIBXSMM library optimization" 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
  dgl_option(REBUILD_LIBXSMM "Clean LIBXSMM build cache at every build" OFF) # Set env HADOOP_HDFS_HOME if needed
  dgl_option(USE_EPOLL "Build with epoll for socket communicator" ON)
  dgl_option(BUILD_TORCH "Build the PyTorch plugin" OFF)
  dgl_option(BUILD_SPARSE "Build DGL sparse library" ON)
  dgl_option(BUILD_GRAPHBOLT "Build Graphbolt library" OFF)
  dgl_option(TORCH_PYTHON_INTERPS "Python interpreter used to build tensoradapter and DGL sparse library" python3)
else()
  # Options for building DGL.
  # NOTE: do not modify this file to change option values.
  # Use bash script/build_dgl.sh -e '-DOPTION=VALUE' through command-line.
  dgl_option(
      BUILD_TYPE
      "Type of the build: dev, test or release"
      "dev"
  )
  message(STATUS "Build for ${BUILD_TYPE}")

  dgl_option(
      USE_CUDA
      "Build with CUDA"
      OFF
  )
  dgl_option(
      TORCH_PYTHON_INTERPS
      "Python interpreter used to build tensoradapter and DGL sparse library"
      python3
  )

  # Options for building DGL features.
  # NOTE: do not modify this file to change option values.
  # Use bash script/build_dgl.sh -e '-DFEATURE_NAME=ON/OFF' through command-line.
  dgl_feature_option(
      BUILD_SPARSE
      "Build DGL sparse library"
      "dev" "test" "release"
  )
  dgl_feature_option(
      USE_EPOLL
      "Build with epoll for socket communicator"
      "dev" "test" "release"
  )
  dgl_feature_option(
      USE_LIBXSMM
      "Build with LIBXSMM library optimization"
      "dev" "test" "release"
  )
  dgl_feature_option(
      USE_OPENMP
      "Build with OpenMP"
      "dev" "test" "release"
  )

  dgl_feature_option(
      BUILD_GRAPHBOLT
      "Build Graphbolt library"
      "dev" "test"
  )

  dgl_feature_option(
      BUILD_TORCH
      "Build the PyTorch plugin"
      "none"
  )
  dgl_feature_option(
      LIBCXX_ENABLE_PARALLEL_ALGORITHMS
      "Enable the parallel algorithms library. This requires the PSTL to be available."
      "none"
  )
  dgl_feature_option(
      REBUILD_LIBXSMM
      "Clean LIBXSMM build cache at every build"
      "none"
  )
  dgl_feature_option(
      USE_HDFS
      "Build with HDFS support"
      "none"
  ) # Set env HADOOP_HDFS_HOME if needed
  dgl_feature_option(
      USE_S3
      "Build with S3 support"
      "none"
  )

  # Build cpp test only in test build.
  dgl_feature_option(
      BUILD_CPP_TEST
      "Build cpp unittest executables"
      "test"
  )
endif()
113

VoVAllen's avatar
VoVAllen committed
114
115
# Set debug compile option for gdb, only happens when -DCMAKE_BUILD_TYPE=DEBUG
if (NOT MSVC)
116
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -O0 -g3 -ggdb")
VoVAllen's avatar
VoVAllen committed
117
endif(NOT MSVC)
118
119
120

if(USE_CUDA)
  message(STATUS "Build with CUDA support")
121
  project(dgl C CXX)
122
123
  # see https://github.com/NVIDIA/thrust/issues/1401
  add_definitions(-DTHRUST_CUB_WRAPPED_NAMESPACE=dgl)
124
  include(cmake/modules/CUDA.cmake)
125
126
  message(STATUS "Use external CUB/Thrust library for a consistent API and performance.")
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/thrust")
127
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/thrust/dependencies/cub")
128
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/thrust/dependencies/libcudacxx/include")
129
130
endif(USE_CUDA)

Minjie Wang's avatar
Minjie Wang committed
131
# initial variables
132
133
134
135
if(NOT MSVC)
set(DGL_LINKER_LIBS "dl")
endif(NOT MSVC)

136
if(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
Minjie Wang's avatar
Minjie Wang committed
137
set(DGL_RUNTIME_LINKER_LIBS "")
138
139
140
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
141
142
143
144
145
146

# 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)
147
  add_definitions(-DNOMINMAX)
VoVAllen's avatar
VoVAllen committed
148
  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS 1)
Minjie Wang's avatar
Minjie Wang committed
149
150
151
152
153
154
155
156
157
158
159
160
161
162
  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)
163
  set(CMAKE_C_FLAGS "-O2 -Wall -fPIC ${CMAKE_C_FLAGS}")
164
  set(CMAKE_CXX_FLAGS "-O2 -Wall -fPIC ${CMAKE_CXX_FLAGS}")
165
166
167
  if(NOT APPLE)
    set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--warn-common ${CMAKE_SHARED_LINKER_FLAGS}")
  endif(NOT APPLE)
168
endif(MSVC)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
169

170
if(USE_OPENMP)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
171
172
173
174
175
  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)
176
  message(STATUS "Build with OpenMP.")
177
178
endif(USE_OPENMP)

179
180
181
182
183
if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
  message(STATUS "Disabling LIBXSMM on ${CMAKE_SYSTEM_PROCESSOR}.")
  set(USE_LIBXSMM OFF)
endif()

184
185
186
187
188
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)
189

190
191
if ((NOT MSVC) AND USE_EPOLL)
  INCLUDE(CheckIncludeFile)
192
193
  check_include_file("sys/epoll.h" EPOLL_AVAILABLE)
  if (EPOLL_AVAILABLE)
194
195
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_EPOLL")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_EPOLL")
196
197
  else()
    message(WARNING "EPOLL is not available on this platform...")
198
199
200
  endif()
endif ()

201
# To compile METIS correct for DGL.
202
203
204
205
206
207
208
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)
209

210
211
# configure minigun
add_definitions(-DENABLE_PARTIAL_FRONTIER=0)  # disable minigun partial frontier compile
Minjie Wang's avatar
Minjie Wang committed
212
# Source file lists
213
214
file(GLOB DGL_SRC
  src/*.cc
215
216
  src/array/*.cc
  src/array/cpu/*.cc
217
218
  src/random/*.cc
  src/random/cpu/*.cc
219
  src/runtime/*.cc
220
221
  src/geometry/*.cc
  src/geometry/cpu/*.cc
222
  src/partition/*.cc
223
224
225
)

file(GLOB_RECURSE DGL_SRC_1
226
  src/api/*.cc
227
228
229
  src/graph/*.cc
  src/scheduler/*.cc
)
Minjie Wang's avatar
Minjie Wang committed
230

231
list(APPEND DGL_SRC ${DGL_SRC_1})
Minjie Wang's avatar
Minjie Wang committed
232

233
234
235
236
237
238
239
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})

240
# Configure cuda
241
242
243
244
245
246
247
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
248

249
250
set_property(TARGET dgl PROPERTY CXX_STANDARD 14)

Zhi Lin's avatar
Zhi Lin committed
251
252
253
254
255
256
257
# 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")
258
target_include_directories(dgl PRIVATE "third_party/nanoflann/include")
259
target_include_directories(dgl PRIVATE "third_party/libxsmm/include")
260
target_include_directories(dgl PRIVATE "third_party/pcg/include")
261

VoVAllen's avatar
VoVAllen committed
262
# For serialization
263
264
265
if (USE_HDFS)
  option(DMLC_HDFS_SHARED "dgl has to build with dynamic hdfs library" ON)
endif()
VoVAllen's avatar
VoVAllen committed
266
267
268
269
add_subdirectory("third_party/dmlc-core")
list(APPEND DGL_LINKER_LIBS dmlc)
set(GOOGLE_TEST 0) # Turn off dmlc-core test

270
# Compile METIS
271
if(NOT MSVC)
272
  set(GKLIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/third_party/METIS/GKlib")
273
274
  include(${GKLIB_PATH}/GKlibSystem.cmake)
  include_directories(${GKLIB_PATH})
Zhi Lin's avatar
Zhi Lin committed
275
  include_directories("third_party/METIS/include/")
276
277
278
  add_subdirectory("third_party/METIS/libmetis/")
  list(APPEND DGL_LINKER_LIBS metis)
endif(NOT MSVC)
279

280
281
# Compile LIBXSMM
if((NOT MSVC) AND USE_LIBXSMM)
282
283
284
285
  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
286
  if(REBUILD_LIBXSMM)
287
    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
288
289
290
                      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/third_party/libxsmm
                      )
  else(REBUILD_LIBXSMM)
291
    add_custom_target(libxsmm COMMAND make -j ECFLAGS="-Wno-error=deprecated-declarations" BLAS=0 CC=${LIBXSMM_COMPILER}
Jinjing Zhou's avatar
Jinjing Zhou committed
292
293
294
                      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/third_party/libxsmm
                      )
  endif(REBUILD_LIBXSMM)
295
  add_dependencies(dgl libxsmm)
Andrzej Kotłowski's avatar
Andrzej Kotłowski committed
296
  list(APPEND DGL_LINKER_LIBS -L${CMAKE_SOURCE_DIR}/third_party/libxsmm/lib/ xsmm.a)
297
298
endif((NOT MSVC) AND USE_LIBXSMM)

299
300
301
302
303
# Avoid exposing third-party symbols when using DGL as a library.
if((NOT MSVC) AND (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()
304

305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
# Compile gpu_cache
if(USE_CUDA)
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_GPU_CACHE")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_GPU_CACHE")
  # Manually build gpu_cache because CMake always builds it as shared
  file(GLOB gpu_cache_src
    third_party/HugeCTR/gpu_cache/src/nv_gpu_cache.cu
  )
  cuda_add_library(gpu_cache STATIC ${gpu_cache_src})
  target_include_directories(gpu_cache PRIVATE "third_party/HugeCTR/gpu_cache/include")
  target_include_directories(dgl PRIVATE "third_party/HugeCTR/gpu_cache/include")
  list(APPEND DGL_LINKER_LIBS gpu_cache)
  message(STATUS "Build with HugeCTR GPU embedding cache.")
endif(USE_CUDA)

320
321
322
323
# support PARALLEL_ALGORITHMS
if (LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
  add_definitions(-DPARALLEL_ALGORITHMS)
endif(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
324

Minjie Wang's avatar
Minjie Wang committed
325
target_link_libraries(dgl ${DGL_LINKER_LIBS} ${DGL_RUNTIME_LINKER_LIBS})
326
327
328
if(MSVC)
  add_custom_command(
    TARGET dgl POST_BUILD COMMAND
329
    ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:dgl>" "$<TARGET_FILE_DIR:dgl>/..")
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
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}
348
      USE_CUDA=${USE_CUDA}
349
350
351
352
353
354
355
356
357
358
359
      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}
360
      USE_CUDA=${USE_CUDA}
361
362
363
364
365
366
367
      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
368
369
370

# Installation rules
install(TARGETS dgl DESTINATION lib${LIB_SUFFIX})
VoVAllen's avatar
VoVAllen committed
371
372
373

# Testing
if(BUILD_CPP_TEST)
374
  message(STATUS "Build with unittest")
VoVAllen's avatar
VoVAllen committed
375
376
377
  add_subdirectory(./third_party/googletest)
  enable_testing()
  include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
Zhi Lin's avatar
Zhi Lin committed
378
379
380
  include_directories("include")
  include_directories("third_party/dlpack/include")
  include_directories("third_party/dmlc-core/include")
381
  include_directories("third_party/phmap")
382
  include_directories("third_party/libxsmm/include")
383
  include_directories("third_party/pcg/include")
VoVAllen's avatar
VoVAllen committed
384
385
386
387
388
389
  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)
czkkkkkk's avatar
czkkkkkk committed
390
391

if(BUILD_SPARSE)
392
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
428
429
430
431
432
433
  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
434
endif(BUILD_SPARSE)
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469

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)