2.3.2-dtk-22.10.1

cmake/external/python.cmake

+# 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.
+
+include(python_module)
+
+check_py_version(${PY_VERSION})
+
+# Find Python with mnimum PY_VERSION specified or will raise error!
+find_package(PythonInterp ${PY_VERSION} REQUIRED)
+find_package(PythonLibs ${PY_VERSION} REQUIRED)
+
+if(WIN32)
+  execute_process(
+    COMMAND
+      "${PYTHON_EXECUTABLE}" "-c"
+      "from distutils import sysconfig as s;import sys;import struct;
+print(sys.prefix);
+print(s.get_config_var('LDVERSION') or s.get_config_var('VERSION'));
+"
+    RESULT_VARIABLE _PYTHON_SUCCESS
+    OUTPUT_VARIABLE _PYTHON_VALUES
+    ERROR_VARIABLE _PYTHON_ERROR_VALUE)
+
+  if(NOT _PYTHON_SUCCESS EQUAL 0)
+    set(PYTHONLIBS_FOUND FALSE)
+    return()
+  endif()
+
+  # Convert the process output into a list
+  string(REGEX REPLACE ";" "\\\\;" _PYTHON_VALUES ${_PYTHON_VALUES})
+  string(REGEX REPLACE "\n" ";" _PYTHON_VALUES ${_PYTHON_VALUES})
+  list(GET _PYTHON_VALUES 0 PYTHON_PREFIX)
+  list(GET _PYTHON_VALUES 1 PYTHON_LIBRARY_SUFFIX)
+
+  # Make sure all directory separators are '/'
+  string(REGEX REPLACE "\\\\" "/" PYTHON_PREFIX ${PYTHON_PREFIX})
+
+  set(PYTHON_LIBRARY "${PYTHON_PREFIX}/libs/Python${PYTHON_LIBRARY_SUFFIX}.lib")
+
+  # when run in a venv, PYTHON_PREFIX points to it. But the libraries remain in the
+  # original python installation. They may be found relative to PYTHON_INCLUDE_DIR.
+  if(NOT EXISTS "${PYTHON_LIBRARY}")
+    get_filename_component(_PYTHON_ROOT ${PYTHON_INCLUDE_DIR} DIRECTORY)
+    set(PYTHON_LIBRARY
+        "${_PYTHON_ROOT}/libs/Python${PYTHON_LIBRARY_SUFFIX}.lib")
+  endif()
+
+  # raise an error if the python libs are still not found.
+  if(NOT EXISTS "${PYTHON_LIBRARY}")
+    message(FATAL_ERROR "Python libraries not found")
+  endif()
+  set(PYTHON_LIBRARIES "${PYTHON_LIBRARY}")
+endif(WIN32)
+
+# Fixme: Maybe find a static library. Get SHARED/STATIC by FIND_PACKAGE.
+add_library(python SHARED IMPORTED GLOBAL)
+set_property(TARGET python PROPERTY IMPORTED_LOCATION ${PYTHON_LIBRARIES})
+
+set(py_env "")
+if(PYTHONINTERP_FOUND)
+  find_python_module(pip REQUIRED)
+  find_python_module(numpy REQUIRED)
+  find_python_module(wheel REQUIRED)
+  find_python_module(google.protobuf REQUIRED)
+  find_package(NumPy REQUIRED)
+  if(${PY_GOOGLE.PROTOBUF_VERSION} AND ${PY_GOOGLE.PROTOBUF_VERSION}
+                                       VERSION_LESS "3.0.0")
+    message(
+      FATAL_ERROR
+        "Found Python Protobuf ${PY_GOOGLE.PROTOBUF_VERSION} < 3.0.0, "
+        "please use pip to upgrade protobuf. pip install -U protobuf")
+  endif()
+endif(PYTHONINTERP_FOUND)
+
+include_directories(${PYTHON_INCLUDE_DIR})
+include_directories(${PYTHON_NUMPY_INCLUDE_DIR})

cmake/external/rocksdb.cmake

+# 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.
+
+include(ExternalProject)
+
+set(ROCKSDB_PREFIX_DIR ${THIRD_PARTY_PATH}/rocksdb)
+set(ROCKSDB_INSTALL_DIR ${THIRD_PARTY_PATH}/install/rocksdb)
+set(ROCKSDB_INCLUDE_DIR
+    "${ROCKSDB_INSTALL_DIR}/include"
+    CACHE PATH "rocksdb include directory." FORCE)
+set(ROCKSDB_LIBRARIES
+    "${ROCKSDB_INSTALL_DIR}/lib/librocksdb.a"
+    CACHE FILEPATH "rocksdb library." FORCE)
+set(ROCKSDB_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+include_directories(${ROCKSDB_INCLUDE_DIR})
+
+ExternalProject_Add(
+  extern_rocksdb
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  PREFIX ${ROCKSDB_PREFIX_DIR}
+  GIT_REPOSITORY "https://github.com/facebook/rocksdb"
+  GIT_TAG v6.10.1
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+             -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+             -DWITH_BZ2=OFF
+             -DPORTABLE=1
+             -DWITH_GFLAGS=OFF
+             -DCMAKE_CXX_FLAGS=${ROCKSDB_CMAKE_CXX_FLAGS}
+             -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+  #    BUILD_BYPRODUCTS ${ROCKSDB_PREFIX_DIR}/src/extern_rocksdb/librocksdb.a
+  INSTALL_COMMAND
+    mkdir -p ${ROCKSDB_INSTALL_DIR}/lib/ && cp
+    ${ROCKSDB_PREFIX_DIR}/src/extern_rocksdb/librocksdb.a ${ROCKSDB_LIBRARIES}
+    && cp -r ${ROCKSDB_PREFIX_DIR}/src/extern_rocksdb/include
+    ${ROCKSDB_INSTALL_DIR}/
+  BUILD_IN_SOURCE 1
+  BYPRODUCTS ${ROCKSDB_LIBRARIES})
+
+add_dependencies(extern_rocksdb snappy)
+
+add_library(rocksdb STATIC IMPORTED GLOBAL)
+set_property(TARGET rocksdb PROPERTY IMPORTED_LOCATION ${ROCKSDB_LIBRARIES})
+add_dependencies(rocksdb extern_rocksdb)
+
+list(APPEND external_project_dependencies rocksdb)

cmake/external/snappy.cmake

+# Copyright (c) 2018 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.
+
+include(ExternalProject)
+
+# NOTE: snappy is needed when linking with recordio
+
+set(SNAPPY_PREFIX_DIR ${THIRD_PARTY_PATH}/snappy)
+set(SNAPPY_INSTALL_DIR ${THIRD_PARTY_PATH}/install/snappy)
+set(SNAPPY_INCLUDE_DIR
+    "${SNAPPY_INSTALL_DIR}/include"
+    CACHE PATH "snappy include directory." FORCE)
+
+if(WIN32)
+  set(SNAPPY_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4267")
+  if(NOT EXISTS "${SNAPPY_INSTALL_DIR}/lib/libsnappy.lib")
+    add_custom_command(
+      TARGET extern_snappy
+      POST_BUILD
+      COMMAND cmake -E copy ${SNAPPY_INSTALL_DIR}/lib/snappy.lib
+              ${SNAPPY_INSTALL_DIR}/lib/libsnappy.lib)
+  endif()
+  set(SNAPPY_LIBRARIES "${SNAPPY_INSTALL_DIR}/lib/libsnappy.lib")
+else()
+  set(SNAPPY_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+  set(SNAPPY_LIBRARIES "${SNAPPY_INSTALL_DIR}/lib/libsnappy.a")
+endif()
+
+ExternalProject_Add(
+  extern_snappy
+  GIT_REPOSITORY "https://github.com/google/snappy"
+  GIT_TAG "1.1.7"
+  PREFIX ${SNAPPY_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+             -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+             -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+             -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+             -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+             -DCMAKE_CXX_FLAGS=${SNAPPY_CMAKE_CXX_FLAGS}
+             -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+             -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+             -DCMAKE_INSTALL_PREFIX=${SNAPPY_INSTALL_DIR}
+             -DCMAKE_INSTALL_LIBDIR=${SNAPPY_INSTALL_DIR}/lib
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+             -DBUILD_TESTING=OFF
+             -DSNAPPY_BUILD_TESTS:BOOL=OFF
+             -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+             ${EXTERNAL_OPTIONAL_ARGS}
+  CMAKE_CACHE_ARGS
+    -DCMAKE_INSTALL_PREFIX:PATH=${SNAPPY_INSTALL_DIR}
+    -DCMAKE_INSTALL_LIBDIR:PATH=${SNAPPY_INSTALL_DIR}/lib
+    -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+    -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${SNAPPY_LIBRARIES})
+
+add_library(snappy STATIC IMPORTED GLOBAL)
+set_property(TARGET snappy PROPERTY IMPORTED_LOCATION ${SNAPPY_LIBRARIES})
+
+include_directories(${SNAPPY_INCLUDE_DIR})
+add_dependencies(snappy extern_snappy)

cmake/external/threadpool.cmake

+# Copyright (c) 2018 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.
+
+include(ExternalProject)
+
+set(THREADPOOL_PREFIX_DIR ${THIRD_PARTY_PATH}/threadpool)
+if(WITH_ASCEND OR WITH_ASCEND_CL)
+  set(THREADPOOL_REPOSITORY https://gitee.com/tianjianhe/ThreadPool.git)
+else()
+  set(THREADPOOL_REPOSITORY ${GIT_URL}/progschj/ThreadPool.git)
+endif()
+set(THREADPOOL_TAG 9a42ec1329f259a5f4881a291db1dcb8f2ad9040)
+
+set(THREADPOOL_INCLUDE_DIR ${THIRD_PARTY_PATH}/threadpool/src/extern_threadpool)
+include_directories(${THREADPOOL_INCLUDE_DIR})
+
+ExternalProject_Add(
+  extern_threadpool
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${THREADPOOL_REPOSITORY}
+  GIT_TAG ${THREADPOOL_TAG}
+  PREFIX ${THREADPOOL_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND ""
+  TEST_COMMAND "")
+
+add_library(simple_threadpool INTERFACE)
+
+add_dependencies(simple_threadpool extern_threadpool)

cmake/external/utf8proc.cmake

+# Copyright (c) 2021 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.
+
+include(ExternalProject)
+
+set(UTF8PROC_PREFIX_DIR ${THIRD_PARTY_PATH}/utf8proc)
+set(UTF8PROC_INSTALL_DIR ${THIRD_PARTY_PATH}/install/utf8proc)
+# As we add extra features for utf8proc, we use the non-official repo
+set(UTF8PROC_REPOSITORY ${GIT_URL}/JuliaStrings/utf8proc.git)
+set(UTF8PROC_TAG v2.6.1)
+
+if(WIN32)
+  set(UTF8PROC_LIBRARIES "${UTF8PROC_INSTALL_DIR}/lib/utf8proc_static.lib")
+  add_definitions(-DUTF8PROC_STATIC)
+else()
+  set(UTF8PROC_LIBRARIES "${UTF8PROC_INSTALL_DIR}/lib/libutf8proc.a")
+endif()
+
+include_directories(${UTF8PROC_INSTALL_DIR}/include)
+
+ExternalProject_Add(
+  extern_utf8proc
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${UTF8PROC_REPOSITORY}
+  GIT_TAG ${UTF8PROC_TAG}
+  PREFIX ${UTF8PROC_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+             -DBUILD_SHARED=ON
+             -DBUILD_STATIC=ON
+             -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+             -DCMAKE_INSTALL_PREFIX:PATH=${UTF8PROC_INSTALL_DIR}
+             -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${UTF8PROC_LIBRARIES})
+
+add_library(utf8proc STATIC IMPORTED GLOBAL)
+set_property(TARGET utf8proc PROPERTY IMPORTED_LOCATION ${UTF8PROC_LIBRARIES})
+add_dependencies(utf8proc extern_utf8proc)

cmake/external/warpctc.cmake

+# 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.
+
+include(ExternalProject)
+
+if(WITH_ROCM)
+  add_definitions(-DWARPCTC_WITH_HIP)
+endif()
+
+set(WARPCTC_PREFIX_DIR ${THIRD_PARTY_PATH}/warpctc)
+set(WARPCTC_INSTALL_DIR ${THIRD_PARTY_PATH}/install/warpctc)
+# in case of low internet speed
+#set(WARPCTC_REPOSITORY  https://gitee.com/tianjianhe/warp-ctc.git)
+set(WARPCTC_REPOSITORY ${GIT_URL}/baidu-research/warp-ctc.git)
+set(WARPCTC_TAG 37ece0e1bbe8a0019a63ac7e6462c36591c66a5b)
+
+set(WARPCTC_INCLUDE_DIR
+    "${WARPCTC_INSTALL_DIR}/include"
+    CACHE PATH "Warp-ctc Directory" FORCE)
+# Used in unit test test_WarpCTCLayer
+set(WARPCTC_LIB_DIR
+    "${WARPCTC_INSTALL_DIR}/lib"
+    CACHE PATH "Warp-ctc Library Directory" FORCE)
+
+if(WIN32)
+  set(WARPCTC_LIBRARIES
+      "${WARPCTC_INSTALL_DIR}/bin/warpctc${CMAKE_SHARED_LIBRARY_SUFFIX}"
+      CACHE FILEPATH "Warp-ctc Library" FORCE)
+else()
+  set(WARPCTC_LIBRARIES
+      "${WARPCTC_INSTALL_DIR}/lib/libwarpctc${CMAKE_SHARED_LIBRARY_SUFFIX}"
+      CACHE FILEPATH "Warp-ctc Library" FORCE)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
+   OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang"
+   OR WIN32)
+  set(USE_OMP OFF)
+else()
+  set(USE_OMP ON)
+endif()
+
+if(WITH_ASCEND OR WITH_ASCEND_CL)
+  ExternalProject_Add(
+    extern_warpctc
+    ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+    GIT_REPOSITORY ${WARPCTC_REPOSITORY}
+    GIT_TAG ${WARPCTC_TAG}
+    PREFIX ${WARPCTC_PREFIX_DIR}
+    #UPDATE_COMMAND  ""
+    PATCH_COMMAND ""
+    BUILD_ALWAYS 1
+    CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+               -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+               -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+               -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+               -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+               -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+               -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+               -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+               -DCMAKE_INSTALL_PREFIX=${WARPCTC_INSTALL_DIR}
+               -DWITH_GPU=${WITH_GPU}
+               -DWITH_ROCM=${WITH_ROCM}
+               -DWITH_OMP=${USE_OMP}
+               -DWITH_TORCH=OFF
+               -DCMAKE_DISABLE_FIND_PACKAGE_Torch=ON
+               -DBUILD_SHARED=ON
+               -DBUILD_TESTS=OFF
+               -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+               -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+               ${EXTERNAL_OPTIONAL_ARGS}
+    CMAKE_CACHE_ARGS
+      -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+      -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+      -DCMAKE_INSTALL_PREFIX:PATH=${WARPCTC_INSTALL_DIR}
+    BUILD_BYPRODUCTS ${WARPCTC_LIBRARIES})
+else()
+  if(WIN32)
+    set(WARPCTC_C_FLAGS $<FILTER:${CMAKE_C_FLAGS},EXCLUDE,/Zc:inline>)
+    set(WARPCTC_C_FLAGS_DEBUG
+        $<FILTER:${CMAKE_C_FLAGS_DEBUG},EXCLUDE,/Zc:inline>)
+    set(WARPCTC_C_FLAGS_RELEASE
+        $<FILTER:${CMAKE_C_FLAGS_RELEASE},EXCLUDE,/Zc:inline>)
+    set(WARPCTC_CXX_FLAGS $<FILTER:${CMAKE_CXX_FLAGS},EXCLUDE,/Zc:inline>)
+    set(WARPCTC_CXX_FLAGS_RELEASE
+        $<FILTER:${CMAKE_CXX_FLAGS_RELEASE},EXCLUDE,/Zc:inline>)
+    set(WARPCTC_CXX_FLAGS_DEBUG
+        $<FILTER:${CMAKE_CXX_FLAGS_DEBUG},EXCLUDE,/Zc:inline>)
+  else()
+    set(WARPCTC_C_FLAGS ${CMAKE_C_FLAGS})
+    set(WARPCTC_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
+    set(WARPCTC_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE})
+    set(WARPCTC_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+    set(WARPCTC_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
+    set(WARPCTC_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
+  endif()
+  ExternalProject_Add(
+    extern_warpctc
+    ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+    GIT_REPOSITORY ${WARPCTC_REPOSITORY}
+    GIT_TAG ${WARPCTC_TAG}
+    PREFIX ${WARPCTC_PREFIX_DIR}
+    UPDATE_COMMAND ""
+    PATCH_COMMAND ""
+    #BUILD_ALWAYS    1
+    CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+               -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+               -DCMAKE_C_FLAGS=${WARPCTC_C_FLAGS}
+               -DCMAKE_C_FLAGS_DEBUG=${WARPCTC_C_FLAGS_DEBUG}
+               -DCMAKE_C_FLAGS_RELEASE=${WARPCTC_C_FLAGS_RELEASE}
+               -DCMAKE_CXX_FLAGS=${WARPCTC_CXX_FLAGS}
+               -DCMAKE_CXX_FLAGS_RELEASE=${WARPCTC_CXX_FLAGS_RELEASE}
+               -DCMAKE_CXX_FLAGS_DEBUG=${WARPCTC_CXX_FLAGS_DEBUG}
+               -DCMAKE_INSTALL_PREFIX=${WARPCTC_INSTALL_DIR}
+               -DWITH_GPU=${WITH_GPU}
+               -DWITH_ROCM=${WITH_ROCM}
+               -DWITH_OMP=${USE_OMP}
+               -DWITH_TORCH=OFF
+               -DCMAKE_DISABLE_FIND_PACKAGE_Torch=ON
+               -DBUILD_SHARED=ON
+               -DBUILD_TESTS=OFF
+               -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+               -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+               ${EXTERNAL_OPTIONAL_ARGS}
+    CMAKE_CACHE_ARGS
+      -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+      -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+      -DCMAKE_INSTALL_PREFIX:PATH=${WARPCTC_INSTALL_DIR}
+    BUILD_BYPRODUCTS ${WARPCTC_LIBRARIES})
+endif()
+
+message(STATUS "warp-ctc library: ${WARPCTC_LIBRARIES}")
+get_filename_component(WARPCTC_LIBRARY_PATH ${WARPCTC_LIBRARIES} DIRECTORY)
+include_directories(${WARPCTC_INCLUDE_DIR}
+)# For warpctc code to include its headers.
+
+add_library(warpctc SHARED IMPORTED GLOBAL)
+set_property(TARGET warpctc PROPERTY IMPORTED_LOCATION ${WARPCTC_LIBRARIES})
+add_dependencies(warpctc extern_warpctc)

cmake/external/xbyak.cmake

+# Copyright (c) 2018 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.
+
+include(ExternalProject)
+
+set(XBYAK_PROJECT extern_xbyak)
+set(XBYAK_PREFIX_DIR ${THIRD_PARTY_PATH}/xbyak)
+set(XBYAK_INSTALL_ROOT ${THIRD_PARTY_PATH}/install/xbyak)
+set(XBYAK_INC_DIR ${XBYAK_INSTALL_ROOT}/include)
+set(XBYAK_REPOSITORY ${GIT_URL}/herumi/xbyak.git)
+set(XBYAK_TAG v5.81) # Dec 19, 2019
+
+include_directories(${XBYAK_INC_DIR})
+include_directories(${XBYAK_INC_DIR}/xbyak)
+
+add_definitions(-DPADDLE_WITH_XBYAK)
+
+# xbyak options
+add_definitions(-DXBYAK64)
+add_definitions(-DXBYAK_NO_OP_NAMES)
+
+ExternalProject_Add(
+  ${XBYAK_PROJECT}
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${XBYAK_REPOSITORY}
+  GIT_TAG ${XBYAK_TAG}
+  DEPENDS ""
+  PREFIX ${XBYAK_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${XBYAK_INSTALL_ROOT}
+             -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+  CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${XBYAK_INSTALL_ROOT}
+                   -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE})
+
+add_library(xbyak INTERFACE)
+
+add_dependencies(xbyak ${XBYAK_PROJECT})

cmake/external/xpu.cmake

+if(NOT WITH_XPU)
+  return()
+endif()
+
+include(ExternalProject)
+set(XPU_PROJECT "extern_xpu")
+set(XPU_API_LIB_NAME "libxpuapi.so")
+set(XPU_RT_LIB_NAME "libxpurt.so")
+
+if(NOT DEFINED XPU_BASE_URL)
+  set(XPU_BASE_URL_WITHOUT_DATE
+      "https://baidu-kunlun-product.su.bcebos.com/KL-SDK/klsdk-dev")
+  set(XPU_BASE_URL "${XPU_BASE_URL_WITHOUT_DATE}/20220928")
+else()
+  set(XPU_BASE_URL "${XPU_BASE_URL}")
+endif()
+
+# ubuntu and centos: use output by XDNN API team
+if(NOT DEFINED XPU_XDNN_BASE_URL)
+  set(XPU_XDNN_BASE_URL_WITHOUT_DATE
+      "https://klx-sdk-release-public.su.bcebos.com/xdnn/dev")
+  set(XPU_XDNN_BASE_URL "${XPU_XDNN_BASE_URL_WITHOUT_DATE}/20220928")
+else()
+  set(XPU_XDNN_BASE_URL "${XPU_XDNN_BASE_URL}")
+endif()
+
+set(XPU_XCCL_BASE_URL
+    "https://klx-sdk-release-public.su.bcebos.com/xccl/release/1.0.0")
+
+if(WITH_AARCH64)
+  set(XPU_XRE_DIR_NAME "xre-kylin_aarch64")
+  set(XPU_XDNN_DIR_NAME "xdnn-kylin_aarch64")
+  set(XPU_XCCL_DIR_NAME "xccl-kylin_aarch64")
+  set(XPU_XDNN_URL
+      "${XPU_XDNN_BASE_URL}/${XPU_XDNN_DIR_NAME}.tar.gz"
+      CACHE STRING "" FORCE)
+elseif(WITH_SUNWAY)
+  set(XPU_XRE_DIR_NAME "xre-deepin_sw6_64")
+  set(XPU_XDNN_DIR_NAME "xdnn-deepin_sw6_64")
+  set(XPU_XCCL_DIR_NAME "xccl-deepin_sw6_64")
+  set(XPU_XDNN_URL
+      "${XPU_BASE_URL}/${XPU_XDNN_DIR_NAME}.tar.gz"
+      CACHE STRING "" FORCE)
+elseif(WITH_BDCENTOS)
+  set(XPU_XRE_DIR_NAME "xre-bdcentos_x86_64")
+  set(XPU_XDNN_DIR_NAME "xdnn-bdcentos_x86_64")
+  set(XPU_XCCL_DIR_NAME "xccl-bdcentos_x86_64")
+  # ubuntu and centos: use output by XDNN API team
+  set(XPU_XDNN_URL
+      "${XPU_XDNN_BASE_URL}/${XPU_XDNN_DIR_NAME}.tar.gz"
+      CACHE STRING "" FORCE)
+elseif(WITH_UBUNTU)
+  set(XPU_XRE_DIR_NAME "xre-ubuntu_x86_64")
+  set(XPU_XDNN_DIR_NAME "xdnn-ubuntu_x86_64")
+  set(XPU_XCCL_DIR_NAME "xccl-ubuntu_x86_64")
+  # ubuntu and centos: use output by XDNN API team
+  set(XPU_XDNN_URL
+      "${XPU_XDNN_BASE_URL}/${XPU_XDNN_DIR_NAME}.tar.gz"
+      CACHE STRING "" FORCE)
+elseif(WITH_CENTOS)
+  set(XPU_XRE_DIR_NAME "xre-centos7_x86_64")
+  set(XPU_XDNN_DIR_NAME "xdnn-bdcentos_x86_64")
+  set(XPU_XCCL_DIR_NAME "xccl-bdcentos_x86_64")
+  # ubuntu and centos: use output by XDNN API team
+  set(XPU_XDNN_URL
+      "${XPU_XDNN_BASE_URL}/${XPU_XDNN_DIR_NAME}.tar.gz"
+      CACHE STRING "" FORCE)
+else()
+  set(XPU_XRE_DIR_NAME "xre-ubuntu_x86_64")
+  set(XPU_XDNN_DIR_NAME "xdnn-ubuntu_x86_64")
+  set(XPU_XCCL_DIR_NAME "xccl-ubuntu_x86_64")
+  # default: use output by XDNN API team
+  set(XPU_XDNN_URL
+      "${XPU_XDNN_BASE_URL}/${XPU_XDNN_DIR_NAME}.tar.gz"
+      CACHE STRING "" FORCE)
+endif()
+
+set(XPU_XRE_URL
+    "${XPU_BASE_URL}/${XPU_XRE_DIR_NAME}.tar.gz"
+    CACHE STRING "" FORCE)
+set(XPU_XCCL_URL
+    "${XPU_XCCL_BASE_URL}/${XPU_XCCL_DIR_NAME}.tar.gz"
+    CACHE STRING "" FORCE)
+set(XPU_PACK_DEPENCE_URL
+    "https://baidu-kunlun-public.su.bcebos.com/paddle_depence/pack_paddle_depence.sh"
+    CACHE STRING "" FORCE)
+
+set(SNAPPY_PREFIX_DIR "${THIRD_PARTY_PATH}/xpu")
+set(XPU_DOWNLOAD_DIR "${SNAPPY_PREFIX_DIR}/src/${XPU_PROJECT}")
+set(XPU_INSTALL_DIR "${THIRD_PARTY_PATH}/install/xpu")
+set(XPU_INC_DIR "${THIRD_PARTY_PATH}/install/xpu/include")
+set(XPU_LIB_DIR "${THIRD_PARTY_PATH}/install/xpu/lib")
+
+set(XPU_API_LIB "${XPU_LIB_DIR}/${XPU_API_LIB_NAME}")
+set(XPU_RT_LIB "${XPU_LIB_DIR}/${XPU_RT_LIB_NAME}")
+
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH}" "${XPU_INSTALL_DIR}/lib")
+
+file(
+  WRITE ${XPU_DOWNLOAD_DIR}/CMakeLists.txt
+  "PROJECT(XPU)\n" "cmake_minimum_required(VERSION 3.0)\n"
+  "install(DIRECTORY xpu/include xpu/lib \n"
+  "        DESTINATION ${XPU_INSTALL_DIR})\n")
+
+ExternalProject_Add(
+  ${XPU_PROJECT}
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  PREFIX ${SNAPPY_PREFIX_DIR}
+  DOWNLOAD_DIR ${XPU_DOWNLOAD_DIR}
+  DOWNLOAD_COMMAND
+    wget ${XPU_PACK_DEPENCE_URL} && bash pack_paddle_depence.sh ${XPU_XRE_URL}
+    ${XPU_XRE_DIR_NAME} ${XPU_XDNN_URL} ${XPU_XDNN_DIR_NAME} ${XPU_XCCL_URL}
+    ${XPU_XCCL_DIR_NAME}
+  DOWNLOAD_NO_PROGRESS 1
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${XPU_INSTALL_ROOT}
+  CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${XPU_INSTALL_ROOT}
+  BUILD_BYPRODUCTS ${XPU_API_LIB}
+  BUILD_BYPRODUCTS ${XPU_RT_LIB})
+
+include_directories(${XPU_INC_DIR})
+add_library(shared_xpuapi SHARED IMPORTED GLOBAL)
+set_property(TARGET shared_xpuapi PROPERTY IMPORTED_LOCATION "${XPU_API_LIB}")
+
+# generate a static dummy target to track xpulib dependencies
+# for cc_library(xxx SRCS xxx.c DEPS xpulib)
+generate_dummy_static_lib(LIB_NAME "xpulib" GENERATOR "xpu.cmake")
+
+target_link_libraries(xpulib ${XPU_API_LIB} ${XPU_RT_LIB})
+
+if(WITH_XPU_BKCL)
+  message(STATUS "Compile with XPU BKCL!")
+  add_definitions(-DPADDLE_WITH_XPU_BKCL)
+
+  set(XPU_BKCL_LIB_NAME "libbkcl.so")
+  set(XPU_BKCL_LIB "${XPU_LIB_DIR}/${XPU_BKCL_LIB_NAME}")
+  set(XPU_BKCL_INC_DIR "${THIRD_PARTY_PATH}/install/xpu/include")
+  include_directories(${XPU_BKCL_INC_DIR})
+  target_link_libraries(xpulib ${XPU_API_LIB} ${XPU_RT_LIB} ${XPU_BKCL_LIB})
+else()
+  target_link_libraries(xpulib ${XPU_API_LIB} ${XPU_RT_LIB})
+endif()
+
+add_dependencies(xpulib ${XPU_PROJECT})
+
+# Ensure that xpu/api.h can be included without dependency errors.
+file(
+  GENERATE
+  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/.xpu_headers_dummy.cc
+  CONTENT "")
+add_library(xpu_headers_dummy STATIC
+            ${CMAKE_CURRENT_BINARY_DIR}/.xpu_headers_dummy.cc)
+add_dependencies(xpu_headers_dummy extern_xpu)
+link_libraries(xpu_headers_dummy)

cmake/external/xxhash.cmake

+# Copyright (c) 2018 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.
+
+include(ExternalProject)
+
+set(XXHASH_PREFIX_DIR ${THIRD_PARTY_PATH}/xxhash)
+set(XXHASH_SOURCE_DIR ${THIRD_PARTY_PATH}/xxhash/src/extern_xxhash)
+set(XXHASH_INSTALL_DIR ${THIRD_PARTY_PATH}/install/xxhash)
+set(XXHASH_INCLUDE_DIR "${XXHASH_INSTALL_DIR}/include")
+set(XXHASH_REPOSITORY ${GIT_URL}/Cyan4973/xxHash.git)
+set(XXHASH_TAG v0.6.5)
+
+include_directories(${XXHASH_INCLUDE_DIR})
+
+if(APPLE)
+  set(BUILD_CMD
+      sed
+      -i
+      \"\"
+      "s/-Wstrict-prototypes -Wundef/-Wstrict-prototypes -Wundef -fPIC/g"
+      ${XXHASH_SOURCE_DIR}/Makefile
+      &&
+      make
+      lib)
+elseif(UNIX)
+  set(BUILD_CMD
+      sed
+      -i
+      "s/-Wstrict-prototypes -Wundef/-Wstrict-prototypes -Wundef -fPIC/g"
+      ${XXHASH_SOURCE_DIR}/Makefile
+      &&
+      make
+      lib)
+endif()
+
+if(WIN32)
+  set(XXHASH_LIBRARIES "${XXHASH_INSTALL_DIR}/lib/xxhash.lib")
+  set(XXHASH_CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4710 /wd4711")
+  set(XXHASH_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4710 /wd4711")
+else()
+  set(XXHASH_LIBRARIES "${XXHASH_INSTALL_DIR}/lib/libxxhash.a")
+  set(XXHASH_CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
+  set(XXHASH_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+endif()
+
+if(WIN32)
+  ExternalProject_Add(
+    extern_xxhash
+    ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+    GIT_REPOSITORY ${XXHASH_REPOSITORY}
+    GIT_TAG ${XXHASH_TAG}
+    PREFIX ${XXHASH_PREFIX_DIR}
+    UPDATE_COMMAND ""
+    PATCH_COMMAND ""
+    CONFIGURE_COMMAND
+      ${CMAKE_COMMAND} ${XXHASH_SOURCE_DIR}/cmake_unofficial
+      -DCMAKE_INSTALL_PREFIX:PATH=${XXHASH_INSTALL_DIR}
+      -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+      -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF
+      -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON -DBUILD_XXHSUM=OFF
+      -DCMAKE_GENERATOR=${CMAKE_GENERATOR}
+      -DCMAKE_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
+      -DBUILD_SHARED_LIBS=OFF -DCMAKE_CXX_FLAGS=${XXHASH_CMAKE_CXX_FLAGS}
+      -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+      -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+      -DCMAKE_C_FLAGS=${XXHASH_CMAKE_C_FLAGS}
+      -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+      -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE} ${OPTIONAL_CACHE_ARGS}
+    TEST_COMMAND ""
+    BUILD_BYPRODUCTS ${XXHASH_LIBRARIES})
+else()
+  ExternalProject_Add(
+    extern_xxhash
+    ${EXTERNAL_PROJECT_LOG_ARGS}
+    GIT_REPOSITORY ${XXHASH_REPOSITORY}
+    GIT_TAG ${XXHASH_TAG}
+    PREFIX ${XXHASH_PREFIX_DIR}
+    UPDATE_COMMAND ""
+    CONFIGURE_COMMAND ""
+    BUILD_IN_SOURCE 1
+    BUILD_COMMAND ${BUILD_CMD}
+    INSTALL_COMMAND make PREFIX=${XXHASH_INSTALL_DIR} install
+    TEST_COMMAND ""
+    BUILD_BYPRODUCTS ${XXHASH_LIBRARIES})
+endif()
+
+add_library(xxhash STATIC IMPORTED GLOBAL)
+set_property(TARGET xxhash PROPERTY IMPORTED_LOCATION ${XXHASH_LIBRARIES})
+add_dependencies(xxhash extern_xxhash)

cmake/external/zlib.cmake

+# 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.
+
+include(ExternalProject)
+
+set(ZLIB_PREFIX_DIR ${THIRD_PARTY_PATH}/zlib)
+set(ZLIB_INSTALL_DIR ${THIRD_PARTY_PATH}/install/zlib)
+set(ZLIB_ROOT
+    ${ZLIB_INSTALL_DIR}
+    CACHE FILEPATH "zlib root directory." FORCE)
+set(ZLIB_INCLUDE_DIR
+    "${ZLIB_INSTALL_DIR}/include"
+    CACHE PATH "zlib include directory." FORCE)
+set(ZLIB_REPOSITORY ${GIT_URL}/madler/zlib.git)
+set(ZLIB_TAG v1.2.8)
+
+include_directories(${ZLIB_INCLUDE_DIR}
+)# For zlib code to include its own headers.
+include_directories(${THIRD_PARTY_PATH}/install
+)# For Paddle code to include zlib.h.
+
+if(WIN32)
+  set(ZLIB_LIBRARIES
+      "${ZLIB_INSTALL_DIR}/lib/zlibstatic.lib"
+      CACHE FILEPATH "zlib library." FORCE)
+else()
+  set(ZLIB_LIBRARIES
+      "${ZLIB_INSTALL_DIR}/lib/libz.a"
+      CACHE FILEPATH "zlib library." FORCE)
+endif()
+
+ExternalProject_Add(
+  extern_zlib
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${ZLIB_REPOSITORY}
+  GIT_TAG ${ZLIB_TAG}
+  PREFIX ${ZLIB_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+             -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+             -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+             -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+             -DCMAKE_INSTALL_PREFIX=${ZLIB_INSTALL_DIR}
+             -DBUILD_SHARED_LIBS=OFF
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+             -DCMAKE_MACOSX_RPATH=ON
+             -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+             ${EXTERNAL_OPTIONAL_ARGS}
+  CMAKE_CACHE_ARGS
+    -DCMAKE_INSTALL_PREFIX:PATH=${ZLIB_INSTALL_DIR}
+    -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+    -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${ZLIB_LIBRARIES})
+
+add_library(zlib STATIC IMPORTED GLOBAL)
+set_property(TARGET zlib PROPERTY IMPORTED_LOCATION ${ZLIB_LIBRARIES})
+add_dependencies(zlib extern_zlib)

cmake/flags.cmake

+# Setting Paddle Compile Flags
+include(CheckCXXCompilerFlag)
+include(CheckCCompilerFlag)
+include(CheckCXXSymbolExists)
+include(CheckTypeSize)
+
+function(CheckCompilerCXX14Flag)
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 5.4)
+      message(FATAL_ERROR "Unsupported GCC version. GCC >= 5.4 required.")
+    elseif(${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER 8.2)
+      message(
+        WARNING
+          "Found GCC ${CMAKE_CXX_COMPILER_VERSION} which is too high, recommended to use GCC 8.2"
+      )
+    endif()
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID
+                                                        STREQUAL "Clang")
+    # cmake >= 3.0 compiler id "AppleClang" on Mac OS X, otherwise "Clang"
+    # Apple Clang is a different compiler than upstream Clang which havs different version numbers.
+    # https://gist.github.com/yamaya/2924292
+    if(APPLE) # cmake < 3.0 compiler id "Clang" on Mac OS X
+      if(${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 5.1)
+        message(
+          FATAL_ERROR
+            "Unsupported AppleClang version. AppleClang >= 5.1 required.")
+      endif()
+    else()
+      if(${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 3.4)
+        message(FATAL_ERROR "Unsupported Clang version. Clang >= 3.4 required.")
+      endif()
+    endif()
+  endif()
+endfunction()
+
+checkcompilercxx14flag()
+if(NOT WIN32)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+else()
+  set(CMAKE_CXX_STANDARD 14)
+endif()
+
+# safe_set_flag
+#
+# Set a compile flag only if compiler is support
+# is_c: is C flag or C++ flag, bool type.
+# src_list: The list name which the flag name will be append to.
+# flag_name: the flag name for compiler, such as '-Werror' '-Wall' etc
+# rest arguments: not used.
+function(safe_set_flag is_c src_list flag_name)
+  string(REPLACE "-" "_" safe_name ${flag_name})
+  string(REPLACE "=" "_" safe_name ${safe_name})
+
+  if(${flag_name} MATCHES "fsanitize")
+    set(CMAKE_REQUIRED_FLAGS_RETAINED ${CMAKE_REQUIRED_FLAGS})
+    set(CMAKE_REQUIRED_FLAGS ${flag_name})
+  endif()
+
+  if(is_c)
+    check_c_compiler_flag(${flag_name} C_COMPILER_SUPPORT_FLAG_${safe_name})
+    set(safe_name C_COMPILER_SUPPORT_FLAG_${safe_name})
+  else()
+    check_cxx_compiler_flag(${flag_name} CXX_COMPILER_SUPPORT_FLAG_${safe_name})
+    set(safe_name CXX_COMPILER_SUPPORT_FLAG_${safe_name})
+  endif()
+  if(${safe_name})
+    set(${src_list}
+        "${${src_list}} ${flag_name}"
+        PARENT_SCOPE)
+  endif()
+
+  if(${flag_name} MATCHES "fsanitize")
+    set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_RETAINED})
+  endif()
+endfunction()
+
+# helper macro to set cflag
+macro(safe_set_cflag src_list flag_name)
+  safe_set_flag(ON ${src_list} ${flag_name})
+endmacro()
+
+# helper macro to set cxxflag
+macro(safe_set_cxxflag src_list flag_name)
+  safe_set_flag(OFF ${src_list} ${flag_name})
+endmacro()
+
+# helper macro to set nvcc flag
+macro(safe_set_nvflag flag_name)
+  string(REPLACE "-" "_" safe_name ${flag_name})
+  string(REPLACE "=" "_" safe_name ${safe_name})
+  check_c_compiler_flag(${flag_name} C_COMPILER_SUPPORT_FLAG_${safe_name})
+  set(safe_name C_COMPILER_SUPPORT_FLAG_${safe_name})
+  if(${safe_name})
+    set(SAFE_GPU_COMMON_FLAGS
+        "${SAFE_GPU_COMMON_FLAGS} -Xcompiler=\"${flag_name}\"")
+  endif()
+endmacro()
+
+check_cxx_symbol_exists(UINT64_MAX "stdint.h" UINT64_MAX_EXISTS)
+if(NOT UINT64_MAX_EXISTS)
+  set(CMAKE_REQUIRED_DEFINITIONS -D__STDC_LIMIT_MACROS)
+  check_cxx_symbol_exists(UINT64_MAX "stdint.h" UINT64_MAX_EXISTS_HERE)
+  if(UINT64_MAX_EXISTS_HERE)
+    set(CMAKE_REQUIRED_DEFINITIONS)
+    add_definitions(-D__STDC_LIMIT_MACROS)
+  else()
+    message(FATAL_ERROR "Cannot find symbol UINT64_MAX")
+  endif()
+endif()
+
+set(CMAKE_EXTRA_INCLUDE_FILES "pthread.h")
+check_type_size(pthread_spinlock_t SPINLOCK_FOUND)
+check_type_size(pthread_barrier_t BARRIER_FOUND)
+if(SPINLOCK_FOUND)
+  add_definitions(-DPADDLE_USE_PTHREAD_SPINLOCK)
+endif()
+if(BARRIER_FOUND)
+  add_definitions(-DPADDLE_USE_PTHREAD_BARRIER)
+endif()
+set(CMAKE_EXTRA_INCLUDE_FILES "")
+
+# Only one sanitizer is allowed in compile time
+string(TOLOWER "${SANITIZER_TYPE}" sanitizer_type)
+if(sanitizer_type STREQUAL "address")
+  set(fsanitize "-fsanitize=address")
+elseif(sanitizer_type STREQUAL "leak")
+  set(fsanitize "-fsanitize=leak")
+elseif(sanitizer_type STREQUAL "memory")
+  set(fsanitize "-fsanitize=memory")
+elseif(sanitizer_type STREQUAL "thread")
+  set(fsanitize "-fsanitize=thread")
+elseif(sanitizer_type STREQUAL "undefined")
+  set(fsanitize "-fsanitize=undefined")
+endif()
+
+# Common flags. the compiler flag used for C/C++ sources whenever release or debug
+# Do not care if this flag is support for gcc.
+
+# https://github.com/PaddlePaddle/Paddle/issues/12773
+if(NOT WIN32)
+  set(COMMON_FLAGS
+      -fPIC
+      -fno-omit-frame-pointer
+      -Werror
+      -Wall
+      -Wextra
+      -Wnon-virtual-dtor
+      -Wdelete-non-virtual-dtor
+      -Wno-unused-parameter
+      -Wno-unused-function
+      -Wno-error=literal-suffix
+      -Wno-error=unused-local-typedefs
+      -Wno-error=ignored-attributes # Warnings in Eigen, gcc 6.3
+      -Wno-error=terminate # Warning in PADDLE_ENFORCE
+      -Wno-error=int-in-bool-context # Warning in Eigen gcc 7.2
+      -Wimplicit-fallthrough=0 # Warning in tinyformat.h
+      -Wno-error=maybe-uninitialized # Warning in boost gcc 7.2
+      ${fsanitize})
+
+  if(WITH_IPU)
+    set(COMMON_FLAGS ${COMMON_FLAGS} -Wno-sign-compare # Warnings in Popart
+                     -Wno-non-virtual-dtor # Warnings in Popart
+    )
+  endif()
+
+  if(WITH_ASCEND_CL AND WITH_ARM_BRPC)
+    set(COMMON_FLAGS ${COMMON_FLAGS} -faligned-new)
+  endif()
+
+  if(NOT APPLE)
+    if((${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER 8.0) OR (WITH_ROCM))
+      set(COMMON_FLAGS
+          ${COMMON_FLAGS}
+          -Wno-format-truncation # Warning in boost gcc 8.2
+          -Wno-error=parentheses # Warning in boost gcc 8.2
+          -Wno-error=catch-value # Warning in boost gcc 8.2
+          -Wno-error=nonnull-compare # Warning in boost gcc 8.2
+          -Wno-error=address # Warning in boost gcc 8.2
+          -Wno-ignored-qualifiers # Warning in boost gcc 8.2
+          -Wno-ignored-attributes # Warning in Eigen gcc 8.3
+          -Wno-parentheses # Warning in Eigen gcc 8.3
+      )
+    endif()
+  endif()
+
+  set(GPU_COMMON_FLAGS
+      -fPIC
+      -fno-omit-frame-pointer
+      -Wnon-virtual-dtor
+      -Wdelete-non-virtual-dtor
+      -Wno-unused-parameter
+      -Wno-unused-function
+      -Wno-error=literal-suffix
+      -Wno-error=unused-local-typedefs
+      -Wno-error=unused-function # Warnings in Numpy Header.
+      -Wno-error=array-bounds # Warnings in Eigen::array
+  )
+  if(NOT WITH_NV_JETSON
+     AND NOT WITH_ARM
+     AND NOT WITH_SW
+     AND NOT WITH_MIPS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64")
+  endif()
+endif()
+
+if(APPLE)
+  if(WITH_ARM)
+    set(CMAKE_OSX_ARCHITECTURES
+        "arm64"
+        CACHE STRING "Build architectures for OSX" FORCE)
+  else()
+    set(CMAKE_OSX_ARCHITECTURES
+        "x86_64"
+        CACHE STRING "Build architectures for OSX" FORCE)
+  endif()
+  # On Mac OS X register class specifier is deprecated and will cause warning error on latest clang 10.0
+  set(COMMON_FLAGS -Wno-deprecated-register)
+endif()
+
+if(WITH_HETERPS AND WITH_PSLIB)
+  set(COMMON_FLAGS -D_GLIBCXX_USE_CXX11_ABI=0 ${COMMON_FLAGS})
+
+  set(GPU_COMMON_FLAGS -D_GLIBCXX_USE_CXX11_ABI=0 ${GPU_COMMON_FLAGS})
+endif()
+
+if(LINUX)
+  set(GPU_COMMON_FLAGS -Wall -Wextra -Werror ${GPU_COMMON_FLAGS})
+endif()
+
+foreach(flag ${COMMON_FLAGS})
+  safe_set_cflag(CMAKE_C_FLAGS ${flag})
+  safe_set_cxxflag(CMAKE_CXX_FLAGS ${flag})
+endforeach()
+
+set(SAFE_GPU_COMMON_FLAGS "")
+foreach(flag ${GPU_COMMON_FLAGS})
+  safe_set_nvflag(${flag})
+endforeach()
+
+if(WITH_GPU)
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${SAFE_GPU_COMMON_FLAGS}")
+endif()
+
+if(WITH_ROCM)
+  set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} ${SAFE_GPU_COMMON_FLAGS} --gpu-max-threads-per-block=1024")
+endif()
+
+# Disable -Werror, otherwise the compile will fail for rocblas_gemm_ex
+if(WITH_ROCM)
+  string(REPLACE "-Werror" "-Wno-error" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+  string(REPLACE "-Werror" "-Wno-error" CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
+endif()
+
+if(WITH_PSCORE OR WITH_PSLIB)
+  string(REPLACE "-Wnon-virtual-dtor" "-Wno-non-virtual-dtor" CMAKE_CXX_FLAGS
+                 ${CMAKE_CXX_FLAGS})
+  string(REPLACE "-Wnon-virtual-dtor" "-Wno-non-virtual-dtor" CMAKE_C_FLAGS
+                 ${CMAKE_C_FLAGS})
+endif()

cmake/generic.cmake

+# 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.
+#
+
+# generic.cmake defines CMakes functions that look like Bazel's
+# building rules (https://bazel.build/).
+#
+#
+# -------------------------------------------
+#     C++        CUDA C++       Go
+# -------------------------------------------
+# cc_library    nv_library   go_library
+# cc_binary     nv_binary    go_binary
+# cc_test       nv_test      go_test
+# -------------------------------------------
+#
+# To build a static library example.a from example.cc using the system
+#  compiler (like GCC):
+#
+#   cc_library(example SRCS example.cc)
+#
+# To build a static library example.a from multiple source files
+# example{1,2,3}.cc:
+#
+#   cc_library(example SRCS example1.cc example2.cc example3.cc)
+#
+# To build a shared library example.so from example.cc:
+#
+#   cc_library(example SHARED SRCS example.cc)
+#
+# To build a library using Nvidia's NVCC from .cu file(s), use the nv_
+# prefixed version:
+#
+#   nv_library(example SRCS example.cu)
+#
+# To specify that a library new_example.a depends on other libraies:
+#
+#   cc_library(new_example SRCS new_example.cc DEPS example)
+#
+# Static libraries can be composed of other static libraries:
+#
+#   cc_library(composed DEPS dependent1 dependent2 dependent3)
+#
+# To build an executable binary file from some source files and
+# dependent libraries:
+#
+#   cc_binary(example SRCS main.cc something.cc DEPS example1 example2)
+#
+# To build an executable binary file using NVCC, use the nv_ prefixed
+# version:
+#
+#   nv_binary(example SRCS main.cc something.cu DEPS example1 example2)
+#
+# To build a unit test binary, which is an executable binary with
+# GoogleTest linked:
+#
+#   cc_test(example_test SRCS example_test.cc DEPS example)
+#
+# To build a unit test binary using NVCC, use the nv_ prefixed version:
+#
+#   nv_test(example_test SRCS example_test.cu DEPS example)
+#
+# It is pretty often that executable and test binaries depend on
+# pre-defined external libaries like glog and gflags defined in
+# /cmake/external/*.cmake:
+#
+#   cc_test(example_test SRCS example_test.cc DEPS example glog gflags)
+#
+# To build a go static library using Golang, use the go_ prefixed version:
+#
+#   go_library(example STATIC)
+#
+# To build a go shared library using Golang, use the go_ prefixed version:
+#
+#   go_library(example SHARED)
+#
+
+# including binary directory for generated headers.
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+# including io directory for inference lib paddle_api.h
+include_directories("${PADDLE_SOURCE_DIR}/paddle/fluid/framework/io")
+
+if(NOT APPLE AND NOT WIN32)
+  find_package(Threads REQUIRED)
+  link_libraries(${CMAKE_THREAD_LIBS_INIT})
+  if(WITH_PSLIB OR WITH_DISTRIBUTE)
+    set(CMAKE_CXX_LINK_EXECUTABLE
+        "${CMAKE_CXX_LINK_EXECUTABLE} -pthread -ldl -lrt -lz -lssl -lcrypto")
+  else()
+    set(CMAKE_CXX_LINK_EXECUTABLE
+        "${CMAKE_CXX_LINK_EXECUTABLE} -pthread -ldl -lrt")
+  endif()
+endif()
+
+set_property(GLOBAL PROPERTY FLUID_MODULES "")
+# find all fluid modules is used for paddle fluid static library
+# for building inference libs
+function(find_fluid_modules TARGET_NAME)
+  get_filename_component(__target_path ${TARGET_NAME} ABSOLUTE)
+  string(REGEX REPLACE "^${PADDLE_SOURCE_DIR}/" "" __target_path
+                       ${__target_path})
+  string(FIND "${__target_path}" "fluid" pos)
+  if(pos GREATER 1)
+    get_property(fluid_modules GLOBAL PROPERTY FLUID_MODULES)
+    set(fluid_modules ${fluid_modules} ${TARGET_NAME})
+    set_property(GLOBAL PROPERTY FLUID_MODULES "${fluid_modules}")
+  endif()
+endfunction()
+
+set_property(GLOBAL PROPERTY PHI_MODULES "")
+# find all phi modules is used for paddle static library
+# for building inference libs
+function(find_phi_modules TARGET_NAME)
+  get_filename_component(__target_path ${TARGET_NAME} ABSOLUTE)
+  string(REGEX REPLACE "^${PADDLE_SOURCE_DIR}/" "" __target_path
+                       ${__target_path})
+  string(FIND "${__target_path}" "phi" pos)
+  if(pos GREATER 1)
+    get_property(phi_modules GLOBAL PROPERTY PHI_MODULES)
+    set(phi_modules ${phi_modules} ${TARGET_NAME})
+    set_property(GLOBAL PROPERTY PHI_MODULES "${phi_modules}")
+  endif()
+endfunction()
+
+function(common_link TARGET_NAME)
+  if(WITH_PROFILER)
+    target_link_libraries(${TARGET_NAME} gperftools::profiler)
+  endif()
+endfunction()
+
+# find all third_party modules is used for paddle static library
+# for reduce the dependency when building the inference libs.
+set_property(GLOBAL PROPERTY FLUID_THIRD_PARTY)
+function(find_fluid_thirdparties TARGET_NAME)
+  get_filename_component(__target_path ${TARGET_NAME} ABSOLUTE)
+  string(REGEX REPLACE "^${PADDLE_SOURCE_DIR}/" "" __target_path
+                       ${__target_path})
+  string(FIND "${__target_path}" "third_party" pos)
+  if(pos GREATER 1)
+    get_property(fluid_ GLOBAL PROPERTY FLUID_THIRD_PARTY)
+    set(fluid_third_partys ${fluid_third_partys} ${TARGET_NAME})
+    set_property(GLOBAL PROPERTY FLUID_THIRD_PARTY "${fluid_third_partys}")
+  endif()
+endfunction()
+
+function(create_static_lib TARGET_NAME)
+  set(libs ${ARGN})
+  list(REMOVE_DUPLICATES libs)
+  if(WIN32)
+    set(dummy_index 1)
+    set(dummy_offset 1)
+    # the dummy target would be consisted of limit size libraries
+    set(dummy_limit 60)
+    list(LENGTH libs libs_len)
+    foreach(lib ${libs})
+      list(APPEND dummy_list ${lib})
+      list(LENGTH dummy_list listlen)
+      if((${listlen} GREATER ${dummy_limit}) OR (${dummy_offset} EQUAL
+                                                 ${libs_len}))
+        merge_static_libs(${TARGET_NAME}_dummy_${dummy_index} ${dummy_list})
+        set(dummy_list)
+        list(APPEND ${TARGET_NAME}_dummy_list
+             ${TARGET_NAME}_dummy_${dummy_index})
+        math(EXPR dummy_index "${dummy_index}+1")
+      endif()
+      math(EXPR dummy_offset "${dummy_offset}+1")
+    endforeach()
+    merge_static_libs(${TARGET_NAME} ${${TARGET_NAME}_dummy_list})
+  else()
+    merge_static_libs(${TARGET_NAME} ${libs})
+  endif()
+endfunction()
+
+function(create_dummy_static_lib TARGET_NAME)
+  set(options "")
+  set(oneValueArgs "")
+  set(multiValueArgs LIBS DEPS LIMIT)
+  cmake_parse_arguments(merge "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  list(REMOVE_DUPLICATES merge_LIBS)
+  set(index 1)
+  set(offset 1)
+  # the dummy target would be consisted of limit size libraries
+  set(limit ${merge_LIMIT})
+  list(LENGTH merge_LIBS libs_len)
+  foreach(lib ${merge_LIBS})
+    list(APPEND merge_list ${lib})
+    list(LENGTH merge_list listlen)
+    if((${listlen} GREATER ${limit}) OR (${offset} EQUAL ${libs_len}))
+      message(
+        "Merge and generate static library: ${TARGET_NAME}_static_${index}")
+      merge_static_libs(${TARGET_NAME}_static_${index} ${merge_list})
+      if(merge_DEPS)
+        target_link_libraries(${TARGET_NAME}_static_${index} ${merge_DEPS})
+      endif()
+      set(merge_list)
+      list(APPEND ${TARGET_NAME}_list ${TARGET_NAME}_static_${index})
+      math(EXPR index "${index}+1")
+    endif()
+    math(EXPR offset "${offset}+1")
+  endforeach()
+  cc_library(${TARGET_NAME} DEPS ${${TARGET_NAME}_list})
+endfunction()
+
+function(merge_static_libs TARGET_NAME)
+  set(libs ${ARGN})
+  list(REMOVE_DUPLICATES libs)
+
+  # Get all propagation dependencies from the merged libraries
+  foreach(lib ${libs})
+    list(APPEND libs_deps ${${lib}_LIB_DEPENDS})
+  endforeach()
+  if(libs_deps)
+    list(REMOVE_DUPLICATES libs_deps)
+  endif()
+
+  # To produce a library we need at least one source file.
+  # It is created by add_custom_command below and will helps
+  # also help to track dependencies.
+  set(target_SRCS ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}_dummy.c)
+
+  # Make the generated dummy source file depended on all static input
+  # libs. If input lib changes,the source file is touched
+  # which causes the desired effect (relink).
+  add_custom_command(
+    OUTPUT ${target_SRCS}
+    COMMAND ${CMAKE_COMMAND} -E touch ${target_SRCS}
+    DEPENDS ${libs})
+
+  # Generate dummy staic lib
+  generate_dummy_static_lib(LIB_NAME ${TARGET_NAME} FILE_PATH ${target_SRCS}
+                            GENERATOR "generic.cmake:merge_static_libs")
+  target_link_libraries(${TARGET_NAME} ${libs_deps})
+
+  # OSX: use 'libtool' to merge archives
+  if(APPLE)
+    foreach(lib ${libs})
+      # Get the file names of the libraries to be merged
+      set(libfiles ${libfiles} $<TARGET_FILE:${lib}>)
+    endforeach()
+    add_custom_command(
+      TARGET ${TARGET_NAME}
+      POST_BUILD
+      COMMENT "Merge and generate static lib: lib${TARGET_NAME}.a"
+      COMMAND rm "${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET_NAME}.a"
+      COMMAND /usr/bin/libtool -static -o
+              "${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET_NAME}.a" ${libfiles})
+  endif()
+
+  # LINUX: use "ar" to extract objects and re-add to a common lib
+  if(LINUX)
+    set(mri_file
+        ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}.mri
+        CACHE INTERNAL "phi_static.mri file")
+    get_property(
+      ABS_MERGE_LIB_PATH
+      TARGET ${TARGET_NAME}
+      PROPERTY LOCATION)
+    file(WRITE ${mri_file} "create ${ABS_MERGE_LIB_PATH}\n")
+
+    foreach(lib ${libs})
+      get_property(
+        ABS_LIB_PATH
+        TARGET ${lib}
+        PROPERTY LOCATION)
+      file(APPEND ${mri_file} "addlib ${ABS_LIB_PATH}\n")
+    endforeach()
+    file(APPEND ${mri_file} "save\nend\n")
+
+    add_custom_command(
+      TARGET ${TARGET_NAME}
+      POST_BUILD
+      COMMENT "Merge and generate static lib: lib${TARGET_NAME}.a"
+      COMMAND ${CMAKE_AR} -M < ${mri_file}
+      COMMAND ${CMAKE_RANLIB} "$<TARGET_FILE:${TARGET_NAME}>")
+  endif()
+
+  # Windows do not support gcc/nvcc combined compiling. Use msvc 'lib.exe' to merge libs.
+  if(WIN32)
+    foreach(lib ${libs})
+      set(libfiles ${libfiles} $<TARGET_FILE:${lib}>)
+    endforeach()
+    # msvc compiler will put libarary in directory of "/Release/xxxlib" by default
+    add_custom_command(
+      TARGET ${TARGET_NAME}
+      POST_BUILD
+      COMMENT "Merge and generate static lib: lib${TARGET_NAME}.lib"
+      COMMAND cmake -E make_directory $<TARGET_FILE_DIR:${TARGET_NAME}>
+      COMMAND lib /OUT:$<TARGET_FILE:${TARGET_NAME}> ${libfiles})
+  endif()
+endfunction()
+
+function(check_coverage_opt TARGET_NAME SRCS)
+  if(WITH_COVERAGE AND WITH_INCREMENTAL_COVERAGE)
+    # if pybind.cc add '-g -O0 -fprofile-arcs -ftest-coverage' only, some testcase will fail.
+    if("$ENV{PADDLE_GIT_DIFF_H_FILE}" STREQUAL ""
+       AND (NOT ("$ENV{PADDLE_GIT_DIFF_CC_FILE}" MATCHES "pybind.cc")))
+      if(NOT ("$ENV{PADDLE_GIT_DIFF_CC_FILE}" STREQUAL ""))
+        string(REPLACE "," ";" CC_FILE_LIST $ENV{PADDLE_GIT_DIFF_CC_FILE})
+        set(use_coverage_opt FALSE)
+        foreach(cc_file ${CC_FILE_LIST})
+          if("${SRCS};" MATCHES "${cc_file}")
+            set(use_coverage_opt TRUE)
+            break()
+          endif()
+        endforeach()
+
+        if(use_coverage_opt)
+          message(STATUS "cc changed, add coverage opt for ${TARGET_NAME}")
+          target_compile_options(${TARGET_NAME} PRIVATE -g -O0 -fprofile-arcs
+                                                        -ftest-coverage)
+          target_link_libraries(${TARGET_NAME} -fprofile-arcs)
+          get_target_property(WH_TARGET_COMPILE_OPTIONS ${TARGET_NAME}
+                              COMPILE_OPTIONS)
+          message(
+            STATUS "property for ${TARGET_NAME} is ${WH_TARGET_COMPILE_OPTIONS}"
+          )
+        endif()
+      endif()
+    endif()
+  endif()
+endfunction()
+
+function(cc_library TARGET_NAME)
+  set(options STATIC static SHARED shared INTERFACE interface)
+  set(oneValueArgs "")
+  set(multiValueArgs SRCS DEPS)
+  cmake_parse_arguments(cc_library "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+  if(WIN32)
+    # add libxxx.lib prefix in windows
+    set(${TARGET_NAME}_LIB_NAME
+        "${CMAKE_STATIC_LIBRARY_PREFIX}${TARGET_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+        CACHE STRING "output library name for target ${TARGET_NAME}")
+  endif()
+  if(cc_library_SRCS)
+    if(cc_library_SHARED OR cc_library_shared) # build *.so
+      add_library(${TARGET_NAME} SHARED ${cc_library_SRCS})
+    elseif(cc_library_INTERFACE OR cc_library_interface)
+      generate_dummy_static_lib(
+        LIB_NAME ${TARGET_NAME} FILE_PATH ${target_SRCS} GENERATOR
+        "generic.cmake:cc_library")
+    else()
+      add_library(${TARGET_NAME} STATIC ${cc_library_SRCS})
+      find_fluid_modules(${TARGET_NAME})
+      find_phi_modules(${TARGET_NAME})
+    endif()
+    if(cc_library_DEPS)
+      # Don't need link libwarpctc.so
+      if("${cc_library_DEPS};" MATCHES "warpctc;")
+        list(REMOVE_ITEM cc_library_DEPS warpctc)
+        add_dependencies(${TARGET_NAME} warpctc)
+      endif()
+      # Only deps libmklml.so, not link
+      if("${cc_library_DEPS};" MATCHES "mklml;")
+        list(REMOVE_ITEM cc_library_DEPS mklml)
+        if(NOT "${TARGET_NAME}" MATCHES "dynload_mklml")
+          list(APPEND cc_library_DEPS dynload_mklml)
+        endif()
+        add_dependencies(${TARGET_NAME} mklml)
+        if(WIN32)
+          target_link_libraries(${TARGET_NAME} ${MKLML_IOMP_LIB})
+        else()
+          target_link_libraries(${TARGET_NAME}
+                                "-L${MKLML_LIB_DIR} -liomp5 -Wl,--as-needed")
+        endif()
+      endif()
+      # remove link to python, see notes at:
+      # https://github.com/pybind/pybind11/blob/master/docs/compiling.rst#building-manually
+      if("${cc_library_DEPS};" MATCHES "python;")
+        list(REMOVE_ITEM cc_library_DEPS python)
+        add_dependencies(${TARGET_NAME} python)
+        if(WIN32)
+          target_link_libraries(${TARGET_NAME} ${PYTHON_LIBRARIES})
+        else()
+          target_link_libraries(${TARGET_NAME} "-Wl,-undefined,dynamic_lookup")
+        endif()
+      endif()
+      target_link_libraries(${TARGET_NAME} ${cc_library_DEPS}
+                            ${PYTHON_LIBRARIES})
+      common_link(${TARGET_NAME})
+    endif()
+
+    # cpplint code style
+    foreach(source_file ${cc_library_SRCS})
+      string(REGEX REPLACE "\\.[^.]*$" "" source ${source_file})
+      if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+        list(APPEND cc_library_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+      endif()
+    endforeach()
+
+    check_coverage_opt(${TARGET_NAME} ${cc_library_SRCS})
+
+  else()
+    if(cc_library_DEPS)
+      list(REMOVE_DUPLICATES cc_library_DEPS)
+
+      generate_dummy_static_lib(
+        LIB_NAME ${TARGET_NAME} FILE_PATH ${target_SRCS} GENERATOR
+        "generic.cmake:cc_library")
+
+      target_link_libraries(${TARGET_NAME} ${cc_library_DEPS})
+    else()
+      message(
+        FATAL_ERROR
+          "Please specify source files or libraries in cc_library(${TARGET_NAME} ...)."
+      )
+    endif()
+  endif()
+endfunction()
+
+function(cc_binary TARGET_NAME)
+  set(options "")
+  set(oneValueArgs "")
+  set(multiValueArgs SRCS DEPS)
+  cmake_parse_arguments(cc_binary "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+  add_executable(${TARGET_NAME} ${cc_binary_SRCS})
+  if(cc_binary_DEPS)
+    target_link_libraries(${TARGET_NAME} ${cc_binary_DEPS})
+    add_dependencies(${TARGET_NAME} ${cc_binary_DEPS})
+    common_link(${TARGET_NAME})
+  endif()
+  get_property(os_dependency_modules GLOBAL PROPERTY OS_DEPENDENCY_MODULES)
+  target_link_libraries(${TARGET_NAME} ${os_dependency_modules})
+  if(WITH_ROCM)
+    target_link_libraries(${TARGET_NAME} ${ROCM_HIPRTC_LIB})
+  endif()
+
+  check_coverage_opt(${TARGET_NAME} ${cc_binary_SRCS})
+
+endfunction()
+
+function(cc_test_build TARGET_NAME)
+  if(WITH_TESTING)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(cc_test "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    add_executable(${TARGET_NAME} ${cc_test_SRCS})
+    if(WIN32)
+      if("${cc_test_DEPS};" MATCHES "python;")
+        list(REMOVE_ITEM cc_test_DEPS python)
+        target_link_libraries(${TARGET_NAME} ${PYTHON_LIBRARIES})
+      endif()
+    endif()
+    get_property(os_dependency_modules GLOBAL PROPERTY OS_DEPENDENCY_MODULES)
+    target_link_libraries(
+      ${TARGET_NAME}
+      ${cc_test_DEPS}
+      ${os_dependency_modules}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog)
+    add_dependencies(
+      ${TARGET_NAME}
+      ${cc_test_DEPS}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog)
+    common_link(${TARGET_NAME})
+    if(WITH_ROCM)
+      target_link_libraries(${TARGET_NAME} ${ROCM_HIPRTC_LIB})
+    endif()
+    check_coverage_opt(${TARGET_NAME} ${cc_test_SRCS})
+  endif()
+endfunction()
+
+function(cc_test_run TARGET_NAME)
+  if(WITH_TESTING)
+    set(oneValueArgs "")
+    set(multiValueArgs COMMAND ARGS)
+    cmake_parse_arguments(cc_test "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    add_test(
+      NAME ${TARGET_NAME}
+      COMMAND ${cc_test_COMMAND} ${cc_test_ARGS}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cpu_deterministic=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_init_allocated_mem=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cudnn_deterministic=true)
+    # No unit test should exceed 2 minutes.
+    if(WIN32)
+      set_tests_properties(${TARGET_NAME} PROPERTIES TIMEOUT 150)
+    endif()
+    if(APPLE)
+      set_tests_properties(${TARGET_NAME} PROPERTIES TIMEOUT 20)
+    endif()
+  elseif(WITH_TESTING AND NOT TEST ${TARGET_NAME})
+    add_test(NAME ${TARGET_NAME} COMMAND ${CMAKE_COMMAND} -E echo CI skip
+                                         ${TARGET_NAME}.)
+  endif()
+endfunction()
+
+function(cc_test TARGET_NAME)
+  if(WITH_TESTING)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS ARGS)
+    cmake_parse_arguments(cc_test "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    cc_test_build(${TARGET_NAME} SRCS ${cc_test_SRCS} DEPS ${cc_test_DEPS})
+    # we dont test hcom op, because it need complex configuration
+    # with more than one machine
+    if(NOT
+       ("${TARGET_NAME}" STREQUAL "c_broadcast_op_npu_test"
+        OR "${TARGET_NAME}" STREQUAL "c_allreduce_sum_op_npu_test"
+        OR "${TARGET_NAME}" STREQUAL "c_allreduce_max_op_npu_test"
+        OR "${TARGET_NAME}" STREQUAL "c_reducescatter_op_npu_test"
+        OR "${TARGET_NAME}" STREQUAL "c_allgather_op_npu_test"
+        OR "${TARGET_NAME}" STREQUAL "send_v2_op_npu_test"
+        OR "${TARGET_NAME}" STREQUAL "c_reduce_sum_op_npu_test"
+        OR "${TARGET_NAME}" STREQUAL "recv_v2_op_npu_test"))
+      cc_test_run(${TARGET_NAME} COMMAND ${TARGET_NAME} ARGS ${cc_test_ARGS})
+    endif()
+  elseif(WITH_TESTING AND NOT TEST ${TARGET_NAME})
+    add_test(NAME ${TARGET_NAME} COMMAND ${CMAKE_COMMAND} -E echo CI skip
+                                         ${TARGET_NAME}.)
+  endif()
+endfunction()
+
+function(nv_library TARGET_NAME)
+  if(WITH_GPU)
+    set(options STATIC static SHARED shared)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(nv_library "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    if(nv_library_SRCS)
+      # Attention:
+      # 1. cuda_add_library is deprecated after cmake v3.10, use add_library for CUDA please.
+      # 2. cuda_add_library does not support ccache.
+      # Reference: https://cmake.org/cmake/help/v3.10/module/FindCUDA.html
+      if(nv_library_SHARED OR nv_library_shared) # build *.so
+        add_library(${TARGET_NAME} SHARED ${nv_library_SRCS})
+      else()
+        add_library(${TARGET_NAME} STATIC ${nv_library_SRCS})
+        find_fluid_modules(${TARGET_NAME})
+        find_phi_modules(${TARGET_NAME})
+      endif()
+      if(nv_library_DEPS)
+        add_dependencies(${TARGET_NAME} ${nv_library_DEPS})
+        target_link_libraries(${TARGET_NAME} ${nv_library_DEPS})
+      endif()
+      # cpplint code style
+      foreach(source_file ${nv_library_SRCS})
+        string(REGEX REPLACE "\\.[^.]*$" "" source ${source_file})
+        if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+          list(APPEND nv_library_HEADERS
+               ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+        endif()
+      endforeach()
+    else()
+      if(nv_library_DEPS)
+        list(REMOVE_DUPLICATES nv_library_DEPS)
+        generate_dummy_static_lib(
+          LIB_NAME ${TARGET_NAME} FILE_PATH ${target_SRCS} GENERATOR
+          "generic.cmake:nv_library")
+
+        target_link_libraries(${TARGET_NAME} ${nv_library_DEPS})
+        add_dependencies(${TARGET_NAME} ${nv_library_DEPS})
+      else()
+        message(FATAL "Please specify source file or library in nv_library.")
+      endif()
+    endif()
+    if((CUDA_VERSION GREATER 9.2)
+       AND (CUDA_VERSION LESS 11.0)
+       AND (MSVC_VERSION LESS 1910))
+      set_target_properties(${TARGET_NAME} PROPERTIES VS_USER_PROPS
+                                                      ${WIN_PROPS})
+    endif()
+  endif()
+endfunction()
+
+function(nv_binary TARGET_NAME)
+  if(WITH_GPU)
+    set(options "")
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(nv_binary "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    add_executable(${TARGET_NAME} ${nv_binary_SRCS})
+    if(nv_binary_DEPS)
+      target_link_libraries(${TARGET_NAME} ${nv_binary_DEPS})
+      add_dependencies(${TARGET_NAME} ${nv_binary_DEPS})
+      common_link(${TARGET_NAME})
+    endif()
+    if((CUDA_VERSION GREATER 9.2)
+       and (CUDA_VERSION LESS 11.0)
+       and (MSVC_VERSION LESS 1910))
+      set_target_properties(${TARGET_NAME} PROPERTIES VS_USER_PROPS
+                                                      ${WIN_PROPS})
+    endif()
+  endif()
+endfunction()
+
+function(nv_test TARGET_NAME)
+  if(WITH_GPU AND WITH_TESTING)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(nv_test "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    # Attention:
+    # 1. cuda_add_executable is deprecated after cmake v3.10, use cuda_add_executable for CUDA please.
+    # 2. cuda_add_executable does not support ccache.
+    # Reference: https://cmake.org/cmake/help/v3.10/module/FindCUDA.html
+    add_executable(${TARGET_NAME} ${nv_test_SRCS})
+    get_property(os_dependency_modules GLOBAL PROPERTY OS_DEPENDENCY_MODULES)
+    target_link_libraries(
+      ${TARGET_NAME}
+      ${nv_test_DEPS}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog
+      ${os_dependency_modules})
+    add_dependencies(
+      ${TARGET_NAME}
+      ${nv_test_DEPS}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog)
+    common_link(${TARGET_NAME})
+    add_test(${TARGET_NAME} ${TARGET_NAME})
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cpu_deterministic=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_init_allocated_mem=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cudnn_deterministic=true)
+    if((CUDA_VERSION GREATER 9.2)
+       AND (CUDA_VERSION LESS 11.0)
+       AND (MSVC_VERSION LESS 1910))
+      set_target_properties(${TARGET_NAME} PROPERTIES VS_USER_PROPS
+                                                      ${WIN_PROPS})
+    endif()
+  endif()
+endfunction()
+
+function(hip_library TARGET_NAME)
+  if(WITH_ROCM)
+    set(options STATIC static SHARED shared)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(hip_library "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    if(hip_library_SRCS)
+      # FindHIP.cmake defined hip_add_library, HIP_SOURCE_PROPERTY_FORMAT is requried if no .cu files found
+      if(NOT (${CMAKE_CURRENT_SOURCE_DIR} MATCHES ".*/operators"
+              OR ${CMAKE_CURRENT_SOURCE_DIR} MATCHES ".*/phi/kernels"))
+        set_source_files_properties(${hip_library_SRCS}
+                                    PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+      endif()
+      if(hip_library_SHARED OR hip_library_shared) # build *.so
+        hip_add_library(${TARGET_NAME} SHARED ${hip_library_SRCS})
+      else()
+        hip_add_library(${TARGET_NAME} STATIC ${hip_library_SRCS})
+        find_fluid_modules(${TARGET_NAME})
+        find_phi_modules(${TARGET_NAME})
+      endif()
+      if(hip_library_DEPS)
+        add_dependencies(${TARGET_NAME} ${hip_library_DEPS})
+        target_link_libraries(${TARGET_NAME} ${hip_library_DEPS})
+      endif()
+      # cpplint code style
+      foreach(source_file ${hip_library_SRCS})
+        string(REGEX REPLACE "\\.[^.]*$" "" source ${source_file})
+        if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+          list(APPEND hip_library_HEADERS
+               ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+        endif()
+      endforeach()
+    else()
+      if(hip_library_DEPS)
+        list(REMOVE_DUPLICATES hip_library_DEPS)
+        generate_dummy_static_lib(
+          LIB_NAME ${TARGET_NAME} FILE_PATH ${target_SRCS} GENERATOR
+          "generic.cmake:hip_library")
+
+        target_link_libraries(${TARGET_NAME} ${hip_library_DEPS})
+        add_dependencies(${TARGET_NAME} ${hip_library_DEPS})
+      else()
+        message(FATAL "Please specify source file or library in hip_library.")
+      endif()
+    endif()
+  endif()
+endfunction()
+
+function(hip_binary TARGET_NAME)
+  if(WITH_ROCM)
+    set(options "")
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(hip_binary "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    # FindHIP.cmake defined hip_add_executable, HIP_SOURCE_PROPERTY_FORMAT is requried for .cc files
+    hip_add_executable(${TARGET_NAME} ${hip_binary_SRCS})
+    if(hip_binary_DEPS)
+      target_link_libraries(${TARGET_NAME} ${hip_binary_DEPS})
+      add_dependencies(${TARGET_NAME} ${hip_binary_DEPS})
+      common_link(${TARGET_NAME})
+    endif()
+  endif()
+endfunction()
+
+function(hip_test TARGET_NAME)
+  if(WITH_ROCM AND WITH_TESTING)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(hip_test "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    # FindHIP.cmake defined hip_add_executable,
+    # HIP_SOURCE_PROPERTY_FORMAT is requried for .cc files
+    hip_add_executable(${TARGET_NAME} ${hip_test_SRCS})
+    # "-pthread -ldl -lrt" is defined in CMAKE_CXX_LINK_EXECUTABLE
+    target_link_options(${TARGET_NAME} PRIVATE -pthread -ldl -lrt)
+    get_property(os_dependency_modules GLOBAL PROPERTY OS_DEPENDENCY_MODULES)
+    target_link_libraries(
+      ${TARGET_NAME}
+      ${hip_test_DEPS}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog
+      ${os_dependency_modules})
+    add_dependencies(
+      ${TARGET_NAME}
+      ${hip_test_DEPS}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog)
+    common_link(${TARGET_NAME})
+    add_test(${TARGET_NAME} ${TARGET_NAME})
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cpu_deterministic=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_init_allocated_mem=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cudnn_deterministic=true)
+    set_property(
+      TEST ${TARGET_NAME}
+      PROPERTY
+        ENVIRONMENT
+        "LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/python/paddle/libs:$LD_LIBRARY_PATH"
+    )
+  endif()
+endfunction()
+
+function(xpu_library TARGET_NAME)
+  if(WITH_XPU_KP)
+    set(options STATIC static SHARED shared)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(xpu_library "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+
+    if(xpu_library_SRCS)
+      if(xpu_library_SHARED OR xpu_library_shared) # build *.so
+        message(
+          FATAL_ERROR "XPU kernel currently does not support dynamic links")
+      else()
+        xpu_add_library(${TARGET_NAME} STATIC ${xpu_library_SRCS} DEPENDS
+                        ${xpu_library_DEPS})
+        find_fluid_modules(${TARGET_NAME})
+        find_phi_modules(${TARGET_NAME})
+      endif()
+      if(xpu_library_DEPS)
+        add_dependencies(${TARGET_NAME} ${xpu_library_DEPS})
+        target_link_libraries(${TARGET_NAME} ${xpu_library_DEPS})
+      endif()
+      # cpplint code style
+      foreach(source_file ${xpu_library_SRCS})
+        string(REGEX REPLACE "\\.[^.]*$" "" source ${source_file})
+        if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+          list(APPEND xpu_library_HEADERS
+               ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
+        endif()
+      endforeach()
+    else()
+      if(xpu_library_DEPS)
+        list(REMOVE_DUPLICATES xpu_library_DEPS)
+        generate_dummy_static_lib(
+          LIB_NAME ${TARGET_NAME} FILE_PATH ${target_SRCS} GENERATOR
+          "generic.cmake:xpu_library")
+        target_link_libraries(${TARGET_NAME} ${xpu_library_DEPS})
+        add_dependencies(${TARGET_NAME} ${xpu_library_DEPS})
+      else()
+        message(FATAL "Please specify source file or library in xpu_library.")
+      endif()
+    endif()
+  endif()
+endfunction()
+
+function(xpu_binary TARGET_NAME)
+  if(WITH_XPU_KP)
+    set(options "")
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(xpu_binary "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    add_executable(${TARGET_NAME} ${xpu_binary_SRCS})
+    if(xpu_binary_DEPS)
+      target_link_libraries(${TARGET_NAME} ${xpu_binary_DEPS})
+      add_dependencies(${TARGET_NAME} ${xpu_binary_DEPS})
+      common_link(${TARGET_NAME})
+    endif()
+  endif()
+endfunction()
+
+function(xpu_test TARGET_NAME)
+  if(WITH_XPU_KP AND WITH_TESTING)
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS)
+    cmake_parse_arguments(xpu_test "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+    add_executable(${TARGET_NAME} ${xpu_test_SRCS})
+    # "-pthread -ldl -lrt" is defined in CMAKE_CXX_LINK_EXECUTABLE
+    target_link_options(${TARGET_NAME} PRIVATE -pthread -ldl -lrt)
+    get_property(os_dependency_modules GLOBAL PROPERTY OS_DEPENDENCY_MODULES)
+    target_link_libraries(
+      ${TARGET_NAME}
+      ${xpu_test_DEPS}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog
+      ${os_dependency_modules})
+    add_dependencies(
+      ${TARGET_NAME}
+      ${xpu_test_DEPS}
+      paddle_gtest_main
+      lod_tensor
+      memory
+      gtest
+      gflags
+      glog)
+    common_link(${TARGET_NAME})
+    add_test(${TARGET_NAME} ${TARGET_NAME})
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cpu_deterministic=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_init_allocated_mem=true)
+    set_property(TEST ${TARGET_NAME} PROPERTY ENVIRONMENT
+                                              FLAGS_cudnn_deterministic=true)
+  endif()
+endfunction()
+
+function(go_library TARGET_NAME)
+  set(options STATIC static SHARED shared)
+  set(oneValueArgs "")
+  set(multiValueArgs DEPS)
+  cmake_parse_arguments(go_library "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  if(go_library_SHARED OR go_library_shared)
+    set(BUILD_MODE "-buildmode=c-shared")
+    set(${TARGET_NAME}_LIB_NAME
+        "${CMAKE_SHARED_LIBRARY_PREFIX}${TARGET_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}"
+        CACHE STRING "output library name for target ${TARGET_NAME}")
+  else()
+    set(BUILD_MODE "-buildmode=c-archive")
+    set(${TARGET_NAME}_LIB_NAME
+        "${CMAKE_STATIC_LIBRARY_PREFIX}${TARGET_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+        CACHE STRING "output library name for target ${TARGET_NAME}")
+  endif()
+
+  set(dummyfile ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}_dummy.c)
+
+  # This custom command will always run since it depends on a not
+  # existing file.
+  add_custom_command(OUTPUT dummy_rebulid_${TARGET_NAME} COMMAND cmake -E touch
+                                                                 ${dummyfile})
+  # Create a custom target that depends on the custom command output
+  # file, so the custom command can be referenced as a dependency by
+  # `add_dependencies`.
+  add_custom_target(rebuild_${TARGET_NAME} DEPENDS dummy_rebulid_${TARGET_NAME})
+
+  # Add dummy code to support `make target_name` under Terminal Command
+  file(WRITE ${dummyfile}
+       "const char *dummy_${TARGET_NAME} = \"${dummyfile}\";")
+  if(go_library_SHARED OR go_library_shared)
+    add_library(${TARGET_NAME} SHARED ${dummyfile})
+  else()
+    add_library(${TARGET_NAME} STATIC ${dummyfile})
+  endif()
+  if(go_library_DEPS)
+    add_dependencies(${TARGET_NAME} ${go_library_DEPS})
+    common_link(${TARGET_NAME})
+  endif()
+
+  # The "source file" of the library is `${dummyfile}` which never
+  # change, so the target will never rebuild. Make the target depends
+  # on the custom command that touches the library "source file", so
+  # rebuild will always happen.
+  add_dependencies(${TARGET_NAME} rebuild_${TARGET_NAME})
+
+  set(${TARGET_NAME}_LIB_PATH
+      "${CMAKE_CURRENT_BINARY_DIR}/${${TARGET_NAME}_LIB_NAME}"
+      CACHE STRING "output library path for target ${TARGET_NAME}")
+
+  file(
+    GLOB GO_SOURCE
+    RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+    "*.go")
+  string(REPLACE "${PADDLE_GO_PATH}/" "" CMAKE_CURRENT_SOURCE_REL_DIR
+                 ${CMAKE_CURRENT_SOURCE_DIR})
+
+  add_custom_command(
+    TARGET ${TARGET_NAME}
+    POST_BUILD
+    COMMAND rm "${${TARGET_NAME}_LIB_PATH}"
+    # Golang build source code
+    COMMAND
+      GOPATH=${GOPATH} ${CMAKE_Go_COMPILER} build ${BUILD_MODE} -o
+      "${${TARGET_NAME}_LIB_PATH}"
+      "./${CMAKE_CURRENT_SOURCE_REL_DIR}/${GO_SOURCE}"
+    # must run under GOPATH
+    WORKING_DIRECTORY "${PADDLE_IN_GOPATH}/go")
+  add_dependencies(${TARGET_NAME} go_vendor)
+endfunction()
+
+function(go_binary TARGET_NAME)
+  set(options OPTIONAL)
+  set(oneValueArgs "")
+  set(multiValueArgs SRCS DEPS)
+  cmake_parse_arguments(go_binary "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+  string(REPLACE "${PADDLE_GO_PATH}/" "" CMAKE_CURRENT_SOURCE_REL_DIR
+                 ${CMAKE_CURRENT_SOURCE_DIR})
+
+  add_custom_command(
+    OUTPUT ${TARGET_NAME}_timestamp
+    COMMAND
+      env GOPATH=${GOPATH} ${CMAKE_Go_COMPILER} build -o
+      "${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}"
+      "./${CMAKE_CURRENT_SOURCE_REL_DIR}/${go_binary_SRCS}"
+    WORKING_DIRECTORY "${PADDLE_IN_GOPATH}/go")
+  add_custom_target(
+    ${TARGET_NAME} ALL DEPENDS go_vendor ${TARGET_NAME}_timestamp
+                               ${go_binary_DEPS})
+  install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME} DESTINATION bin)
+
+  check_coverage_opt(${TARGET_NAME} ${go_binary_SRCS})
+
+endfunction()
+
+function(go_test TARGET_NAME)
+  set(options OPTIONAL)
+  set(oneValueArgs "")
+  set(multiValueArgs DEPS)
+  cmake_parse_arguments(go_test "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+  string(REPLACE "${PADDLE_GO_PATH}" "" CMAKE_CURRENT_SOURCE_REL_DIR
+                 ${CMAKE_CURRENT_SOURCE_DIR})
+  add_custom_target(${TARGET_NAME} ALL DEPENDS go_vendor ${go_test_DEPS})
+  add_custom_command(
+    TARGET ${TARGET_NAME}
+    POST_BUILD
+    COMMAND
+      env GOPATH=${GOPATH} ${CMAKE_Go_COMPILER} test -race -c -o
+      "${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}"
+      ".${CMAKE_CURRENT_SOURCE_REL_DIR}"
+    WORKING_DIRECTORY "${PADDLE_IN_GOPATH}/go")
+  add_test(
+    NAME ${TARGET_NAME}
+    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+endfunction()
+
+# Modification of standard 'protobuf_generate_cpp()' with protobuf-lite support
+# Usage:
+#   paddle_protobuf_generate_cpp(<proto_srcs> <proto_hdrs> <proto_files>)
+
+function(paddle_protobuf_generate_cpp SRCS HDRS)
+  if(NOT ARGN)
+    message(
+      SEND_ERROR
+        "Error: paddle_protobuf_generate_cpp() called without any proto files")
+    return()
+  endif()
+
+  set(${SRCS})
+  set(${HDRS})
+
+  foreach(FIL ${ARGN})
+    get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
+    get_filename_component(FIL_WE ${FIL} NAME_WE)
+
+    set(_protobuf_protoc_src "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc")
+    set(_protobuf_protoc_hdr "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h")
+    list(APPEND ${SRCS} "${_protobuf_protoc_src}")
+    list(APPEND ${HDRS} "${_protobuf_protoc_hdr}")
+
+    add_custom_command(
+      OUTPUT "${_protobuf_protoc_src}" "${_protobuf_protoc_hdr}"
+      COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}"
+      COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} -I${CMAKE_CURRENT_SOURCE_DIR}
+              --cpp_out "${CMAKE_CURRENT_BINARY_DIR}" ${ABS_FIL}
+      # Set `EXTERN_PROTOBUF_DEPEND` only if need to compile `protoc.exe`.
+      DEPENDS ${ABS_FIL} ${EXTERN_PROTOBUF_DEPEND}
+      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
+      VERBATIM)
+  endforeach()
+
+  set_source_files_properties(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
+  set(${SRCS}
+      ${${SRCS}}
+      PARENT_SCOPE)
+  set(${HDRS}
+      ${${HDRS}}
+      PARENT_SCOPE)
+endfunction()
+
+function(proto_library TARGET_NAME)
+  set(oneValueArgs "")
+  set(multiValueArgs SRCS DEPS)
+  cmake_parse_arguments(proto_library "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+  set(proto_srcs)
+  set(proto_hdrs)
+  paddle_protobuf_generate_cpp(proto_srcs proto_hdrs ${proto_library_SRCS})
+  cc_library(
+    ${TARGET_NAME}
+    SRCS ${proto_srcs}
+    DEPS ${proto_library_DEPS} protobuf)
+  add_dependencies(extern_xxhash ${TARGET_NAME})
+endfunction()
+
+function(py_proto_compile TARGET_NAME)
+  set(oneValueArgs "")
+  set(multiValueArgs SRCS)
+  cmake_parse_arguments(py_proto_compile "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+  set(py_srcs)
+  protobuf_generate_python(py_srcs ${py_proto_compile_SRCS})
+  add_custom_target(${TARGET_NAME} ALL DEPENDS ${py_srcs} protobuf)
+endfunction()
+
+function(py_test TARGET_NAME)
+  if(WITH_TESTING)
+    set(options "")
+    set(oneValueArgs "")
+    set(multiValueArgs SRCS DEPS ARGS ENVS)
+    cmake_parse_arguments(py_test "${options}" "${oneValueArgs}"
+                          "${multiValueArgs}" ${ARGN})
+
+    if(WITH_COVERAGE AND NOT (WITH_INCREMENTAL_COVERAGE
+                              AND "$ENV{PADDLE_GIT_DIFF_PY_FILE}" STREQUAL ""))
+      add_test(
+        NAME ${TARGET_NAME}
+        COMMAND
+          ${CMAKE_COMMAND} -E env FLAGS_init_allocated_mem=true
+          FLAGS_cudnn_deterministic=true FLAGS_cpu_deterministic=true
+          PYTHONPATH=${PADDLE_BINARY_DIR}/python ${py_test_ENVS}
+          COVERAGE_FILE=${PADDLE_BINARY_DIR}/python-coverage.data
+          ${PYTHON_EXECUTABLE} -m coverage run --branch -p ${py_test_SRCS}
+          ${py_test_ARGS}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    else()
+      add_test(
+        NAME ${TARGET_NAME}
+        COMMAND
+          ${CMAKE_COMMAND} -E env FLAGS_init_allocated_mem=true
+          FLAGS_cudnn_deterministic=true FLAGS_cpu_deterministic=true
+          ${py_test_ENVS} ${PYTHON_EXECUTABLE} -u ${py_test_SRCS}
+          ${py_test_ARGS}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+
+    if(WIN32)
+      set_tests_properties(${TARGET_NAME} PROPERTIES TIMEOUT 150)
+    endif()
+    if(APPLE)
+      set_tests_properties(${TARGET_NAME} PROPERTIES TIMEOUT 20)
+    endif()
+
+  endif()
+endfunction()
+
+# grpc_library generate grpc code using grpc_cpp_plugin and protoc
+# then build the generated protobuf code and grpc code with your
+# implementation source codes together. Use SRCS argument for your
+# implementation source files and PROTO argument for your .proto
+# files.
+#
+# Usage: grpc_library(my_target SRCS my_client.cc PROTO my_target.proto DEPS my_dep)
+
+function(grpc_library TARGET_NAME)
+  set(oneValueArgs PROTO)
+  set(multiValueArgs SRCS DEPS)
+  set(options "")
+  cmake_parse_arguments(grpc_library "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  message(STATUS "generating grpc ${grpc_library_PROTO}")
+
+  get_filename_component(ABS_PROTO ${grpc_library_PROTO} ABSOLUTE)
+  get_filename_component(PROTO_WE ${grpc_library_PROTO} NAME_WE)
+  get_filename_component(PROTO_PATH ${ABS_PROTO} PATH)
+
+  # FIXME(putcn): the follwoing line is supposed to generate *.pb.h and cc, but
+  # somehow it didn't. line 602 to 604 is to patching this. Leaving this here
+  # for now to enable dist CI.
+  paddle_protobuf_generate_cpp(grpc_proto_srcs grpc_proto_hdrs "${ABS_PROTO}")
+  set(grpc_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.cc")
+  set(grpc_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.h")
+  cc_library("${TARGET_NAME}_proto" SRCS "${grpc_proto_srcs}")
+
+  add_custom_command(
+    OUTPUT "${grpc_grpc_srcs}" "${grpc_grpc_hdrs}"
+    COMMAND
+      ${PROTOBUF_PROTOC_EXECUTABLE} ARGS --grpc_out
+      "${CMAKE_CURRENT_BINARY_DIR}" -I "${PROTO_PATH}"
+      --plugin=protoc-gen-grpc="${GRPC_CPP_PLUGIN}" "${ABS_PROTO}"
+    COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} ARGS --cpp_out
+            "${CMAKE_CURRENT_BINARY_DIR}" -I "${PROTO_PATH}" "${ABS_PROTO}"
+    DEPENDS "${ABS_PROTO}" ${PROTOBUF_PROTOC_EXECUTABLE} extern_grpc)
+
+  # FIXME(typhoonzero): grpc generated code do not generate virtual-dtor, mark it
+  # as compiler warnings instead of error. Should try remove the warnings also.
+  set_source_files_properties(
+    ${grpc_grpc_srcs}
+    PROPERTIES
+      COMPILE_FLAGS
+      "-Wno-non-virtual-dtor -Wno-error=non-virtual-dtor -Wno-error=delete-non-virtual-dtor"
+  )
+  cc_library("${TARGET_NAME}_grpc" SRCS "${grpc_grpc_srcs}")
+
+  set_source_files_properties(
+    ${grpc_library_SRCS}
+    PROPERTIES
+      COMPILE_FLAGS
+      "-Wno-non-virtual-dtor -Wno-error=non-virtual-dtor -Wno-error=delete-non-virtual-dtor"
+  )
+  cc_library(
+    "${TARGET_NAME}"
+    SRCS "${grpc_library_SRCS}"
+    DEPS "${TARGET_NAME}_grpc" "${TARGET_NAME}_proto" "${grpc_library_DEPS}")
+endfunction()
+
+function(brpc_library TARGET_NAME)
+  set(oneValueArgs PROTO)
+  set(multiValueArgs SRCS DEPS)
+  set(options "")
+  cmake_parse_arguments(brpc_library "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  message(STATUS "generating brpc ${brpc_library_PROTO}")
+
+  get_filename_component(ABS_PROTO ${brpc_library_PROTO} ABSOLUTE)
+  get_filename_component(PROTO_WE ${brpc_library_PROTO} NAME_WE)
+  get_filename_component(PROTO_PATH ${ABS_PROTO} PATH)
+
+  paddle_protobuf_generate_cpp(brpc_proto_srcs brpc_proto_hdrs "${ABS_PROTO}")
+  cc_library("${TARGET_NAME}_proto" SRCS "${brpc_proto_srcs}")
+  cc_library(
+    "${TARGET_NAME}"
+    SRCS "${brpc_library_SRCS}"
+    DEPS "${TARGET_NAME}_proto" "${brpc_library_DEPS}")
+endfunction()
+
+# copy_if_different from src_file to dst_file At the beginning of the build.
+function(copy_if_different src_file dst_file)
+  get_filename_component(FILE_NAME ${dst_file} NAME_WE)
+
+  # this is a dummy target for custom command, should always be run firstly to update ${dst_file}
+  add_custom_target(
+    copy_${FILE_NAME}_command ALL
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src_file} ${dst_file}
+    COMMENT "copy_if_different ${dst_file}"
+    VERBATIM)
+
+  add_dependencies(extern_glog copy_${FILE_NAME}_command)
+endfunction()
+
+# create a dummy source file, then create a static library.
+# LIB_NAME should be the static lib name.
+# FILE_PATH should be the dummy source file path.
+# GENERATOR should be the file name invoke this function.
+# CONTENT should be some helpful info.
+# example: generate_dummy_static_lib(mylib FILE_PATH /path/to/dummy.c GENERATOR mylib.cmake CONTENT "helpful info")
+function(generate_dummy_static_lib)
+  set(options "")
+  set(oneValueArgs LIB_NAME FILE_PATH GENERATOR CONTENT)
+  set(multiValueArgs "")
+  cmake_parse_arguments(dummy "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+  if(NOT dummy_LIB_NAME)
+    message(FATAL_ERROR "You must provide a static lib name.")
+  endif()
+  if(NOT dummy_FILE_PATH)
+    set(dummy_FILE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${dummy_LIB_NAME}_dummy.c")
+  endif()
+  if(NOT dummy_GENERATOR)
+    message(FATAL_ERROR "You must provide a generator file name.")
+  endif()
+  if(NOT dummy_CONTENT)
+    set(dummy_CONTENT "${dummy_LIB_NAME}_dummy.c for lib ${dummy_LIB_NAME}")
+  endif()
+
+  configure_file(${PROJECT_SOURCE_DIR}/cmake/dummy.c.in ${dummy_FILE_PATH}
+                 @ONLY)
+  add_library(${dummy_LIB_NAME} STATIC ${dummy_FILE_PATH})
+endfunction()
+
+function(math_library TARGET)
+  # math_library is a function to create math library.
+  # The interface is the same as cc_library.
+  # But it handle split GPU/CPU code and link some common library.
+  set(cc_srcs)
+  set(cu_srcs)
+  set(hip_srcs)
+  set(math_common_deps device_context framework_proto enforce)
+  if(WITH_GPU)
+    if(${CMAKE_CUDA_COMPILER_VERSION} LESS 11.0)
+      list(APPEND math_common_deps cub)
+    else()
+      list(APPEND math_common_deps)
+    endif()
+  endif()
+  set(multiValueArgs DEPS)
+  cmake_parse_arguments(math_library "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET}.cc)
+    list(APPEND cc_srcs ${TARGET}.cc)
+  endif()
+  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET}.cu)
+    list(APPEND cu_srcs ${TARGET}.cu)
+  endif()
+  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET}.cu.cc)
+    list(APPEND cu_srcs ${TARGET}.cu.cc)
+  endif()
+
+  list(LENGTH cc_srcs cc_srcs_len)
+  if(WITH_GPU)
+    nv_library(
+      ${TARGET}
+      SRCS ${cc_srcs} ${cu_srcs}
+      DEPS ${math_library_DEPS} ${math_common_deps})
+  elseif(WITH_ROCM)
+    hip_library(
+      ${TARGET}
+      SRCS ${cc_srcs} ${cu_srcs}
+      DEPS ${math_library_DEPS} ${math_common_deps})
+  elseif(${cc_srcs_len} GREATER 0)
+    cc_library(
+      ${TARGET}
+      SRCS ${cc_srcs}
+      DEPS ${math_library_DEPS} ${math_common_deps})
+  endif()
+endfunction()

cmake/hip.cmake

+if(NOT WITH_ROCM)
+  return()
+endif()
+
+if(NOT DEFINED ENV{ROCM_PATH})
+  set(ROCM_PATH
+      "/opt/rocm"
+      CACHE PATH "Path to which ROCm has been installed")
+  set(HIP_PATH
+      ${ROCM_PATH}/hip
+      CACHE PATH "Path to which HIP has been installed")
+  set(HIP_CLANG_PATH
+      ${ROCM_PATH}/llvm/bin
+      CACHE PATH "Path to which clang has been installed")
+else()
+  set(ROCM_PATH
+      $ENV{ROCM_PATH}
+      CACHE PATH "Path to which ROCm has been installed")
+  set(HIP_PATH
+      ${ROCM_PATH}/hip
+      CACHE PATH "Path to which HIP has been installed")
+  set(HIP_CLANG_PATH
+      ${ROCM_PATH}/llvm/bin
+      CACHE PATH "Path to which clang has been installed")
+endif()
+set(CMAKE_MODULE_PATH "${HIP_PATH}/cmake" ${CMAKE_MODULE_PATH})
+
+find_package(HIP REQUIRED)
+include_directories(${ROCM_PATH}/include)
+message(STATUS "HIP version: ${HIP_VERSION}")
+message(STATUS "HIP_CLANG_PATH: ${HIP_CLANG_PATH}")
+
+macro(find_hip_version hip_header_file)
+  file(READ ${hip_header_file} HIP_VERSION_FILE_CONTENTS)
+
+  string(REGEX MATCH "define HIP_VERSION_MAJOR +([0-9]+)" HIP_MAJOR_VERSION
+               "${HIP_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define HIP_VERSION_MAJOR +([0-9]+)" "\\1"
+                       HIP_MAJOR_VERSION "${HIP_MAJOR_VERSION}")
+  string(REGEX MATCH "define HIP_VERSION_MINOR +([0-9]+)" HIP_MINOR_VERSION
+               "${HIP_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define HIP_VERSION_MINOR +([0-9]+)" "\\1"
+                       HIP_MINOR_VERSION "${HIP_MINOR_VERSION}")
+  string(REGEX MATCH "define HIP_VERSION_PATCH +([0-9]+)" HIP_PATCH_VERSION
+               "${HIP_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define HIP_VERSION_PATCH +([0-9]+)" "\\1"
+                       HIP_PATCH_VERSION "${HIP_PATCH_VERSION}")
+
+  if(NOT HIP_MAJOR_VERSION)
+    set(HIP_VERSION "???")
+    message(
+      WARNING "Cannot find HIP version in ${HIP_PATH}/include/hip/hip_version.h"
+    )
+  else()
+    math(
+      EXPR
+      HIP_VERSION
+      "${HIP_MAJOR_VERSION} * 10000000 + ${HIP_MINOR_VERSION} * 100000   + ${HIP_PATCH_VERSION}"
+    )
+    message(
+      STATUS
+        "Current HIP header is ${HIP_PATH}/include/hip/hip_version.h "
+        "Current HIP version is v${HIP_MAJOR_VERSION}.${HIP_MINOR_VERSION}.${HIP_PATCH_VERSION}. "
+    )
+  endif()
+endmacro()
+find_hip_version(${HIP_PATH}/include/hip/hip_version.h)
+
+macro(find_package_and_include PACKAGE_NAME)
+  find_package("${PACKAGE_NAME}" REQUIRED)
+  include_directories("${ROCM_PATH}/${PACKAGE_NAME}/include")
+  message(STATUS "${PACKAGE_NAME} version: ${${PACKAGE_NAME}_VERSION}")
+endmacro()
+
+find_package_and_include(miopen)
+find_package_and_include(rocblas)
+find_package_and_include(hiprand)
+find_package_and_include(rocrand)
+find_package_and_include(rccl)
+find_package_and_include(rocthrust)
+find_package_and_include(hipcub)
+find_package_and_include(rocprim)
+find_package_and_include(hipsparse)
+find_package_and_include(rocsparse)
+find_package_and_include(rocfft)
+
+# set CXX flags for HIP
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__HIP_PLATFORM_HCC__")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__HIP_PLATFORM_HCC__")
+set(CMAKE_CXX_FLAGS
+    "${CMAKE_CXX_FLAGS} -DTHRUST_DEVICE_SYSTEM=THRUST_DEVICE_SYSTEM_HIP")
+set(THRUST_DEVICE_SYSTEM THRUST_DEVICE_SYSTEM_HIP)
+
+# define HIP_CXX_FLAGS
+list(APPEND HIP_CXX_FLAGS -fPIC)
+list(APPEND HIP_CXX_FLAGS -D__HIP_PLATFORM_HCC__=1)
+# Note(qili93): HIP has compile conflicts of float16.h as platform::float16 overload std::is_floating_point and std::is_integer
+list(APPEND HIP_CXX_FLAGS -D__HIP_NO_HALF_CONVERSIONS__=1)
+list(APPEND HIP_CXX_FLAGS -Wno-macro-redefined)
+list(APPEND HIP_CXX_FLAGS -Wno-inconsistent-missing-override)
+list(APPEND HIP_CXX_FLAGS -Wno-exceptions)
+list(APPEND HIP_CXX_FLAGS -Wno-shift-count-negative)
+list(APPEND HIP_CXX_FLAGS -Wno-shift-count-overflow)
+list(APPEND HIP_CXX_FLAGS -Wno-unused-command-line-argument)
+list(APPEND HIP_CXX_FLAGS -Wno-duplicate-decl-specifier)
+list(APPEND HIP_CXX_FLAGS -Wno-implicit-int-float-conversion)
+list(APPEND HIP_CXX_FLAGS -Wno-pass-failed)
+list(APPEND HIP_CXX_FLAGS -DTHRUST_DEVICE_SYSTEM=THRUST_DEVICE_SYSTEM_HIP)
+list(APPEND HIP_CXX_FLAGS -std=c++14)
+
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+  list(APPEND HIP_CXX_FLAGS -g2)
+  list(APPEND HIP_CXX_FLAGS -O0)
+  list(APPEND HIP_HIPCC_FLAGS -fdebug-info-for-profiling)
+endif()
+
+set(HIP_HCC_FLAGS ${HIP_CXX_FLAGS})
+set(HIP_CLANG_FLAGS ${HIP_CXX_FLAGS})
+# Ask hcc to generate device code during compilation so we can use
+# host linker to link.
+list(APPEND HIP_HCC_FLAGS -fno-gpu-rdc)
+list(APPEND HIP_HCC_FLAGS --amdgpu-target=gfx906)
+list(APPEND HIP_HCC_FLAGS --amdgpu-target=gfx908)
+list(APPEND HIP_CLANG_FLAGS -fno-gpu-rdc)
+list(APPEND HIP_CLANG_FLAGS --amdgpu-target=gfx906)
+list(APPEND HIP_CLANG_FLAGS --amdgpu-target=gfx908)
+
+if(HIP_COMPILER STREQUAL clang)
+  set(hip_library_name amdhip64)
+else()
+  set(hip_library_name hip_hcc)
+endif()
+message(STATUS "HIP library name: ${hip_library_name}")
+
+# set HIP link libs
+find_library(ROCM_HIPRTC_LIB ${hip_library_name} HINTS ${HIP_PATH}/lib)
+message(STATUS "ROCM_HIPRTC_LIB: ${ROCM_HIPRTC_LIB}")
+
+include(thrust)

cmake/inference_lib.cmake

+# Copyright (c) 2018 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.
+
+# make package for paddle fluid shared and static library
+set(PADDLE_INSTALL_DIR
+    "${CMAKE_BINARY_DIR}/paddle_install_dir"
+    CACHE STRING "A path setting paddle shared and static libraries")
+
+set(PADDLE_INFERENCE_INSTALL_DIR
+    "${CMAKE_BINARY_DIR}/paddle_inference_install_dir"
+    CACHE STRING "A path setting paddle inference shared and static libraries")
+
+# At present, the size of static lib in Windows is very large,
+# so we need to crop the library size.
+if(WIN32)
+  #todo: remove the option
+  option(WITH_STATIC_LIB
+         "Compile demo with static/shared library, default use dynamic." OFF)
+  if(NOT PYTHON_EXECUTABLE)
+    find_package(PythonInterp REQUIRED)
+  endif()
+endif()
+
+set(COPY_SCRIPT_DIR ${PADDLE_SOURCE_DIR}/cmake)
+function(copy TARGET)
+  set(options "")
+  set(oneValueArgs "")
+  set(multiValueArgs SRCS DSTS)
+  cmake_parse_arguments(copy_lib "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  list(LENGTH copy_lib_SRCS copy_lib_SRCS_len)
+  list(LENGTH copy_lib_DSTS copy_lib_DSTS_len)
+  if(NOT ${copy_lib_SRCS_len} EQUAL ${copy_lib_DSTS_len})
+    message(
+      FATAL_ERROR
+        "${TARGET} source numbers are not equal to destination numbers")
+  endif()
+  math(EXPR len "${copy_lib_SRCS_len} - 1")
+  foreach(index RANGE ${len})
+    list(GET copy_lib_SRCS ${index} src)
+    list(GET copy_lib_DSTS ${index} dst)
+    if(WIN32) #windows
+      file(TO_NATIVE_PATH ${src} native_src)
+      file(TO_NATIVE_PATH ${dst} native_dst)
+      add_custom_command(
+        TARGET ${TARGET}
+        POST_BUILD
+        COMMAND ${PYTHON_EXECUTABLE} ${COPY_SCRIPT_DIR}/copyfile.py
+                ${native_src} ${native_dst})
+    else() #not windows
+      add_custom_command(
+        TARGET ${TARGET}
+        POST_BUILD
+        COMMAND mkdir -p "${dst}"
+        COMMAND cp -r "${src}" "${dst}"
+        COMMENT "copying ${src} -> ${dst}")
+    endif() # not windows
+  endforeach()
+endfunction()
+
+function(copy_part_of_thrid_party TARGET DST)
+  if(${CBLAS_PROVIDER} STREQUAL MKLML)
+    set(dst_dir "${DST}/third_party/install/mklml")
+    if(WIN32)
+      copy(
+        ${TARGET}
+        SRCS ${MKLML_LIB} ${MKLML_IOMP_LIB} ${MKLML_SHARED_LIB}
+             ${MKLML_SHARED_IOMP_LIB} ${MKLML_INC_DIR}
+        DSTS ${dst_dir}/lib ${dst_dir}/lib ${dst_dir}/lib ${dst_dir}/lib
+             ${dst_dir})
+    else()
+      copy(
+        ${TARGET}
+        SRCS ${MKLML_LIB} ${MKLML_IOMP_LIB} ${MKLML_INC_DIR}
+        DSTS ${dst_dir}/lib ${dst_dir}/lib ${dst_dir})
+      if(WITH_STRIP)
+        add_custom_command(
+          TARGET ${TARGET}
+          POST_BUILD
+          COMMAND strip -s ${dst_dir}/lib/libiomp5.so
+          COMMAND strip -s ${dst_dir}/lib/libmklml_intel.so
+          COMMENT "striping libiomp5.so\nstriping libmklml_intel.so")
+      endif()
+    endif()
+  elseif(${CBLAS_PROVIDER} STREQUAL EXTERN_OPENBLAS)
+    set(dst_dir "${DST}/third_party/install/openblas")
+    if(WIN32)
+      copy(
+        ${TARGET}
+        SRCS ${CBLAS_INSTALL_DIR}/lib ${OPENBLAS_SHARED_LIB}
+             ${CBLAS_INSTALL_DIR}/include
+        DSTS ${dst_dir} ${dst_dir}/lib ${dst_dir})
+    else()
+      copy(
+        ${TARGET}
+        SRCS ${CBLAS_INSTALL_DIR}/lib ${CBLAS_INSTALL_DIR}/include
+        DSTS ${dst_dir} ${dst_dir})
+    endif()
+
+    if(WITH_SPARSELT)
+      set(dst_dir "${DST}/third_party/install/cusparselt")
+      copy(
+        ${TARGET}
+        SRCS ${CUSPARSELT_INC_DIR} ${CUSPARSELT_LIB_DIR}
+        DSTS ${dst_dir} ${dst_dir})
+    endif()
+  endif()
+
+  if(WITH_MKLDNN)
+    set(dst_dir "${DST}/third_party/install/mkldnn")
+    if(WIN32)
+      copy(
+        ${TARGET}
+        SRCS ${MKLDNN_INC_DIR} ${MKLDNN_SHARED_LIB} ${MKLDNN_LIB}
+        DSTS ${dst_dir} ${dst_dir}/lib ${dst_dir}/lib)
+    else()
+      copy(
+        ${TARGET}
+        SRCS ${MKLDNN_INC_DIR} ${MKLDNN_SHARED_LIB}
+        DSTS ${dst_dir} ${dst_dir}/lib)
+      if(WITH_STRIP)
+        add_custom_command(
+          TARGET ${TARGET}
+          POST_BUILD
+          COMMAND strip -s ${dst_dir}/lib/libmkldnn.so.0
+          COMMENT "striping libmkldnn.so.0")
+      endif()
+      add_custom_command(
+        TARGET ${TARGET}
+        POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E create_symlink libmkldnn.so.0
+                ${dst_dir}/lib/libdnnl.so.1
+        COMMAND ${CMAKE_COMMAND} -E create_symlink libmkldnn.so.0
+                ${dst_dir}/lib/libdnnl.so.2
+        COMMENT "Make a symbol link of libmkldnn.so.0")
+    endif()
+  endif()
+
+  if(WITH_ONNXRUNTIME)
+    set(dst_dir "${DST}/third_party/install/onnxruntime")
+    copy(
+      ${TARGET}
+      SRCS ${ONNXRUNTIME_INC_DIR} ${ONNXRUNTIME_LIB_DIR}
+      DSTS ${dst_dir} ${dst_dir})
+
+    set(dst_dir "${DST}/third_party/install/paddle2onnx")
+    copy(
+      ${TARGET}
+      SRCS ${PADDLE2ONNX_INC_DIR}/paddle2onnx ${PADDLE2ONNX_LIB_DIR}
+      DSTS ${dst_dir}/include ${dst_dir})
+  endif()
+
+  set(dst_dir "${DST}/third_party/install/gflags")
+  copy(
+    ${TARGET}
+    SRCS ${GFLAGS_INCLUDE_DIR} ${GFLAGS_LIBRARIES}
+    DSTS ${dst_dir} ${dst_dir}/lib)
+
+  set(dst_dir "${DST}/third_party/install/glog")
+  copy(
+    ${TARGET}
+    SRCS ${GLOG_INCLUDE_DIR} ${GLOG_LIBRARIES}
+    DSTS ${dst_dir} ${dst_dir}/lib)
+
+  set(dst_dir "${DST}/third_party/install/utf8proc")
+  copy(
+    ${TARGET}
+    SRCS ${UTF8PROC_INSTALL_DIR}/include ${UTF8PROC_LIBRARIES}
+    DSTS ${dst_dir} ${dst_dir}/lib)
+
+  if(WITH_CRYPTO)
+    set(dst_dir "${DST}/third_party/install/cryptopp")
+    copy(
+      ${TARGET}
+      SRCS ${CRYPTOPP_INCLUDE_DIR} ${CRYPTOPP_LIBRARIES}
+      DSTS ${dst_dir} ${dst_dir}/lib)
+  endif()
+
+  set(dst_dir "${DST}/third_party/install/xxhash")
+  copy(
+    ${TARGET}
+    SRCS ${XXHASH_INCLUDE_DIR} ${XXHASH_LIBRARIES}
+    DSTS ${dst_dir} ${dst_dir}/lib)
+
+  if(NOT PROTOBUF_FOUND OR WIN32)
+    set(dst_dir "${DST}/third_party/install/protobuf")
+    copy(
+      ${TARGET}
+      SRCS ${PROTOBUF_INCLUDE_DIR} ${PROTOBUF_LIBRARY}
+      DSTS ${dst_dir} ${dst_dir}/lib)
+  endif()
+
+  if(LITE_BINARY_DIR)
+    set(dst_dir "${DST}/third_party/install/lite")
+    copy(
+      ${TARGET}
+      SRCS ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/*
+      DSTS ${dst_dir})
+  endif()
+endfunction()
+
+# inference library for only inference
+set(inference_lib_deps third_party paddle_inference paddle_inference_c
+                       paddle_inference_shared paddle_inference_c_shared)
+add_custom_target(inference_lib_dist DEPENDS ${inference_lib_deps})
+
+set(dst_dir "${PADDLE_INFERENCE_INSTALL_DIR}/third_party/threadpool")
+copy(
+  inference_lib_dist
+  SRCS ${THREADPOOL_INCLUDE_DIR}/ThreadPool.h
+  DSTS ${dst_dir})
+
+# GPU must copy externalErrorMsg.pb
+if(WITH_GPU)
+  set(dst_dir "${PADDLE_INFERENCE_INSTALL_DIR}/third_party/externalError/data")
+  copy(
+    inference_lib_dist
+    SRCS ${externalError_INCLUDE_DIR}
+    DSTS ${dst_dir})
+endif()
+
+if(WITH_XPU)
+  set(dst_dir "${PADDLE_INFERENCE_INSTALL_DIR}/third_party/install/xpu")
+  copy(
+    inference_lib_dist
+    SRCS ${XPU_INC_DIR} ${XPU_LIB_DIR}
+    DSTS ${dst_dir} ${dst_dir})
+endif()
+
+# CMakeCache Info
+copy(
+  inference_lib_dist
+  SRCS ${CMAKE_CURRENT_BINARY_DIR}/CMakeCache.txt
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR})
+
+copy_part_of_thrid_party(inference_lib_dist ${PADDLE_INFERENCE_INSTALL_DIR})
+
+set(src_dir "${PADDLE_SOURCE_DIR}/paddle/fluid")
+
+if(WIN32)
+  if(WITH_STATIC_LIB)
+    set(paddle_inference_lib
+        $<TARGET_FILE_DIR:paddle_inference>/libpaddle_inference.lib
+        $<TARGET_FILE_DIR:paddle_inference>/paddle_inference.*)
+  else()
+    set(paddle_inference_lib
+        $<TARGET_FILE_DIR:paddle_inference_shared>/paddle_inference.dll
+        $<TARGET_FILE_DIR:paddle_inference_shared>/paddle_inference.lib)
+  endif()
+  copy(
+    inference_lib_dist
+    SRCS ${src_dir}/inference/api/paddle_*.h ${paddle_inference_lib}
+    DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include
+         ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/lib
+         ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/lib)
+else()
+  set(paddle_inference_lib
+      ${PADDLE_BINARY_DIR}/paddle/fluid/inference/libpaddle_inference.*)
+  copy(
+    inference_lib_dist
+    SRCS ${src_dir}/inference/api/paddle_*.h ${paddle_inference_lib}
+    DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include
+         ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/lib)
+endif()
+
+copy(
+  inference_lib_dist
+  SRCS ${CMAKE_BINARY_DIR}/paddle/fluid/framework/framework.pb.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/internal)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/fluid/framework/io/crypto/cipher.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/crypto/)
+include_directories(${CMAKE_BINARY_DIR}/../paddle/fluid/framework/io)
+
+# copy api headers for phi & custom op
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/phi/api/ext/*.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/phi/api/ext/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/phi/api/include/*.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/phi/api/include/
+)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/phi/api/all.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/phi/api/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/phi/common/*.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/phi/common/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/phi/core/macros.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/phi/core/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/phi/core/visit_type.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/phi/core/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/utils/any.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/utils/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/utils/optional.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/utils/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/utils/none.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/utils/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/utils/flat_hash_map.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/utils/)
+copy(
+  inference_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/extension.h
+  DSTS ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/)
+
+# the header file of phi is copied to the experimental directory,
+# the include path of phi needs to be changed to adapt to inference api path
+add_custom_command(
+  TARGET inference_lib_dist
+  POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -P "${PADDLE_SOURCE_DIR}/cmake/phi_header.cmake"
+  COMMENT "Change phi header include path to adapt to inference api path")
+
+# CAPI inference library for only inference
+set(PADDLE_INFERENCE_C_INSTALL_DIR
+    "${CMAKE_BINARY_DIR}/paddle_inference_c_install_dir"
+    CACHE STRING "A path setting CAPI paddle inference shared")
+copy_part_of_thrid_party(inference_lib_dist ${PADDLE_INFERENCE_C_INSTALL_DIR})
+
+set(src_dir "${PADDLE_SOURCE_DIR}/paddle/fluid")
+if(WIN32)
+  set(paddle_inference_c_lib
+      $<TARGET_FILE_DIR:paddle_inference_c>/paddle_inference_c.*)
+else()
+  set(paddle_inference_c_lib
+      ${PADDLE_BINARY_DIR}/paddle/fluid/inference/capi_exp/libpaddle_inference_c.*
+  )
+endif()
+
+copy(
+  inference_lib_dist
+  SRCS ${src_dir}/inference/capi_exp/pd_*.h ${paddle_inference_c_lib}
+  DSTS ${PADDLE_INFERENCE_C_INSTALL_DIR}/paddle/include
+       ${PADDLE_INFERENCE_C_INSTALL_DIR}/paddle/lib)
+
+if(WITH_STRIP AND NOT WIN32)
+  add_custom_command(
+    TARGET inference_lib_dist
+    POST_BUILD
+    COMMAND
+      strip -s
+      ${PADDLE_INFERENCE_C_INSTALL_DIR}/paddle/lib/libpaddle_inference_c.so
+    COMMAND strip -s
+            ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/lib/libpaddle_inference.so
+    COMMENT "striping libpaddle_inference_c.so\nstriping libpaddle_inference.so"
+  )
+endif()
+
+# fluid library for both train and inference
+set(fluid_lib_deps inference_lib_dist)
+add_custom_target(fluid_lib_dist ALL DEPENDS ${fluid_lib_deps})
+
+set(dst_dir "${PADDLE_INSTALL_DIR}/paddle/fluid")
+set(module "inference")
+if(WIN32)
+  copy(
+    fluid_lib_dist
+    SRCS ${src_dir}/${module}/*.h ${src_dir}/${module}/api/paddle_*.h
+         ${paddle_inference_lib}
+    DSTS ${dst_dir}/${module} ${dst_dir}/${module} ${dst_dir}/${module}
+         ${dst_dir}/${module})
+else()
+  copy(
+    fluid_lib_dist
+    SRCS ${src_dir}/${module}/*.h ${src_dir}/${module}/api/paddle_*.h
+         ${paddle_inference_lib}
+    DSTS ${dst_dir}/${module} ${dst_dir}/${module} ${dst_dir}/${module})
+endif()
+
+set(module "framework")
+set(framework_lib_deps framework_proto data_feed_proto trainer_desc_proto)
+add_dependencies(fluid_lib_dist ${framework_lib_deps})
+copy(
+  fluid_lib_dist
+  SRCS ${src_dir}/${module}/*.h
+       ${src_dir}/${module}/details/*.h
+       ${PADDLE_BINARY_DIR}/paddle/fluid/framework/trainer_desc.pb.h
+       ${PADDLE_BINARY_DIR}/paddle/fluid/framework/framework.pb.h
+       ${PADDLE_BINARY_DIR}/paddle/fluid/framework/data_feed.pb.h
+       ${src_dir}/${module}/ir/memory_optimize_pass/*.h
+       ${src_dir}/${module}/ir/*.h
+       ${src_dir}/${module}/fleet/*.h
+  DSTS ${dst_dir}/${module}
+       ${dst_dir}/${module}/details
+       ${dst_dir}/${module}
+       ${dst_dir}/${module}
+       ${dst_dir}/${module}
+       ${dst_dir}/${module}/ir/memory_optimize_pass
+       ${dst_dir}/${module}/ir
+       ${dst_dir}/${module}/fleet)
+
+set(module "operators")
+copy(
+  fluid_lib_dist
+  SRCS ${src_dir}/${module}/reader/blocking_queue.h
+  DSTS ${dst_dir}/${module}/reader/)
+
+set(module "memory")
+copy(
+  fluid_lib_dist
+  SRCS ${src_dir}/${module}/allocation/*.h
+  DSTS ${dst_dir}/${module}/allocation)
+
+set(module "platform")
+set(platform_lib_deps profiler_proto errors)
+if(WITH_GPU)
+  set(platform_lib_deps ${platform_lib_deps} external_error_proto)
+endif()
+
+add_dependencies(fluid_lib_dist ${platform_lib_deps})
+copy(
+  fluid_lib_dist
+  SRCS ${src_dir}/${module}/*.h ${src_dir}/${module}/dynload/*.h
+       ${src_dir}/${module}/details/*.h
+       ${PADDLE_BINARY_DIR}/paddle/fluid/platform/*.pb.h
+  DSTS ${dst_dir}/${module} ${dst_dir}/${module}/dynload
+       ${dst_dir}/${module}/details ${dst_dir}/${module})
+
+set(module "string")
+copy(
+  fluid_lib_dist
+  SRCS ${PADDLE_SOURCE_DIR}/paddle/utils/${module}/*.h
+       ${PADDLE_SOURCE_DIR}/paddle/utils/${module}/tinyformat/*.h
+  DSTS ${dst_dir}/${module} ${dst_dir}/${module}/tinyformat)
+
+set(module "imperative")
+copy(
+  fluid_lib_dist
+  SRCS ${src_dir}/${module}/*.h ${src_dir}/${module}/jit/*.h
+  DSTS ${dst_dir}/${module} ${dst_dir}/${module}/jit)
+
+set(module "pybind")
+copy(
+  fluid_lib_dist
+  SRCS ${CMAKE_CURRENT_BINARY_DIR}/paddle/fluid/${module}/pybind.h
+  DSTS ${dst_dir}/${module})
+
+set(dst_dir "${PADDLE_INSTALL_DIR}/third_party/eigen3")
+copy(
+  inference_lib_dist
+  SRCS ${EIGEN_INCLUDE_DIR}/Eigen/Core ${EIGEN_INCLUDE_DIR}/Eigen/src
+       ${EIGEN_INCLUDE_DIR}/unsupported/Eigen
+  DSTS ${dst_dir}/Eigen ${dst_dir}/Eigen ${dst_dir}/unsupported)
+
+set(dst_dir "${PADDLE_INSTALL_DIR}/third_party/dlpack")
+copy(
+  inference_lib_dist
+  SRCS ${DLPACK_INCLUDE_DIR}/dlpack
+  DSTS ${dst_dir})
+
+set(dst_dir "${PADDLE_INSTALL_DIR}/third_party/install/zlib")
+copy(
+  inference_lib_dist
+  SRCS ${ZLIB_INCLUDE_DIR} ${ZLIB_LIBRARIES}
+  DSTS ${dst_dir} ${dst_dir}/lib)
+
+# CMakeCache Info
+copy(
+  fluid_lib_dist
+  SRCS ${PADDLE_INFERENCE_INSTALL_DIR}/third_party
+       ${CMAKE_CURRENT_BINARY_DIR}/CMakeCache.txt
+  DSTS ${PADDLE_INSTALL_DIR} ${PADDLE_INSTALL_DIR})
+
+# paddle fluid version
+function(version version_file)
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} log --pretty=format:%H -1
+    WORKING_DIRECTORY ${PADDLE_SOURCE_DIR}
+    OUTPUT_VARIABLE PADDLE_GIT_COMMIT)
+  file(
+    WRITE ${version_file}
+    "GIT COMMIT ID: ${PADDLE_GIT_COMMIT}\n"
+    "WITH_MKL: ${WITH_MKL}\n"
+    "WITH_MKLDNN: ${WITH_MKLDNN}\n"
+    "WITH_GPU: ${WITH_GPU}\n"
+    "WITH_ROCM: ${WITH_ROCM}\n"
+    "WITH_ASCEND_CL: ${WITH_ASCEND_CL}\n"
+    "WITH_ASCEND_CXX11: ${WITH_ASCEND_CXX11}\n"
+    "WITH_IPU: ${WITH_IPU}\n")
+  if(WITH_GPU)
+    file(APPEND ${version_file}
+         "CUDA version: ${CUDA_VERSION}\n"
+         "CUDNN version: v${CUDNN_MAJOR_VERSION}.${CUDNN_MINOR_VERSION}\n")
+  endif()
+  if(WITH_ROCM)
+    file(APPEND ${version_file}
+         "HIP version: v${HIP_MAJOR_VERSION}.${HIP_MINOR_VERSION}\n"
+         "MIOpen version: v${MIOPEN_MAJOR_VERSION}.${MIOPEN_MINOR_VERSION}\n")
+  endif()
+  if(WITH_ASCEND_CL)
+    file(APPEND ${version_file}
+         "Ascend Toolkit version: ${ASCEND_TOOLKIT_VERSION}\n"
+         "Ascend Driver version: ${ASCEND_DRIVER_VERSION}\n")
+  endif()
+  if(WITH_IPU)
+    file(APPEND ${version_file} "PopART version: ${POPART_VERSION}\n")
+  endif()
+  file(APPEND ${version_file}
+       "CXX compiler version: ${CMAKE_CXX_COMPILER_VERSION}\n")
+  if(TENSORRT_FOUND)
+    file(
+      APPEND ${version_file}
+      "WITH_TENSORRT: ${TENSORRT_FOUND}\n"
+      "TensorRT version: v${TENSORRT_MAJOR_VERSION}.${TENSORRT_MINOR_VERSION}.${TENSORRT_PATCH_VERSION}.${TENSORRT_BUILD_VERSION}\n"
+    )
+  endif()
+  if(WITH_LITE)
+    file(APPEND ${version_file} "WITH_LITE: ${WITH_LITE}\n"
+                                "LITE_GIT_TAG: ${LITE_GIT_TAG}\n")
+  endif()
+
+endfunction()
+version(${PADDLE_INSTALL_DIR}/version.txt)
+version(${PADDLE_INFERENCE_INSTALL_DIR}/version.txt)
+version(${PADDLE_INFERENCE_C_INSTALL_DIR}/version.txt)

cmake/infrt_lib.cmake

+# Copyright (c) 2021 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.
+
+set(INFRT_INSTALL_DIR
+    "${CMAKE_BINARY_DIR}/paddle_infrt_install_dir"
+    CACHE STRING "A path setting paddle infrt shared and static libraries")
+
+function(copy TARGET)
+  set(options "")
+  set(oneValueArgs "")
+  set(multiValueArgs SRCS DSTS)
+  cmake_parse_arguments(copy_lib "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  list(LENGTH copy_lib_SRCS copy_lib_SRCS_len)
+  list(LENGTH copy_lib_DSTS copy_lib_DSTS_len)
+  if(NOT ${copy_lib_SRCS_len} EQUAL ${copy_lib_DSTS_len})
+    message(
+      FATAL_ERROR
+        "${TARGET} source numbers are not equal to destination numbers")
+  endif()
+  math(EXPR len "${copy_lib_SRCS_len} - 1")
+  foreach(index RANGE ${len})
+    list(GET copy_lib_SRCS ${index} src)
+    list(GET copy_lib_DSTS ${index} dst)
+    add_custom_command(
+      TARGET ${TARGET}
+      POST_BUILD
+      COMMAND mkdir -p "${dst}"
+      COMMAND cp -r "${src}" "${dst}"
+      COMMENT "copying ${src} -> ${dst}")
+  endforeach()
+endfunction()
+
+function(copy_part_of_thrid_party TARGET DST)
+  set(dst_dir "${DST}/third_party/install/glog")
+  copy(
+    ${TARGET}
+    SRCS ${GLOG_INCLUDE_DIR} ${GLOG_LIBRARIES}
+    DSTS ${dst_dir} ${dst_dir}/lib)
+endfunction()
+
+# inference library for only inference
+set(infrt_lib_deps third_party infrt infrt_static)
+add_custom_target(infrt_lib_dist DEPENDS ${infrt_lib_deps})
+
+# CMakeCache Info
+copy(
+  infrt_lib_dist
+  SRCS ${CMAKE_BINARY_DIR}/CMakeCache.txt
+  DSTS ${INFRT_INSTALL_DIR})
+
+set(infrt_lib ${INFRT_BINARY_DIR}/libinfrt.*)
+copy(
+  infrt_lib_dist
+  SRCS ${INFRT_SOURCE_DIR}/api/infrt_api.h ${infrt_lib}
+  DSTS ${INFRT_INSTALL_DIR}/infrt/include ${INFRT_INSTALL_DIR}/infrt/lib)
+
+copy(
+  infrt_lib_dist
+  SRCS ${INFRT_BINARY_DIR}/paddle/framework.pb.h
+  DSTS ${INFRT_INSTALL_DIR}/infrt/include/internal)
+
+# paddle fluid version
+function(version version_file)
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} log --pretty=format:%H -1
+    WORKING_DIRECTORY ${PADDLE_SOURCE_DIR}
+    OUTPUT_VARIABLE PADDLE_GIT_COMMIT)
+  file(WRITE ${version_file} "GIT COMMIT ID: ${PADDLE_GIT_COMMIT}\n")
+  file(APPEND ${version_file}
+       "CXX compiler version: ${CMAKE_CXX_COMPILER_VERSION}\n")
+endfunction()
+version(${INFRT_INSTALL_DIR}/version.txt)

cmake/init.cmake

+# Attention: cmake will append these flags to compile command automatically.
+# So if you want to add global option, change this file rather than flags.cmake
+
+# Linux
+# DEBUG:  default: "-g"
+# RELEASE:  default: "-O3 -DNDEBUG"
+# RELWITHDEBINFO: default: "-O2 -g -DNDEBUG"
+# MINSIZEREL: default: "-O2 -g -DNDEBUG"
+
+if(NOT WIN32)
+  set(CMAKE_C_FLAGS_DEBUG "-g")
+  set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG")
+  set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG")
+  set(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG")
+
+  set(CMAKE_CXX_FLAGS_DEBUG "-g")
+  set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG")
+  set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
+
+  if(WITH_GPU)
+    set(CMAKE_CUDA_FLAGS_DEBUG "-g")
+    set(CMAKE_CUDA_FLAGS_RELEASE "-O3 -DNDEBUG")
+    set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG")
+    set(CMAKE_CUDA_FLAGS_MINSIZEREL "-O1 -DNDEBUG")
+  endif()
+else()
+  set(CMAKE_C_FLAGS_DEBUG "/MDd /Zi /Ob0 /Od /RTC1")
+  set(CMAKE_C_FLAGS_RELEASE "/MD /O2 /Ob2 /DNDEBUG")
+  set(CMAKE_C_FLAGS_RELWITHDEBINFO "/MD /Zi /O2 /Ob1 /DNDEBUG")
+  set(CMAKE_C_FLAGS_MINSIZEREL "/MD /O1 /Ob1 /DNDEBUG")
+
+  set(CMAKE_CXX_FLAGS_DEBUG "/MDd /Zi /Ob0 /Od /RTC1")
+  set(CMAKE_CXX_FLAGS_RELEASE "/MD /O2 /Ob2 /DNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/MD /Zi /O2 /Ob1 /DNDEBUG")
+  set(CMAKE_CXX_FLAGS_MINSIZEREL "/MD /O1 /Ob1 /DNDEBUG")
+
+  if(WITH_GPU)
+    set(CMAKE_CUDA_FLAGS_DEBUG "-Xcompiler=\"-MDd -Zi -Ob0 -Od /RTC1\"")
+    set(CMAKE_CUDA_FLAGS_RELEASE "-Xcompiler=\"-MD -O2 -Ob2\" -DNDEBUG")
+    set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO
+        "-Xcompiler=\"-MD -Zi -O2 -Ob1\" -DNDEBUG")
+    set(CMAKE_CUDA_FLAGS_MINSIZEREL "-Xcompiler=\"-MD -O1 -Ob1\" -DNDEBUG")
+  endif()
+
+  # It can specify CUDA compile flag manualy,
+  # its use is to remvoe /Zi to reduce GPU static library size. But it's dangerous
+  # because CUDA will update by nvidia, then error will occur.
+  # Now, it's only used in VS2015 + CUDA:[10.0, 10.2]
+  set(WIN_PROPS ${CMAKE_SOURCE_DIR}/cmake/paddle_win.props)
+endif()

cmake/make_resource.py

+#   Copyright (c) 2018 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.
+
+import os
+import re
+import sys
+
+res = sys.argv[1]
+out = sys.argv[2]
+var = re.sub(r'[ .-]', '_', os.path.basename(res))
+
+open(out, "w").write("const unsigned char " + var + "[] = {" +
+                     ",".join(["0x%02x" % ord(c)
+                               for c in open(res).read()]) + ",0};\n" +
+                     "const unsigned " + var + "_size = sizeof(" + var + ");\n")

cmake/miopen.cmake

+if(NOT WITH_ROCM)
+  return()
+endif()
+
+# Now we don't support ROCm on windows
+if(WIN32)
+  return()
+endif()
+
+set(MIOPEN_ROOT
+    ${ROCM_PATH}/miopen
+    CACHE PATH "MIOPEN ROOT")
+
+find_path(
+  MIOPEN_INCLUDE_DIR "miopen/miopen.h"
+  PATHS ${MIOPEN_ROOT} ${MIOPEN_ROOT}/include ${MIOPEN_ROOT}/local/include
+        $ENV{MIOPEN_ROOT} $ENV{MIOPEN_ROOT}/include
+        $ENV{MIOPEN_ROOT}/local/include
+  NO_DEFAULT_PATH)
+
+find_library(
+  MIOPEN_LIBRARY
+  NAMES "libMIOpen.so"
+  PATHS ${MIOPEN_ROOT}
+        ${MIOPEN_ROOT}/lib
+        ${MIOPEN_ROOT}/lib64
+        ${__libpath_hist}
+        $ENV{MIOPEN_ROOT}
+        $ENV{MIOPEN_ROOT}/lib
+        $ENV{MIOPEN_ROOT}/lib64
+  NO_DEFAULT_PATH
+  DOC "Path to MIOpen library.")
+
+if(MIOPEN_INCLUDE_DIR AND MIOPEN_LIBRARY)
+  set(MIOPEN_FOUND ON)
+else()
+  set(MIOPEN_FOUND OFF)
+endif()
+
+macro(find_miopen_version miopen_header_file)
+  file(READ ${miopen_header_file} MIOPEN_VERSION_FILE_CONTENTS)
+  get_filename_component(MIOPEN_LIB_PATH ${MIOPEN_LIBRARY} DIRECTORY)
+
+  string(REGEX MATCH "define MIOPEN_VERSION_MAJOR +([0-9]+)"
+               MIOPEN_MAJOR_VERSION "${MIOPEN_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define MIOPEN_VERSION_MAJOR +([0-9]+)" "\\1"
+                       MIOPEN_MAJOR_VERSION "${MIOPEN_MAJOR_VERSION}")
+  string(REGEX MATCH "define MIOPEN_VERSION_MINOR +([0-9]+)"
+               MIOPEN_MINOR_VERSION "${MIOPEN_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define MIOPEN_VERSION_MINOR +([0-9]+)" "\\1"
+                       MIOPEN_MINOR_VERSION "${MIOPEN_MINOR_VERSION}")
+  string(REGEX MATCH "define MIOPEN_VERSION_PATCH +([0-9]+)"
+               MIOPEN_PATCH_VERSION "${MIOPEN_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define MIOPEN_VERSION_PATCH +([0-9]+)" "\\1"
+                       MIOPEN_PATCH_VERSION "${MIOPEN_PATCH_VERSION}")
+  string(REGEX MATCH "define MIOPEN_VERSION_TWEAK +([0-9]+)"
+               MIOPEN_TWEAK_VERSION "${MIOPEN_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define MIOPEN_VERSION_TWEAK +([0-9]+)" "\\1"
+                       MIOPEN_TWEAK_VERSION "${MIOPEN_TWEAK_VERSION}")
+
+  if(NOT MIOPEN_MAJOR_VERSION)
+    set(MIOPEN_VERSION "???")
+  else()
+    add_definitions("-DMIOPEN_MAJOR_VERSION=\"${MIOPEN_MAJOR_VERSION}\"")
+    math(EXPR MIOPEN_VERSION "${MIOPEN_MAJOR_VERSION} * 1000 +
+             ${MIOPEN_MINOR_VERSION} * 10 + ${MIOPEN_PATCH_VERSION}")
+    message(
+      STATUS "Current MIOpen header is ${MIOPEN_INCLUDE_DIR}/miopen/miopen.h "
+             "Current MIOpen version is v${MIOPEN_MAJOR_VERSION}.\
+        ${MIOPEN_MINOR_VERSION}.${MIOPEN_PATCH_VERSION}. ")
+  endif()
+endmacro()
+
+if(MIOPEN_FOUND)
+  find_miopen_version(${MIOPEN_INCLUDE_DIR}/miopen/version.h)
+endif()

cmake/mpi.cmake

+if(NOT WITH_DISTRIBUTE OR NOT WITH_MPI)
+  return()
+endif()
+
+find_package(MPI)
+
+if(NOT MPI_CXX_FOUND)
+  set(WITH_MPI
+      OFF
+      CACHE STRING "Disable MPI" FORCE)
+  message(WARNING "Not found MPI support in current system")
+  return()
+endif()
+
+message(STATUS "MPI compile flags: " ${MPI_CXX_COMPILE_FLAGS})
+message(STATUS "MPI include path: " ${MPI_CXX_INCLUDE_PATH})
+message(STATUS "MPI LINK flags path: " ${MPI_CXX_LINK_FLAGS})
+message(STATUS "MPI libraries: " ${MPI_CXX_LIBRARIES})
+include_directories(SYSTEM ${MPI_CXX_INCLUDE_PATH})
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MPI_CXX_LINK_FLAGS}")
+add_definitions("-DPADDLE_WITH_MPI")
+find_program(
+  OMPI_INFO
+  NAMES ompi_info
+  HINTS ${MPI_CXX_LIBRARIES}/../bin)
+
+if(OMPI_INFO)
+  execute_process(COMMAND ${OMPI_INFO} OUTPUT_VARIABLE output_)
+  if(output_ MATCHES "smcuda")
+    #NOTE some mpi lib support mpi cuda aware.
+    add_definitions("-DPADDLE_WITH_MPI_AWARE")
+  endif()
+endif()

cmake/nccl.cmake

+if(NOT WITH_GPU)
+  return()
+endif()
+
+# Now we don't support NCCL on windows
+if(WIN32)
+  return()
+endif()
+
+if(WITH_NCCL)
+  set(NCCL_ROOT
+      "/usr"
+      CACHE PATH "NCCL ROOT")
+  find_path(
+    NCCL_INCLUDE_DIR nccl.h
+    PATHS ${NCCL_ROOT} ${NCCL_ROOT}/include ${NCCL_ROOT}/local/include
+          $ENV{NCCL_ROOT} $ENV{NCCL_ROOT}/include $ENV{NCCL_ROOT}/local/include
+    NO_DEFAULT_PATH)
+
+  file(READ ${NCCL_INCLUDE_DIR}/nccl.h NCCL_VERSION_FILE_CONTENTS)
+
+  string(REGEX MATCH "define NCCL_VERSION_CODE +([0-9]+)" NCCL_VERSION
+               "${NCCL_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define NCCL_VERSION_CODE +([0-9]+)" "\\1" NCCL_VERSION
+                       "${NCCL_VERSION}")
+
+  if("${NCCL_VERSION}" GREATER "2000")
+    message(STATUS "Current NCCL header is ${NCCL_INCLUDE_DIR}/nccl.h. "
+                   "Current NCCL version is v${NCCL_VERSION}. ")
+  else()
+    # in old version nccl, it may not define NCCL_VERSION_CODE
+    string(REGEX MATCH "define NCCL_MAJOR +([0-9]+)" NCCL_MAJOR_VERSION
+                 "${NCCL_VERSION_FILE_CONTENTS}")
+    string(REGEX REPLACE "define NCCL_MAJOR +([0-9]+)" "\\1" NCCL_MAJOR_VERSION
+                         "${NCCL_MAJOR_VERSION}")
+    string(REGEX MATCH "define NCCL_MINOR +([0-9]+)" NCCL_MINOR_VERSION
+                 "${NCCL_VERSION_FILE_CONTENTS}")
+    string(REGEX REPLACE "define NCCL_MINOR +([0-9]+)" "\\1" NCCL_MINOR_VERSION
+                         "${NCCL_MINOR_VERSION}")
+    string(REGEX MATCH "define NCCL_PATCH +([0-9]+)" NCCL_PATCH_VERSION
+                 "${NCCL_VERSION_FILE_CONTENTS}")
+    string(REGEX REPLACE "define NCCL_PATCH +([0-9]+)" "\\1" NCCL_PATCH_VERSION
+                         "${NCCL_PATCH_VERSION}")
+
+    if(NOT NCCL_MAJOR_VERSION)
+      set(NCCL_VERSION "0")
+    else()
+      math(EXPR NCCL_VERSION "${NCCL_MAJOR_VERSION} * 1000 +
+                 ${NCCL_MINOR_VERSION} * 100 + ${NCCL_PATCH_VERSION}")
+    endif()
+    add_definitions("-DNCCL_VERSION_CODE=$NCCL_VERSION")
+
+    message(STATUS "Current NCCL header is ${NCCL_INCLUDE_DIR}/nccl.h. "
+                   "Current NCCL version is \
+        v${NCCL_MAJOR_VERSION}.${NCCL_MINOR_VERSION}.${NCCL_PATCH_VERSION} ")
+  endif()
+endif()