CMakeLists.txt 23 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
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
sangwzh's avatar
sangwzh committed
10
set(CMAKE_HIP_STANDARD 17)
11

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

17
18
19
# 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.
20
dgl_option(BUILD_TYPE "Type of the build: dev, dogfood or release" "dev")
21
message(STATUS "Build for ${BUILD_TYPE}")
22

23
24
dgl_option(USE_CUDA "Build with CUDA" OFF)
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
# 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"
sangwzh's avatar
sangwzh committed
69
    "none"
70
)
sangwzh's avatar
sangwzh committed
71
72

message(STATUS "USE_LIBXSMM: ${USE_LIBXSMM}")
73
74
75
76
77
dgl_feature_option(
    USE_OPENMP
    "Build with OpenMP"
    "all"
)
78

79
80
81
dgl_feature_option(
    BUILD_GRAPHBOLT
    "Build Graphbolt library"
82
    "all"
83
)
84

sangwzh's avatar
sangwzh committed
85
86
message(STATUS "BUILD_GRAPHBOLT: ${BUILD_GRAPHBOLT}")

87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
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"
)
107

108
109
110
111
112
113
# Only build C++ tests for unit testing purposes in dev build.
dgl_feature_option(
    BUILD_CPP_TEST
    "Build cpp unittest executables"
    "dev"
)
114

115
116
117
118
119
120
121
122
123
124
125
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)

126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
# 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()
144
145
146

if(USE_CUDA)
  message(STATUS "Build with CUDA support")
147
  project(dgl C CXX)
148
  include(cmake/modules/CUDA.cmake)
149
150
151
152
  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")
153
154
endif(USE_CUDA)

sangwzh's avatar
sangwzh committed
155
156
157
158
159
if(USE_HIP)
  message(STATUS "Build with ROCM support")
  project(dgl C CXX HIP)
  include(cmake/modules/ROCM.cmake)
  # target_compile_features(dgl PRIVATE cxx_std_17)
sangwz's avatar
sangwz committed
160
  set(CMAKE_HIP_ARCHITECTURES gfx906;gfx928;gfx926;gfx936)
sangwzh's avatar
sangwzh committed
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
  # see https://github.com/NVIDIA/thrust/issues/1401
  if(NOT DEFINED ENV{ROCM_PATH})
    set(ROCM_PATH "/opt/dtk" CACHE PATH "Path to which RoCm has been installed")
    set(HIP_PATH ${ROCM_PATH}/hip CACHE PATH "Path to which HIP has been installed")
  else()
    set(ROCM_PATH $ENV{ROCM_PATH} CACHE PATH "Path to which ROCm has been installed")
    set(HIP_PATH ${ROCM_PATH}/hip CACHE PATH "Path to which HIP has been installed")
  endif()
  set(CMAKE_MODULE_PATH "${HIP_PATH}/cmake" ${CMAKE_MODULE_PATH})
  find_package(hip REQUIRED)
  set(HIP_FOUND TRUE)
  message(STATUS "HIP_FOUND  :${HIP_FOUND}")
  # add_definitions(-DTHRUST_CUB_WRAPPED_NAMESPACE=dgl)
  include(cmake/modules/ROCM.cmake)
  message(STATUS "Use external CUB/Thrust library for a consistent API and performance.")
endif(USE_HIP)

Minjie Wang's avatar
Minjie Wang committed
178
# initial variables
179
180
181
182
if(NOT MSVC)
set(DGL_LINKER_LIBS "dl")
endif(NOT MSVC)

183
if(MSVC OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
Minjie Wang's avatar
Minjie Wang committed
184
set(DGL_RUNTIME_LINKER_LIBS "")
185
186
187
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
188
189
190
191
192
193

# 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)
194
  add_definitions(-DNOMINMAX)
VoVAllen's avatar
VoVAllen committed
195
  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS 1)
Minjie Wang's avatar
Minjie Wang committed
196
197
198
199
200
201
202
203
204
205
206
207
208
209
  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)
210
211
  set(CMAKE_C_FLAGS "-Wall -fPIC ${CMAKE_C_FLAGS}")
  set(CMAKE_CXX_FLAGS "-Wall -fPIC ${CMAKE_CXX_FLAGS}")
212
213
214
  if(NOT APPLE)
    set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--warn-common ${CMAKE_SHARED_LINKER_FLAGS}")
  endif(NOT APPLE)
215
endif(MSVC)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
216

217
if(USE_OPENMP)
Quan (Andy) Gan's avatar
Quan (Andy) Gan committed
218
219
220
221
222
  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)
223
  message(STATUS "Build with OpenMP.")
224
225
endif(USE_OPENMP)

226
227
228
229
230
if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
  message(STATUS "Disabling LIBXSMM on ${CMAKE_SYSTEM_PROCESSOR}.")
  set(USE_LIBXSMM OFF)
endif()

231
if(USE_LIBXSMM)
232
233
  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")
234
235
  message(STATUS "Build with LIBXSMM optimization.")
endif(USE_LIBXSMM)
236

237
238
if ((NOT MSVC) AND USE_EPOLL)
  INCLUDE(CheckIncludeFile)
239
240
  check_include_file("sys/epoll.h" EPOLL_AVAILABLE)
  if (EPOLL_AVAILABLE)
241
242
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_EPOLL")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_EPOLL")
243
244
  else()
    message(WARNING "EPOLL is not available on this platform...")
245
246
247
  endif()
endif ()

248
# To compile METIS correct for DGL.
249
250
251
252
253
254
255
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)
256

257
258
# configure minigun
add_definitions(-DENABLE_PARTIAL_FRONTIER=0)  # disable minigun partial frontier compile
Minjie Wang's avatar
Minjie Wang committed
259
# Source file lists
260
261
file(GLOB DGL_SRC
  src/*.cc
262
263
  src/array/*.cc
  src/array/cpu/*.cc
264
265
  src/random/*.cc
  src/random/cpu/*.cc
266
  src/runtime/*.cc
267
268
  src/geometry/*.cc
  src/geometry/cpu/*.cc
269
  src/partition/*.cc
270
271
272
)

file(GLOB_RECURSE DGL_SRC_1
273
  src/api/*.cc
274
275
276
  src/graph/*.cc
  src/scheduler/*.cc
)
Minjie Wang's avatar
Minjie Wang committed
277

278
list(APPEND DGL_SRC ${DGL_SRC_1})
Minjie Wang's avatar
Minjie Wang committed
279

280
281
282
283
284
285
286
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})

sangwzh's avatar
sangwzh committed
287
288
289
290
291
292
293
294
295
296
# Configure hip
message(STATUS ">>>>>>>> USE_HIP: ${USE_HIP}")
message(STATUS ">>>>>>>> DGL_SRC: ${DGL_SRC}")
message(STATUS ">>>>>>>> DGL_RPC_SRC: ${DGL_RPC_SRC}")
if(USE_HIP)
  dgl_config_hip(DGL_CUDA_SRC)
  list(APPEND DGL_SRC ${DGL_CUDA_SRC})
  set(HIP_HIPCC_FLAGS "-std=c++17")
  add_library(dgl SHARED ${DGL_SRC})
  target_link_options(dgl PRIVATE "-Wl,--allow-multiple-definition")
297
  target_compile_options(dgl PUBLIC "--gpu-max-threads-per-block=1024")
sangwzh's avatar
sangwzh committed
298
299
300
301
302
303
304
305
306
307
308
  # set_target_properties(dgl PROPERTIES LINKER_LANGUAGE hip)
  target_link_libraries(dgl ${DGL_LINKER_LIBS})
  target_include_directories(dgl PRIVATE "${CMAKE_SOURCE_DIR}/include/dgl")
  target_include_directories(dgl PRIVATE "${CMAKE_SOURCE_DIR}/include")
  target_include_directories(dgl PRIVATE "${ROCM_PATH}/include")
  target_include_directories(dgl PRIVATE "${ROCM_PATH}/include/hiprand")
  target_include_directories(dgl PRIVATE "${ROCM_PATH}/include/rocrand")
  message(STATUS ">>>>>>>> DGL_LINKER_LIBS: ${DGL_LINKER_LIBS}")
  
endif(USE_HIP)

309
# Configure cuda
310
if(USE_CUDA)
311
312
313
314
315
316
317
318
319
320
321
322
323
324
  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
  )
325
  list(APPEND DGL_SRC ${DGL_CUDA_SRC})
326
  dgl_config_cuda(DGL_LINKER_LIBS)
327
  cuda_add_library(dgl SHARED ${DGL_SRC})
sangwzh's avatar
sangwzh committed
328
329
endif()
if(NOT USE_CUDA AND NOT USE_HIP)
330
  add_library(dgl SHARED ${DGL_SRC})
sangwzh's avatar
sangwzh committed
331
endif()
Minjie Wang's avatar
Minjie Wang committed
332

sangwzh's avatar
sangwzh committed
333
334
target_include_directories(dgl PUBLIC "include")
target_include_directories(dgl PUBLIC "${CMAKE_SOURCE_DIR}/include")
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
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
392
393
394
395
396
397
398
399
400
# 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
401
target_include_directories(dgl PRIVATE "tensoradapter/include")
402
target_include_directories(dgl PRIVATE "third_party/pcg/include")
403

404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
if(CMAKE_SYSTEM_NAME MATCHES "Linux")
  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=${LIBURING_INSTALL_DIR}
    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()
421

422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
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})
440
  endif()
441
442
443
444
445
446
447
448
449
450
451
452
453
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)

454

455
456
457
458
459
# 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()
460

461
462
463
464
465
466
467
468
469
470
471
472
473
# 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.")
sangwzh's avatar
sangwzh committed
474
475
476
477
478
479
480
481
482
483
484
485
486
487
elseif(USE_HIP)
  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.hip
  )
  add_library(gpu_cache STATIC ${gpu_cache_src})
  target_compile_options(gpu_cache PRIVATE "-fPIC")
  set_target_properties(gpu_cache PROPERTIES LINKER_LANGUAGE HIP)
  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.")
488
489
endif(USE_CUDA)

490
491
492
493
# support PARALLEL_ALGORITHMS
if (LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
  add_definitions(-DPARALLEL_ALGORITHMS)
endif(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
494

Minjie Wang's avatar
Minjie Wang committed
495
target_link_libraries(dgl ${DGL_LINKER_LIBS} ${DGL_RUNTIME_LINKER_LIBS})
496
497
498
if(MSVC)
  add_custom_command(
    TARGET dgl POST_BUILD COMMAND
499
    ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:dgl>" "$<TARGET_FILE_DIR:dgl>/..")
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
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}
518
      USE_CUDA=${USE_CUDA}
519
      EXTERNAL_DMLC_LIB_PATH=${EXTERNAL_DMLC_LIB_PATH}
520
521
522
523
524
525
526
527
528
529
      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}
sangwzh's avatar
sangwzh committed
530
531
      # CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
      USE_HIP=${USE_HIP}
532
      EXTERNAL_DMLC_LIB_PATH=${EXTERNAL_DMLC_LIB_PATH}
533
534
535
536
537
538
539
      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
540
541
542

# Installation rules
install(TARGETS dgl DESTINATION lib${LIB_SUFFIX})
VoVAllen's avatar
VoVAllen committed
543
544
545

# Testing
if(BUILD_CPP_TEST)
546
  message(STATUS "Build with unittest")
VoVAllen's avatar
VoVAllen committed
547
548
549
  add_subdirectory(./third_party/googletest)
  enable_testing()
  include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
Zhi Lin's avatar
Zhi Lin committed
550
551
552
  include_directories("include")
  include_directories("third_party/dlpack/include")
  include_directories("third_party/dmlc-core/include")
553
  include_directories("third_party/phmap")
554
  include_directories("third_party/libxsmm/include")
555
  include_directories("third_party/pcg/include")
VoVAllen's avatar
VoVAllen committed
556
557
558
559
  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)
sangwzh's avatar
sangwzh committed
560
561
  target_link_options(runUnitTests PRIVATE -Wl,--allow-multiple-definition  -fuse-ld=lld)
  target_compile_options(runUnitTests PRIVATE "-fPIC")
VoVAllen's avatar
VoVAllen committed
562
563
  add_test(UnitTests runUnitTests)
endif(BUILD_CPP_TEST)
czkkkkkk's avatar
czkkkkkk committed
564
565

if(BUILD_SPARSE)
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
  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}
sangwzh's avatar
sangwzh committed
596
      USE_HIP=${USE_HIP}
597
598
599
600
601
602
603
604
605
606
      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
607
endif(BUILD_SPARSE)
608
609
610

if(BUILD_GRAPHBOLT)
  message(STATUS "Configuring graphbolt library")
sangwzh's avatar
sangwzh committed
611
  # string(REPLACE ";" "\\;" CUDA_ARCHITECTURES_ESCAPED "${CUDA_ARCHITECTURES}")
612
613
  file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR} BINDIR)
  file(TO_NATIVE_PATH ${CMAKE_COMMAND} CMAKE_CMD)
sangwzh's avatar
sangwzh committed
614
  if(USE_HIP)
615
    get_target_property(GPU_CACHE_INCLUDE_DIRS gpu_cache INCLUDE_DIRECTORIES)
sangwzh's avatar
sangwzh committed
616
  endif(USE_HIP)
617
  string(REPLACE ";" "\\;" GPU_CACHE_INCLUDE_DIRS_ESCAPED "${GPU_CACHE_INCLUDE_DIRS}")
618
619
620
621
622
623
624
  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}
625
626
      CUDA_TOOLKIT_ROOT_DIR=${CUDA_TOOLKIT_ROOT_DIR}
      USE_CUDA=${USE_CUDA}
627
      BINDIR=${BINDIR}
628
      GPU_CACHE_INCLUDE_DIRS="${GPU_CACHE_INCLUDE_DIRS_ESCAPED}"
629
630
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
631
      CUDAARCHS="${CUDA_ARCHITECTURES_ESCAPED}"
632
633
634
635
636
637
638
639
640
641
642
      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}
sangwzh's avatar
sangwzh committed
643
      USE_HIP=${USE_HIP}
644
      BINDIR=${CMAKE_CURRENT_BINARY_DIR}
645
      GPU_CACHE_INCLUDE_DIRS="${GPU_CACHE_INCLUDE_DIRS_ESCAPED}"
646
647
      CFLAGS=${CMAKE_C_FLAGS}
      CXXFLAGS=${CMAKE_CXX_FLAGS}
648
      CUDAARCHS="${CUDA_ARCHITECTURES_ESCAPED}"
649
650
651
652
653
      LDFLAGS=${CMAKE_SHARED_LINKER_FLAGS}
      bash ${BUILD_SCRIPT} ${TORCH_PYTHON_INTERPS}
      DEPENDS ${BUILD_SCRIPT}
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/graphbolt)
  endif(MSVC)
654
655
656
  if(USE_CUDA)
    add_dependencies(graphbolt gpu_cache)
  endif(USE_CUDA)
657
endif(BUILD_GRAPHBOLT)