# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License
cmake_minimum_required ( VERSION 3.10 )
set ( CMAKE_MODULE_PATH ${ CMAKE_MODULE_PATH } "${CMAKE_CURRENT_SOURCE_DIR}/cmake" )
set ( PADDLE_SOURCE_DIR ${ CMAKE_CURRENT_SOURCE_DIR } )
set ( PADDLE_BINARY_DIR ${ CMAKE_CURRENT_BINARY_DIR } )
include ( system )
project ( paddle CXX C )
include ( init )
include ( generic ) # simplify cmake module
# enable language CUDA
# TODO(Shibo Tao): remove find_package(CUDA) completely.
find_package ( CUDA QUIET )
option ( WITH_GPU "Compile PaddlePaddle with NVIDIA GPU" ${ CUDA_FOUND } )
option ( WITH_TENSORRT "Compile PaddlePaddle with NVIDIA TensorRT" OFF )
option ( WITH_XPU "Compile PaddlePaddle with BAIDU KUNLUN" OFF )
if ( WITH_GPU AND WITH_XPU )
message ( FATAL_ERROR "Error when compile GPU and XPU at the same time" )
endif ( )
# cmake 3.12, 3.13, 3.14 will append gcc link options to nvcc, and nvcc doesn't recognize them.
if ( WITH_GPU AND ( ${ CMAKE_VERSION } VERSION_GREATER_EQUAL 3.12 ) AND ( ${ CMAKE_VERSION } VERSION_LESS 3.15 ) )
message ( FATAL_ERROR "cmake ${CMAKE_VERSION} is not supported when WITH_GPU=ON because of bug https://cmake.org/pipermail/cmake/2018-September/068195.html. "
" Y o u c a n u s e c m a k e 3 . 16 ( recommended ) , 3 . 1 0 , 3 . 1 1 , 3 . 1 5 o r 3 . 1 7 . P l e a s e r e f e r t o t h e i n s t a l l d o c u m e n t : h t t p s : / / c m a k e . o r g / i n s t a l l / " )
endif ( )
if ( WITH_GPU AND NOT APPLE )
enable_language ( CUDA )
message ( STATUS "CUDA compiler: ${CMAKE_CUDA_COMPILER}, version: "
" $ { C M A K E _ C U D A _ C O M P I L E R _ I D } $ { C M A K E _ C U D A _ C O M P I L E R _ V E R S I O N } " )
endif ( )
message ( STATUS "CXX compiler: ${CMAKE_CXX_COMPILER}, version: "
" $ { C M A K E _ C X X _ C O M P I L E R _ I D } $ { C M A K E _ C X X _ C O M P I L E R _ V E R S I O N } " )
message ( STATUS "C compiler: ${CMAKE_C_COMPILER}, version: "
" $ { C M A K E _ C _ C O M P I L E R _ I D } $ { C M A K E _ C _ C O M P I L E R _ V E R S I O N } " )
message ( STATUS "AR tools: ${CMAKE_AR}" )
if ( WIN32 )
option ( MSVC_STATIC_CRT "use static C Runtime library by default" ON )
set ( CMAKE_SUPPRESS_REGENERATION ON )
set ( CMAKE_STATIC_LIBRARY_PREFIX lib )
if ( MSVC_STATIC_CRT )
message ( STATUS "Use static C runtime time, refer to https://docs.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features?view=vs-2019" )
set ( CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /bigobj /MTd" )
set ( CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /bigobj /MT" )
set ( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /bigobj /MTd" )
set ( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /bigobj /MT" )
foreach ( flag_var
C M A K E _ C X X _ F L A G S C M A K E _ C X X _ F L A G S _ D E B U G C M A K E _ C X X _ F L A G S _ R E L E A S E
C M A K E _ C X X _ F L A G S _ M I N S I Z E R E L C M A K E _ C X X _ F L A G S _ R E L W I T H D E B I N F O
C M A K E _ C _ F L A G S C M A K E _ C _ F L A G S _ D E B U G C M A K E _ C _ F L A G S _ R E L E A S E
C M A K E _ C _ F L A G S _ M I N S I Z E R E L C M A K E _ C _ F L A G S _ R E L W I T H D E B I N F O )
if ( ${ flag_var } MATCHES "/MD" )
string ( REGEX REPLACE "/MD" "/MT" ${ flag_var } "${${flag_var}}" )
endif ( )
endforeach ( flag_var )
endif ( )
# windows build turn off warnings, use parallel compiling.
foreach ( flag_var
C M A K E _ C X X _ F L A G S C M A K E _ C X X _ F L A G S _ D E B U G C M A K E _ C X X _ F L A G S _ R E L E A S E
C M A K E _ C X X _ F L A G S _ M I N S I Z E R E L C M A K E _ C X X _ F L A G S _ R E L W I T H D E B I N F O
C M A K E _ C _ F L A G S C M A K E _ C _ F L A G S _ D E B U G C M A K E _ C _ F L A G S _ R E L E A S E
C M A K E _ C _ F L A G S _ M I N S I Z E R E L C M A K E _ C _ F L A G S _ R E L W I T H D E B I N F O )
string ( REGEX REPLACE "/W[1-4]" " /W0 " ${ flag_var } "${${flag_var}}" )
set ( ${ flag_var } "${${flag_var}} /MP" )
endforeach ( flag_var )
foreach ( flag_var CMAKE_CXX_FLAGS CMAKE_C_FLAGS )
set ( ${ flag_var } "${${flag_var}} /w" )
endforeach ( flag_var )
# Windows Remove /Zi, /ZI for Release, MinSizeRel builds
foreach ( flag_var
C M A K E _ C _ F L A G S C M A K E _ C _ F L A G S _ R E L E A S E C M A K E _ C _ F L A G S _ M I N S I Z E R E L
C M A K E _ C X X _ F L A G S C M A K E _ C X X _ F L A G S _ R E L E A S E C M A K E _ C X X _ F L A G S _ M I N S I Z E R E L )
if ( ${ flag_var } MATCHES "/Z[iI]" )
string ( REGEX REPLACE "/Z[iI]" "" ${ flag_var } "${${flag_var}}" )
endif ( )
endforeach ( flag_var )
set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4068 /wd4129 /wd4244 /wd4267 /wd4297 /wd4530 /wd4577 /wd4819 /wd4838" )
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4068 /wd4129 /wd4244 /wd4267 /wd4297 /wd4530 /wd4577 /wd4819 /wd4838" )
else ( WIN32 )
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=deprecated-declarations -Wno-deprecated-declarations" )
endif ( WIN32 )
find_package ( Git REQUIRED )
# config GIT_URL with github mirrors to speed up dependent repos clone
option ( GIT_URL "Git URL to clone dependent repos" ${ GIT_URL } )
if ( NOT GIT_URL )
set ( GIT_URL "https://github.com" )
endif ( )
find_package ( Threads REQUIRED )
include ( simd )
################################ Exposed Configurations #######################################
option ( WITH_AVX "Compile PaddlePaddle with AVX intrinsics" ${ AVX_FOUND } )
option ( WITH_PYTHON "Compile PaddlePaddle with python interpreter" ON )
option ( WITH_TESTING "Compile PaddlePaddle with unit testing" OFF )
option ( WITH_MKL "Compile PaddlePaddle with MKL support." ${ AVX_FOUND } )
option ( WITH_SYSTEM_BLAS "Use system blas library" OFF )
option ( WITH_DISTRIBUTE "Compile with distributed support" OFF )
option ( WITH_BRPC_RDMA "Use brpc rdma as the rpc protocal" OFF )
option ( ON_INFER "Turn on inference optimization and inference-lib generation" OFF )
################################ Internal Configurations #######################################
option ( WITH_AMD_GPU "Compile PaddlePaddle with AMD GPU" OFF )
option ( WITH_NV_JETSON "Compile PaddlePaddle with NV JETSON" OFF )
option ( WITH_PROFILER "Compile PaddlePaddle with GPU profiler and gperftools" OFF )
option ( WITH_COVERAGE "Compile PaddlePaddle with code coverage" OFF )
OPTION ( WITH_LIBXSMM "Compile with libxsmm" OFF )
option ( COVERALLS_UPLOAD "Package code coverage data to coveralls" OFF )
option ( WITH_PSLIB "Compile with pslib support" OFF )
option ( WITH_BOX_PS "Compile with box_ps support" OFF )
option ( WITH_XBYAK "Compile with xbyak support" ON )
option ( WITH_CONTRIB "Compile the third-party contributation" OFF )
option ( WITH_GRPC "Use grpc as the default rpc framework" ${ WITH_DISTRIBUTE } )
option ( WITH_INFERENCE_API_TEST "Test fluid inference C++ high-level api interface" OFF )
option ( PY_VERSION "Compile PaddlePaddle with python3 support" ${ PY_VERSION } )
option ( WITH_DGC "Use DGC(Deep Gradient Compression) or not" ${ WITH_DISTRIBUTE } )
option ( SANITIZER_TYPE "Choose the type of sanitizer, options are: Address, Leak, Memory, Thread, Undefined" OFF )
option ( WITH_LITE "Compile Paddle Fluid with Lite Engine" OFF )
option ( WITH_NCCL "Compile PaddlePaddle with NCCL support" ON )
option ( WITH_CRYPTO "Compile PaddlePaddle with crypto support" ON )
option ( WITH_ARM "Compile PaddlePaddle with arm support" OFF )
option ( WITH_SW "Compile PaddlePaddle with sw support" OFF )
option ( WITH_MUSL "Compile with musl libc instead of gblic" OFF )
# PY_VERSION
if ( NOT PY_VERSION )
set ( PY_VERSION 2.7 )
endif ( )
set ( PYBIND11_PYTHON_VERSION ${ PY_VERSION } )
# CMAKE_BUILD_TYPE
if ( NOT CMAKE_BUILD_TYPE )
set ( CMAKE_BUILD_TYPE "Release" CACHE STRING
" C h o o s e t h e t y p e o f b u i l d , o p t i o n s a r e : D e b u g R e l e a s e R e l W i t h D e b I n f o M i n S i z e R e l "
F O R C E )
endif ( )
# the type of sanitizer, options are: Address, Leak, Memory, Thread, Undefined. Default: OFF
if ( SANITIZER_TYPE AND NOT "${SANITIZER_TYPE}" MATCHES "^(Address|Leak|Memory|Thread|Undefined)$" )
message ( "Choose the correct type of sanitizer" )
return ( )
endif ( )
if ( WIN32 )
if ( WITH_DISTRIBUTE )
MESSAGE ( WARNING
" D i s a b l e D I S T R I B U T E w h e n c o m p i l i n g f o r W i n d o w s . F o r c e W I T H _ D I S T R I B U T E = O F F . " )
set ( WITH_DISTRIBUTE OFF CACHE STRING
" D i s a b l e D I S T R I B U T E w h e n c o m p i l i n g f o r W i n d o w s " F O R C E )
endif ( )
if ( WITH_NCCL )
MESSAGE ( WARNING
" D i s a b l e N C C L w h e n c o m p i l i n g f o r W i n d o w s . F o r c e W I T H _ N C C L = O F F . " )
set ( WITH_NCCL OFF CACHE STRING
" D i s a b l e N C C L w h e n c o m p i l i n g f o r W i n d o w s " F O R C E )
endif ( )
endif ( )
if ( NOT WITH_GPU AND WITH_NCCL )
MESSAGE ( WARNING
" D i s a b l e N C C L w h e n c o m p i l i n g w i t h o u t G P U . F o r c e W I T H _ N C C L = O F F . " )
set ( WITH_NCCL OFF CACHE STRING
" D i s a b l e N C C L w h e n c o m p i l i n g w i t h o u t G P U " F O R C E )
endif ( )
if ( WITH_NCCL )
add_definitions ( "-DPADDLE_WITH_NCCL" )
Support SelelctedRows allreduce in multi-cards imperative mode (#24690)
* support selectedrows allreduce in multi-cards dygraph, test=develop
* remove useless import modules in unittests, test=develop
* add nccl cmake to get nccl version, test=develop
* add if-condition to compiled correctly, test=develop
* add detail version parseing for old nccl, test=develop
* polish camke details, test=develop
* fix remove test cmake error, test=develop
* fix cmake condition, test=develop
* change unittest camke list, test=develop
* fix unittest cmake rule, test=develop, test=framep0
5 years ago
include ( nccl )
else ( )
if ( WITH_GPU )
MESSAGE ( WARNING "If the environment is multi-card, the WITH_NCCL option needs to be turned on, otherwise only a single card can be used." )
endif ( )
endif ( )
if ( WITH_BRPC_RDMA )
message ( STATUS "Use brpc with rdma." )
if ( WITH_GRPC )
message ( FATAL_ERROR "Can't use grpc with brpc rdma." )
endif ( )
if ( NOT WITH_DISTRIBUTE )
message ( FATAL_ERROR "Can't use brpc rdma in no distribute env." )
endif ( )
endif ( )
if ( WITH_GPU )
include ( cuda )
# lite subgraph compilation depends on CUDNN_ROOT,
# so include(cudnn) needs to be in front of include(third_party/lite)
include ( cudnn ) # set cudnn libraries, must before configure
include ( tensorrt )
# there is no official support of nccl, cupti in windows
if ( NOT WIN32 )
include ( cupti )
endif ( )
endif ( )
include ( third_party ) # download, build, install third_party, Contains about 20+ dependencies
if ( WITH_DISTRIBUTE )
if ( WITH_GRPC )
message ( STATUS "Use grpc framework." )
include ( external/grpc )
else ( )
message ( STATUS "Use brpc framework." )
include ( external/leveldb )
include ( external/brpc )
endif ( )
endif ( )
include ( flags ) # set paddle compile flags
if ( WITH_PROFILER )
find_package ( Gperftools REQUIRED )
include_directories ( ${ GPERFTOOLS_INCLUDE_DIR } )
add_definitions ( -DWITH_GPERFTOOLS )
endif ( )
if ( WITH_DISTRIBUTE )
if ( LINUX )
set ( WITH_GLOO ON CACHE STRING "Enable GLOO when compiling WITH_DISTRIBUTE=ON." FORCE )
endif ( )
endif ( )
include ( ccache ) # set ccache for compilation
include ( util ) # set unittest and link libs
include ( version ) # set PADDLE_VERSION
include ( coveralls ) # set code coverage
include ( configure ) # add paddle env configuration
include_directories ( "${PADDLE_SOURCE_DIR}" )
if ( WITH_AMD_GPU )
find_package ( HIP )
include ( hip )
endif ( WITH_AMD_GPU )
if ( WITH_ARM )
set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC" )
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC" )
set ( WITH_XBYAK OFF CACHE STRING "Disable XBYAK when compiling WITH_ARM=ON" FORCE )
set ( WITH_MKL OFF CACHE STRING "Disable MKL when compiling WITH_ARM=ON." FORCE )
add_definitions ( -DPADDLE_WITH_ARM )
endif ( )
if ( WITH_SW )
# mieee flag solves floating-point exceptions under sw and ALPHA architectures
set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -mieee" )
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -mieee" )
set ( WITH_XBYAK OFF CACHE STRING "Disable XBYAK when compiling WITH_SW=ON" FORCE )
set ( WITH_MKL OFF CACHE STRING "Disable MKL when compiling WITH_SW=ON." FORCE )
add_definitions ( -DPADDLE_WITH_SW )
endif ( )
set ( PADDLE_PYTHON_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/python/build" )
set ( CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG" )
set ( CMAKE_C_FLAGS_RELWITHDEBINFO "-O3 -g -DNDEBUG" )
if ( ON_INFER )
# you can trun off the paddle fluid and inference lib by set ON_INFER=OFF
message ( STATUS "On inference mode, will take place some specific optimization." )
include ( inference_lib )
add_definitions ( -DPADDLE_ON_INFERENCE )
else ( )
#TODO(luotao), combine this warning with `make inference_lib_dist` command.
message ( WARNING "On inference mode, will take place some specific optimization. Turn on the ON_INFER flag when building inference_lib only." )
endif ( )
add_subdirectory ( paddle )
if ( WITH_PYTHON )
add_subdirectory ( python )
endif ( )
