2.3.2-dtk-22.10.1

cmake/cuda.cmake

+if(NOT WITH_GPU)
+  return()
+endif()
+
+if(WITH_NV_JETSON)
+  add_definitions(-DWITH_NV_JETSON)
+  set(paddle_known_gpu_archs "53 62 72")
+  set(paddle_known_gpu_archs10 "53 62 72")
+elseif(NEW_RELEASE_ALL)
+  message("Using New Release Strategy - All Arches Packge")
+  add_definitions(-DNEW_RELEASE_ALL)
+  set(paddle_known_gpu_archs "35 50 52 60 61 70 75 80 86")
+  set(paddle_known_gpu_archs10 "35 50 52 60 61 70 75")
+  set(paddle_known_gpu_archs11 "50 60 61 70 75 80")
+elseif(NEW_RELEASE_PYPI)
+  message("Using New Release Strategy - Cubin Packge")
+  add_definitions(-DNEW_RELEASE_PYPI)
+  set(paddle_known_gpu_archs "35 50 52 60 61 70 75 80 86")
+  set(paddle_known_gpu_archs10 "")
+  set(paddle_known_gpu_archs11 "60 61 70 75 80")
+elseif(NEW_RELEASE_JIT)
+  message("Using New Release Strategy - JIT Packge")
+  add_definitions(-DNEW_RELEASE_JIT)
+  set(paddle_known_gpu_archs "35 50 52 60 61 70 75 80 86")
+  set(paddle_known_gpu_archs10 "35 50 60 70 75")
+  set(paddle_known_gpu_archs11 "35 50 60 70 75 80")
+else()
+  set(paddle_known_gpu_archs "35 50 52 60 61 70 75 80")
+  set(paddle_known_gpu_archs10 "35 50 52 60 61 70 75")
+  set(paddle_known_gpu_archs11 "52 60 61 70 75 80")
+endif()
+
+######################################################################################
+# A function for automatic detection of GPUs installed  (if autodetection is enabled)
+# Usage:
+#   detect_installed_gpus(out_variable)
+function(detect_installed_gpus out_variable)
+  if(NOT CUDA_gpu_detect_output)
+    set(cufile ${PROJECT_BINARY_DIR}/detect_cuda_archs.cu)
+
+    file(
+      WRITE ${cufile}
+      ""
+      "#include \"stdio.h\"\n"
+      "#include \"cuda.h\"\n"
+      "#include \"cuda_runtime.h\"\n"
+      "int main() {\n"
+      "  int count = 0;\n"
+      "  if (cudaSuccess != cudaGetDeviceCount(&count)) return -1;\n"
+      "  if (count == 0) return -1;\n"
+      "  for (int device = 0; device < count; ++device) {\n"
+      "    cudaDeviceProp prop;\n"
+      "    if (cudaSuccess == cudaGetDeviceProperties(&prop, device))\n"
+      "      printf(\"%d.%d \", prop.major, prop.minor);\n"
+      "  }\n"
+      "  return 0;\n"
+      "}\n")
+
+    execute_process(
+      COMMAND "${CUDA_NVCC_EXECUTABLE}" "--run" "${cufile}"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/CMakeFiles/"
+      RESULT_VARIABLE nvcc_res
+      OUTPUT_VARIABLE nvcc_out
+      ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+    if(nvcc_res EQUAL 0)
+      # only keep the last line of nvcc_out
+      string(REGEX REPLACE ";" "\\\\;" nvcc_out "${nvcc_out}")
+      string(REGEX REPLACE "\n" ";" nvcc_out "${nvcc_out}")
+      list(GET nvcc_out -1 nvcc_out)
+      string(REPLACE "2.1" "2.1(2.0)" nvcc_out "${nvcc_out}")
+      set(CUDA_gpu_detect_output
+          ${nvcc_out}
+          CACHE INTERNAL
+                "Returned GPU architetures from detect_installed_gpus tool"
+                FORCE)
+    endif()
+  endif()
+
+  if(NOT CUDA_gpu_detect_output)
+    message(
+      STATUS
+        "Automatic GPU detection failed. Building for all known architectures.")
+    set(${out_variable}
+        ${paddle_known_gpu_archs}
+        PARENT_SCOPE)
+  else()
+    set(${out_variable}
+        ${CUDA_gpu_detect_output}
+        PARENT_SCOPE)
+  endif()
+endfunction()
+
+########################################################################
+# Function for selecting GPU arch flags for nvcc based on CUDA_ARCH_NAME
+# Usage:
+#   select_nvcc_arch_flags(out_variable)
+function(select_nvcc_arch_flags out_variable)
+  # List of arch names
+  set(archs_names
+      "Kepler"
+      "Maxwell"
+      "Pascal"
+      "Volta"
+      "Turing"
+      "Ampere"
+      "All"
+      "Manual")
+  set(archs_name_default "Auto")
+  list(APPEND archs_names "Auto")
+
+  # set CUDA_ARCH_NAME strings (so it will be seen as dropbox in CMake-Gui)
+  set(CUDA_ARCH_NAME
+      ${archs_name_default}
+      CACHE STRING "Select target NVIDIA GPU achitecture.")
+  set_property(CACHE CUDA_ARCH_NAME PROPERTY STRINGS "" ${archs_names})
+  mark_as_advanced(CUDA_ARCH_NAME)
+
+  # verify CUDA_ARCH_NAME value
+  if(NOT ";${archs_names};" MATCHES ";${CUDA_ARCH_NAME};")
+    string(REPLACE ";" ", " archs_names "${archs_names}")
+    message(
+      FATAL_ERROR "Only ${archs_names} architectures names are supported.")
+  endif()
+
+  if(${CUDA_ARCH_NAME} STREQUAL "Manual")
+    set(CUDA_ARCH_BIN
+        ${paddle_known_gpu_archs}
+        CACHE
+          STRING
+          "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported"
+    )
+    set(CUDA_ARCH_PTX
+        ""
+        CACHE
+          STRING
+          "Specify 'virtual' PTX architectures to build PTX intermediate code for"
+    )
+    mark_as_advanced(CUDA_ARCH_BIN CUDA_ARCH_PTX)
+  else()
+    unset(CUDA_ARCH_BIN CACHE)
+    unset(CUDA_ARCH_PTX CACHE)
+  endif()
+
+  if(${CUDA_ARCH_NAME} STREQUAL "Kepler")
+    set(cuda_arch_bin "30 35")
+  elseif(${CUDA_ARCH_NAME} STREQUAL "Maxwell")
+    if(WITH_NV_JETSON)
+      set(cuda_arch_bin "53")
+    else()
+      set(cuda_arch_bin "50")
+    endif()
+  elseif(${CUDA_ARCH_NAME} STREQUAL "Pascal")
+    if(WITH_NV_JETSON)
+      set(cuda_arch_bin "62")
+    else()
+      set(cuda_arch_bin "60 61")
+    endif()
+  elseif(${CUDA_ARCH_NAME} STREQUAL "Volta")
+    if(WITH_NV_JETSON)
+      set(cuda_arch_bin "72")
+    else()
+      set(cuda_arch_bin "70")
+    endif()
+  elseif(${CUDA_ARCH_NAME} STREQUAL "Turing")
+    set(cuda_arch_bin "75")
+  elseif(${CUDA_ARCH_NAME} STREQUAL "Ampere")
+    if(${CMAKE_CUDA_COMPILER_VERSION} LESS 11.1) # CUDA 11.0
+      set(cuda_arch_bin "80")
+    elseif(${CMAKE_CUDA_COMPILER_VERSION} LESS 12.0) # CUDA 11.1+
+      set(cuda_arch_bin "80 86")
+    endif()
+  elseif(${CUDA_ARCH_NAME} STREQUAL "All")
+    set(cuda_arch_bin ${paddle_known_gpu_archs})
+  elseif(${CUDA_ARCH_NAME} STREQUAL "Auto")
+    message(
+      STATUS
+        "WARNING: This is just a warning for publishing release.
+      You are building GPU version without supporting different architectures.
+      So the wheel package may fail on other GPU architectures.
+      You can add -DCUDA_ARCH_NAME=All in cmake command
+      to get a full wheel package to resolve this warning.
+      While, this version will still work on local GPU architecture.")
+    detect_installed_gpus(cuda_arch_bin)
+  else() # (${CUDA_ARCH_NAME} STREQUAL "Manual")
+    set(cuda_arch_bin ${CUDA_ARCH_BIN})
+  endif()
+
+  if(NEW_RELEASE_JIT)
+    set(cuda_arch_ptx "${cuda_arch_ptx}${cuda_arch_bin}")
+    set(cuda_arch_bin "")
+  endif()
+
+  # remove dots and convert to lists
+  string(REGEX REPLACE "\\." "" cuda_arch_bin "${cuda_arch_bin}")
+  string(REGEX REPLACE "\\." "" cuda_arch_ptx "${cuda_arch_ptx}")
+  string(REGEX MATCHALL "[0-9()]+" cuda_arch_bin "${cuda_arch_bin}")
+  string(REGEX MATCHALL "[0-9]+" cuda_arch_ptx "${cuda_arch_ptx}")
+
+  list(REMOVE_DUPLICATES cuda_arch_bin)
+  list(REMOVE_DUPLICATES cuda_arch_ptx)
+
+  set(nvcc_flags "")
+  set(nvcc_archs_readable "")
+
+  # Tell NVCC to add binaries for the specified GPUs
+  foreach(arch ${cuda_arch_bin})
+    if(arch MATCHES "([0-9]+)\\(([0-9]+)\\)")
+      # User explicitly specified PTX for the concrete BIN
+      string(APPEND nvcc_flags
+             " -gencode arch=compute_${CMAKE_MATCH_2},code=sm_${CMAKE_MATCH_1}")
+      string(APPEND nvcc_archs_readable " sm_${CMAKE_MATCH_1}")
+    else()
+      # User didn't explicitly specify PTX for the concrete BIN, we assume PTX=BIN
+      string(APPEND nvcc_flags " -gencode arch=compute_${arch},code=sm_${arch}")
+      string(APPEND nvcc_archs_readable " sm_${arch}")
+    endif()
+  endforeach()
+
+  # Tell NVCC to add PTX intermediate code for the specified architectures
+  foreach(arch ${cuda_arch_ptx})
+    string(APPEND nvcc_flags
+           " -gencode arch=compute_${arch},code=compute_${arch}")
+    string(APPEND nvcc_archs_readable " compute_${arch}")
+  endforeach()
+
+  string(REPLACE ";" " " nvcc_archs_readable "${nvcc_archs_readable}")
+  set(${out_variable}
+      ${nvcc_flags}
+      PARENT_SCOPE)
+  set(${out_variable}_readable
+      ${nvcc_archs_readable}
+      PARENT_SCOPE)
+endfunction()
+
+message(STATUS "CUDA detected: " ${CMAKE_CUDA_COMPILER_VERSION})
+if(${CMAKE_CUDA_COMPILER_VERSION} LESS 11.0) # CUDA 10.x
+  set(paddle_known_gpu_archs ${paddle_known_gpu_archs10})
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D_MWAITXINTRIN_H_INCLUDED")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D__STRICT_ANSI__")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
+elseif(${CMAKE_CUDA_COMPILER_VERSION} LESS 11.2) # CUDA 11.0/11.1
+  set(paddle_known_gpu_archs ${paddle_known_gpu_archs11})
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D_MWAITXINTRIN_H_INCLUDED")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D__STRICT_ANSI__")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
+elseif(${CMAKE_CUDA_COMPILER_VERSION} LESS 12.0) # CUDA 11.2+
+  set(paddle_known_gpu_archs "${paddle_known_gpu_archs11} 86")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D_MWAITXINTRIN_H_INCLUDED")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -D__STRICT_ANSI__")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
+endif()
+
+if(NOT ${CMAKE_CUDA_COMPILER_VERSION} LESS 10.0)
+  add_definitions("-DTRT_PLUGIN_FP16_AVALIABLE")
+endif()
+
+add_definitions("-DCUDA_VERSION_MAJOR=\"${CUDA_VERSION_MAJOR}\"")
+add_definitions("-DCUDA_VERSION_MINOR=\"${CUDA_VERSION_MINOR}\"")
+add_definitions("-DCUDA_TOOLKIT_ROOT_DIR=\"${CUDA_TOOLKIT_ROOT_DIR}\"")
+
+# setting nvcc arch flags
+select_nvcc_arch_flags(NVCC_FLAGS_EXTRA)
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${NVCC_FLAGS_EXTRA}")
+message(STATUS "NVCC_FLAGS_EXTRA: ${NVCC_FLAGS_EXTRA}")
+
+# Set C++14 support
+set(CUDA_PROPAGATE_HOST_FLAGS OFF)
+# Release/Debug flags set by cmake. Such as -O3 -g -DNDEBUG etc.
+# So, don't set these flags here.
+set(CMAKE_CUDA_STANDARD 14)
+
+# (Note) For windows, if delete /W[1-4], /W1 will be added defaultly and conflic with -w
+# So replace /W[1-4] with /W0
+if(WIN32)
+  string(REGEX REPLACE "/W[1-4]" " /W0 " CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS}")
+endif()
+# in cuda9, suppress cuda warning on eigen
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -w")
+# Set :expt-relaxed-constexpr to suppress Eigen warnings
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
+# Set :expt-extended-lambda to enable HOSTDEVICE annotation on lambdas
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-extended-lambda")
+
+if(WIN32)
+  set(CMAKE_CUDA_FLAGS
+      "${CMAKE_CUDA_FLAGS} -Xcompiler \"/wd4244 /wd4267 /wd4819 \"")
+  set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler /bigobj")
+  if(MSVC_STATIC_CRT)
+    foreach(flag_var
+            CMAKE_CUDA_FLAGS CMAKE_CUDA_FLAGS_DEBUG CMAKE_CUDA_FLAGS_RELEASE
+            CMAKE_CUDA_FLAGS_MINSIZEREL CMAKE_CUDA_FLAGS_RELWITHDEBINFO)
+      if(${flag_var} MATCHES "-MD")
+        string(REGEX REPLACE "-MD" "-MT" ${flag_var} "${${flag_var}}")
+      endif()
+    endforeach()
+  endif()
+endif()
+
+mark_as_advanced(CUDA_BUILD_CUBIN CUDA_BUILD_EMULATION CUDA_VERBOSE_BUILD)
+mark_as_advanced(CUDA_SDK_ROOT_DIR CUDA_SEPARABLE_COMPILATION)
+
+include(thrust)

cmake/cudnn.cmake

+if(NOT WITH_GPU)
+  return()
+endif()
+
+if(WIN32)
+  set(CUDNN_ROOT ${CUDA_TOOLKIT_ROOT_DIR})
+else()
+  set(CUDNN_ROOT
+      "/usr"
+      CACHE PATH "CUDNN ROOT")
+endif()
+
+find_path(
+  CUDNN_INCLUDE_DIR cudnn.h
+  PATHS ${CUDNN_ROOT} ${CUDNN_ROOT}/include $ENV{CUDNN_ROOT}
+        $ENV{CUDNN_ROOT}/include ${CUDA_TOOLKIT_INCLUDE}
+  NO_DEFAULT_PATH)
+
+get_filename_component(__libpath_hist ${CUDA_CUDART_LIBRARY} PATH)
+
+set(TARGET_ARCH "x86_64")
+if(NOT ${CMAKE_SYSTEM_PROCESSOR})
+  set(TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+endif()
+
+list(
+  APPEND
+  CUDNN_CHECK_LIBRARY_DIRS
+  ${CUDNN_ROOT}
+  ${CUDNN_ROOT}/lib64
+  ${CUDNN_ROOT}/lib
+  ${CUDNN_ROOT}/lib/${TARGET_ARCH}-linux-gnu
+  ${CUDNN_ROOT}/local/cuda-${CUDA_VERSION}/targets/${TARGET_ARCH}-linux/lib/
+  $ENV{CUDNN_ROOT}
+  $ENV{CUDNN_ROOT}/lib64
+  $ENV{CUDNN_ROOT}/lib
+  /usr/lib
+  ${CUDA_TOOLKIT_ROOT_DIR}
+  ${CUDA_TOOLKIT_ROOT_DIR}/lib/x64)
+set(CUDNN_LIB_NAME "")
+
+if(LINUX)
+  set(CUDNN_LIB_NAME "libcudnn.so")
+endif()
+
+if(WIN32)
+  # only support cudnn7
+  set(CUDNN_LIB_NAME "cudnn.lib" "cudnn64_7.dll")
+endif()
+
+if(APPLE)
+  set(CUDNN_LIB_NAME "libcudnn.dylib" "libcudnn.so")
+endif()
+
+find_library(
+  CUDNN_LIBRARY
+  NAMES ${CUDNN_LIB_NAME} # libcudnn_static.a
+  PATHS ${CUDNN_CHECK_LIBRARY_DIRS} ${CUDNN_INCLUDE_DIR} ${__libpath_hist}
+  NO_DEFAULT_PATH
+  DOC "Path to cuDNN library.")
+
+if(CUDNN_INCLUDE_DIR AND CUDNN_LIBRARY)
+  set(CUDNN_FOUND ON)
+else()
+  set(CUDNN_FOUND OFF)
+endif()
+
+macro(find_cudnn_version cudnn_header_file)
+  file(READ ${cudnn_header_file} CUDNN_VERSION_FILE_CONTENTS)
+  get_filename_component(CUDNN_LIB_PATH ${CUDNN_LIBRARY} DIRECTORY)
+
+  string(REGEX MATCH "define CUDNN_VERSION +([0-9]+)" CUDNN_VERSION
+               "${CUDNN_VERSION_FILE_CONTENTS}")
+  string(REGEX REPLACE "define CUDNN_VERSION +([0-9]+)" "\\1" CUDNN_VERSION
+                       "${CUDNN_VERSION}")
+
+  if("${CUDNN_VERSION}" STREQUAL "2000")
+    message(STATUS "Current cuDNN version is v2. ")
+  else()
+    string(REGEX MATCH "define CUDNN_MAJOR +([0-9]+)" CUDNN_MAJOR_VERSION
+                 "${CUDNN_VERSION_FILE_CONTENTS}")
+    string(REGEX REPLACE "define CUDNN_MAJOR +([0-9]+)" "\\1"
+                         CUDNN_MAJOR_VERSION "${CUDNN_MAJOR_VERSION}")
+    string(REGEX MATCH "define CUDNN_MINOR +([0-9]+)" CUDNN_MINOR_VERSION
+                 "${CUDNN_VERSION_FILE_CONTENTS}")
+    string(REGEX REPLACE "define CUDNN_MINOR +([0-9]+)" "\\1"
+                         CUDNN_MINOR_VERSION "${CUDNN_MINOR_VERSION}")
+    string(REGEX MATCH "define CUDNN_PATCHLEVEL +([0-9]+)"
+                 CUDNN_PATCHLEVEL_VERSION "${CUDNN_VERSION_FILE_CONTENTS}")
+    string(REGEX REPLACE "define CUDNN_PATCHLEVEL +([0-9]+)" "\\1"
+                         CUDNN_PATCHLEVEL_VERSION "${CUDNN_PATCHLEVEL_VERSION}")
+
+    if(NOT CUDNN_MAJOR_VERSION)
+      set(CUDNN_VERSION "???")
+    else()
+      add_definitions("-DCUDNN_MAJOR_VERSION=\"${CUDNN_MAJOR_VERSION}\"")
+      math(EXPR CUDNN_VERSION "${CUDNN_MAJOR_VERSION} * 1000 +
+                 ${CUDNN_MINOR_VERSION} * 100 + ${CUDNN_PATCHLEVEL_VERSION}")
+      message(
+        STATUS
+          "Current cuDNN header is ${cudnn_header_file} "
+          "Current cuDNN version is v${CUDNN_MAJOR_VERSION}.${CUDNN_MINOR_VERSION}.${CUDNN_PATCHLEVEL_VERSION}. "
+      )
+    endif()
+  endif()
+endmacro()
+
+if(CUDNN_FOUND)
+  find_cudnn_version(${CUDNN_INCLUDE_DIR}/cudnn.h)
+  if(NOT CUDNN_MAJOR_VERSION)
+    find_cudnn_version(${CUDNN_INCLUDE_DIR}/cudnn_version.h)
+  endif()
+endif()

cmake/cupti.cmake

+if(NOT WITH_GPU AND NOT WITH_ROCM)
+  return()
+endif()
+
+set(CUPTI_ROOT
+    "/usr"
+    CACHE PATH "CUPTI ROOT")
+find_path(
+  CUPTI_INCLUDE_DIR cupti.h
+  PATHS ${CUPTI_ROOT}
+        ${CUPTI_ROOT}/include
+        $ENV{CUPTI_ROOT}
+        $ENV{CUPTI_ROOT}/include
+        ${CUDA_TOOLKIT_ROOT_DIR}/extras/CUPTI/include
+        ${CUDA_TOOLKIT_ROOT_DIR}/targets/x86_64-linux/include
+        ${CUDA_TOOLKIT_ROOT_DIR}/targets/aarch64-linux/include
+  NO_DEFAULT_PATH)
+
+get_filename_component(__libpath_hist ${CUDA_CUDART_LIBRARY} PATH)
+
+set(TARGET_ARCH "x86_64")
+if(NOT ${CMAKE_SYSTEM_PROCESSOR})
+  set(TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+endif()
+
+list(
+  APPEND
+  CUPTI_CHECK_LIBRARY_DIRS
+  ${CUPTI_ROOT}
+  ${CUPTI_ROOT}/lib64
+  ${CUPTI_ROOT}/lib
+  ${CUPTI_ROOT}/lib/${TARGET_ARCH}-linux-gnu
+  $ENV{CUPTI_ROOT}
+  $ENV{CUPTI_ROOT}/lib64
+  $ENV{CUPTI_ROOT}/lib
+  /usr/lib
+  ${CUDA_TOOLKIT_ROOT_DIR}/targets/x86_64-linux/lib64
+  ${CUDA_TOOLKIT_ROOT_DIR}/extras/CUPTI/lib64)
+find_library(
+  CUPTI_LIBRARY
+  NAMES libcupti.so libcupti.dylib # libcupti_static.a
+  PATHS ${CUPTI_CHECK_LIBRARY_DIRS} ${CUPTI_INCLUDE_DIR} ${__libpath_hist}
+  NO_DEFAULT_PATH
+  DOC "Path to cuPTI library.")
+
+get_filename_component(CUPTI_LIBRARY_PATH ${CUPTI_LIBRARY} DIRECTORY)
+if(CUPTI_INCLUDE_DIR AND CUPTI_LIBRARY)
+  set(CUPTI_FOUND ON)
+else()
+  set(CUPTI_FOUND OFF)
+endif()

cmake/dummy.c.in

+// Generated by @dummy_GENERATOR@. DO NOT EDIT!!!
+
+const char *dummy = "@dummy_CONTENT@";

cmake/experimental.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.
+
+# this file contains experimental build options
+
+include(experiments/cuda_module_loading_lazy)

cmake/experiments/cuda_module_loading_lazy.cmake

+# Copyright (c) 2022 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.
+
+# this file contains experimental build options for lazy cuda module loading
+# cuda moduel lazy loading is supported by CUDA 11.7+
+# this experiment option makes Paddle supports lazy loading before CUDA 11.7.
+
+if(LINUX)
+  if(NOT ON_INFER)
+    message(
+      "EXP_CUDA_MODULE_LOADING_LAZY only works with ON_INFER=ON on Linux platforms"
+    )
+    return()
+  endif()
+  if(NOT WITH_GPU)
+    message("EXP_CUDA_MODULE_LOADING_LAZY only works with GPU")
+    return()
+  endif()
+  if(${CUDA_VERSION} VERSION_GREATER_EQUAL "11.7")
+    message("cuda 11.7+ already support lazy module loading")
+    return()
+  endif()
+
+  message(
+    "for cuda before 11.7, libcudart.so must be used for the lazy module loading trick to work, instead of libcudart_static.a"
+  )
+  set(CUDA_USE_STATIC_CUDA_RUNTIME
+      OFF
+      CACHE BOOL "" FORCE)
+  set(CMAKE_CUDA_FLAGS "--cudart shared")
+  enable_language(CUDA)
+  execute_process(
+    COMMAND "rm" "-rf" "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy"
+    COMMAND "chmod" "755" "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy.sh"
+    COMMAND "bash" "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy.sh"
+            "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy" "${CUDA_TOOLKIT_ROOT_DIR}")
+  execute_process(COMMAND "chmod" "755" "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy")
+  set(CUDA_NVCC_EXECUTABLE
+      "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy"
+      CACHE FILEPATH "" FORCE)
+  set(CMAKE_CUDA_COMPILER
+      "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy"
+      CACHE FILEPATH "" FORCE)
+endif()

cmake/external/arm_brpc.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)
+
+#find_package(OpenSSL REQUIRED)
+
+#message(STATUS "ssl:" ${OPENSSL_SSL_LIBRARY})
+#message(STATUS "crypto:" ${OPENSSL_CRYPTO_LIBRARY})
+
+#ADD_LIBRARY(ssl SHARED IMPORTED GLOBAL)
+#SET_PROPERTY(TARGET ssl PROPERTY IMPORTED_LOCATION ${OPENSSL_SSL_LIBRARY})
+
+#ADD_LIBRARY(crypto SHARED IMPORTED GLOBAL)
+#SET_PROPERTY(TARGET crypto PROPERTY IMPORTED_LOCATION ${OPENSSL_CRYPTO_LIBRARY})
+
+if((NOT DEFINED ARM_BRPC_NAME) OR (NOT DEFINED ARM_BRPC_URL))
+  set(ARM_BRPC_VER
+      "1.1.0"
+      CACHE STRING "" FORCE)
+  set(ARM_BRPC_NAME
+      "arm_brpc"
+      CACHE STRING "" FORCE)
+endif()
+
+message(STATUS "ARM_BRPC_NAME: ${ARM_BRPC_NAME}, ARM_BRPC_URL: ${ARM_BRPC_URL}")
+set(ARM_BRPC_PREFIX_DIR "${THIRD_PARTY_PATH}/arm_brpc")
+set(ARM_BRPC_PROJECT "extern_arm_brpc")
+set(ARM_BRPC_DOWNLOAD_DIR "${ARM_BRPC_PREFIX_DIR}/src/${ARM_BRPC_PROJECT}")
+set(ARM_BRPC_DST_DIR "output")
+set(ARM_BRPC_INSTALL_ROOT "${THIRD_PARTY_PATH}/install")
+set(ARM_BRPC_INSTALL_DIR ${ARM_BRPC_INSTALL_ROOT}/arm_brpc/output)
+set(ARM_BRPC_ROOT ${ARM_BRPC_INSTALL_DIR})
+set(ARM_BRPC_INC_DIR ${ARM_BRPC_ROOT}/include)
+set(ARM_BRPC_LIB_DIR ${ARM_BRPC_ROOT}/lib)
+set(ARM_BRPC_LIB ${ARM_BRPC_LIB_DIR}/libbrpc.a)
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH}" "${ARM_BRPC_ROOT}/lib")
+
+include_directories(${ARM_BRPC_INSTALL_ROOT}/${ARM_BRPC_NAME}/output/include)
+
+file(
+  WRITE ${ARM_BRPC_DOWNLOAD_DIR}/CMakeLists.txt
+  "PROJECT(ARM_BRPC)\n" "cmake_minimum_required(VERSION 3.0)\n"
+  "install(DIRECTORY ${ARM_BRPC_DST_DIR} ${ARM_BRPC_DST_DIR} \n"
+  "        DESTINATION ${ARM_BRPC_NAME})\n")
+
+set(ARM_BRPC_URL
+    "https://paddlerec.bj.bcebos.com/online_infer/arm_brpc_ubuntu18/output.tar.gz"
+    CACHE STRING "" FORCE)
+ExternalProject_Add(
+  ${ARM_BRPC_PROJECT}
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  PREFIX ${ARM_BRPC_PREFIX_DIR}
+  DOWNLOAD_DIR ${ARM_BRPC_DOWNLOAD_DIR}
+  DOWNLOAD_COMMAND rm -rf output.tar.gz && wget --no-check-certificate
+                   ${ARM_BRPC_URL} && tar zxvf output.tar.gz
+  #DOWNLOAD_COMMAND      cp /home/wangbin44/Paddle/build/output.tar.gz .
+  #                      && tar zxvf output.tar.gz
+  DOWNLOAD_NO_PROGRESS 1
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${ARM_BRPC_INSTALL_ROOT}
+             -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+  CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${ARM_BRPC_INSTALL_ROOT}
+                   -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${ARM_BRPC_LIB})
+
+add_library(arm_brpc STATIC IMPORTED GLOBAL) # 直接导入已经生成的库
+set_property(TARGET arm_brpc PROPERTY IMPORTED_LOCATION ${ARM_BRPC_LIB})
+add_dependencies(arm_brpc ${ARM_BRPC_PROJECT})

cmake/external/ascend.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.
+
+#NOTE: Logic is from
+# https://github.com/mindspore-ai/graphengine/blob/master/CMakeLists.txt
+if(DEFINED ENV{ASCEND_CUSTOM_PATH})
+  set(ASCEND_DIR $ENV{ASCEND_CUSTOM_PATH})
+else()
+  set(ASCEND_DIR /usr/local/Ascend)
+endif()
+
+if(EXISTS
+   ${ASCEND_DIR}/ascend-toolkit/latest/fwkacllib/include/graph/ascend_string.h)
+  # It means CANN 20.2 +
+  add_definitions(-DPADDLE_WITH_ASCEND_STRING)
+endif()
+
+if(WITH_ASCEND OR WITH_ASCEND_CL)
+  set(ASCEND_DRIVER_DIR ${ASCEND_DIR}/driver/lib64)
+  set(ASCEND_DRIVER_COMMON_DIR ${ASCEND_DIR}/driver/lib64/common)
+  set(ASCEND_DRIVER_SHARE_DIR ${ASCEND_DIR}/driver/lib64/share)
+  set(ASCEND_RUNTIME_DIR ${ASCEND_DIR}/fwkacllib/lib64)
+  set(ASCEND_ATC_DIR ${ASCEND_DIR}/atc/lib64)
+  set(ASCEND_ACL_DIR ${ASCEND_DIR}/acllib/lib64)
+  set(STATIC_ACL_LIB ${ASCEND_ACL_DIR})
+
+  set(ASCEND_MS_RUNTIME_PATH ${ASCEND_RUNTIME_DIR} ${ASCEND_ACL_DIR}
+                             ${ASCEND_ATC_DIR})
+  set(ASCEND_MS_DRIVER_PATH ${ASCEND_DRIVER_DIR} ${ASCEND_DRIVER_COMMON_DIR})
+  set(ATLAS_RUNTIME_DIR ${ASCEND_DIR}/ascend-toolkit/latest/fwkacllib/lib64)
+  set(ATLAS_RUNTIME_INC_DIR
+      ${ASCEND_DIR}/ascend-toolkit/latest/fwkacllib/include)
+  set(ATLAS_ACL_DIR ${ASCEND_DIR}/ascend-toolkit/latest/acllib/lib64)
+  set(ATLAS_ATC_DIR ${ASCEND_DIR}/ascend-toolkit/latest/atc/lib64)
+  set(ATLAS_MS_RUNTIME_PATH ${ATLAS_RUNTIME_DIR} ${ATLAS_ACL_DIR}
+                            ${ATLAS_ATC_DIR})
+
+  set(atlas_graph_lib ${ATLAS_RUNTIME_DIR}/libgraph.so)
+  set(atlas_ge_runner_lib ${ATLAS_RUNTIME_DIR}/libge_runner.so)
+  set(atlas_acl_lib ${ATLAS_RUNTIME_DIR}/libascendcl.so)
+  include_directories(${ATLAS_RUNTIME_INC_DIR})
+
+  add_library(ascend_ge SHARED IMPORTED GLOBAL)
+  set_property(TARGET ascend_ge PROPERTY IMPORTED_LOCATION
+                                         ${atlas_ge_runner_lib})
+
+  add_library(ascend_graph SHARED IMPORTED GLOBAL)
+  set_property(TARGET ascend_graph PROPERTY IMPORTED_LOCATION
+                                            ${atlas_graph_lib})
+
+  add_library(atlas_acl SHARED IMPORTED GLOBAL)
+  set_property(TARGET atlas_acl PROPERTY IMPORTED_LOCATION ${atlas_acl_lib})
+
+  add_custom_target(extern_ascend DEPENDS ascend_ge ascend_graph atlas_acl)
+endif()
+
+if(WITH_ASCEND_CL)
+  set(ASCEND_CL_DIR ${ASCEND_DIR}/ascend-toolkit/latest/fwkacllib/lib64)
+
+  set(ascend_hccl_lib ${ASCEND_CL_DIR}/libhccl.so)
+  set(ascendcl_lib ${ASCEND_CL_DIR}/libascendcl.so)
+  set(acl_op_compiler_lib ${ASCEND_CL_DIR}/libacl_op_compiler.so)
+  set(FWKACLLIB_INC_DIR ${ASCEND_DIR}/ascend-toolkit/latest/fwkacllib/include)
+  set(ACLLIB_INC_DIR ${ASCEND_DIR}/ascend-toolkit/latest/acllib/include)
+
+  message(STATUS "FWKACLLIB_INC_DIR ${FWKACLLIB_INC_DIR}")
+  message(STATUS "ASCEND_CL_DIR ${ASCEND_CL_DIR}")
+  include_directories(${FWKACLLIB_INC_DIR})
+  include_directories(${ACLLIB_INC_DIR})
+
+  add_library(ascendcl SHARED IMPORTED GLOBAL)
+  set_property(TARGET ascendcl PROPERTY IMPORTED_LOCATION ${ascendcl_lib})
+
+  add_library(ascend_hccl SHARED IMPORTED GLOBAL)
+  set_property(TARGET ascend_hccl PROPERTY IMPORTED_LOCATION ${ascend_hccl_lib})
+
+  add_library(acl_op_compiler SHARED IMPORTED GLOBAL)
+  set_property(TARGET acl_op_compiler PROPERTY IMPORTED_LOCATION
+                                               ${acl_op_compiler_lib})
+  add_custom_target(extern_ascend_cl DEPENDS ascendcl acl_op_compiler)
+endif()
+
+if(WITH_ASCEND_CL)
+  macro(find_ascend_toolkit_version ascend_toolkit_version_info)
+    file(READ ${ascend_toolkit_version_info} ASCEND_TOOLKIT_VERSION_CONTENTS)
+    string(REGEX MATCH "version=([0-9]+\.[0-9]+\.(RC)?[0-9][.a-z0-9]*)"
+                 ASCEND_TOOLKIT_VERSION "${ASCEND_TOOLKIT_VERSION_CONTENTS}")
+    string(REGEX REPLACE "version=([0-9]+\.[0-9]+\.(RC)?[0-9][.a-z0-9]*)" "\\1"
+                         ASCEND_TOOLKIT_VERSION "${ASCEND_TOOLKIT_VERSION}")
+    string(REGEX REPLACE "[A-Z]|[a-z|\.]" "" CANN_VERSION
+                         ${ASCEND_TOOLKIT_VERSION})
+    string(SUBSTRING "${CANN_VERSION}000" 0 6 CANN_VERSION)
+    add_definitions("-DCANN_VERSION_CODE=${CANN_VERSION}")
+    if(NOT ASCEND_TOOLKIT_VERSION)
+      set(ASCEND_TOOLKIT_VERSION "???")
+    else()
+      message(
+        STATUS "Current Ascend Toolkit version is ${ASCEND_TOOLKIT_VERSION}")
+    endif()
+  endmacro()
+
+  macro(find_ascend_driver_version ascend_driver_version_info)
+    file(READ ${ascend_driver_version_info} ASCEND_DRIVER_VERSION_CONTENTS)
+    string(REGEX MATCH "Version=([0-9]+\.[0-9]+\.[0-9]+)" ASCEND_DRIVER_VERSION
+                 "${ASCEND_DRIVER_VERSION_CONTENTS}")
+    string(REGEX REPLACE "Version=([0-9]+\.[0-9]+\.[0-9]+)" "\\1"
+                         ASCEND_DRIVER_VERSION "${ASCEND_DRIVER_VERSION}")
+    if(NOT ASCEND_DRIVER_VERSION)
+      set(ASCEND_DRIVER_VERSION "???")
+    else()
+      message(
+        STATUS "Current Ascend Driver version is ${ASCEND_DRIVER_VERSION}")
+    endif()
+  endmacro()
+
+  if(WITH_ARM)
+    set(ASCEND_TOOLKIT_DIR ${ASCEND_DIR}/ascend-toolkit/latest/arm64-linux)
+  else()
+    set(ASCEND_TOOLKIT_DIR ${ASCEND_DIR}/ascend-toolkit/latest/x86_64-linux)
+  endif()
+
+  find_ascend_toolkit_version(${ASCEND_TOOLKIT_DIR}/ascend_toolkit_install.info)
+  find_ascend_driver_version(${ASCEND_DIR}/driver/version.info)
+endif()

cmake/external/box_ps.cmake

+# Copyright (c) 2019 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(BOX_PS_PROJECT "extern_box_ps")
+if((NOT DEFINED BOX_PS_VER) OR (NOT DEFINED BOX_PS_URL))
+  message(STATUS "use pre defined download url")
+  set(BOX_PS_VER
+      "0.1.1"
+      CACHE STRING "" FORCE)
+  set(BOX_PS_NAME
+      "box_ps"
+      CACHE STRING "" FORCE)
+  set(BOX_PS_URL
+      "http://box-ps.gz.bcebos.com/box_ps.tar.gz"
+      CACHE STRING "" FORCE)
+endif()
+message(STATUS "BOX_PS_NAME: ${BOX_PS_NAME}, BOX_PS_URL: ${BOX_PS_URL}")
+set(BOX_PS_SOURCE_DIR "${THIRD_PARTY_PATH}/box_ps")
+set(BOX_PS_DOWNLOAD_DIR "${BOX_PS_SOURCE_DIR}/src/${BOX_PS_PROJECT}")
+set(BOX_PS_DST_DIR "box_ps")
+set(BOX_PS_INSTALL_ROOT "${THIRD_PARTY_PATH}/install")
+set(BOX_PS_INSTALL_DIR ${BOX_PS_INSTALL_ROOT}/${BOX_PS_DST_DIR})
+set(BOX_PS_ROOT ${BOX_PS_INSTALL_DIR})
+set(BOX_PS_INC_DIR ${BOX_PS_ROOT}/include)
+set(BOX_PS_LIB_DIR ${BOX_PS_ROOT}/lib)
+set(BOX_PS_LIB ${BOX_PS_LIB_DIR}/libbox_ps.so)
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH}" "${BOX_PS_ROOT}/lib")
+
+include_directories(${BOX_PS_INC_DIR})
+file(
+  WRITE ${BOX_PS_DOWNLOAD_DIR}/CMakeLists.txt
+  "PROJECT(BOX_PS)\n" "cmake_minimum_required(VERSION 3.0)\n"
+  "install(DIRECTORY ${BOX_PS_NAME}/include ${BOX_PS_NAME}/lib \n"
+  "        DESTINATION ${BOX_PS_DST_DIR})\n")
+ExternalProject_Add(
+  ${BOX_PS_PROJECT}
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  PREFIX ${BOX_PS_SOURCE_DIR}
+  DOWNLOAD_DIR ${BOX_PS_DOWNLOAD_DIR}
+  DOWNLOAD_COMMAND wget --no-check-certificate ${BOX_PS_URL} -c -q -O
+                   ${BOX_PS_NAME}.tar.gz && tar zxvf ${BOX_PS_NAME}.tar.gz
+  DOWNLOAD_NO_PROGRESS 1
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${BOX_PS_INSTALL_ROOT}
+             -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+  CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${BOX_PS_INSTALL_ROOT}
+                   -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${BOX_PS_LIB})
+add_library(box_ps SHARED IMPORTED GLOBAL)
+set_property(TARGET box_ps PROPERTY IMPORTED_LOCATION ${BOX_PS_LIB})
+add_dependencies(box_ps ${BOX_PS_PROJECT})

cmake/external/brpc.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)
+
+find_package(OpenSSL REQUIRED)
+
+message(STATUS "ssl:" ${OPENSSL_SSL_LIBRARY})
+message(STATUS "crypto:" ${OPENSSL_CRYPTO_LIBRARY})
+
+add_library(ssl SHARED IMPORTED GLOBAL)
+set_property(TARGET ssl PROPERTY IMPORTED_LOCATION ${OPENSSL_SSL_LIBRARY})
+
+add_library(crypto SHARED IMPORTED GLOBAL)
+set_property(TARGET crypto PROPERTY IMPORTED_LOCATION ${OPENSSL_CRYPTO_LIBRARY})
+
+set(BRPC_PREFIX_DIR ${THIRD_PARTY_PATH}/brpc)
+set(BRPC_INSTALL_DIR ${THIRD_PARTY_PATH}/install/brpc)
+set(BRPC_INCLUDE_DIR
+    "${BRPC_INSTALL_DIR}/include"
+    CACHE PATH "brpc include directory." FORCE)
+set(BRPC_LIBRARIES
+    "${BRPC_INSTALL_DIR}/lib/libbrpc.a"
+    CACHE FILEPATH "brpc library." FORCE)
+
+include_directories(${BRPC_INCLUDE_DIR})
+
+# Reference https://stackoverflow.com/questions/45414507/pass-a-list-of-prefix-paths-to-externalproject-add-in-cmake-args
+set(prefix_path
+    "${THIRD_PARTY_PATH}/install/gflags|${THIRD_PARTY_PATH}/install/leveldb|${THIRD_PARTY_PATH}/install/snappy|${THIRD_PARTY_PATH}/install/gtest|${THIRD_PARTY_PATH}/install/protobuf|${THIRD_PARTY_PATH}/install/zlib|${THIRD_PARTY_PATH}/install/glog"
+)
+
+# If minimal .a is need, you can set  WITH_DEBUG_SYMBOLS=OFF
+ExternalProject_Add(
+  extern_brpc
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  GIT_REPOSITORY "https://github.com/apache/incubator-brpc"
+  GIT_TAG 1.2.0
+  PREFIX ${BRPC_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+             -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+             -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+             -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+             -DCMAKE_INSTALL_PREFIX=${BRPC_INSTALL_DIR}
+             -DCMAKE_INSTALL_LIBDIR=${BRPC_INSTALL_DIR}/lib
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+             -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+             -DCMAKE_PREFIX_PATH=${prefix_path}
+             -DWITH_GLOG=ON
+             -DBUILD_BRPC_TOOLS=ON
+             -DBUILD_SHARED_LIBS=ON
+             ${EXTERNAL_OPTIONAL_ARGS}
+  LIST_SEPARATOR |
+  CMAKE_CACHE_ARGS
+    -DCMAKE_INSTALL_PREFIX:PATH=${BRPC_INSTALL_DIR}
+    -DCMAKE_INSTALL_LIBDIR:PATH=${BRPC_INSTALL_DIR}/lib
+    -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+    -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${BRPC_LIBRARIES})
+
+# ADD_DEPENDENCIES(extern_brpc protobuf ssl crypto leveldb gflags glog gtest snappy)
+add_dependencies(
+  extern_brpc
+  protobuf
+  ssl
+  crypto
+  leveldb
+  gflags
+  glog
+  snappy)
+add_library(brpc STATIC IMPORTED GLOBAL)
+set_property(TARGET brpc PROPERTY IMPORTED_LOCATION ${BRPC_LIBRARIES})
+add_dependencies(brpc extern_brpc)
+
+add_definitions(-DBRPC_WITH_GLOG)
+
+list(APPEND external_project_dependencies brpc)

cmake/external/cinn.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.
+
+if(NOT WITH_CINN)
+  return()
+endif()
+
+if(NOT CINN_GIT_TAG)
+  set(CINN_GIT_TAG release/v0.2)
+endif()
+
+message(STATUS "CINN version: " ${CINN_GIT_TAG})
+
+# TODO(zhhsplendid): CINN has lots of warnings during early development.
+# They will be treated as errors under paddle. We set no-error now and we will
+# clean the code in the future.
+add_definitions(-w)
+
+######################################
+# Build CINN from Git External Project
+######################################
+include(ExternalProject)
+set(CINN_PREFIX_DIR ${THIRD_PARTY_PATH}/CINN)
+set(CINN_OPTIONAL_ARGS
+    -DPY_VERSION=${PY_VERSION}
+    -DWITH_CUDA=${WITH_GPU}
+    -DWITH_CUDNN=${WITH_GPU}
+    -DWITH_MKL_CBLAS=${WITH_MKL}
+    -DWITH_MKLDNN=${WITH_MKL}
+    -DPUBLISH_LIBS=ON
+    -DWITH_TESTING=ON)
+set(CINN_BUILD_COMMAND $(MAKE) cinnapi -j)
+ExternalProject_Add(
+  external_cinn
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  GIT_REPOSITORY "${GIT_URL}/PaddlePaddle/CINN.git"
+  GIT_TAG ${CINN_GIT_TAG}
+  PREFIX ${CINN_PREFIX_DIR}
+  BUILD_COMMAND ${CINN_BUILD_COMMAND}
+  INSTALL_COMMAND ""
+  CMAKE_ARGS ${CINN_OPTIONAL_ARGS})
+
+ExternalProject_Get_Property(external_cinn BINARY_DIR)
+ExternalProject_Get_Property(external_cinn SOURCE_DIR)
+set(CINN_BINARY_DIR ${BINARY_DIR})
+set(CINN_SOURCE_DIR ${SOURCE_DIR})
+
+message(STATUS "CINN BINARY_DIR: ${CINN_BINARY_DIR}")
+message(STATUS "CINN SOURCE_DIR: ${CINN_SOURCE_DIR}")
+
+######################################
+# Add CINN's dependencies header files
+######################################
+
+# Add absl
+set(ABSL_INCLUDE_DIR "${CINN_BINARY_DIR}/dist/third_party/absl/include")
+include_directories(${ABSL_INCLUDE_DIR})
+
+# Add isl
+set(ISL_INCLUDE_DIR "${CINN_BINARY_DIR}/dist/third_party/isl/include")
+include_directories(${ISL_INCLUDE_DIR})
+
+# Add LLVM
+set(LLVM_INCLUDE_DIR "${CINN_BINARY_DIR}/dist/third_party/llvm/include")
+include_directories(${LLVM_INCLUDE_DIR})
+
+######################################################
+# Put external_cinn and dependencies together as a lib
+######################################################
+
+set(CINN_LIB_NAME "libcinnapi.so")
+set(CINN_LIB_LOCATION "${CINN_BINARY_DIR}/dist/cinn/lib")
+set(CINN_INCLUDE_DIR "${CINN_BINARY_DIR}/dist/cinn/include")
+
+add_library(cinn SHARED IMPORTED GLOBAL)
+set_target_properties(cinn PROPERTIES IMPORTED_LOCATION
+                                      "${CINN_LIB_LOCATION}/${CINN_LIB_NAME}")
+include_directories(${CINN_INCLUDE_DIR})
+add_dependencies(cinn external_cinn)

cmake/external/concurrentqueue.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(CONCURRENTQUEUE_PROJECT "extern_concurrentqueue")
+set(CONCURRENTQUEUE_VER "v1.0.3")
+set(CONCURRENTQUEUE_URL_MD5 118e5bb661b567634647312991e10222)
+set(CONCURRENTQUEUE_PREFIX_URL
+    "https://github.com/cameron314/concurrentqueue/archive/refs/tags")
+set(CONCURRENTQUEUE_URL
+    "${CONCURRENTQUEUE_PREFIX_URL}/${CONCURRENTQUEUE_VER}.tar.gz")
+
+message(
+  STATUS
+    "CONCURRENTQUEUE_VERSION: ${CONCURRENTQUEUE_VER}, CONCURRENTQUEUE_URL: ${CONCURRENTQUEUE_URL}"
+)
+
+set(CONCURRENTQUEUE_PREFIX_DIR ${THIRD_PARTY_PATH}/concurrentqueue)
+set(CONCURRENTQUEUE_SOURCE_DIR ${THIRD_PARTY_PATH}/concurrentqueue/src/)
+set(CONCURRENTQUEUE_INCLUDE_DIR
+    "${CONCURRENTQUEUE_SOURCE_DIR}/extern_concurrentqueue")
+
+ExternalProject_Add(
+  ${CONCURRENTQUEUE_PROJECT}
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  URL ${CONCURRENTQUEUE_URL}
+  URL_MD5 ${CONCURRENTQUEUE_URL_MD5}
+  PREFIX ${CONCURRENTQUEUE_PREFIX_DIR}
+  DOWNLOAD_NO_PROGRESS 1
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND ""
+  UPDATE_COMMAND "")
+
+include_directories(${CONCURRENTQUEUE_INCLUDE_DIR})

cmake/external/cryptopp.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(CRYPTOPP_PREFIX_DIR ${THIRD_PARTY_PATH}/cryptopp)
+set(CRYPTOPP_INSTALL_DIR ${THIRD_PARTY_PATH}/install/cryptopp)
+set(CRYPTOPP_INCLUDE_DIR
+    "${CRYPTOPP_INSTALL_DIR}/include"
+    CACHE PATH "cryptopp include directory." FORCE)
+set(CRYPTOPP_REPOSITORY ${GIT_URL}/weidai11/cryptopp.git)
+set(CRYPTOPP_TAG CRYPTOPP_8_2_0)
+
+if(WIN32)
+  set(CRYPTOPP_LIBRARIES
+      "${CRYPTOPP_INSTALL_DIR}/lib/cryptopp-static.lib"
+      CACHE FILEPATH "cryptopp library." FORCE)
+  # There is a compilation parameter "/FI\"winapifamily.h\"" or "/FIwinapifamily.h" can't be used correctly
+  # with Ninja on Windows. The only difference between the patch file and original
+  # file is that the compilation parameters are changed to '/nologo'. This
+  # patch command can be removed when upgrading to a higher version.
+  if("${CMAKE_GENERATOR}" STREQUAL "Ninja")
+    set(CRYPTOPP_PATCH_COMMAND
+        ${CMAKE_COMMAND} -E copy_if_different
+        "${PADDLE_SOURCE_DIR}/patches/cryptopp/CMakeLists.txt" "<SOURCE_DIR>/")
+  endif()
+else()
+  set(CRYPTOPP_LIBRARIES
+      "${CRYPTOPP_INSTALL_DIR}/lib/libcryptopp.a"
+      CACHE FILEPATH "cryptopp library." FORCE)
+endif()
+
+if(APPLE AND WITH_ARM)
+  set(CMAKE_CXX_FLAGS "-DCRYPTOPP_ARM_CRC32_AVAILABLE=0")
+endif()
+
+set(CRYPTOPP_CMAKE_ARGS
+    ${COMMON_CMAKE_ARGS}
+    -DBUILD_SHARED=ON
+    -DBUILD_STATIC=ON
+    -DBUILD_TESTING=OFF
+    -DCMAKE_INSTALL_LIBDIR=${CRYPTOPP_INSTALL_DIR}/lib
+    -DCMAKE_INSTALL_PREFIX=${CRYPTOPP_INSTALL_DIR}
+    -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+    -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+    -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+    -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER})
+
+include_directories(${CRYPTOPP_INCLUDE_DIR})
+
+ExternalProject_Add(
+  extern_cryptopp
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${CRYPTOPP_REPOSITORY}
+  GIT_TAG ${CRYPTOPP_TAG}
+  PREFIX ${CRYPTOPP_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  PATCH_COMMAND
+  COMMAND ${CMAKE_COMMAND} -E remove_directory "<SOURCE_DIR>/cmake/"
+  COMMAND git clone ${GIT_URL}/noloader/cryptopp-cmake "<SOURCE_DIR>/cmake"
+  COMMAND cd "<SOURCE_DIR>/cmake" && git checkout tags/${CRYPTOPP_TAG} -b
+          ${CRYPTOPP_TAG}
+  COMMAND ${CMAKE_COMMAND} -E copy_directory "<SOURCE_DIR>/cmake/"
+          "<SOURCE_DIR>/"
+  COMMAND ${CRYPTOPP_PATCH_COMMAND}
+  INSTALL_DIR ${CRYPTOPP_INSTALL_DIR}
+  CMAKE_ARGS ${CRYPTOPP_CMAKE_ARGS}
+  CMAKE_CACHE_ARGS
+    -DCMAKE_INSTALL_PREFIX:PATH=${CRYPTOPP_INSTALL_DIR}
+    -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+    -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${CRYPTOPP_LIBRARIES})
+
+add_library(cryptopp STATIC IMPORTED GLOBAL)
+set_property(TARGET cryptopp PROPERTY IMPORTED_LOCATION ${CRYPTOPP_LIBRARIES})
+add_dependencies(cryptopp extern_cryptopp)

cmake/external/cub.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(zhouwei): extern_cub  has code __FILE_, If the path of extern_cub is changed,
+# it will effect about 30+ cu files sccache hit and slow compile speed  on windows.
+# Therefore, a fixed CUB_PATH will be input to increase the sccache hit rate.
+set(CUB_PATH
+    "${THIRD_PARTY_PATH}/cub"
+    CACHE STRING "A path setting for external_cub path.")
+set(CUB_PREFIX_DIR ${CUB_PATH})
+
+set(CUB_REPOSITORY ${GIT_URL}/NVlabs/cub.git)
+
+if(${CMAKE_CUDA_COMPILER_VERSION} GREATER_EQUAL 11.6)
+  # cuda_11.6.2_511.65‘s own cub is 1.15.0, which will cause compiling error in windows.
+  set(CUB_TAG 1.16.0)
+  # cub 1.16.0 is not compitable with current thrust version
+  add_definitions(-DTHRUST_IGNORE_CUB_VERSION_CHECK)
+else()
+  set(CUB_TAG 1.8.0)
+endif()
+
+set(CUB_INCLUDE_DIR ${CUB_PREFIX_DIR}/src/extern_cub)
+message("CUB_INCLUDE_DIR is ${CUB_INCLUDE_DIR}")
+include_directories(${CUB_INCLUDE_DIR})
+
+ExternalProject_Add(
+  extern_cub
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${CUB_REPOSITORY}
+  GIT_TAG ${CUB_TAG}
+  PREFIX ${CUB_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND ""
+  TEST_COMMAND "")
+
+add_library(cub INTERFACE)
+
+add_dependencies(cub extern_cub)

cmake/external/cusparselt.cmake

+# Copyright (c) 2022 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.
+
+if(NOT (WITH_CUSPARSELT AND WITH_TENSORRT))
+  return()
+endif()
+
+if(WITH_ARM OR WIN32)
+  message(SEND_ERROR "The current sparselt support linux only")
+  return()
+endif()
+
+include(ExternalProject)
+
+set(CUSPARSELT_PROJECT "extern_cusparselt")
+set(CUSPARSELT_P "https://developer.download.nvidia.com/compute")
+set(CUSPARSELT_F "libcusparse_lt-linux-x86_64-0.2.0.1.tar.gz")
+set(CUSPARSELT_URL
+    "${CUSPARSELT_P}/libcusparse-lt/0.2.0/local_installers/${CUSPARSELT_F}"
+    CACHE STRING "" FORCE)
+set(CUSPARSELT_PREFIX_DIR ${THIRD_PARTY_PATH}/cusparselt)
+set(CUSPARSELT_INSTALL_DIR ${THIRD_PARTY_PATH}/install/cusparselt)
+set(CUSPARSELT_INC_DIR
+    "${CUSPARSELT_INSTALL_DIR}/include"
+    CACHE PATH "sparselt include directory." FORCE)
+set(CUSPARSELT_LIB_DIR
+    "${CUSPARSELT_INSTALL_DIR}/lib64"
+    CACHE PATH "sparselt lib directory." FORCE)
+set_directory_properties(PROPERTIES CLEAN_NO_CUSTOM 1)
+include_directories(${CUSPARSELT_INC_DIR})
+
+ExternalProject_Add(
+  ${CUSPARSELT_PROJECT}
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  URL ${CUSPARSELT_URL}
+  PREFIX ${CUSPARSELT_PREFIX_DIR}
+  DOWNLOAD_NO_PROGRESS 1
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND
+    ${CMAKE_COMMAND} -E copy_directory
+    ${CUSPARSELT_PREFIX_DIR}/src/extern_cusparselt/lib64 ${CUSPARSELT_LIB_DIR}
+    && ${CMAKE_COMMAND} -E copy_directory
+    ${CUSPARSELT_PREFIX_DIR}/src/extern_cusparselt/include ${CUSPARSELT_INC_DIR}
+  UPDATE_COMMAND "")
+
+add_library(cusparselt INTERFACE)
+add_dependencies(cusparselt ${CUSPARSELT_PROJECT})
+set(CUSPARSELT_FOUND ON)
+add_definitions(-DPADDLE_WITH_CUSPARSELT)

cmake/external/dgc.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(DGC_PREFIX_DIR "${THIRD_PARTY_PATH}/dgc")
+set(DGC_SOURCES_DIR "${THIRD_PARTY_PATH}/dgc/src/extern_dgc")
+set(DGC_INSTALL_DIR "${THIRD_PARTY_PATH}/install/dgc")
+set(DGC_INCLUDE_DIR
+    "${DGC_INSTALL_DIR}/include"
+    CACHE PATH "dgc include directory." FORCE)
+set(DGC_LIBRARIES
+    "${DGC_INSTALL_DIR}/lib/libdgc.a"
+    CACHE FILEPATH "dgc library." FORCE)
+set(DGC_URL "https://fleet.bj.bcebos.com/dgc/collective_f66ef73.tgz")
+include_directories(${DGC_INCLUDE_DIR})
+
+ExternalProject_Add(
+  extern_dgc
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  URL ${DGC_URL}
+  URL_MD5 "94e6fa1bc97169d0e1aad44570fe3251"
+  PREFIX "${DGC_PREFIX_DIR}"
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND make -j${NPROC}
+  INSTALL_COMMAND
+    mkdir -p ${DGC_INSTALL_DIR}/lib/ ${DGC_INCLUDE_DIR}/dgc && cp
+    ${DGC_SOURCES_DIR}/build/lib/libdgc.a ${DGC_LIBRARIES} && cp
+    ${DGC_SOURCES_DIR}/build/include/dgc.h ${DGC_INCLUDE_DIR}/dgc/
+  BUILD_IN_SOURCE 1
+  BUILD_BYPRODUCTS ${DGC_LIBRARIES})
+
+add_library(dgc STATIC IMPORTED GLOBAL)
+set_property(TARGET dgc PROPERTY IMPORTED_LOCATION ${DGC_LIBRARIES})
+add_dependencies(dgc extern_dgc)

cmake/external/dirent.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.
+
+# Note(chenxin33): dirent.h is only exist in Linux, so get it from github when build in windows.
+# use dirent tag v1.23.2 on 09/05//2018 https://github.com/tronkko/dirent.git
+
+include(ExternalProject)
+
+set(DIRENT_PREFIX_DIR ${THIRD_PARTY_PATH}/dirent)
+set(DIRENT_INCLUDE_DIR ${THIRD_PARTY_PATH}/dirent/src/extern_dirent/include)
+
+include_directories(${DIRENT_INCLUDE_DIR})
+
+set(DIRENT_REPOSITORY ${GIT_URL}/tronkko/dirent)
+set(DIRENT_TAG 1.23.2)
+
+ExternalProject_Add(
+  extern_dirent
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${DIRENT_REPOSITORY}
+  GIT_TAG ${DIRENT_TAG}
+  PREFIX ${DIRENT_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND ""
+  TEST_COMMAND "")
+
+add_library(dirent INTERFACE)
+
+add_dependencies(dirent extern_dirent)

cmake/external/dlpack.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(DLPACK_PREFIX_DIR ${THIRD_PARTY_PATH}/dlpack)
+
+set(DLPACK_REPOSITORY ${GIT_URL}/dmlc/dlpack.git)
+set(DLPACK_TAG v0.4)
+
+set(DLPACK_INCLUDE_DIR ${THIRD_PARTY_PATH}/dlpack/src/extern_dlpack/include)
+include_directories(${DLPACK_INCLUDE_DIR})
+
+ExternalProject_Add(
+  extern_dlpack
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${DLPACK_REPOSITORY}
+  GIT_TAG ${DLPACK_TAG}
+  PREFIX ${DLPACK_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND ""
+  TEST_COMMAND "")
+
+add_library(dlpack INTERFACE)
+
+add_dependencies(dlpack extern_dlpack)

cmake/external/eigen.cmake

+# Copyright (c) 2017 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)
+
+# update eigen to the commit id f612df27 on 03/16/2021
+set(EIGEN_PREFIX_DIR ${THIRD_PARTY_PATH}/eigen3)
+set(EIGEN_SOURCE_DIR ${THIRD_PARTY_PATH}/eigen3/src/extern_eigen3)
+set(EIGEN_REPOSITORY https://gitlab.com/libeigen/eigen.git)
+set(EIGEN_TAG f612df273689a19d25b45ca4f8269463207c4fee)
+
+if(WIN32)
+  add_definitions(-DEIGEN_STRONG_INLINE=inline)
+elseif(LINUX)
+  if(WITH_ROCM)
+    # For HIPCC Eigen::internal::device::numeric_limits is not EIGEN_DEVICE_FUNC
+    # which will cause compiler error of using __host__ funciont
+    # in __host__ __device__
+    file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/eigen/Meta.h native_src)
+    file(TO_NATIVE_PATH ${EIGEN_SOURCE_DIR}/Eigen/src/Core/util/Meta.h
+         native_dst)
+    file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/eigen/TensorReductionGpu.h
+         native_src1)
+    file(
+      TO_NATIVE_PATH
+      ${EIGEN_SOURCE_DIR}/unsupported/Eigen/CXX11/src/Tensor/TensorReductionGpu.h
+      native_dst1)
+    set(EIGEN_PATCH_COMMAND cp ${native_src} ${native_dst} && cp ${native_src1}
+                            ${native_dst1})
+  endif()
+endif()
+
+set(EIGEN_INCLUDE_DIR ${EIGEN_SOURCE_DIR})
+include_directories(${EIGEN_INCLUDE_DIR})
+
+ExternalProject_Add(
+  extern_eigen3
+  ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+  GIT_REPOSITORY ${EIGEN_REPOSITORY}
+  GIT_TAG ${EIGEN_TAG}
+  PREFIX ${EIGEN_PREFIX_DIR}
+  UPDATE_COMMAND ""
+  PATCH_COMMAND ${EIGEN_PATCH_COMMAND}
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND ""
+  TEST_COMMAND "")
+
+add_library(eigen3 INTERFACE)
+
+add_dependencies(eigen3 extern_eigen3)
+
+# sw not support thread_local semantic
+if(WITH_SW)
+  add_definitions(-DEIGEN_AVOID_THREAD_LOCAL)
+endif()

cmake/external/gflags.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(GFLAGS_PREFIX_DIR ${THIRD_PARTY_PATH}/gflags)
+set(GFLAGS_INSTALL_DIR ${THIRD_PARTY_PATH}/install/gflags)
+set(GFLAGS_INCLUDE_DIR
+    "${GFLAGS_INSTALL_DIR}/include"
+    CACHE PATH "gflags include directory." FORCE)
+set(GFLAGS_REPOSITORY ${GIT_URL}/gflags/gflags.git)
+set(GFLAGS_TAG "v2.2.2")
+if(WIN32)
+  set(GFLAGS_LIBRARIES
+      "${GFLAGS_INSTALL_DIR}/lib/gflags_static.lib"
+      CACHE FILEPATH "GFLAGS_LIBRARIES" FORCE)
+else()
+  set(GFLAGS_LIBRARIES
+      "${GFLAGS_INSTALL_DIR}/lib/libgflags.a"
+      CACHE FILEPATH "GFLAGS_LIBRARIES" FORCE)
+  set(BUILD_COMMAND ${CMAKE_COMMAND} --build .)
+  set(INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install)
+endif()
+
+include_directories(${GFLAGS_INCLUDE_DIR})
+
+if(WITH_ARM_BRPC)
+  set(ARM_GFLAGS_URL
+      "https://paddlerec.bj.bcebos.com/online_infer/arm_brpc_ubuntu18/arm_gflags.tar.gz"
+      CACHE STRING "" FORCE)
+  set(GFLAGS_SOURCE_DIR ${THIRD_PARTY_PATH}/gflags/src/extern_gflags)
+  file(
+    WRITE ${GFLAGS_SOURCE_DIR}/CMakeLists.txt
+    "PROJECT(ARM_GFLAGS)\n" "cmake_minimum_required(VERSION 3.0)\n"
+    "install(DIRECTORY arm_gflags/bin  arm_gflags/include arm_gflags/lib \n"
+    "        DESTINATION . USE_SOURCE_PERMISSIONS)\n")
+  ExternalProject_Add(
+    extern_gflags
+    ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+    PREFIX ${GFLAGS_PREFIX_DIR}
+    DOWNLOAD_DIR ${GFLAGS_SOURCE_DIR}
+    DOWNLOAD_COMMAND rm -rf arm_gflags.tar.gz && wget --no-check-certificate
+                     ${ARM_GFLAGS_URL} && tar zxvf arm_gflags.tar.gz
+    #DOWNLOAD_COMMAND    cp /home/wangbin44/Paddle/build/arm_gflags.tar.gz .
+    #                    && tar zxvf arm_gflags.tar.gz
+    UPDATE_COMMAND ""
+    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${GFLAGS_INSTALL_DIR}
+               -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+    CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${GFLAGS_INSTALL_DIR}
+                     -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+    BUILD_BYPRODUCTS ${GFLAGS_LIBRARIES})
+else()
+  ExternalProject_Add(
+    extern_gflags
+    ${EXTERNAL_PROJECT_LOG_ARGS} ${SHALLOW_CLONE}
+    GIT_REPOSITORY ${GFLAGS_REPOSITORY}
+    GIT_TAG ${GFLAGS_TAG}
+    PREFIX ${GFLAGS_PREFIX_DIR}
+    UPDATE_COMMAND ""
+    BUILD_COMMAND ${BUILD_COMMAND}
+    INSTALL_COMMAND ${INSTALL_COMMAND}
+    CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+               -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+               -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+               -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+               -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+               -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+               -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+               -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+               -DBUILD_STATIC_LIBS=ON
+               -DCMAKE_INSTALL_PREFIX=${GFLAGS_INSTALL_DIR}
+               -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+               -DBUILD_TESTING=OFF
+               -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+               ${EXTERNAL_OPTIONAL_ARGS}
+    CMAKE_CACHE_ARGS
+      -DCMAKE_INSTALL_PREFIX:PATH=${GFLAGS_INSTALL_DIR}
+      -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+      -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+    BUILD_BYPRODUCTS ${GFLAGS_LIBRARIES})
+endif()
+
+add_library(gflags STATIC IMPORTED GLOBAL)
+set_property(TARGET gflags PROPERTY IMPORTED_LOCATION ${GFLAGS_LIBRARIES})
+add_dependencies(gflags extern_gflags)
+
+# On Windows (including MinGW), the Shlwapi library is used by gflags if available.
+if(WIN32)
+  include(CheckIncludeFileCXX)
+  check_include_file_cxx("shlwapi.h" HAVE_SHLWAPI)
+  if(HAVE_SHLWAPI)
+    set_property(GLOBAL PROPERTY OS_DEPENDENCY_MODULES shlwapi.lib)
+  endif()
+endif()