CMakeLists.txt 27.3 KB
Newer Older
1
2
3
4
5
option(USE_MPI "Enable MPI-based distributed learning" OFF)
option(USE_OPENMP "Enable OpenMP" ON)
option(USE_GPU "Enable GPU-accelerated training" OFF)
option(USE_SWIG "Enable SWIG to generate Java API" OFF)
option(USE_TIMETAG "Set to ON to output time costs" OFF)
6
option(USE_CUDA "Enable CUDA-accelerated training " OFF)
7
option(USE_DEBUG "Set to ON for Debug mode" OFF)
8
option(USE_SANITIZER "Use sanitizer flags" OFF)
9
set(
10
11
12
13
14
15
16
  ENABLED_SANITIZERS
  "address" "leak" "undefined"
  CACHE
  STRING
  "Semicolon separated list of sanitizer names, e.g., 'address;leak'. \
Supported sanitizers are address, leak, undefined and thread."
)
17
18
option(USE_HOMEBREW_FALLBACK "(macOS-only) also look in 'brew --prefix' for libraries (e.g. OpenMP)" ON)
option(BUILD_CLI "Build the 'lightgbm' command-line interface in addition to lib_lightgbm" ON)
19
20
option(BUILD_CPP_TEST "Build C++ tests with Google Test" OFF)
option(BUILD_STATIC_LIB "Build static library" OFF)
21
option(INSTALL_HEADERS "Install headers to CMAKE_INSTALL_PREFIX (e.g. '/usr/local/include')" ON)
22
23
option(__BUILD_FOR_PYTHON "Set to ON if building lib_lightgbm for use with the Python-package" OFF)
option(__BUILD_FOR_R "Set to ON if building lib_lightgbm for use with the R-package" OFF)
24
option(__INTEGRATE_OPENCL "Set to ON if building LightGBM with the OpenCL ICD Loader and its dependencies included" OFF)
25

26
cmake_minimum_required(VERSION 3.28)
Guolin Ke's avatar
Guolin Ke committed
27

28
29
30
31
32
33
34
35
# If using Visual Studio generators, always target v10.x of the Windows SDK.
# Doing this avoids lookups that could fall back to very old versions, e.g. by finding
# outdated registry entries.
# ref: https://cmake.org/cmake/help/latest/variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.html
if(CMAKE_GENERATOR MATCHES "Visual Studio")
    set(CMAKE_SYSTEM_VERSION 10.0 CACHE INTERNAL "target Windows SDK version" FORCE)
endif()

36
project(lightgbm LANGUAGES C CXX)
Guolin Ke's avatar
Guolin Ke committed
37

38
39
40
41
42
43
44
if(BUILD_CPP_TEST)
  set(CMAKE_CXX_STANDARD 14)
else()
  set(CMAKE_CXX_STANDARD 11)
endif()
set(CMAKE_CXX_STANDARD_REQUIRED ON)

45
46
47
list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules")

#-- Sanitizer
48
if(USE_SANITIZER)
49
50
  if(MSVC)
    message(FATAL_ERROR "Sanitizers are not supported with MSVC.")
51
  endif()
52
53
  include(cmake/Sanitizer.cmake)
  enable_sanitizers("${ENABLED_SANITIZERS}")
54
endif()
55

56
57
58
59
60
61
if(__INTEGRATE_OPENCL)
  set(__INTEGRATE_OPENCL ON CACHE BOOL "" FORCE)
  set(USE_GPU OFF CACHE BOOL "" FORCE)
  message(STATUS "Building library with integrated OpenCL components")
endif()

62
if(__BUILD_FOR_PYTHON OR __BUILD_FOR_R OR USE_SWIG)
63
    # the SWIG wrapper, the Python and R packages don't require the CLI
64
    set(BUILD_CLI OFF)
65
    # installing the SWIG wrapper, the R and Python packages shouldn't place LightGBM's headers
66
67
68
69
    # outside of where the package is installed
    set(INSTALL_HEADERS OFF)
endif()

Qiwei Ye's avatar
Qiwei Ye committed
70
71
72
73
74
75
76
77
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.8.2")
    message(FATAL_ERROR "Insufficient gcc version")
  endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.8")
    message(FATAL_ERROR "Insufficient Clang version")
  endif()
78
79
80
81
82
83
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.1.0")
    message(FATAL_ERROR "Insufficient AppleClang version")
  endif()
elseif(MSVC)
  if(MSVC_VERSION LESS 1900)
84
85
86
87
    message(
      FATAL_ERROR
      "The compiler ${CMAKE_CXX_COMPILER} doesn't support required C++11 features. Please use a newer MSVC."
    )
88
  endif()
89
endif()
Guolin Ke's avatar
Guolin Ke committed
90

91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
if(USE_SWIG)
  find_package(SWIG REQUIRED)
  find_package(Java REQUIRED)
  find_package(JNI REQUIRED)
  include(UseJava)
  include(UseSWIG)
  set(SWIG_CXX_EXTENSION "cxx")
  set(SWIG_EXTRA_LIBRARIES "")
  set(SWIG_JAVA_EXTRA_FILE_EXTENSIONS ".java" "JNI.java")
  set(SWIG_MODULE_JAVA_LANGUAGE "JAVA")
  set(SWIG_MODULE_JAVA_SWIG_LANGUAGE_FLAG "java")
  set(CMAKE_SWIG_OUTDIR "${CMAKE_CURRENT_BINARY_DIR}/java")
  include_directories(Java_INCLUDE_DIRS)
  include_directories(JNI_INCLUDE_DIRS)
  include_directories($ENV{JAVA_HOME}/include)
106
  if(WIN32)
107
      set(LGBM_SWIG_DESTINATION_DIR "${CMAKE_CURRENT_BINARY_DIR}/com/microsoft/ml/lightgbm/windows/x86_64")
108
      include_directories($ENV{JAVA_HOME}/include/win32)
109
  elseif(APPLE)
110
      set(LGBM_SWIG_DESTINATION_DIR "${CMAKE_CURRENT_BINARY_DIR}/com/microsoft/ml/lightgbm/osx/x86_64")
111
      include_directories($ENV{JAVA_HOME}/include/darwin)
112
  else()
113
      set(LGBM_SWIG_DESTINATION_DIR "${CMAKE_CURRENT_BINARY_DIR}/com/microsoft/ml/lightgbm/linux/x86_64")
114
115
      include_directories($ENV{JAVA_HOME}/include/linux)
  endif()
116
  file(MAKE_DIRECTORY "${LGBM_SWIG_DESTINATION_DIR}")
117
endif()
118

119
set(EIGEN_DIR "${PROJECT_SOURCE_DIR}/external_libs/eigen")
120
121
include_directories(${EIGEN_DIR})

122
# See https://gitlab.com/libeigen/eigen/-/blob/master/COPYING.README
123
add_definitions(-DEIGEN_MPL2_ONLY)
124
add_definitions(-DEIGEN_DONT_PARALLELIZE)
125

126
127
128
129
130
131
set(FAST_DOUBLE_PARSER_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/external_libs/fast_double_parser/include")
include_directories(${FAST_DOUBLE_PARSER_INCLUDE_DIR})

set(FMT_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/external_libs/fmt/include")
include_directories(${FMT_INCLUDE_DIR})

132
if(__BUILD_FOR_R)
133
134
135
    find_package(LibR REQUIRED)
    message(STATUS "LIBR_EXECUTABLE: ${LIBR_EXECUTABLE}")
    message(STATUS "LIBR_INCLUDE_DIRS: ${LIBR_INCLUDE_DIRS}")
136
    message(STATUS "LIBR_LIBS_DIR: ${LIBR_LIBS_DIR}")
137
138
    message(STATUS "LIBR_CORE_LIBRARY: ${LIBR_CORE_LIBRARY}")
    include_directories(${LIBR_INCLUDE_DIRS})
139
    add_definitions(-DLGB_R_BUILD)
140
endif()
141

142
if(USE_TIMETAG)
143
    add_definitions(-DTIMETAG)
144
endif()
145

Guolin Ke's avatar
Guolin Ke committed
146
if(USE_DEBUG)
147
    add_definitions(-DDEBUG)
148
endif()
Guolin Ke's avatar
Guolin Ke committed
149

Guolin Ke's avatar
Guolin Ke committed
150
if(USE_MPI)
Guolin Ke's avatar
Guolin Ke committed
151
    find_package(MPI REQUIRED)
152
    add_definitions(-DUSE_MPI)
Guolin Ke's avatar
Guolin Ke committed
153
else()
154
    add_definitions(-DUSE_SOCKET)
155
endif()
Guolin Ke's avatar
Guolin Ke committed
156

157
if(USE_CUDA)
158
    set(CMAKE_CUDA_HOST_COMPILER "${CMAKE_CXX_COMPILER}")
159
    enable_language(CUDA)
160
    set(USE_OPENMP ON CACHE BOOL "CUDA requires OpenMP" FORCE)
161
endif()
162

163
if(USE_OPENMP)
164
165
166
    if(APPLE)
        find_package(OpenMP)
        if(NOT OpenMP_FOUND)
167
168
169
170
            if(USE_HOMEBREW_FALLBACK)
                # libomp 15.0+ from brew is keg-only, so have to search in other locations.
                # See https://github.com/Homebrew/homebrew-core/issues/112107#issuecomment-1278042927.
                execute_process(COMMAND brew --prefix libomp
171
172
                            OUTPUT_VARIABLE HOMEBREW_LIBOMP_PREFIX
                            OUTPUT_STRIP_TRAILING_WHITESPACE)
173
174
175
176
177
178
                set(OpenMP_C_FLAGS "-Xpreprocessor -fopenmp -I${HOMEBREW_LIBOMP_PREFIX}/include")
                set(OpenMP_CXX_FLAGS "-Xpreprocessor -fopenmp -I${HOMEBREW_LIBOMP_PREFIX}/include")
                set(OpenMP_C_LIB_NAMES omp)
                set(OpenMP_CXX_LIB_NAMES omp)
                set(OpenMP_omp_LIBRARY ${HOMEBREW_LIBOMP_PREFIX}/lib/libomp.dylib)
            endif()
179
180
181
182
183
            find_package(OpenMP REQUIRED)
        endif()
    else()
        find_package(OpenMP REQUIRED)
    endif()
184
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
185
endif()
Guolin Ke's avatar
Guolin Ke committed
186

187
if(USE_GPU)
188
    set(BOOST_COMPUTE_HEADER_DIR ${PROJECT_SOURCE_DIR}/external_libs/compute/include)
189
    include_directories(${BOOST_COMPUTE_HEADER_DIR})
190
191
    find_package(OpenCL REQUIRED)
    include_directories(${OpenCL_INCLUDE_DIRS})
192
    message(STATUS "OpenCL include directory: " ${OpenCL_INCLUDE_DIRS})
193
    if(WIN32)
Guolin Ke's avatar
Guolin Ke committed
194
195
        set(Boost_USE_STATIC_LIBS ON)
    endif()
196
    find_package(Boost 1.56.0 COMPONENTS filesystem system REQUIRED)
197
    if(WIN32)
198
        # disable autolinking in boost
199
        add_definitions(-DBOOST_ALL_NO_LIB)
200
    endif()
Guolin Ke's avatar
Guolin Ke committed
201
    include_directories(${Boost_INCLUDE_DIRS})
202
    add_definitions(-DUSE_GPU)
203
endif()
204

205
if(__INTEGRATE_OPENCL)
206
207
208
    if(APPLE)
        message(FATAL_ERROR "Integrated OpenCL build is not available on macOS")
    else()
209
        include(cmake/IntegratedOpenCL.cmake)
210
        add_definitions(-DUSE_GPU)
211
212
    endif()
endif()
213

214
215
216
217
218
if(BUILD_CPP_TEST AND MSVC)
  # Use /MT flag to statically link the C runtime
  set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
endif()

219
if(USE_CUDA)
220
221
    find_package(CUDAToolkit 11.0 REQUIRED)
    include_directories(${CUDAToolkit_INCLUDE_DIRS})
222
    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=${OpenMP_CXX_FLAGS} -Xcompiler=-fPIC -Xcompiler=-Wall")
223

224
225
    # reference for mapping of CUDA toolkit component versions to supported architectures ("compute capabilities"):
    # https://en.wikipedia.org/wiki/CUDA#GPUs_supported
226
    set(CUDA_ARCHS "60" "61" "62" "70" "75")
227
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.0")
228
        list(APPEND CUDA_ARCHS "80")
229
    endif()
230
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.1")
231
        list(APPEND CUDA_ARCHS "86")
232
    endif()
233
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.5")
234
        list(APPEND CUDA_ARCHS "87")
235
    endif()
236
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.8")
237
238
        list(APPEND CUDA_ARCHS "89")
        list(APPEND CUDA_ARCHS "90")
239
    endif()
240
241
242
243
244
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "12.8")
        list(APPEND CUDA_ARCHS "100")
        list(APPEND CUDA_ARCHS "120")
    endif()
    # Generate PTX for the most recent architecture for forwards compatibility
245
    list(POP_BACK CUDA_ARCHS CUDA_LAST_SUPPORTED_ARCH)
246
247
248
    list(TRANSFORM CUDA_ARCHS APPEND "-real")
    list(APPEND CUDA_ARCHS "${CUDA_LAST_SUPPORTED_ARCH}-real" "${CUDA_LAST_SUPPORTED_ARCH}-virtual")
    message(STATUS "CUDA_ARCHITECTURES: ${CUDA_ARCHS}")
249
    if(USE_DEBUG)
250
      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -g")
251
    else()
252
      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -O3 -lineinfo")
253
254
255
    endif()
    message(STATUS "CMAKE_CUDA_FLAGS: ${CMAKE_CUDA_FLAGS}")

256
    add_definitions(-DUSE_CUDA)
257

258
    if(NOT DEFINED CMAKE_CUDA_STANDARD)
259
260
261
      set(CMAKE_CUDA_STANDARD 11)
      set(CMAKE_CUDA_STANDARD_REQUIRED ON)
    endif()
262
endif()
263

264
265
266
267
268
269
270
271
272
273
274
include(CheckCXXSourceCompiles)
check_cxx_source_compiles("
#include <xmmintrin.h>
int main() {
  int a = 0;
  _mm_prefetch(&a, _MM_HINT_NTA);
  return 0;
}
" MM_PREFETCH)

if(${MM_PREFETCH})
275
  message(STATUS "Using _mm_prefetch")
276
  add_definitions(-DMM_PREFETCH)
277
278
endif()

279
280
281
282
283
284
285
286
287
288
289
include(CheckCXXSourceCompiles)
check_cxx_source_compiles("
#include <mm_malloc.h>
int main() {
  char *a = (char*)_mm_malloc(8, 16);
  _mm_free(a);
  return 0;
}
" MM_MALLOC)

if(${MM_MALLOC})
290
  message(STATUS "Using _mm_malloc")
291
  add_definitions(-DMM_MALLOC)
292
293
endif()

Guolin Ke's avatar
Guolin Ke committed
294
if(UNIX OR MINGW OR CYGWIN)
295
  set(
296
    CMAKE_CXX_FLAGS
297
    "${CMAKE_CXX_FLAGS} -pthread -Wextra -Wall -Wno-ignored-attributes -Wno-unknown-pragmas -Wno-return-type"
298
  )
299
300
301
302
303
304
305
  if(MINGW)
    # ignore this warning: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95353
    set(
      CMAKE_CXX_FLAGS
      "${CMAKE_CXX_FLAGS} -Wno-stringop-overflow"
    )
  endif()
306
  if(USE_DEBUG)
307
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0")
308
  else()
309
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
310
311
  endif()
  if(USE_SWIG)
312
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing")
313
314
  endif()
  if(NOT USE_OPENMP)
315
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-pragmas -Wno-unused-private-field")
316
317
  endif()
  if(__BUILD_FOR_R AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
318
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-cast-function-type")
319
  endif()
Guolin Ke's avatar
Guolin Ke committed
320
321
endif()

Nikita Titov's avatar
Nikita Titov committed
322
if(WIN32 AND MINGW)
323
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++")
Nikita Titov's avatar
Nikita Titov committed
324
325
endif()

326
327
328
329
330
331
332
333
334
335
336
337
# Check if inet_pton is already available, to avoid conflicts with the implementation in LightGBM.
# As of 2022, MinGW started including a definition of inet_pton.
if(WIN32)
  include(CheckSymbolExists)
  list(APPEND CMAKE_REQUIRED_LIBRARIES "ws2_32")
  check_symbol_exists(inet_pton "ws2tcpip.h" WIN_INET_PTON_FOUND)
  if(WIN_INET_PTON_FOUND)
    add_definitions(-DWIN_HAS_INET_PTON)
  endif()
  list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "ws2_32")
endif()

Guolin Ke's avatar
Guolin Ke committed
338
if(MSVC)
339
340
    # compiling 'fmt' on MSVC: "Unicode support requires compiling with /utf-8"
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /MP /utf-8")
341
342
343
344
345
346
347
    if(__BUILD_FOR_R)
        # MSVC does not like this commit:
        # https://github.com/wch/r-source/commit/fb52ac1a610571fcb8ac92d886b9fefcffaa7d48
        #
        # and raises "error C3646: 'private_data_c': unknown override specifier"
        add_definitions(-DR_LEGACY_RCOMPLEX)
    endif()
Guolin Ke's avatar
Guolin Ke committed
348
    if(USE_DEBUG)
349
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Od")
Guolin Ke's avatar
Guolin Ke committed
350
    else()
351
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /Ob2 /Oi /Ot /Oy")
Guolin Ke's avatar
Guolin Ke committed
352
    endif()
Guolin Ke's avatar
Guolin Ke committed
353
else()
354
355
356
    if(NOT BUILD_STATIC_LIB)
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
    endif()
Guolin Ke's avatar
Guolin Ke committed
357
    if(NOT USE_DEBUG)
358
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -funroll-loops")
Guolin Ke's avatar
Guolin Ke committed
359
    endif()
360
endif()
Guolin Ke's avatar
Guolin Ke committed
361

362
set(LightGBM_HEADER_DIR ${PROJECT_SOURCE_DIR}/include)
Guolin Ke's avatar
Guolin Ke committed
363

364
365
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
Guolin Ke's avatar
Guolin Ke committed
366

367
include_directories(${LightGBM_HEADER_DIR})
Guolin Ke's avatar
Guolin Ke committed
368
369
370

if(USE_MPI)
  include_directories(${MPI_CXX_INCLUDE_PATH})
371
endif()
Guolin Ke's avatar
Guolin Ke committed
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
401
402
403
404
405
406
407
408
set(
    LGBM_SOURCES
      src/boosting/boosting.cpp
      src/boosting/gbdt_model_text.cpp
      src/boosting/gbdt_prediction.cpp
      src/boosting/gbdt.cpp
      src/boosting/prediction_early_stop.cpp
      src/boosting/sample_strategy.cpp
      src/io/bin.cpp
      src/io/config_auto.cpp
      src/io/config.cpp
      src/io/dataset_loader.cpp
      src/io/dataset.cpp
      src/io/file_io.cpp
      src/io/json11.cpp
      src/io/metadata.cpp
      src/io/parser.cpp
      src/io/train_share_states.cpp
      src/io/tree.cpp
      src/metric/dcg_calculator.cpp
      src/metric/metric.cpp
      src/network/linker_topo.cpp
      src/network/linkers_mpi.cpp
      src/network/linkers_socket.cpp
      src/network/network.cpp
      src/objective/objective_function.cpp
      src/treelearner/data_parallel_tree_learner.cpp
      src/treelearner/feature_histogram.cpp
      src/treelearner/feature_parallel_tree_learner.cpp
      src/treelearner/gpu_tree_learner.cpp
      src/treelearner/gradient_discretizer.cpp
      src/treelearner/linear_tree_learner.cpp
      src/treelearner/serial_tree_learner.cpp
      src/treelearner/tree_learner.cpp
      src/treelearner/voting_parallel_tree_learner.cpp
      src/utils/openmp_wrapper.cpp
409
)
410
set(
411
    LGBM_CUDA_SOURCES
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
      src/boosting/cuda/cuda_score_updater.cpp
      src/boosting/cuda/cuda_score_updater.cu
      src/metric/cuda/cuda_binary_metric.cpp
      src/metric/cuda/cuda_pointwise_metric.cpp
      src/metric/cuda/cuda_regression_metric.cpp
      src/metric/cuda/cuda_pointwise_metric.cu
      src/objective/cuda/cuda_binary_objective.cpp
      src/objective/cuda/cuda_multiclass_objective.cpp
      src/objective/cuda/cuda_rank_objective.cpp
      src/objective/cuda/cuda_regression_objective.cpp
      src/objective/cuda/cuda_binary_objective.cu
      src/objective/cuda/cuda_multiclass_objective.cu
      src/objective/cuda/cuda_rank_objective.cu
      src/objective/cuda/cuda_regression_objective.cu
      src/treelearner/cuda/cuda_best_split_finder.cpp
      src/treelearner/cuda/cuda_data_partition.cpp
      src/treelearner/cuda/cuda_histogram_constructor.cpp
      src/treelearner/cuda/cuda_leaf_splits.cpp
      src/treelearner/cuda/cuda_single_gpu_tree_learner.cpp
      src/treelearner/cuda/cuda_best_split_finder.cu
      src/treelearner/cuda/cuda_data_partition.cu
      src/treelearner/cuda/cuda_gradient_discretizer.cu
      src/treelearner/cuda/cuda_histogram_constructor.cu
      src/treelearner/cuda/cuda_leaf_splits.cu
      src/treelearner/cuda/cuda_single_gpu_tree_learner.cu
      src/io/cuda/cuda_column_data.cu
      src/io/cuda/cuda_tree.cu
      src/io/cuda/cuda_column_data.cpp
      src/io/cuda/cuda_metadata.cpp
      src/io/cuda/cuda_row_data.cpp
      src/io/cuda/cuda_tree.cpp
      src/cuda/cuda_utils.cpp
      src/cuda/cuda_algorithms.cu
Guolin Ke's avatar
Guolin Ke committed
445
446
)

447
if(USE_CUDA)
448
  list(APPEND LGBM_SOURCES ${LGBM_CUDA_SOURCES})
449
450
endif()

451
add_library(lightgbm_objs OBJECT ${LGBM_SOURCES})
452

453
454
455
456
if(BUILD_CLI)
    add_executable(lightgbm src/main.cpp src/application/application.cpp)
    target_link_libraries(lightgbm PRIVATE lightgbm_objs)
endif()
457

458
set(API_SOURCES "src/c_api.cpp")
459
# Only build the R part of the library if building for
460
# use with the R-package
461
if(__BUILD_FOR_R)
462
  list(APPEND API_SOURCES "src/lightgbm_R.cpp")
463
endif()
464

465
466
add_library(lightgbm_capi_objs OBJECT ${API_SOURCES})

467
if(BUILD_STATIC_LIB)
468
  add_library(_lightgbm STATIC)
469
else()
470
  add_library(_lightgbm SHARED)
471
endif()
472
473
474
475
476
477
478
479
480
481
482

# R expects libraries of the form <project>.{dll,dylib,so}, not lib_<project>.{dll,dylib,so}
if(__BUILD_FOR_R)
  set_target_properties(
    _lightgbm
    PROPERTIES
      PREFIX ""
      OUTPUT_NAME "lightgbm"
  )
endif()

483
# LightGBM headers include openmp, cuda, R etc. headers,
484
485
# thus PUBLIC is required for building _lightgbm_swig target.
target_link_libraries(_lightgbm PUBLIC lightgbm_capi_objs lightgbm_objs)
486

487
if(MSVC AND NOT __BUILD_FOR_R)
488
  set_target_properties(_lightgbm PROPERTIES OUTPUT_NAME "lib_lightgbm")
489
endif()
490

491
492
if(USE_SWIG)
  set_property(SOURCE swig/lightgbmlib.i PROPERTY CPLUSPLUS ON)
493
  list(APPEND swig_options -package com.microsoft.ml.lightgbm)
494
  set_property(SOURCE swig/lightgbmlib.i PROPERTY SWIG_FLAGS "${swig_options}")
495
  swig_add_library(_lightgbm_swig LANGUAGE java SOURCES swig/lightgbmlib.i)
496
  swig_link_libraries(_lightgbm_swig _lightgbm)
497
498
499
500
501
502
503
504
  set_target_properties(
    _lightgbm_swig
    PROPERTIES
      # needed to ensure Linux build does not have lib prefix specified twice, e.g. liblib_lightgbm_swig
      PREFIX ""
      # needed in some versions of CMake for VS and MinGW builds to ensure output dll has lib prefix
      OUTPUT_NAME "lib_lightgbm_swig"
  )
505
  if(WIN32)
506
    set(LGBM_SWIG_LIB_DESTINATION_PATH "${LGBM_SWIG_DESTINATION_DIR}/lib_lightgbm_swig.dll")
507
    if(MINGW OR CYGWIN)
508
509
        set(LGBM_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm.dll")
        set(LGBM_SWIG_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm_swig.dll")
510
    else()
511
512
        set(LGBM_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/Release/lib_lightgbm.dll")
        set(LGBM_SWIG_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/Release/lib_lightgbm_swig.dll")
513
    endif()
514
  elseif(APPLE)
515
516
517
    set(LGBM_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm.dylib")
    set(LGBM_SWIG_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm_swig.jnilib")
    set(LGBM_SWIG_LIB_DESTINATION_PATH "${LGBM_SWIG_DESTINATION_DIR}/lib_lightgbm_swig.dylib")
518
  else()
519
520
521
    set(LGBM_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm.so")
    set(LGBM_SWIG_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm_swig.so")
    set(LGBM_SWIG_LIB_DESTINATION_PATH "${LGBM_SWIG_DESTINATION_DIR}/lib_lightgbm_swig.so")
522
  endif()
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
  add_custom_command(
      TARGET _lightgbm_swig
      POST_BUILD
      COMMAND "${Java_JAVAC_EXECUTABLE}" -d . java/*.java
      COMMAND
        "${CMAKE_COMMAND}"
        -E
        copy_if_different
        "${LGBM_LIB_SOURCE_PATH}"
        "${LGBM_SWIG_DESTINATION_DIR}"
      COMMAND
        "${CMAKE_COMMAND}"
        -E
        copy_if_different
        "${LGBM_SWIG_LIB_SOURCE_PATH}"
        "${LGBM_SWIG_LIB_DESTINATION_PATH}"
      COMMAND "${Java_JAR_EXECUTABLE}" -cf lightgbmlib.jar com
    )
541
endif()
Guolin Ke's avatar
Guolin Ke committed
542
543

if(USE_MPI)
544
  target_link_libraries(lightgbm_objs PUBLIC ${MPI_CXX_LIBRARIES})
545
endif()
Guolin Ke's avatar
Guolin Ke committed
546

fanliwen's avatar
fanliwen committed
547
if(USE_OPENMP)
548
  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
549
550
551
552
553
554
555
556
557
    target_link_libraries(lightgbm_objs PUBLIC OpenMP::OpenMP_CXX)
    # c_api headers also includes OpenMP headers, thus compiling
    # lightgbm_capi_objs needs include directory for OpenMP.
    # Specifying OpenMP in target_link_libraries will get include directory
    # requirements for compilation.
    # This uses CMake's Transitive Usage Requirements. Refer to CMake doc:
    # https://cmake.org/cmake/help/v3.16/manual/cmake-buildsystem.7.html#transitive-usage-requirements
    target_link_libraries(lightgbm_capi_objs PUBLIC OpenMP::OpenMP_CXX)
  endif()
558
endif()
fanliwen's avatar
fanliwen committed
559

560
if(USE_GPU)
561
  target_link_libraries(lightgbm_objs PUBLIC ${OpenCL_LIBRARY} ${Boost_LIBRARIES})
562
endif()
563

564
if(__INTEGRATE_OPENCL)
565
  # targets OpenCL and Boost are added in IntegratedOpenCL.cmake
566
  add_dependencies(lightgbm_objs OpenCL Boost)
567
  # variables INTEGRATED_OPENCL_* are set in IntegratedOpenCL.cmake
568
569
  target_include_directories(lightgbm_objs PRIVATE ${INTEGRATED_OPENCL_INCLUDES})
  target_compile_definitions(lightgbm_objs PRIVATE ${INTEGRATED_OPENCL_DEFINITIONS})
570
  target_link_libraries(lightgbm_objs PUBLIC ${INTEGRATED_OPENCL_LIBRARIES} ${CMAKE_DL_LIBS})
571
572
endif()

573
if(USE_CUDA)
574

575
576
577
  set_target_properties(
    lightgbm_objs
    PROPERTIES
578
      CUDA_ARCHITECTURES "${CUDA_ARCHS}"
579
580
581
582
583
584
      CUDA_SEPARABLE_COMPILATION ON
  )

  set_target_properties(
    _lightgbm
    PROPERTIES
585
      CUDA_ARCHITECTURES "${CUDA_ARCHS}"
586
587
      CUDA_RESOLVE_DEVICE_SYMBOLS ON
  )
588

589
  if(BUILD_CLI)
590
591
592
    set_target_properties(
      lightgbm
      PROPERTIES
593
        CUDA_ARCHITECTURES "${CUDA_ARCHS}"
594
595
        CUDA_RESOLVE_DEVICE_SYMBOLS ON
    )
596
  endif()
597
endif()
598

599
600
if(WIN32)
    if(MINGW OR CYGWIN)
601
      target_link_libraries(lightgbm_objs PUBLIC ws2_32 iphlpapi)
602
603
    endif()
endif()
Guolin Ke's avatar
Guolin Ke committed
604

605
if(__BUILD_FOR_R)
606
607
  # utils/log.h and capi uses R headers, thus both object libraries need to link
  # with R lib.
608
  if(MSVC)
609
    set(R_LIB ${LIBR_MSVC_CORE_LIBRARY})
610
  else()
611
    set(R_LIB ${LIBR_CORE_LIBRARY})
612
  endif()
613
614
  target_link_libraries(lightgbm_objs PUBLIC ${R_LIB})
  target_link_libraries(lightgbm_capi_objs PUBLIC ${R_LIB})
615
endif()
616

617
618
619
620
621
622
623
624
625
#-- Google C++ tests
if(BUILD_CPP_TEST)
  find_package(GTest CONFIG)
  if(NOT GTEST_FOUND)
    message(STATUS "Did not find Google Test in the system root. Fetching Google Test now...")
    include(FetchContent)
    FetchContent_Declare(
      googletest
      GIT_REPOSITORY https://github.com/google/googletest.git
626
      GIT_TAG        v1.14.0
627
628
629
630
    )
    FetchContent_MakeAvailable(googletest)
    add_library(GTest::GTest ALIAS gtest)
  endif()
631
632
633
634

  set(LightGBM_TEST_HEADER_DIR ${PROJECT_SOURCE_DIR}/tests/cpp_tests)
  include_directories(${LightGBM_TEST_HEADER_DIR})

635
636
637
638
639
640
641
642
643
644
645
646
647
  set(
    CPP_TEST_SOURCES
      tests/cpp_tests/test_array_args.cpp
      tests/cpp_tests/test_arrow.cpp
      tests/cpp_tests/test_byte_buffer.cpp
      tests/cpp_tests/test_chunked_array.cpp
      tests/cpp_tests/test_common.cpp
      tests/cpp_tests/test_main.cpp
      tests/cpp_tests/test_serialize.cpp
      tests/cpp_tests/test_single_row.cpp
      tests/cpp_tests/test_stream.cpp
      tests/cpp_tests/testutils.cpp
    )
648
  if(MSVC)
June Liu's avatar
June Liu committed
649
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /permissive-")
650
  endif()
651
  add_executable(testlightgbm ${CPP_TEST_SOURCES})
652
  target_link_libraries(testlightgbm PRIVATE lightgbm_objs lightgbm_capi_objs GTest::GTest)
653
654
endif()

655
656
657
658
659
660
661
if(BUILD_CLI)
    install(
      TARGETS lightgbm
      RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin
    )
endif()

662
663
664
665
if(__BUILD_FOR_PYTHON)
    set(CMAKE_INSTALL_PREFIX "lightgbm")
endif()

666
# The macOS linker puts an absolute path to linked libraries in lib_lightgbm.dylib.
667
668
669
# This block overrides that information for LightGBM's OpenMP dependency, to allow
# finding that library in more places.
#
670
# This reduces the risk of runtime issues resulting from multiple {libgomp,libiomp,libomp}.dylib being loaded.
671
#
672
if(APPLE AND USE_OPENMP AND NOT BUILD_STATIC_LIB)
673
  # store path to {libgomp,libiomp,libomp}.dylib found at build time in a variable
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
  get_target_property(
    OpenMP_LIBRARY_LOCATION
    OpenMP::OpenMP_CXX
    INTERFACE_LINK_LIBRARIES
  )
  # get just the filename of that path
  # (to deal with the possibility that it might be 'libomp.dylib' or 'libgomp.dylib' or 'libiomp.dylib')
  get_filename_component(
    OpenMP_LIBRARY_NAME
    ${OpenMP_LIBRARY_LOCATION}
    NAME
  )
  # get directory of that path
  get_filename_component(
    OpenMP_LIBRARY_DIR
    ${OpenMP_LIBRARY_LOCATION}
    DIRECTORY
  )
  # get exact name of the library in a variable
  get_target_property(
    __LIB_LIGHTGBM_OUTPUT_NAME
    _lightgbm
    OUTPUT_NAME
  )
  if(NOT __LIB_LIGHTGBM_OUTPUT_NAME)
    set(__LIB_LIGHTGBM_OUTPUT_NAME "lib_lightgbm")
  endif()

  if(CMAKE_SHARED_LIBRARY_SUFFIX_CXX)
    set(
      __LIB_LIGHTGBM_FILENAME "${__LIB_LIGHTGBM_OUTPUT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX_CXX}"
      CACHE INTERNAL "lightgbm shared library filename"
    )
  else()
    set(
      __LIB_LIGHTGBM_FILENAME "${__LIB_LIGHTGBM_OUTPUT_NAME}.dylib"
      CACHE INTERNAL "lightgbm shared library filename"
    )
  endif()

  # Override the absolute path to OpenMP with a relative one using @rpath.
  #
716
  # This also ensures that if a {libgomp,libiomp,libomp}.dylib has already been loaded, it'll just use that.
717
718
719
720
721
722
723
724
725
726
727
728
729
730
  add_custom_command(
    TARGET _lightgbm
    POST_BUILD
      COMMAND
        install_name_tool
        -change
        ${OpenMP_LIBRARY_LOCATION}
        "@rpath/${OpenMP_LIBRARY_NAME}"
        "${__LIB_LIGHTGBM_FILENAME}"
      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
      COMMENT "Replacing hard-coded OpenMP install_name with '@rpath/${OpenMP_LIBRARY_NAME}'..."
  )
  # add RPATH entries to ensure the loader looks in the following, in the following order:
  #
731
  #   - (R-only) ${LIBR_LIBS_DIR}    (wherever R for macOS stores vendored third-party libraries)
732
  #   - ${OpenMP_LIBRARY_DIR}        (wherever find_package(OpenMP) found OpenMP at build time)
733
734
  #   - /opt/homebrew/opt/libomp/lib (where 'brew install' / 'brew link' puts libomp.dylib)
  #   - /opt/local/lib/libomp        (where 'port install' puts libomp.dylib)
735
  #
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774

  # with some compilers, OpenMP ships with the compiler (e.g. libgomp with gcc)
  list(APPEND __omp_install_rpaths "${OpenMP_LIBRARY_DIR}")

  # with clang, libomp doesn't ship with the compiler and might be supplied separately
  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
      list(
        APPEND __omp_install_rpaths
          "/opt/homebrew/opt/libomp/lib"
          "/opt/local/lib/libomp"
      )
      # It appears that CRAN's macOS binaries compiled with -fopenmp have install names
      # of the form:
      #
      #   /Library/Frameworks/R.framework/Versions/4.3-arm64/Resources/lib/libomp.dylib
      #
      # That corresponds to the libomp.dylib that ships with the R framework for macOS, available
      # from https://cran.r-project.org/bin/macosx/.
      #
      # That absolute-path install name leads to that library being loaded unconditionally.
      #
      # That can result in e.g. 'library(data.table)' loading R's libomp.dylib and 'library(lightgbm)' loading
      # Homebrew's. Having 2 loaded in the same process can lead to segfaults and unpredictable behavior.
      #
      # This can't be easily avoided by forcing R-package builds in LightGBM to use R's libomp.dylib
      # at build time... LightGBM's CMake uses find_package(OpenMP), and R for macOS only provides the
      # library, not CMake config files for it.
      #
      # Best we can do, to allow CMake-based builds of the R-package here to continue to work
      # alongside CRAN-prepared binaries of other packages with OpenMP dependencies, is to
      # ensure that R's library directory is the first place the loader searches for
      # libomp.dylib when clang is used.
      #
      # ref: https://github.com/microsoft/LightGBM/issues/6628
      #
      if(__BUILD_FOR_R)
        list(PREPEND __omp_install_rpaths "${LIBR_LIBS_DIR}")
      endif()
  endif()
775
776
777
778
  set_target_properties(
    _lightgbm
    PROPERTIES
      BUILD_WITH_INSTALL_RPATH TRUE
779
      INSTALL_RPATH "${__omp_install_rpaths}"
780
781
782
783
      INSTALL_RPATH_USE_LINK_PATH FALSE
  )
endif()

784
install(
785
  TARGETS _lightgbm
786
787
788
789
  RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin
  LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
  ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
)
790

791
if(INSTALL_HEADERS)
792
793
794
795
796
797
798
799
800
801
802
803
804
    install(
      DIRECTORY ${LightGBM_HEADER_DIR}/LightGBM
      DESTINATION ${CMAKE_INSTALL_PREFIX}/include
    )
    install(
      FILES ${FAST_DOUBLE_PARSER_INCLUDE_DIR}/fast_double_parser.h
      DESTINATION ${CMAKE_INSTALL_PREFIX}/include/LightGBM/utils
    )
    install(
      DIRECTORY ${FMT_INCLUDE_DIR}/
      DESTINATION ${CMAKE_INSTALL_PREFIX}/include/LightGBM/utils
      FILES_MATCHING PATTERN "*.h"
    )
805
endif()