CMakeLists.txt 28.7 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
8
option(USE_DEBUG "Set to ON for Debug mode" OFF)
option(USE_SANITIZER "Use santizer flags" OFF)
9
option(USE_HOMEBREW_FALLBACK "(macOS-only) also look in 'brew --prefix' for libraries (e.g. OpenMP)" ON)
10
set(
11
12
13
14
15
16
17
  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."
)
18
option(BUILD_CLI "Build the 'lightbgm' 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
22
option(INSTALL_HEADERS "Install headers to CMAKE_INSTALL_PREFIX (e.g. '/usr/local/include')" ON)
option(__BUILD_FOR_PYTHON "Set to ON if building lib_lightgbm for use with the Python package" OFF)
23
24
option(__BUILD_FOR_R "Set to ON if building lib_lightgbm for use with the R package" OFF)
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
63
if(__BUILD_FOR_PYTHON OR __BUILD_FOR_R OR USE_SWIG)
    # the SWIG wrapper, the Python and R package don't require the CLI
64
    set(BUILD_CLI OFF)
65
    # installing the SWIG wrapper, the R and Python package 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
227
228
    set(CUDA_ARCHS "60" "61" "62" "70" "75")
    if(CUDA_VERSION VERSION_GREATER_EQUAL "110")
        list(APPEND CUDA_ARCHS "80")
229
    endif()
230
231
    if(CUDA_VERSION VERSION_GREATER_EQUAL "111")
        list(APPEND CUDA_ARCHS "86")
232
    endif()
233
234
    if(CUDA_VERSION VERSION_GREATER_EQUAL "115")
        list(APPEND CUDA_ARCHS "87")
235
    endif()
236
237
238
    if(CUDA_VERSION VERSION_GREATER_EQUAL "118")
        list(APPEND CUDA_ARCHS "89")
        list(APPEND CUDA_ARCHS "90")
239
    endif()
240
241
    list(POP_BACK CUDA_ARCHS CUDA_LAST_SUPPORTED_ARCH)
    list(APPEND CUDA_ARCHS "${CUDA_LAST_SUPPORTED_ARCH}+PTX")
242
    if(USE_DEBUG)
243
      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -g")
244
    else()
245
      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -O3 -lineinfo")
246
247
248
    endif()
    message(STATUS "CMAKE_CUDA_FLAGS: ${CMAKE_CUDA_FLAGS}")

249
    add_definitions(-DUSE_CUDA)
250

251
    if(NOT DEFINED CMAKE_CUDA_STANDARD)
252
253
254
255
      set(CMAKE_CUDA_STANDARD 11)
      set(CMAKE_CUDA_STANDARD_REQUIRED ON)
    endif()

256
257
258
259
    set(
      BASE_DEFINES
      -DPOWER_FEATURE_WORKGROUPS=12
      -DUSE_CONSTANT_BUF=0
260
    )
261
262
263
264
    set(
      ALLFEATS_DEFINES
      ${BASE_DEFINES}
      -DENABLE_ALL_FEATURES
265
    )
266
267
268
269
    set(
      FULLDATA_DEFINES
      ${ALLFEATS_DEFINES}
      -DIGNORE_INDICES
270
271
272
273
274
275
276
    )

    message(STATUS "ALLFEATS_DEFINES: ${ALLFEATS_DEFINES}")
    message(STATUS "FULLDATA_DEFINES: ${FULLDATA_DEFINES}")

    function(add_histogram hsize hname hadd hconst hdir)
      add_library(histo${hsize}${hname} OBJECT src/treelearner/kernels/histogram${hsize}.cu)
277
278
279
280
281
282
      set_target_properties(
        histo${hsize}${hname}
        PROPERTIES
          CUDA_SEPARABLE_COMPILATION ON
          CUDA_ARCHITECTURES ${CUDA_ARCHS}
      )
283
284
285
286
287
      if(hadd)
        list(APPEND histograms histo${hsize}${hname})
        set(histograms ${histograms} PARENT_SCOPE)
      endif()
      target_compile_definitions(
288
289
        histo${hsize}${hname}
        PRIVATE
290
291
292
293
294
        -DCONST_HESSIAN=${hconst}
        ${hdir}
      )
    endfunction()

295
    foreach(hsize _16_64_256)
296
297
298
299
300
301
302
      add_histogram("${hsize}" "_sp_const" "True" "1" "${BASE_DEFINES}")
      add_histogram("${hsize}" "_sp" "True" "0" "${BASE_DEFINES}")
      add_histogram("${hsize}" "-allfeats_sp_const" "False" "1" "${ALLFEATS_DEFINES}")
      add_histogram("${hsize}" "-allfeats_sp" "False" "0" "${ALLFEATS_DEFINES}")
      add_histogram("${hsize}" "-fulldata_sp_const" "True" "1" "${FULLDATA_DEFINES}")
      add_histogram("${hsize}" "-fulldata_sp" "True" "0" "${FULLDATA_DEFINES}")
    endforeach()
303
endif()
304

305
306
307
308
309
310
311
312
313
314
315
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})
316
  message(STATUS "Using _mm_prefetch")
317
  add_definitions(-DMM_PREFETCH)
318
319
endif()

320
321
322
323
324
325
326
327
328
329
330
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})
331
  message(STATUS "Using _mm_malloc")
332
  add_definitions(-DMM_MALLOC)
333
334
endif()

Guolin Ke's avatar
Guolin Ke committed
335
if(UNIX OR MINGW OR CYGWIN)
336
  set(
337
    CMAKE_CXX_FLAGS
338
    "${CMAKE_CXX_FLAGS} -pthread -Wextra -Wall -Wno-ignored-attributes -Wno-unknown-pragmas -Wno-return-type"
339
  )
340
341
342
343
344
345
346
  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()
347
  if(USE_DEBUG)
348
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0")
349
  else()
350
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
351
352
  endif()
  if(USE_SWIG)
353
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing")
354
355
  endif()
  if(NOT USE_OPENMP)
356
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-pragmas -Wno-unused-private-field")
357
358
  endif()
  if(__BUILD_FOR_R AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
359
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-cast-function-type")
360
  endif()
Guolin Ke's avatar
Guolin Ke committed
361
362
endif()

Nikita Titov's avatar
Nikita Titov committed
363
if(WIN32 AND MINGW)
364
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++")
Nikita Titov's avatar
Nikita Titov committed
365
366
endif()

367
368
369
370
371
372
373
374
375
376
377
378
# 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
379
if(MSVC)
380
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /MP")
381
382
383
384
385
386
387
    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
388
    if(USE_DEBUG)
389
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Od")
Guolin Ke's avatar
Guolin Ke committed
390
    else()
391
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /Ob2 /Oi /Ot /Oy")
Guolin Ke's avatar
Guolin Ke committed
392
    endif()
Guolin Ke's avatar
Guolin Ke committed
393
else()
394
395
396
    if(NOT BUILD_STATIC_LIB)
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
    endif()
Guolin Ke's avatar
Guolin Ke committed
397
    if(NOT USE_DEBUG)
398
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -funroll-loops")
Guolin Ke's avatar
Guolin Ke committed
399
    endif()
400
endif()
Guolin Ke's avatar
Guolin Ke committed
401

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

404
405
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
Guolin Ke's avatar
Guolin Ke committed
406

407
include_directories(${LightGBM_HEADER_DIR})
Guolin Ke's avatar
Guolin Ke committed
408
409
410

if(USE_MPI)
  include_directories(${MPI_CXX_INCLUDE_PATH})
411
endif()
Guolin Ke's avatar
Guolin Ke committed
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
445
446
447
448
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
449
)
450
set(
451
    LGBM_CUDA_SOURCES
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
      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
485
486
)

487
if(USE_CUDA)
488
  list(APPEND LGBM_SOURCES ${LGBM_CUDA_SOURCES})
489
490
endif()

491
add_library(lightgbm_objs OBJECT ${LGBM_SOURCES})
492

493
494
495
496
if(BUILD_CLI)
    add_executable(lightgbm src/main.cpp src/application/application.cpp)
    target_link_libraries(lightgbm PRIVATE lightgbm_objs)
endif()
497

498
set(API_SOURCES "src/c_api.cpp")
499
500
# Only build the R part of the library if building for
# use with the R package
501
if(__BUILD_FOR_R)
502
  list(APPEND API_SOURCES "src/lightgbm_R.cpp")
503
endif()
504

505
506
add_library(lightgbm_capi_objs OBJECT ${API_SOURCES})

507
if(BUILD_STATIC_LIB)
508
  add_library(_lightgbm STATIC)
509
else()
510
  add_library(_lightgbm SHARED)
511
endif()
512
513
514
515
516
517
518
519
520
521
522

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

523
# LightGBM headers include openmp, cuda, R etc. headers,
524
525
# thus PUBLIC is required for building _lightgbm_swig target.
target_link_libraries(_lightgbm PUBLIC lightgbm_capi_objs lightgbm_objs)
526

527
if(MSVC AND NOT __BUILD_FOR_R)
528
  set_target_properties(_lightgbm PROPERTIES OUTPUT_NAME "lib_lightgbm")
529
endif()
530

531
532
if(USE_SWIG)
  set_property(SOURCE swig/lightgbmlib.i PROPERTY CPLUSPLUS ON)
533
  list(APPEND swig_options -package com.microsoft.ml.lightgbm)
534
  set_property(SOURCE swig/lightgbmlib.i PROPERTY SWIG_FLAGS "${swig_options}")
535
  swig_add_library(_lightgbm_swig LANGUAGE java SOURCES swig/lightgbmlib.i)
536
  swig_link_libraries(_lightgbm_swig _lightgbm)
537
538
539
540
541
542
543
544
  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"
  )
545
  if(WIN32)
546
    set(LGBM_SWIG_LIB_DESTINATION_PATH "${LGBM_SWIG_DESTINATION_DIR}/lib_lightgbm_swig.dll")
547
    if(MINGW OR CYGWIN)
548
549
        set(LGBM_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm.dll")
        set(LGBM_SWIG_LIB_SOURCE_PATH "${PROJECT_SOURCE_DIR}/lib_lightgbm_swig.dll")
550
    else()
551
552
        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")
553
    endif()
554
  elseif(APPLE)
555
556
557
    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")
558
  else()
559
560
561
    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")
562
  endif()
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
  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
    )
581
endif()
Guolin Ke's avatar
Guolin Ke committed
582
583

if(USE_MPI)
584
  target_link_libraries(lightgbm_objs PUBLIC ${MPI_CXX_LIBRARIES})
585
endif()
Guolin Ke's avatar
Guolin Ke committed
586

fanliwen's avatar
fanliwen committed
587
if(USE_OPENMP)
588
  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
589
590
591
592
593
594
595
596
597
    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()
598
endif()
fanliwen's avatar
fanliwen committed
599

600
if(USE_GPU)
601
  target_link_libraries(lightgbm_objs PUBLIC ${OpenCL_LIBRARY} ${Boost_LIBRARIES})
602
endif()
603

604
if(__INTEGRATE_OPENCL)
605
  # targets OpenCL and Boost are added in IntegratedOpenCL.cmake
606
  add_dependencies(lightgbm_objs OpenCL Boost)
607
  # variables INTEGRATED_OPENCL_* are set in IntegratedOpenCL.cmake
608
609
  target_include_directories(lightgbm_objs PRIVATE ${INTEGRATED_OPENCL_INCLUDES})
  target_compile_definitions(lightgbm_objs PRIVATE ${INTEGRATED_OPENCL_DEFINITIONS})
610
  target_link_libraries(lightgbm_objs PUBLIC ${INTEGRATED_OPENCL_LIBRARIES} ${CMAKE_DL_LIBS})
611
612
endif()

613
if(USE_CUDA)
614

615
616
617
618
619
620
621
622
623
624
625
626
627
  set_target_properties(
    lightgbm_objs
    PROPERTIES
      CUDA_ARCHITECTURES ${CUDA_ARCHS}
      CUDA_SEPARABLE_COMPILATION ON
  )

  set_target_properties(
    _lightgbm
    PROPERTIES
      CUDA_ARCHITECTURES ${CUDA_ARCHS}
      CUDA_RESOLVE_DEVICE_SYMBOLS ON
  )
628

629
  if(BUILD_CLI)
630
631
632
633
634
635
    set_target_properties(
      lightgbm
      PROPERTIES
        CUDA_ARCHITECTURES ${CUDA_ARCHS}
        CUDA_RESOLVE_DEVICE_SYMBOLS ON
    )
636
  endif()
637
638
639
640

  # histograms are list of object libraries. Linking object library to other
  # object libraries only gets usage requirements, the linked objects won't be
  # used. Thus we have to call target_link_libraries on final targets here.
641
642
643
  if(BUILD_CLI)
    target_link_libraries(lightgbm PRIVATE ${histograms})
  endif()
644
  target_link_libraries(_lightgbm PRIVATE ${histograms})
645
endif()
646

647
648
if(WIN32)
    if(MINGW OR CYGWIN)
649
      target_link_libraries(lightgbm_objs PUBLIC ws2_32 iphlpapi)
650
651
    endif()
endif()
Guolin Ke's avatar
Guolin Ke committed
652

653
if(__BUILD_FOR_R)
654
655
  # utils/log.h and capi uses R headers, thus both object libraries need to link
  # with R lib.
656
  if(MSVC)
657
    set(R_LIB ${LIBR_MSVC_CORE_LIBRARY})
658
  else()
659
    set(R_LIB ${LIBR_CORE_LIBRARY})
660
  endif()
661
662
  target_link_libraries(lightgbm_objs PUBLIC ${R_LIB})
  target_link_libraries(lightgbm_capi_objs PUBLIC ${R_LIB})
663
endif()
664

665
666
667
668
669
670
671
672
673
#-- 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
674
      GIT_TAG        v1.14.0
675
676
677
678
    )
    FetchContent_MakeAvailable(googletest)
    add_library(GTest::GTest ALIAS gtest)
  endif()
679
680
681
682

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

683
684
685
686
687
688
689
690
691
692
693
694
695
  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
    )
696
  if(MSVC)
June Liu's avatar
June Liu committed
697
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /permissive-")
698
  endif()
699
  add_executable(testlightgbm ${CPP_TEST_SOURCES})
700
  target_link_libraries(testlightgbm PRIVATE lightgbm_objs lightgbm_capi_objs GTest::GTest)
701
702
endif()

703
704
705
706
707
708
709
if(BUILD_CLI)
    install(
      TARGETS lightgbm
      RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin
    )
endif()

710
711
712
713
if(__BUILD_FOR_PYTHON)
    set(CMAKE_INSTALL_PREFIX "lightgbm")
endif()

714
# The macOS linker puts an absolute path to linked libraries in lib_lightgbm.dylib.
715
716
717
# This block overrides that information for LightGBM's OpenMP dependency, to allow
# finding that library in more places.
#
718
# This reduces the risk of runtime issues resulting from multiple {libgomp,libiomp,libomp}.dylib being loaded.
719
#
720
if(APPLE AND USE_OPENMP AND NOT BUILD_STATIC_LIB)
721
  # store path to {libgomp,libiomp,libomp}.dylib found at build time in a variable
722
723
724
725
726
727
728
729
730
731
732
733
734
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
  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.
  #
764
  # This also ensures that if a {libgomp,libiomp,libomp}.dylib has already been loaded, it'll just use that.
765
766
767
768
769
770
771
772
773
774
775
776
777
778
  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:
  #
779
  #   - (R-only) ${LIBR_LIBS_DIR}    (wherever R for macOS stores vendored third-party libraries)
780
  #   - ${OpenMP_LIBRARY_DIR}        (wherever find_package(OpenMP) found OpenMP at build time)
781
782
  #   - /opt/homebrew/opt/libomp/lib (where 'brew install' / 'brew link' puts libomp.dylib)
  #   - /opt/local/lib/libomp        (where 'port install' puts libomp.dylib)
783
  #
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822

  # 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()
823
824
825
826
  set_target_properties(
    _lightgbm
    PROPERTIES
      BUILD_WITH_INSTALL_RPATH TRUE
827
      INSTALL_RPATH "${__omp_install_rpaths}"
828
829
830
831
      INSTALL_RPATH_USE_LINK_PATH FALSE
  )
endif()

832
install(
833
  TARGETS _lightgbm
834
835
836
837
  RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin
  LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
  ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
)
838

839
if(INSTALL_HEADERS)
840
841
842
843
844
845
846
847
848
849
850
851
852
    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"
    )
853
endif()