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

8
9
10
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

11
12
13
14
# cmake utils
include(cmake/util/Util.cmake)
include(cmake/util/MshadowUtil.cmake)
include(cmake/util/FindCUDA.cmake)
Minjie Wang's avatar
Minjie Wang committed
15

16
17
18
# Options for building DGL.
# NOTE: Please avoid editing this file to change build type. Instead, using
# bash script/build_dgl.sh -e -t release to overwrite the value.
19
dgl_option(BUILD_TYPE "Type of the build: dev, dogfood or release" "dev")
20
message(STATUS "Build for ${BUILD_TYPE}")
21

22
dgl_option(USE_CUDA "Build with CUDA" OFF)
pyynb's avatar
pyynb committed
23
dgl_option(USE_LIBURING "Build with liburing" OFF)
24
dgl_option(TORCH_PYTHON_INTERPS "Python interpreter for building sub-components" python3)
25

26
27
28
29
30
31
32
33
34
35
# Conda build related options.
dgl_option(EXTERNAL_DLPACK_PATH "Path to external dlpack" OFF)
dgl_option(EXTERNAL_DMLC_PATH "Path to external dmlc-core" OFF)
dgl_option(EXTERNAL_DMLC_LIB_PATH "Path to external dmlc-core library" OFF)
dgl_option(EXTERNAL_PHMAP_PATH "Path to external parallel-hashmap" OFF)
dgl_option(EXTERNAL_NANOFLANN_PATH "Path to use external nanoflann" OFF)
dgl_option(EXTERNAL_METIS_PATH "Path to external metis" OFF)
dgl_option(EXTERNAL_METIS_LIB_PATH "Path to external metis library" OFF)
dgl_option(EXTERNAL_GKLIB_PATH "Path to external gklib" OFF)

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
# Options for building DGL features: "none," "dev," "dogfood," "release," and
# "all."
#    "none"  - The feature is OFF for all build types. This is used when
#              disabling a feature.
#    "dev"   - The feature is ON for dev build. The default build from source
#              and the build for unit tests are using this build type.
#  "dogfood" - The major function of this feature is done. The regression and
#              benchmark framework are using this build type.
#  "release" - The feature will be build for release.
#    "all"   - The feature is ON for all build types. Equivalent to set ["dev"
#              "dogfood" "release"].
# NOTE: Please avoid editing this file to change feature options for a local
# build. Instead, using bash script/build_dgl.sh -e '-DFEATURE_NAME=ON/OFF' to
# overwrite the value.
dgl_feature_option(
    BUILD_SPARSE
    "Build DGL sparse library"
    "all"
)
dgl_feature_option(
    BUILD_TORCH
    "Build the PyTorch plugin"
    "all"
)
dgl_feature_option(
    USE_EPOLL
    "Build with epoll for socket communicator"
    "all"
)
dgl_feature_option(
    USE_LIBXSMM
    "Build with LIBXSMM library optimization"
    "all"
)
dgl_feature_option(
    USE_OPENMP
    "Build with OpenMP"
    "all"
)
75

76
77
78
dgl_feature_option(
    BUILD_GRAPHBOLT
    "Build Graphbolt library"
79
    "all"
80
)
81

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
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"
)
102

103
104
105
106
107
108
# Only build C++ tests for unit testing purposes in dev build.
dgl_feature_option(
    BUILD_CPP_TEST
    "Build cpp unittest executables"
    "dev"
)
109

110
111
112
113
114
115
116
117
118
119
120
if (EXTERNAL_DLPACK_PATH OR EXTERNAL_DMLC_PATH OR EXTERNAL_NANOFLANN_PATH OR EXTERNAL_NANOFLANN_PATH OR EXTERNAL_METIS_PATH OR EXTERNAL_GKLIB_PATH)
  message(STATUS "Using at least one external library")
  set(USE_EXTERNAL_LIBS ON)
  
  if (BUILD_CPP_TEST)
    message(FATAL_ERROR "Cannot build cpp unittests with external libraries")
  endif(BUILD_CPP_TEST)
endif()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)

121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
# Set optimization options for different build types.
if (${BUILD_TYPE} STREQUAL "dev")
  if (MSVC)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Od")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Od")
  else()
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g3 -ggdb")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g3 -ggdb")
  endif()
else()
  if (MSVC)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /O2")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2")
  else()
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
  endif()
endif()
139
140
141

if(USE_CUDA)
  message(STATUS "Build with CUDA support")
142
  project(dgl C CXX)
143
  include(cmake/modules/CUDA.cmake)
144
145
146
147
  message(STATUS "Use external CCCL library for a consistent API and performance.")
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/cccl/thrust")
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/cccl/cub")
  cuda_include_directories(BEFORE "${CMAKE_SOURCE_DIR}/third_party/cccl/libcudacxx/include")
148
149
endif(USE_CUDA)

Minjie Wang's avatar
Minjie Wang committed
150
# initial variables
151
152
153
154
if(NOT MSVC)
set(DGL_LINKER_LIBS "dl")
endif(NOT MSVC)

155
if(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
Minjie Wang's avatar
Minjie Wang committed
156
set(DGL_RUNTIME_LINKER_LIBS "")
157
158
159
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
160
161
162
163
164
165

# 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)
166
  add_definitions(-DNOMINMAX)
VoVAllen's avatar
VoVAllen committed
167
  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS 1)
Minjie Wang's avatar
Minjie Wang committed
168
169
170
171
172
173
174
175
176
177
178
179
180
181
  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)
182
183
  set(CMAKE_C_FLAGS "-Wall -fPIC ${CMAKE_C_FLAGS}")
  set(CMAKE_CXX_FLAGS "-Wall -fPIC ${CMAKE_CXX_FLAGS}")
184
185
186
  if(NOT APPLE)
    set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--warn-common ${CMAKE_SHARED_LINKER_FLAGS}")
  endif(NOT APPLE)
187
endif(MSVC)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
188

189
if(USE_OPENMP)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
190
191
192
193
194
  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)
195
  message(STATUS "Build with OpenMP.")
196
197
endif(USE_OPENMP)

198
199
200
201
202
if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
  message(STATUS "Disabling LIBXSMM on ${CMAKE_SYSTEM_PROCESSOR}.")
  set(USE_LIBXSMM OFF)
endif()

203
if(USE_LIBXSMM)
204
205
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_LIBXSMM -DDGL_CPU_LLC_SIZE=40000000 -D__BLAS=0")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_LIBXSMM -DDGL_CPU_LLC_SIZE=40000000 -D__BLAS=0")
206
207
  message(STATUS "Build with LIBXSMM optimization.")
endif(USE_LIBXSMM)
208

209
210
if ((NOT MSVC) AND USE_EPOLL)
  INCLUDE(CheckIncludeFile)
211
212
  check_include_file("sys/epoll.h" EPOLL_AVAILABLE)
  if (EPOLL_AVAILABLE)
213
214
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_EPOLL")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_EPOLL")
215
216
  else()
    message(WARNING "EPOLL is not available on this platform...")
217
218
219
  endif()
endif ()

220
# To compile METIS correct for DGL.
221
222
223
224
225
226
227
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)
228

229
230
# configure minigun
add_definitions(-DENABLE_PARTIAL_FRONTIER=0)  # disable minigun partial frontier compile
Minjie Wang's avatar
Minjie Wang committed
231
# Source file lists
232
233
file(GLOB DGL_SRC
  src/*.cc
234
235
  src/array/*.cc
  src/array/cpu/*.cc
236
237
  src/random/*.cc
  src/random/cpu/*.cc
238
  src/runtime/*.cc
239
240
  src/geometry/*.cc
  src/geometry/cpu/*.cc
241
  src/partition/*.cc
242
243
244
)

file(GLOB_RECURSE DGL_SRC_1
245
  src/api/*.cc
246
247
248
  src/graph/*.cc
  src/scheduler/*.cc
)
Minjie Wang's avatar
Minjie Wang committed
249

250
list(APPEND DGL_SRC ${DGL_SRC_1})
Minjie Wang's avatar
Minjie Wang committed
251

252
253
254
255
256
257
258
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})

259
# Configure cuda
260
if(USE_CUDA)
261
262
263
264
265
266
267
268
269
270
271
272
273
274
  file(GLOB_RECURSE DGL_CUDA_SRC
    src/array/cuda/*.cc
    src/array/cuda/*.cu
    src/array/cuda/uvm/*.cc
    src/array/cuda/uvm/*.cu
    src/kernel/cuda/*.cc
    src/kernel/cuda/*.cu
    src/partition/cuda/*.cu
    src/runtime/cuda/*.cc
    src/runtime/cuda/*.cu
    src/geometry/cuda/*.cu
    src/graph/transform/cuda/*.cu
    src/graph/sampling/randomwalks/*.cu
  )
275
  list(APPEND DGL_SRC ${DGL_CUDA_SRC})
276
  dgl_config_cuda(DGL_LINKER_LIBS)
277
278
279
280
  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
281

Zhi Lin's avatar
Zhi Lin committed
282
283
# include directories
target_include_directories(dgl PRIVATE "include")
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
# check for conda includes
if("$ENV{CONDA_BUILD}" STREQUAL "1")
  set(in_conda_build TRUE)
  message(STATUS "Conda build environment detected")
elseif(DEFINED ENV{CONDA_PREFIX})
  set(in_conda_prefix TRUE)
  message(STATUS "Conda environment detected: $ENV{CONDA_PREFIX}")
endif()

if (USE_CONDA_INCLUDES)
  if(in_conda_build)
    message(STATUS "Using Conda build environment includes: $ENV{PREFIX}")
    target_include_directories(dgl PRIVATE "$ENV{PREFIX}/include" "$ENV{BUILD_PREFIX}/include")
  elseif(in_conda_prefix)
    message(STATUS "Using Conda environment includes: $ENV{CONDA_PREFIX}")
    target_include_directories(dgl PRIVATE "$ENV{CONDA_PREFIX}/include")
  else()
    message(FATAL_ERROR "Conda environment not detected")
  endif()
endif()

if(EXTERNAL_DLPACK_PATH)
  message(STATUS "looking for dlpack headers in ${EXTERNAL_DLPACK_PATH}")
  include_directories(SYSTEM ${EXTERNAL_DLPACK_PATH})
else(EXTERNAL_DLPACK_PATH)
  target_include_directories(dgl PRIVATE "third_party/dlpack/include")
endif(EXTERNAL_DLPACK_PATH)

if(EXTERNAL_DMLC_PATH)
  if (USE_HDFS)
    message(FATAL_ERROR "Cannot use HDFS and external dmlc-core at the same time")
  endif()
  message(STATUS "looking for dmlc headers in ${EXTERNAL_DMLC_PATH}")
  include_directories(SYSTEM ${EXTERNAL_DMLC_PATH})
  
  if (NOT EXTERNAL_DMLC_LIB_PATH)
    message(FATAL_ERROR "EXTERNAL_DMLC_LIB_PATH must be set if EXTERNAL_DMLC_PATH is set")
  endif()
  message(STATUS "looking for dmlc library in ${EXTERNAL_DMLC_LIB_PATH}")
  find_package(dmlc
    REQUIRED
    HINTS ${EXTERNAL_DMLC_LIB_PATH}
  )
  if(NOT dmlc_FOUND)
      message(FATAL_ERROR "Failed to find DMLC library")
  endif()
  list(APPEND DGL_LINKER_LIBS dmlc::dmlc)

else(EXTERNAL_DMLC_PATH)
  target_include_directories(dgl PRIVATE "third_party/dmlc-core/include")
  # 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
endif(EXTERNAL_DMLC_PATH)

if(EXTERNAL_PHMAP_PATH)
  include_directories(SYSTEM ${EXTERNAL_PHMAP_PATH})
else(EXTERNAL_PHMAP_PATH)
  target_include_directories(dgl PRIVATE "third_party/phmap")
endif(EXTERNAL_PHMAP_PATH)


Zhi Lin's avatar
Zhi Lin committed
350
target_include_directories(dgl PRIVATE "tensoradapter/include")
351
target_include_directories(dgl PRIVATE "third_party/pcg/include")
352

pyynb's avatar
pyynb committed
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
if(USE_LIBURING)
  if(CMAKE_SYSTEM_NAME MATCHES "Linux")
    add_definitions(-DHAVE_LIBRARY_LIBURING)
    include(ExternalProject)
    set(LIBURING_INSTALL_DIR ${CMAKE_BINARY_DIR}/third_party/liburing)
    ExternalProject_Add(
      liburing
      SOURCE_DIR ${CMAKE_SOURCE_DIR}/third_party/liburing
      CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=/
      BUILD_COMMAND bash -c "make -j 4"
      BUILD_IN_SOURCE ON
      INSTALL_COMMAND make install DESTDIR=${LIBURING_INSTALL_DIR}
      BUILD_BYPRODUCTS ${LIBURING_INSTALL_DIR}/lib/liburing.a
      BUILD_BYPRODUCTS ${LIBURING_INSTALL_DIR}/include
      DOWNLOAD_EXTRACT_TIMESTAMP true
    )
    set(LIBURING_INCLUDE ${LIBURING_INSTALL_DIR}/include)
    set(LIBURING ${LIBURING_INSTALL_DIR}/lib/liburing.a)
  endif()
endif(USE_LIBURING)
373

374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
if(EXTERNAL_NANOFLANN_PATH)
  include_directories(SYSTEM ${EXTERNAL_NANOFLANN_PATH})
else(EXTERNAL_NANOFLANN_PATH)
  target_include_directories(dgl PRIVATE "third_party/nanoflann/include")
endif(EXTERNAL_NANOFLANN_PATH)

if (USE_LIBXSMM)
  target_include_directories(dgl PRIVATE "third_party/libxsmm/include")
endif()

if (EXTERNAL_METIS_PATH)
  find_package(METIS REQUIRED)
  if (NOT METIS_FOUND)
    message(FATAL_ERROR "Failed to find METIS library")
  else()
    message(STATUS "Found METIS library")
    target_include_directories(dgl SYSTEM PUBLIC ${METIS_INCLUDE_DIR})
    list(APPEND DGL_LINKER_LIBS ${METIS_LIBRARIES})
392
  endif()
393
394
395
396
397
398
399
400
401
402
403
404
405
else(EXTERNAL_METIS_PATH)
  target_include_directories(dgl PRIVATE "third_party/METIS/include")
  # Compile METIS
  if(NOT MSVC)
    set(GKLIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/third_party/METIS/GKlib")
    include(${GKLIB_PATH}/GKlibSystem.cmake)
    include_directories(${GKLIB_PATH})
    include_directories("third_party/METIS/include/")
    add_subdirectory("third_party/METIS/libmetis/")
    list(APPEND DGL_LINKER_LIBS metis)
    endif(NOT MSVC)
endif(EXTERNAL_METIS_PATH)

406

407
408
409
410
411
# 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()
412

413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
# 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)

428
429
430
431
# support PARALLEL_ALGORITHMS
if (LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
  add_definitions(-DPARALLEL_ALGORITHMS)
endif(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
432

Minjie Wang's avatar
Minjie Wang committed
433
target_link_libraries(dgl ${DGL_LINKER_LIBS} ${DGL_RUNTIME_LINKER_LIBS})
434
435
436
if(MSVC)
  add_custom_command(
    TARGET dgl POST_BUILD COMMAND
437
    ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:dgl>" "$<TARGET_FILE_DIR:dgl>/..")
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
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}
456
      USE_CUDA=${USE_CUDA}
457
      EXTERNAL_DMLC_LIB_PATH=${EXTERNAL_DMLC_LIB_PATH}
458
459
460
461
462
463
464
465
466
467
468
      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}
469
      USE_CUDA=${USE_CUDA}
470
      EXTERNAL_DMLC_LIB_PATH=${EXTERNAL_DMLC_LIB_PATH}
471
472
473
474
475
476
477
      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
478
479
480

# Installation rules
install(TARGETS dgl DESTINATION lib${LIB_SUFFIX})
VoVAllen's avatar
VoVAllen committed
481
482
483

# Testing
if(BUILD_CPP_TEST)
484
  message(STATUS "Build with unittest")
VoVAllen's avatar
VoVAllen committed
485
486
487
  add_subdirectory(./third_party/googletest)
  enable_testing()
  include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
Zhi Lin's avatar
Zhi Lin committed
488
489
490
  include_directories("include")
  include_directories("third_party/dlpack/include")
  include_directories("third_party/dmlc-core/include")
491
  include_directories("third_party/phmap")
492
  include_directories("third_party/libxsmm/include")
493
  include_directories("third_party/pcg/include")
VoVAllen's avatar
VoVAllen committed
494
495
496
497
498
499
  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
500
501

if(BUILD_SPARSE)
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
  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
544
endif(BUILD_SPARSE)
545
546
547

if(BUILD_GRAPHBOLT)
  message(STATUS "Configuring graphbolt library")
548
  string(REPLACE ";" "\\;" CUDA_ARCHITECTURES_ESCAPED "${CUDA_ARCHITECTURES}")
549
550
  file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR} BINDIR)
  file(TO_NATIVE_PATH ${CMAKE_COMMAND} CMAKE_CMD)
551
552
553
554
  if(USE_CUDA)
    get_target_property(GPU_CACHE_INCLUDE_DIRS gpu_cache INCLUDE_DIRECTORIES)
  endif(USE_CUDA)
  string(REPLACE ";" "\\;" GPU_CACHE_INCLUDE_DIRS_ESCAPED "${GPU_CACHE_INCLUDE_DIRS}")
555
556
557
558
559
560
561
  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}
562
563
      CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
      USE_CUDA=${USE_CUDA}
564
      BINDIR=${BINDIR}
565
      GPU_CACHE_INCLUDE_DIRS="${GPU_CACHE_INCLUDE_DIRS_ESCAPED}"
566
567
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
568
      CUDAARCHS="${CUDA_ARCHITECTURES_ESCAPED}"
569
570
571
572
573
574
575
576
577
578
579
      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}
580
581
      CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
      USE_CUDA=${USE_CUDA}
582
      BINDIR=${CMAKE_CURRENT_BINARY_DIR}
583
      GPU_CACHE_INCLUDE_DIRS="${GPU_CACHE_INCLUDE_DIRS_ESCAPED}"
584
585
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
586
      CUDAARCHS="${CUDA_ARCHITECTURES_ESCAPED}"
587
588
589
590
591
      LDFLAGS=${CMAKE_SHARED_LINKER_FLAGS}
      bash ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/graphbolt)
  endif(MSVC)
592
593
594
  if(USE_CUDA)
    add_dependencies(graphbolt gpu_cache)
  endif(USE_CUDA)
pyynb's avatar
pyynb committed
595
596
597
598
599
  if(USE_LIBURING)
    if(CMAKE_SYSTEM_NAME MATCHES "Linux")
      add_dependencies(graphbolt liburing)
    endif()
  endif(USE_LIBURING)
600
endif(BUILD_GRAPHBOLT)