You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
167 lines
5.0 KiB
167 lines
5.0 KiB
cmake_minimum_required(VERSION 2.8)
|
|
|
|
project(paddle CXX C)
|
|
|
|
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")
|
|
set(PROJ_ROOT ${CMAKE_SOURCE_DIR})
|
|
include(package)
|
|
find_package(SWIG 2.0)
|
|
find_package(CUDA QUIET)
|
|
find_package(Protobuf REQUIRED)
|
|
|
|
# Check protobuf library version.
|
|
execute_process(COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} --version
|
|
OUTPUT_VARIABLE PROTOBUF_VERSION)
|
|
string(REPLACE "libprotoc " "" PROTOBUF_VERSION ${PROTOBUF_VERSION})
|
|
|
|
set(PROTOBUF_3 OFF)
|
|
if (${PROTOBUF_VERSION} VERSION_GREATER "3.0.0" OR ${PROTOBUF_VERSION} VERSION_EQUAL "3.0.0")
|
|
set(PROTOBUF_3 ON)
|
|
endif()
|
|
|
|
find_package(PythonLibs 2.7 REQUIRED)
|
|
find_package(PythonInterp 2.7 REQUIRED)
|
|
find_package(ZLIB REQUIRED)
|
|
find_package(NumPy REQUIRED)
|
|
find_package(Threads REQUIRED)
|
|
find_package(AVX QUIET)
|
|
find_package(Glog REQUIRED)
|
|
find_package(Gflags REQUIRED)
|
|
find_package(GTest)
|
|
find_package(Sphinx)
|
|
find_package(Doxygen)
|
|
include(cblas)
|
|
find_program(M4_EXECUTABLE m4)
|
|
###################### Configurations ###########################
|
|
option(WITH_DSO "Compile PaddlePaddle with dynamic linked libraries" ON)
|
|
option(WITH_GPU "Compile PaddlePaddle with gpu" ${CUDA_FOUND})
|
|
option(WITH_DOUBLE "Compile PaddlePaddle with double precision, otherwise use single precision" OFF)
|
|
option(WITH_AVX "Compile PaddlePaddle with avx intrinsics" ${AVX_FOUND})
|
|
option(WITH_PYTHON "Compile PaddlePaddle with python interpreter" ON)
|
|
option(WITH_STYLE_CHECK "Style Check for PaddlePaddle" ${PYTHONINTERP_FOUND})
|
|
option(WITH_RDMA "Compile PaddlePaddle with rdma support" OFF)
|
|
option(WITH_TIMER "Compile PaddlePaddle use timer" OFF)
|
|
option(WITH_PROFILER "Compile PaddlePaddle use gpu profiler" OFF)
|
|
option(WITH_TESTING "Compile and run unittest for PaddlePaddle" ${GTEST_FOUND})
|
|
option(WITH_DOC "Compile PaddlePaddle with documentation" OFF)
|
|
option(WITH_SWIG_PY "Compile PaddlePaddle with py PaddlePaddle prediction api" ${SWIG_FOUND})
|
|
option(ON_TRAVIS "Running test on travis-ci or not." OFF)
|
|
option(ON_COVERALLS "Generating code coverage data on coveralls or not." OFF)
|
|
option(COVERALLS_UPLOAD "Uploading the generated coveralls json." ON)
|
|
|
|
|
|
include(cpplint)
|
|
include(ccache)
|
|
if(WITH_RDMA)
|
|
include(rdma)
|
|
endif()
|
|
include(util)
|
|
include(flags)
|
|
include(cudnn)
|
|
include(FindPythonModule)
|
|
include(check_packages)
|
|
include(swig)
|
|
include(coveralls)
|
|
|
|
# Set PaddlePaddle version to Git tag name or Git commit ID.
|
|
find_package(Git REQUIRED)
|
|
# version.cmake will get the current PADDLE_VERSION
|
|
include(version)
|
|
add_definitions(-DPADDLE_VERSION=${PADDLE_VERSION})
|
|
|
|
if(NOT WITH_GPU)
|
|
add_definitions(-DPADDLE_ONLY_CPU)
|
|
add_definitions(-DHPPL_STUB_FUNC)
|
|
|
|
list(APPEND CMAKE_CXX_SOURCE_FILE_EXTENSIONS cu)
|
|
else()
|
|
if(${CUDA_VERSION_MAJOR} VERSION_LESS 7)
|
|
message(FATAL_ERROR "Paddle need CUDA >= 7.0 to compile")
|
|
endif()
|
|
|
|
if(NOT CUDNN_FOUND)
|
|
message(FATAL_ERROR "Paddle need cudnn to compile")
|
|
endif()
|
|
|
|
if(WITH_AVX)
|
|
set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler ${AVX_FLAG}")
|
|
else(WITH_AVX)
|
|
set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler ${SSE3_FLAG}")
|
|
endif(WITH_AVX)
|
|
|
|
# Include cuda and cudnn
|
|
include_directories(${CUDNN_INCLUDE_DIR})
|
|
include_directories(${CUDA_TOOLKIT_INCLUDE})
|
|
endif(NOT WITH_GPU)
|
|
|
|
if(WITH_DSO)
|
|
add_definitions(-DPADDLE_USE_DSO)
|
|
endif(WITH_DSO)
|
|
|
|
if(WITH_DOUBLE)
|
|
add_definitions(-DPADDLE_TYPE_DOUBLE)
|
|
set(ACCURACY double)
|
|
else(WITH_DOUBLE)
|
|
set(ACCURACY float)
|
|
endif(WITH_DOUBLE)
|
|
|
|
if(NOT WITH_TIMER)
|
|
add_definitions(-DPADDLE_DISABLE_TIMER)
|
|
endif(NOT WITH_TIMER)
|
|
|
|
if(NOT WITH_PROFILER)
|
|
add_definitions(-DPADDLE_DISABLE_PROFILER)
|
|
endif(NOT WITH_PROFILER)
|
|
|
|
if(WITH_AVX)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${AVX_FLAG}")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${AVX_FLAG}")
|
|
else(WITH_AVX)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SSE3_FLAG}")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SSE3_FLAG}")
|
|
endif(WITH_AVX)
|
|
|
|
if(WITH_PYTHON)
|
|
include_directories(${PYTHON_INCLUDE_DIR})
|
|
include_directories(${PYTHON_NUMPY_INCLUDE_DIR})
|
|
else(WITH_PYTHON)
|
|
add_definitions(-DPADDLE_NO_PYTHON)
|
|
endif(WITH_PYTHON)
|
|
|
|
if(WITH_RDMA)
|
|
include_directories("${RDMA_INC_DIR}")
|
|
else(WITH_RDMA)
|
|
add_definitions(-DPADDLE_DISABLE_RDMA)
|
|
endif(WITH_RDMA)
|
|
|
|
# glog
|
|
include_directories(${LIBGLOG_INCLUDE_DIR})
|
|
|
|
#gflags
|
|
add_definitions(-DGFLAGS_NS=${GFLAGS_NAMESPACE})
|
|
include_directories(${GFLAGS_INCLUDE_DIRS})
|
|
|
|
if(WITH_TESTING)
|
|
enable_testing()
|
|
include_directories(${GTEST_INCLUDE_DIRS})
|
|
endif()
|
|
|
|
include_directories("${CBLAS_INC_DIR}")
|
|
include_directories("${PROJ_ROOT}")
|
|
include_directories("${PROJ_ROOT}/paddle/cuda/include")
|
|
include_directories(${PROTOBUF_INCLUDE_DIRS})
|
|
include_directories("${CMAKE_CURRENT_BINARY_DIR}/proto")
|
|
if(EXISTS "${PROJ_ROOT}/paddle/internals/CMakeLists.txt")
|
|
set(PADDLE_WITH_INTERNAL ON)
|
|
include(paddle/internals/CMakeLists.txt)
|
|
else()
|
|
set(PADDLE_WITH_INTERNAL OFF)
|
|
set(INTERNAL_PROTO_PATH "")
|
|
endif()
|
|
add_subdirectory(proto)
|
|
add_subdirectory(paddle)
|
|
add_subdirectory(python)
|
|
if(WITH_DOC)
|
|
add_subdirectory(doc)
|
|
endif()
|