CMakeLists.txt 29.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_ROCM "Enable ROCm-accelerated training " OFF)
8
option(USE_DEBUG "Set to ON for Debug mode" OFF)
9
option(USE_SANITIZER "Use sanitizer flags" OFF)
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
19
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)
20
21
option(BUILD_CPP_TEST "Build C++ tests with Google Test" OFF)
option(BUILD_STATIC_LIB "Build static library" OFF)
22
option(INSTALL_HEADERS "Install headers to CMAKE_INSTALL_PREFIX (e.g. '/usr/local/include')" ON)
23
24
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)
25
option(__INTEGRATE_OPENCL "Set to ON if building LightGBM with the OpenCL ICD Loader and its dependencies included" OFF)
26

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

29
30
31
32
33
34
35
36
# 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()

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

39
set(CMAKE_CXX_STANDARD 17)
40
41
set(CMAKE_CXX_STANDARD_REQUIRED ON)

42
43
44
list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules")

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

53
54
55
56
57
58
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()

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

Qiwei Ye's avatar
Qiwei Ye committed
67
68
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.8.2")
69
    message(FATAL_ERROR "Insufficient gcc version (${CMAKE_CXX_COMPILER_VERSION})")
Qiwei Ye's avatar
Qiwei Ye committed
70
71
72
  endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.8")
73
    message(FATAL_ERROR "Insufficient Clang version (${CMAKE_CXX_COMPILER_VERSION})")
Qiwei Ye's avatar
Qiwei Ye committed
74
  endif()
75
76
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.1.0")
77
    message(FATAL_ERROR "Insufficient AppleClang version (${CMAKE_CXX_COMPILER_VERSION})")
78
79
80
  endif()
elseif(MSVC)
  if(MSVC_VERSION LESS 1900)
81
    message(FATAL_ERROR "Insufficient MSVC version (${MSVC_VERSION})")
82
  endif()
83
endif()
Guolin Ke's avatar
Guolin Ke committed
84

85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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)
100
  if(WIN32)
101
      set(LGBM_SWIG_DESTINATION_DIR "${CMAKE_CURRENT_BINARY_DIR}/com/microsoft/ml/lightgbm/windows/x86_64")
102
      include_directories($ENV{JAVA_HOME}/include/win32)
103
  elseif(APPLE)
104
      set(LGBM_SWIG_DESTINATION_DIR "${CMAKE_CURRENT_BINARY_DIR}/com/microsoft/ml/lightgbm/osx/x86_64")
105
      include_directories($ENV{JAVA_HOME}/include/darwin)
106
  else()
107
      set(LGBM_SWIG_DESTINATION_DIR "${CMAKE_CURRENT_BINARY_DIR}/com/microsoft/ml/lightgbm/linux/x86_64")
108
109
      include_directories($ENV{JAVA_HOME}/include/linux)
  endif()
110
  file(MAKE_DIRECTORY "${LGBM_SWIG_DESTINATION_DIR}")
111
endif()
112

113
set(EIGEN_DIR "${PROJECT_SOURCE_DIR}/external_libs/eigen")
114
115
include_directories(${EIGEN_DIR})

116
# See https://gitlab.com/libeigen/eigen/-/blob/master/COPYING.README
117
add_definitions(-DEIGEN_MPL2_ONLY)
118
add_definitions(-DEIGEN_DONT_PARALLELIZE)
119

120
121
122
123
124
125
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})

126
if(__BUILD_FOR_R)
127
128
129
    find_package(LibR REQUIRED)
    message(STATUS "LIBR_EXECUTABLE: ${LIBR_EXECUTABLE}")
    message(STATUS "LIBR_INCLUDE_DIRS: ${LIBR_INCLUDE_DIRS}")
130
    message(STATUS "LIBR_LIBS_DIR: ${LIBR_LIBS_DIR}")
131
132
    message(STATUS "LIBR_CORE_LIBRARY: ${LIBR_CORE_LIBRARY}")
    include_directories(${LIBR_INCLUDE_DIRS})
133
    add_definitions(-DLGB_R_BUILD)
134
endif()
135

136
if(USE_TIMETAG)
137
    add_definitions(-DTIMETAG)
138
endif()
139

Guolin Ke's avatar
Guolin Ke committed
140
if(USE_DEBUG)
141
    add_definitions(-DDEBUG)
142
endif()
Guolin Ke's avatar
Guolin Ke committed
143

Guolin Ke's avatar
Guolin Ke committed
144
if(USE_MPI)
Guolin Ke's avatar
Guolin Ke committed
145
    find_package(MPI REQUIRED)
146
    add_definitions(-DUSE_MPI)
Guolin Ke's avatar
Guolin Ke committed
147
else()
148
    add_definitions(-DUSE_SOCKET)
149
endif()
Guolin Ke's avatar
Guolin Ke committed
150

151
if(USE_CUDA)
152
    set(CMAKE_CUDA_HOST_COMPILER "${CMAKE_CXX_COMPILER}")
153
    enable_language(CUDA)
154
    set(USE_OPENMP ON CACHE BOOL "CUDA requires OpenMP" FORCE)
155
endif()
156

157
158
159
160
161
if(USE_ROCM)
    enable_language(HIP)
    set(USE_OPENMP ON CACHE BOOL "ROCm requires OpenMP" FORCE)
endif()

162
if(USE_OPENMP)
163
164
165
    if(APPLE)
        find_package(OpenMP)
        if(NOT OpenMP_FOUND)
166
167
168
169
            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
170
171
                            OUTPUT_VARIABLE HOMEBREW_LIBOMP_PREFIX
                            OUTPUT_STRIP_TRAILING_WHITESPACE)
172
173
174
175
176
177
                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()
178
179
180
181
182
            find_package(OpenMP REQUIRED)
        endif()
    else()
        find_package(OpenMP REQUIRED)
    endif()
183
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
184
endif()
Guolin Ke's avatar
Guolin Ke committed
185

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

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

213
214
215
216
217
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()

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

223
224
    # reference for mapping of CUDA toolkit component versions to supported architectures ("compute capabilities"):
    # https://en.wikipedia.org/wiki/CUDA#GPUs_supported
225
    set(CUDA_ARCHS "60" "61" "62" "70" "75")
226
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.0")
227
        list(APPEND CUDA_ARCHS "80")
228
    endif()
229
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.1")
230
        list(APPEND CUDA_ARCHS "86")
231
    endif()
232
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.5")
233
        list(APPEND CUDA_ARCHS "87")
234
    endif()
235
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "11.8")
236
237
        list(APPEND CUDA_ARCHS "89")
        list(APPEND CUDA_ARCHS "90")
238
    endif()
239
240
241
242
243
    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
244
    list(POP_BACK CUDA_ARCHS CUDA_LAST_SUPPORTED_ARCH)
245
246
247
    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}")
248
    if(USE_DEBUG)
249
      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -g")
250
    else()
251
      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -O3 -lineinfo")
252
253
254
    endif()
    message(STATUS "CMAKE_CUDA_FLAGS: ${CMAKE_CUDA_FLAGS}")

255
    add_definitions(-DUSE_CUDA)
256

257
    if(NOT DEFINED CMAKE_CUDA_STANDARD)
258
      set(CMAKE_CUDA_STANDARD 17)
259
260
      set(CMAKE_CUDA_STANDARD_REQUIRED ON)
    endif()
261
endif()
262

263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
if(USE_ROCM)
    find_package(HIP)
    include_directories(${HIP_INCLUDE_DIRS})
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__HIP_PLATFORM_AMD__")
    set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} ${OpenMP_CXX_FLAGS} -fPIC -Wall")

    # avoid warning: unused variable 'mask' due to __shfl_down_sync work-around
    set(DISABLED_WARNINGS "${DISABLED_WARNINGS} -Wno-unused-variable")
    # avoid warning: 'hipHostAlloc' is deprecated: use hipHostMalloc instead
    set(DISABLED_WARNINGS "${DISABLED_WARNINGS} -Wno-deprecated-declarations")
    # avoid many warnings about missing overrides
    set(DISABLED_WARNINGS "${DISABLED_WARNINGS} -Wno-inconsistent-missing-override")
    # avoid warning: shift count >= width of type in feature_histogram.hpp
    set(DISABLED_WARNINGS "${DISABLED_WARNINGS} -Wno-shift-count-overflow")

    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DISABLED_WARNINGS}")
    set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} ${DISABLED_WARNINGS}")

    if(USE_DEBUG)
      set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} -g -O0")
    else()
      set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} -O3")
    endif()
    message(STATUS "CMAKE_HIP_FLAGS: ${CMAKE_HIP_FLAGS}")

288
289
290
    # Building for ROCm almost always means USE_CUDA.
    # Exceptions to this will be guarded by USE_ROCM.
    add_definitions(-DUSE_CUDA)
291
292
293
    add_definitions(-DUSE_ROCM)
endif()

294
295
296
297
298
299
300
301
302
303
304
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})
305
  message(STATUS "Using _mm_prefetch")
306
  add_definitions(-DMM_PREFETCH)
307
308
endif()

309
310
311
312
313
314
315
316
317
318
319
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})
320
  message(STATUS "Using _mm_malloc")
321
  add_definitions(-DMM_MALLOC)
322
323
endif()

Guolin Ke's avatar
Guolin Ke committed
324
if(UNIX OR MINGW OR CYGWIN)
325
  set(
326
    CMAKE_CXX_FLAGS
327
    "${CMAKE_CXX_FLAGS} -pthread -Wextra -Wall -Wno-ignored-attributes -Wno-unknown-pragmas -Wno-return-type"
328
  )
329
330
331
332
333
334
335
  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()
336
  if(USE_DEBUG)
337
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0")
338
  else()
339
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
340
341
  endif()
  if(USE_SWIG)
342
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing")
343
344
  endif()
  if(NOT USE_OPENMP)
345
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-pragmas -Wno-unused-private-field")
346
347
  endif()
  if(__BUILD_FOR_R AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
348
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-cast-function-type")
349
  endif()
Guolin Ke's avatar
Guolin Ke committed
350
351
endif()

Nikita Titov's avatar
Nikita Titov committed
352
if(WIN32 AND MINGW)
353
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++")
Nikita Titov's avatar
Nikita Titov committed
354
355
endif()

356
357
358
359
360
361
362
363
364
365
366
367
# 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
368
if(MSVC)
369
370
    # compiling 'fmt' on MSVC: "Unicode support requires compiling with /utf-8"
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /MP /utf-8")
371
372
373
374
375
376
377
    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
378
    if(USE_DEBUG)
379
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Od")
Guolin Ke's avatar
Guolin Ke committed
380
    else()
381
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /Ob2 /Oi /Ot /Oy")
Guolin Ke's avatar
Guolin Ke committed
382
    endif()
Guolin Ke's avatar
Guolin Ke committed
383
else()
384
385
386
    if(NOT BUILD_STATIC_LIB)
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
    endif()
Guolin Ke's avatar
Guolin Ke committed
387
    if(NOT USE_DEBUG)
388
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -funroll-loops")
Guolin Ke's avatar
Guolin Ke committed
389
    endif()
390
endif()
Guolin Ke's avatar
Guolin Ke committed
391

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

394
395
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
Guolin Ke's avatar
Guolin Ke committed
396

397
include_directories(${LightGBM_HEADER_DIR})
Guolin Ke's avatar
Guolin Ke committed
398
399
400

if(USE_MPI)
  include_directories(${MPI_CXX_INCLUDE_PATH})
401
endif()
Guolin Ke's avatar
Guolin Ke committed
402

403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
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
439
)
440
set(
441
    LGBM_CUDA_SOURCES
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
      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
475
476
)

477
if(USE_CUDA OR USE_ROCM)
478
  list(APPEND LGBM_SOURCES ${LGBM_CUDA_SOURCES})
479
480
endif()

481
482
483
484
485
486
487
488
489
490
491
if(USE_ROCM)
  set(CU_FILES "")
  foreach(file IN LISTS LGBM_CUDA_SOURCES)
      string(REGEX MATCH "\\.cu$" is_cu_file "${file}")
      if(is_cu_file)
          list(APPEND CU_FILES "${file}")
      endif()
  endforeach()
  set_source_files_properties(${CU_FILES} PROPERTIES LANGUAGE HIP)
endif()

492
add_library(lightgbm_objs OBJECT ${LGBM_SOURCES})
493

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

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

506
507
add_library(lightgbm_capi_objs OBJECT ${API_SOURCES})

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

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

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

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

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

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

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

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

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

614
if(USE_CUDA)
615

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

  set_target_properties(
    _lightgbm
    PROPERTIES
626
      CUDA_ARCHITECTURES "${CUDA_ARCHS}"
627
628
      CUDA_RESOLVE_DEVICE_SYMBOLS ON
  )
629

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

640
641
642
643
if(USE_ROCM)
  target_link_libraries(lightgbm_objs PUBLIC hip::host)
endif()

644
645
if(WIN32)
    if(MINGW OR CYGWIN)
646
      target_link_libraries(lightgbm_objs PUBLIC ws2_32 iphlpapi)
647
648
    endif()
endif()
Guolin Ke's avatar
Guolin Ke committed
649

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

662
663
664
665
666
667
#-- 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)
668
# lint_cmake: -readability/wonkycase
669
    FetchContent_Declare(
670
# lint_cmake: +readability/wonkycase
671
672
      googletest
      GIT_REPOSITORY https://github.com/google/googletest.git
673
      GIT_TAG        v1.14.0
674
    )
675
# lint_cmake: -readability/wonkycase
676
    FetchContent_MakeAvailable(googletest)
677
# lint_cmake: +readability/wonkycase
678
679
    add_library(GTest::GTest ALIAS gtest)
  endif()
680
681
682
683

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

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

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

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

715
# The macOS linker puts an absolute path to linked libraries in lib_lightgbm.dylib.
716
717
718
# This block overrides that information for LightGBM's OpenMP dependency, to allow
# finding that library in more places.
#
719
# This reduces the risk of runtime issues resulting from multiple {libgomp,libiomp,libomp}.dylib being loaded.
720
#
721
if(APPLE AND USE_OPENMP AND NOT BUILD_STATIC_LIB)
722
  # store path to {libgomp,libiomp,libomp}.dylib found at build time in a variable
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
764
  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.
  #
765
  # This also ensures that if a {libgomp,libiomp,libomp}.dylib has already been loaded, it'll just use that.
766
767
768
769
770
771
772
773
774
775
776
777
778
779
  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:
  #
780
  #   - (R-only) ${LIBR_LIBS_DIR}    (wherever R for macOS stores vendored third-party libraries)
781
  #   - ${OpenMP_LIBRARY_DIR}        (wherever find_package(OpenMP) found OpenMP at build time)
782
783
  #   - /opt/homebrew/opt/libomp/lib (where 'brew install' / 'brew link' puts libomp.dylib)
  #   - /opt/local/lib/libomp        (where 'port install' puts libomp.dylib)
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
823

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

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

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