2.5

cmake/cinn/external/absl.cmake

+include(ExternalProject)
+
+set(ABSL_SOURCES_DIR ${PADDLE_SOURCE_DIR}/third_party/absl)
+set(ABSL_INSTALL_DIR ${THIRD_PARTY_PATH}/install/absl)
+set(ABSL_PREFIX_DIR ${THIRD_PARTY_PATH}/absl)
+set(ABSL_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+
+set(ABSL_REPOSITORY "https://github.com/abseil/abseil-cpp.git")
+set(ABSL_TAG "20210324.2")
+
+set(OPTIONAL_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}")
+
+ExternalProject_Add(
+  external_absl
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  DEPENDS gflags
+  PREFIX ${ABSL_PREFIX_DIR}
+  SOURCE_DIR ${ABSL_SOURCES_DIR}
+  UPDATE_COMMAND ""
+  CMAKE_ARGS ${OPTIONAL_ARGS}
+             -DCMAKE_INSTALL_PREFIX=${ABSL_INSTALL_DIR}
+             -DCMAKE_INSTALL_LIBDIR=${ABSL_INSTALL_DIR}/lib
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+             -DWITH_GFLAGS=ON
+             -Dgflags_DIR=${GFLAGS_INSTALL_DIR}/lib/cmake/gflags
+             -DBUILD_TESTING=OFF
+             -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+             ${EXTERNAL_OPTIONAL_ARGS}
+  CMAKE_CACHE_ARGS
+    -DCMAKE_INSTALL_PREFIX:PATH=${ABSL_INSTALL_DIR}
+    -DCMAKE_INSTALL_LIBDIR:PATH=${ABSL_INSTALL_DIR}/lib
+    -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+    -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_base.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_hash.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_wyhash.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_city.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_strings.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_throw_delegate.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_bad_any_cast_impl.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_bad_optional_access.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_bad_variant_access.a
+  BUILD_BYPRODUCTS ${ABSL_INSTALL_DIR}/lib/libabsl_raw_hash_set.a)
+
+# It may be more convinent if we just include all absl libs
+set(ABSL_LIB_NAMES
+    hash
+    wyhash
+    city
+    strings
+    throw_delegate
+    bad_any_cast_impl
+    bad_optional_access
+    bad_variant_access
+    raw_hash_set)
+set(ABSL_LIBS "")
+
+add_library(absl STATIC IMPORTED GLOBAL)
+set_property(TARGET absl PROPERTY IMPORTED_LOCATION
+                                  ${ABSL_INSTALL_DIR}/lib/libabsl_base.a)
+
+if(NOT USE_PREBUILD_EXTERNAL)
+  add_dependencies(absl external_absl)
+endif()
+foreach(lib_name ${ABSL_LIB_NAMES})
+  target_link_libraries(absl
+                        INTERFACE ${ABSL_INSTALL_DIR}/lib/libabsl_${lib_name}.a)
+endforeach()
+include_directories(${ABSL_INSTALL_DIR}/include)

cmake/cinn/external/ginac.cmake

+include(ExternalProject)
+
+# gmp-6.2.1 https://gmplib.org/download/gmp/gmp-6.2.1.tar.xz
+# cln-1.3.6 https://www.ginac.de/CLN/cln-1.3.6.tar.bz2
+# ginac-1.8.1 https://www.ginac.de/ginac-1.8.1.tar.bz2
+#  all build with CFLAGS="-fPIC -DPIC" CXXFLAGS="-fPIC -DPIC" --enable-static=yes
+
+set(GINAC_FILE
+    "ginac-1.8.1_cln-1.3.6_gmp-6.2.1.tar.gz"
+    CACHE STRING "" FORCE)
+set(GINAC_DOWNLOAD_URL
+    "https://paddle-inference-dist.bj.bcebos.com/CINN/${GINAC_FILE}")
+set(GINAC_URL_MD5 ebc3e4b7770dd604777ac3f01bfc8b06)
+set(GINAC_DOWNLOAD_DIR ${PADDLE_SOURCE_DIR}/third_party/ginac)
+set(GINAC_PREFIX_DIR ${THIRD_PARTY_PATH}/ginac)
+set(GINAC_INSTALL_DIR ${THIRD_PARTY_PATH}/install/ginac)
+
+function(download_ginac)
+  message(
+    STATUS
+      "Downloading ${GINAC_DOWNLOAD_URL} to ${GINAC_DOWNLOAD_DIR}/${GINAC_FILE}"
+  )
+  file(
+    DOWNLOAD ${GINAC_DOWNLOAD_URL} ${GINAC_DOWNLOAD_DIR}/${GINAC_FILE}
+    EXPECTED_MD5 ${GINAC_URL_MD5}
+    STATUS ERR)
+  if(ERR EQUAL 0)
+    message(STATUS "Download ${GINAC_FILE} success")
+  else()
+    message(
+      FATAL_ERROR
+        "Download failed, error: ${ERR}\n You can try downloading ${GINAC_FILE} again"
+    )
+  endif()
+endfunction()
+
+# Download and check ginac.
+if(EXISTS ${GINAC_DOWNLOAD_DIR}/${GINAC_FILE})
+  file(MD5 ${GINAC_DOWNLOAD_DIR}/${GINAC_FILE} GINAC_MD5)
+  if(NOT GINAC_MD5 STREQUAL GINAC_URL_MD5)
+    # clean build file
+    file(REMOVE_RECURSE ${GINAC_PREFIX_DIR})
+    file(REMOVE_RECURSE ${GINAC_INSTALL_DIR})
+    download_ginac()
+  endif()
+else()
+  download_ginac()
+endif()
+
+ExternalProject_Add(
+  external_ginac
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  URL ${GINAC_DOWNLOAD_DIR}/${GINAC_FILE}
+  URL_MD5 ${GINAC_URL_MD5}
+  DOWNLOAD_DIR ${GINAC_DOWNLOAD_DIR}
+  PREFIX ${GINAC_PREFIX_DIR}
+  SOURCE_DIR ${GINAC_INSTALL_DIR}
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  UPDATE_COMMAND ""
+  INSTALL_COMMAND ""
+  BUILD_BYPRODUCTS ${GINAC_INSTALL_DIR}/lib/libginac.a
+  BUILD_BYPRODUCTS ${GINAC_INSTALL_DIR}/lib/libcln.a
+  BUILD_BYPRODUCTS ${GINAC_INSTALL_DIR}/lib/libgmp.a)
+
+add_library(ginac STATIC IMPORTED GLOBAL)
+add_dependencies(ginac external_ginac)
+set_property(TARGET ginac PROPERTY IMPORTED_LOCATION
+                                   ${GINAC_INSTALL_DIR}/lib/libginac.a)
+target_link_libraries(ginac INTERFACE ${GINAC_INSTALL_DIR}/lib/libcln.a
+                                      ${GINAC_INSTALL_DIR}/lib/libgmp.a)
+include_directories(${GINAC_INSTALL_DIR}/include)

cmake/cinn/external/isl.cmake

+include(ExternalProject)
+
+# isl https://github.com/inducer/ISL
+# commit-id 6a1760fe46967cda2a06387793a6b7d4a0876581
+#   depends on llvm f9dc2b7079350d0fed3bb3775f496b90483c9e42
+#   depends on gmp-6.2.1
+# static build
+# CPPFLAGS="-fPIC -DPIC" ./configure --with-gmp-prefix=<gmp-install-path> --with-clang-prefix=<llvm-install-path> --enable-shared=no --enable-static=yes
+
+set(ISL_FILE
+    "isl-6a1760fe.tar.gz"
+    CACHE STRING "" FORCE)
+set(ISL_DOWNLOAD_URL
+    "https://paddle-inference-dist.bj.bcebos.com/CINN/${ISL_FILE}")
+set(ISL_URL_MD5 fff10083fb79d394b8a7b7b2089f6183)
+set(ISL_DOWNLOAD_DIR ${PADDLE_SOURCE_DIR}/third_party/isl)
+set(ISL_PREFIX_DIR ${THIRD_PARTY_PATH}/isl)
+set(ISL_INSTALL_DIR ${THIRD_PARTY_PATH}/install/isl)
+
+function(download_isl)
+  message(
+    STATUS "Downloading ${ISL_DOWNLOAD_URL} to ${ISL_DOWNLOAD_DIR}/${ISL_FILE}")
+  file(
+    DOWNLOAD ${ISL_DOWNLOAD_URL} ${ISL_DOWNLOAD_DIR}/${ISL_FILE}
+    EXPECTED_MD5 ${ISL_URL_MD5}
+    STATUS ERR)
+  if(ERR EQUAL 0)
+    message(STATUS "Download ${ISL_FILE} success")
+  else()
+    message(
+      FATAL_ERROR
+        "Download failed, error: ${ERR}\n You can try downloading ${ISL_FILE} again"
+    )
+  endif()
+endfunction()
+
+# Download and check isl.
+if(EXISTS ${ISL_DOWNLOAD_DIR}/${ISL_FILE})
+  file(MD5 ${ISL_DOWNLOAD_DIR}/${ISL_FILE} ISL_MD5)
+  if(NOT ISL_MD5 STREQUAL ISL_URL_MD5)
+    # clean build file
+    file(REMOVE_RECURSE ${ISL_PREFIX_DIR})
+    file(REMOVE_RECURSE ${ISL_INSTALL_DIR})
+    download_isl()
+  endif()
+else()
+  download_isl()
+endif()
+
+ExternalProject_Add(
+  external_isl
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  URL ${ISL_DOWNLOAD_DIR}/${ISL_FILE}
+  URL_MD5 ${ISL_URL_MD5}
+  DOWNLOAD_DIR ${ISL_DOWNLOAD_DIR}
+  PREFIX ${ISL_PREFIX_DIR}
+  SOURCE_DIR ${ISL_INSTALL_DIR}
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  UPDATE_COMMAND ""
+  INSTALL_COMMAND ""
+  BUILD_BYPRODUCTS ${ISL_INSTALL_DIR}/lib/libisl.a)
+
+add_library(isl STATIC IMPORTED GLOBAL)
+set_property(TARGET isl PROPERTY IMPORTED_LOCATION
+                                 ${ISL_INSTALL_DIR}/lib/libisl.a)
+add_dependencies(isl external_isl)
+include_directories(${ISL_INSTALL_DIR}/include)

cmake/cinn/external/jitify.cmake

+if(NOT WITH_GPU)
+  set(JITIFY_FOUND OFF)
+  return()
+endif()
+
+include(ExternalProject)
+
+# clone jitify to Paddle/third_party
+set(JITIFY_SOURCE_DIR ${PADDLE_SOURCE_DIR}/third_party/jitify)
+set(JITIFY_URL https://github.com/NVIDIA/jitify.git)
+set(JITIFY_TAG 57de649139c866eb83acacfe50c92ad7c6278776)
+
+ExternalProject_Add(
+  external_jitify
+  ${EXTERNAL_PROJECT_LOG_ARGS}
+  SOURCE_DIR ${JITIFY_SOURCE_DIR}
+  PREFIX ${THIRD_PARTY_PATH}/jitify
+  CONFIGURE_COMMAND ""
+  PATCH_COMMAND ""
+  BUILD_COMMAND ""
+  UPDATE_COMMAND ""
+  INSTALL_COMMAND "")
+
+include_directories(${JITIFY_SOURCE_DIR})
+
+add_library(extern_jitify INTERFACE)
+add_dependencies(extern_jitify external_jitify)
+set(jitify_deps extern_jitify)

cmake/cinn/external/llvm.cmake

+include(FetchContent)
+
+# set(LLVM_DOWNLOAD_URL https://paddle-inference-dist.bj.bcebos.com/CINN/llvm11.tar.gz)
+# set(LLVM_MD5 39d32b6be466781dddf5869318dcba53)
+
+set(LLVM_DOWNLOAD_URL
+    https://paddle-inference-dist.bj.bcebos.com/CINN/llvm11-glibc2.17.tar.gz)
+set(LLVM_MD5 33c7d3cc6d370585381e8d90bd7c2198)
+
+set(FETCHCONTENT_BASE_DIR ${THIRD_PARTY_PATH}/llvm)
+set(FETCHCONTENT_QUIET OFF)
+FetchContent_Declare(
+  external_llvm
+  URL ${LLVM_DOWNLOAD_URL}
+  URL_MD5 ${LLVM_MD5}
+  PREFIX ${THIRD_PARTY_PATH}/llvm SOURCE_DIR ${THIRD_PARTY_PATH}/install/llvm)
+if(NOT LLVM_PATH)
+  FetchContent_GetProperties(external_llvm)
+  if(NOT external_llvm_POPULATED)
+    FetchContent_Populate(external_llvm)
+  endif()
+  set(LLVM_PATH ${THIRD_PARTY_PATH}/install/llvm)
+  set(LLVM_DIR ${THIRD_PARTY_PATH}/install/llvm/lib/cmake/llvm)
+  set(MLIR_DIR ${THIRD_PARTY_PATH}/install/llvm/lib/cmake/mlir)
+else()
+  set(LLVM_DIR ${LLVM_PATH}/lib/cmake/llvm)
+  set(MLIR_DIR ${LLVM_PATH}/lib/cmake/mlir)
+endif()
+
+if(${CMAKE_CXX_COMPILER} STREQUAL "clang++")
+  set(CMAKE_EXE_LINKER_FLAGS
+      "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -lc++abi")
+endif()
+
+message(STATUS "set LLVM_DIR: ${LLVM_DIR}")
+message(STATUS "set MLIR_DIR: ${MLIR_DIR}")
+find_package(LLVM REQUIRED CONFIG HINTS ${LLVM_DIR})
+find_package(MLIR REQUIRED CONFIG HINTS ${MLIR_DIR})
+find_package(ZLIB REQUIRED)
+
+list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+include(AddLLVM)
+
+include_directories(${LLVM_INCLUDE_DIRS})
+list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+list(APPEND CMAKE_MODULE_PATH "${MLIR_CMAKE_DIR}")
+include(AddLLVM)
+include(TableGen)
+include(AddMLIR)
+
+message(STATUS "Found MLIR: ${MLIR_DIR}")
+message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
+message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
+
+# To build with MLIR, the LLVM is build from source code using the following flags:
+
+#[==[
+cmake -G Ninja ../llvm \
+  -DLLVM_ENABLE_PROJECTS="mlir;clang" \
+  -DLLVM_BUILD_EXAMPLES=OFF \
+  -DLLVM_TARGETS_TO_BUILD="X86" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DLLVM_ENABLE_ASSERTIONS=ON \
+  -DLLVM_ENABLE_ZLIB=OFF \
+  -DLLVM_ENABLE_RTTI=ON \
+  -DLLVM_ENABLE_TERMINFO=OFF \
+  -DCMAKE_INSTALL_PREFIX=./install
+#]==]
+
+# The matched llvm-project version is f9dc2b7079350d0fed3bb3775f496b90483c9e42 (currently a temporary commit)
+# Update: to build llvm in manylinux docker with glibc-2.17, and use it in manylinux and ubuntu docker,
+# the patch https://gist.github.com/zhiqiu/6e8d969176dce13d98fd15338a16265e is needed.
+
+add_definitions(${LLVM_DEFINITIONS})
+
+llvm_map_components_to_libnames(
+  llvm_libs
+  Support
+  Core
+  irreader
+  X86
+  executionengine
+  orcjit
+  mcjit
+  all
+  codegen)
+
+message(STATUS "LLVM libs: ${llvm_libs}")
+
+get_property(mlir_libs GLOBAL PROPERTY MLIR_ALL_LIBS)
+message(STATUS "MLIR libs: ${mlir_libs}")
+add_definitions(${LLVM_DEFINITIONS})
+
+# The minimum needed libraries for MLIR IR parse and transform.
+set(MLIR_IR_LIBS
+    MLIRAnalysis
+    MLIRStandardOps
+    MLIRPass
+    MLIRParser
+    MLIRDialect
+    MLIRIR
+    MLIROptLib)
+
+# tb_base is the name of a xxx.td file (without the .td suffix)
+function(mlir_tablegen_on td_base)
+  set(options)
+  set(oneValueArgs DIALECT)
+  cmake_parse_arguments(mlir_tablegen_on "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  set(LLVM_TARGET_DEFINITIONS ${td_base}.td)
+  mlir_tablegen(${td_base}.hpp.inc -gen-op-decls)
+  mlir_tablegen(${td_base}.cpp.inc -gen-op-defs)
+  if(mlir_tablegen_on_DIALECT)
+    mlir_tablegen(${td_base}_dialect.hpp.inc --gen-dialect-decls
+                  -dialect=${mlir_tablegen_on_DIALECT})
+  endif()
+  add_public_tablegen_target(${td_base}_IncGen)
+  add_custom_target(${td_base}_inc DEPENDS ${td_base}_IncGen)
+endfunction()
+
+function(mlir_add_rewriter td_base)
+  set(LLVM_TARGET_DEFINITIONS ${td_base}.td)
+  mlir_tablegen(${td_base}.hpp.inc -gen-rewriters
+                "-I${CMAKE_SOURCE_DIR}/infrt/dialect/pass")
+  add_public_tablegen_target(${td_base}_IncGen)
+  add_custom_target(${td_base}_inc DEPENDS ${td_base}_IncGen)
+endfunction()

cmake/cinn/external/openmp.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.
+
+if(USE_OPENMP STREQUAL "gnu")
+  find_package(OpenMP)
+  if(OPENMP_FOUND)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+    add_definitions(-DCINN_USE_OPENMP)
+    set(WITH_OPENMP ON)
+    message(STATUS "Build with OpenMP ${OpenMP_CXX_LIBRARIES}")
+    message(STATUS "CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS})
+  else()
+    set(WITH_OPENMP OFF)
+  endif()
+elseif(USE_OPENMP STREQUAL "intel")
+  find_package(OpenMP)
+  if(OPENMP_FOUND)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+    message(STATUS "CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS})
+    add_definitions(-DCINN_USE_OPENMP)
+    set(WITH_OPENMP ON)
+    message(STATUS "Build with OpenMP " ${MKLML_IOMP_LIB})
+  else()
+    set(WITH_OPENMP OFF)
+  endif()
+endif()

cmake/cinn/llvm.cmake

+if(${CMAKE_CXX_COMPILER} STREQUAL "clang++")
+  set(CMAKE_EXE_LINKER_FLAGS
+      "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -lc++abi")
+endif()
+
+message(STATUS "set LLVM_DIR: ${LLVM_DIR}")
+message(STATUS "set MLIR_DIR: ${MLIR_DIR}")
+find_package(LLVM REQUIRED CONFIG HINTS ${LLVM_DIR})
+find_package(MLIR REQUIRED CONFIG HINTS ${MLIR_DIR})
+find_package(ZLIB REQUIRED)
+
+list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+include(AddLLVM)
+
+include_directories(${LLVM_INCLUDE_DIRS})
+list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+list(APPEND CMAKE_MODULE_PATH "${MLIR_CMAKE_DIR}")
+include(AddLLVM)
+include(TableGen)
+include(AddMLIR)
+
+message(STATUS "Found MLIR: ${MLIR_DIR}")
+message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
+message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
+
+# To build with MLIR, the LLVM is build from source code using the following flags:
+
+#[==[
+cmake -G Ninja ../llvm \
+  -DLLVM_ENABLE_PROJECTS=mlir \
+  -DLLVM_BUILD_EXAMPLES=OFF \
+  -DLLVM_TARGETS_TO_BUILD="X86" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DLLVM_ENABLE_ASSERTIONS=ON \
+  -DLLVM_ENABLE_ZLIB=OFF \
+  -DLLVM_ENABLE_RTTI=ON \
+#]==]
+# The matched llvm-project version is f9dc2b7079350d0fed3bb3775f496b90483c9e42 (currently a temporary commit)
+
+add_definitions(${LLVM_DEFINITIONS})
+
+llvm_map_components_to_libnames(
+  llvm_libs
+  Support
+  Core
+  irreader
+  X86
+  executionengine
+  orcjit
+  mcjit
+  all
+  codegen)
+
+message(STATUS "LLVM libs: ${llvm_libs}")
+
+get_property(mlir_libs GLOBAL PROPERTY MLIR_ALL_LIBS)
+message(STATUS "MLIR libs: ${mlir_libs}")
+add_definitions(${LLVM_DEFINITIONS})
+
+# The minimum needed libraries for MLIR IR parse and transform.
+set(MLIR_IR_LIBS
+    MLIRAnalysis
+    MLIRStandardOps
+    MLIRPass
+    MLIRParser
+    MLIRDialect
+    MLIRIR
+    MLIROptLib)
+
+# tb_base is the name of a xxx.td file (without the .td suffix)
+function(mlir_tablegen_on td_base)
+  set(options)
+  set(oneValueArgs DIALECT)
+  cmake_parse_arguments(mlir_tablegen_on "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  set(LLVM_TARGET_DEFINITIONS ${td_base}.td)
+  mlir_tablegen(${td_base}.hpp.inc -gen-op-decls)
+  mlir_tablegen(${td_base}.cpp.inc -gen-op-defs)
+  if(mlir_tablegen_on_DIALECT)
+    mlir_tablegen(${td_base}_dialect.hpp.inc --gen-dialect-decls
+                  -dialect=${mlir_tablegen_on_DIALECT})
+  endif()
+  add_public_tablegen_target(${td_base}_IncGen)
+  add_custom_target(${td_base}_inc DEPENDS ${td_base}_IncGen)
+endfunction()

cmake/cinn/nvrtc.cmake

+if(NOT WITH_GPU)
+  return()
+endif()
+
+find_package(PkgConfig)
+
+find_library(
+  CUDA_NVRTC_LIB libnvrtc nvrtc
+  HINTS "${CUDA_TOOLKIT_ROOT_DIR}/lib64" "${LIBNVRTC_LIBRARY_DIR}"
+        "${CUDA_TOOLKIT_ROOT_DIR}/lib/x64" /usr/lib64 /usr/local/cuda/lib64)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(LibNVRTC DEFAULT_MSG CUDA_NVRTC_LIB)
+
+message(STATUS "found NVRTC: ${CUDA_NVRTC_LIB}")
+
+mark_as_advanced(CUDA_NVRTC_LIB)
+
+if(NOT LIBNVRTC_FOUND)
+  message(
+    FATAL_ERROR
+      "Cuda NVRTC Library not found: Specify the LIBNVRTC_LIBRARY_DIR where libnvrtc is located"
+  )
+endif()

cmake/cinn/nvtx.cmake

+if((NOT WITH_GPU)
+   OR WIN32
+   OR APPLE)
+  set(NVTX_FOUND OFF)
+  return()
+endif()
+
+set(NVTX_ROOT
+    "/usr"
+    CACHE PATH "NVTX ROOT")
+find_path(
+  NVTX_INCLUDE_DIR nvToolsExt.h
+  PATHS ${NVTX_ROOT} ${NVTX_ROOT}/include $ENV{NVTX_ROOT}
+        $ENV{NVTX_ROOT}/include ${CUDA_TOOLKIT_INCLUDE}
+  NO_DEFAULT_PATH)
+
+get_filename_component(__libpath_hint ${CUDA_CUDART_LIBRARY} PATH)
+
+set(TARGET_ARCH "x86_64")
+if(NOT ${CMAKE_SYSTEM_PROCESSOR})
+  set(TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+endif()
+
+list(
+  APPEND
+  NVTX_CHECK_LIBRARY_DIRS
+  ${NVTX_ROOT}
+  ${NVTX_ROOT}/lib64
+  ${NVTX_ROOT}/lib
+  ${NVTX_ROOT}/lib/${TARGET_ARCH}-linux-gnu
+  $ENV{NVTX_ROOT}
+  $ENV{NVTX_ROOT}/lib64
+  $ENV{NVTX_ROOT}/lib
+  ${CUDA_TOOLKIT_ROOT_DIR}
+  ${CUDA_TOOLKIT_ROOT_DIR}/targets/${TARGET_ARCH}-linux/lib)
+
+find_library(
+  CUDA_NVTX_LIB
+  NAMES libnvToolsExt.so
+  PATHS ${NVTX_CHECK_LIBRARY_DIRS} ${NVTX_INCLUDE_DIR} ${__libpath_hint}
+  NO_DEFAULT_PATH
+  DOC "Path to the NVTX library.")
+
+if(NVTX_INCLUDE_DIR AND CUDA_NVTX_LIB)
+  set(NVTX_FOUND ON)
+else()
+  set(NVTX_FOUND OFF)
+endif()
+
+if(NVTX_FOUND)
+  include_directories(${NVTX_INCLUDE_DIR})
+  add_definitions(-DCINN_WITH_NVTX)
+endif()

cmake/cinn/system.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.
+
+# Detects the OS and sets appropriate variables.
+# CMAKE_SYSTEM_NAME only give us a coarse-grained name of the OS CMake is
+# building for, but the host processor name like centos is necessary
+# in some scenes to distinguish system for customization.
+#
+# for instance, protobuf libs path is <install_dir>/lib64
+# on CentOS, but <install_dir>/lib on other systems.
+
+if(UNIX AND NOT APPLE)
+  # except apple from nix*Os family
+  set(LINUX TRUE)
+endif()
+
+if(WIN32)
+  set(HOST_SYSTEM "win32")
+else()
+  if(APPLE)
+    set(HOST_SYSTEM "macosx")
+    exec_program(
+      sw_vers ARGS
+      -productVersion
+      OUTPUT_VARIABLE HOST_SYSTEM_VERSION)
+    string(REGEX MATCH "[0-9]+.[0-9]+" MACOS_VERSION "${HOST_SYSTEM_VERSION}")
+    if(NOT DEFINED $ENV{MACOSX_DEPLOYMENT_TARGET})
+      # Set cache variable - end user may change this during ccmake or cmake-gui configure.
+      set(CMAKE_OSX_DEPLOYMENT_TARGET
+          ${MACOS_VERSION}
+          CACHE
+            STRING
+            "Minimum OS X version to target for deployment (at runtime); newer APIs weak linked. Set to empty string for default value."
+      )
+    endif()
+    set(CMAKE_EXE_LINKER_FLAGS "-framework CoreFoundation -framework Security")
+  else()
+
+    if(EXISTS "/etc/issue")
+      file(READ "/etc/issue" LINUX_ISSUE)
+      if(LINUX_ISSUE MATCHES "CentOS")
+        set(HOST_SYSTEM "centos")
+      elseif(LINUX_ISSUE MATCHES "Debian")
+        set(HOST_SYSTEM "debian")
+      elseif(LINUX_ISSUE MATCHES "Ubuntu")
+        set(HOST_SYSTEM "ubuntu")
+      elseif(LINUX_ISSUE MATCHES "Red Hat")
+        set(HOST_SYSTEM "redhat")
+      elseif(LINUX_ISSUE MATCHES "Fedora")
+        set(HOST_SYSTEM "fedora")
+      endif()
+
+      string(REGEX MATCH "(([0-9]+)\\.)+([0-9]+)" HOST_SYSTEM_VERSION
+                   "${LINUX_ISSUE}")
+    endif()
+
+    if(EXISTS "/etc/redhat-release")
+      file(READ "/etc/redhat-release" LINUX_ISSUE)
+      if(LINUX_ISSUE MATCHES "CentOS")
+        set(HOST_SYSTEM "centos")
+      endif()
+    endif()
+
+    if(NOT HOST_SYSTEM)
+      set(HOST_SYSTEM ${CMAKE_SYSTEM_NAME})
+    endif()
+
+  endif()
+endif()
+
+# query number of logical cores
+cmake_host_system_information(RESULT CPU_CORES QUERY NUMBER_OF_LOGICAL_CORES)
+
+mark_as_advanced(HOST_SYSTEM CPU_CORES)
+
+message(
+  STATUS
+    "Found Paddle host system: ${HOST_SYSTEM}, version: ${HOST_SYSTEM_VERSION}")
+message(STATUS "Found Paddle host system's CPU: ${CPU_CORES} cores")
+
+# external dependencies log output
+set(EXTERNAL_PROJECT_LOG_ARGS
+    LOG_DOWNLOAD
+    0 # Wrap download in script to log output
+    LOG_UPDATE
+    1 # Wrap update in script to log output
+    LOG_CONFIGURE
+    1 # Wrap configure in script to log output
+    LOG_BUILD
+    0 # Wrap build in script to log output
+    LOG_TEST
+    1 # Wrap test in script to log output
+    LOG_INSTALL
+    0 # Wrap install in script to log output
+)

cmake/cinn/version.cmake

+# Get the latest git tag.
+set(CINN_VERSION $ENV{CINN_VERSION})
+set(tmp_version "HEAD")
+set(TAG_VERSION_REGEX "[0-9]+\\.[0-9]+\\.[0-9]+(\\.(a|b|rc)\\.[0-9]+)?")
+set(COMMIT_VERSION_REGEX "[0-9a-f]+[0-9a-f]+[0-9a-f]+[0-9a-f]+[0-9a-f]+")
+while("${CINN_VERSION}" STREQUAL "")
+  # Check current branch name
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref ${tmp_version}
+    WORKING_DIRECTORY ${PADDLE_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_BRANCH_NAME
+    RESULT_VARIABLE GIT_BRANCH_RESULT
+    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if(NOT ${GIT_BRANCH_RESULT})
+    execute_process(
+      COMMAND ${GIT_EXECUTABLE} describe --tags --abbrev=0 --always
+              ${tmp_version}
+      WORKING_DIRECTORY ${PADDLE_SOURCE_DIR}
+      OUTPUT_VARIABLE GIT_TAG_NAME
+      RESULT_VARIABLE GIT_RESULT
+      ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT ${GIT_RESULT})
+      # Check if current branch is release branch
+      if(${GIT_BRANCH_NAME} MATCHES "release/${TAG_VERSION_REGEX}")
+        # Check the tag is a correct version
+        if(${GIT_TAG_NAME} MATCHES "${COMMIT_VERSION_REGEX}")
+          # if no tag was found, set CINN_VERSION to 0.0.0 to represent latest
+          set(CINN_VERSION "0.0.0")
+        elseif(${GIT_TAG_NAME} MATCHES "v${TAG_VERSION_REGEX}")
+          string(REPLACE "v" "" CINN_VERSION ${GIT_TAG_NAME})
+        else() # otherwise, get the previous git tag name.
+          set(tmp_version "${GIT_TAG_NAME}~1")
+        endif()
+      else()
+        execute_process(
+          COMMAND ${GIT_EXECUTABLE} describe --exact-match --tags ${tmp_version}
+          WORKING_DIRECTORY ${PADDLE_SOURCE_DIR}
+          OUTPUT_VARIABLE GIT_EXACT_TAG_NAME
+          RESULT_VARIABLE GIT_EXACT_TAG_RESULT
+          ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(NOT ${GIT_EXACT_TAG_NAME})
+          # Check if current branch is tag branch
+          if(${GIT_EXACT_TAG_NAME} MATCHES "v${TAG_VERSION_REGEX}")
+            string(REPLACE "v" "" CINN_VERSION ${GIT_EXACT_TAG_NAME})
+          else()
+            set(CINN_VERSION "0.0.0")
+          endif()
+        else()
+          # otherwise, we always set CINN_VERSION to 0.0.0 to represent latest
+          set(CINN_VERSION "0.0.0")
+        endif()
+      endif()
+    else()
+      set(CINN_VERSION "0.0.0")
+      message(WARNING "Cannot add CINN version from git tag")
+    endif()
+  else()
+    set(CINN_VERSION "0.0.0")
+    message(WARNING "Cannot add CINN version for wrong git branch result")
+  endif()
+endwhile()
+
+string(REPLACE "-" "." CINN_VER_LIST ${CINN_VERSION})
+string(REPLACE "." ";" CINN_VER_LIST ${CINN_VER_LIST})
+list(GET CINN_VER_LIST 0 CINN_MAJOR_VER)
+list(GET CINN_VER_LIST 1 CINN_MINOR_VER)
+list(GET CINN_VER_LIST 2 CINN_PATCH_VER)
+math(EXPR CINN_VERSION_INTEGER "${CINN_MAJOR_VER} * 1000000
+    + ${CINN_MINOR_VER} * 1000 + ${CINN_PATCH_VER}")
+
+add_definitions(-DCINN_VERSION=${CINN_VERSION})
+add_definitions(-DCINN_VERSION_INTEGER=${CINN_VERSION_INTEGER})
+message(
+  STATUS
+    "CINN version is ${CINN_VERSION} (major: ${CINN_MAJOR_VER}, minor: ${CINN_MINOR_VER}, patch: ${CINN_PATCH_VER})"
+)

cmake/configure.cmake

@@ -93,18 +93,6 @@ if(WITH_BOX_PS)
   add_definitions(-DPADDLE_WITH_BOX_PS)
 endif()
 
-if(WITH_ASCEND)
-  add_definitions(-DPADDLE_WITH_ASCEND)
-endif()
-
-if(WITH_ASCEND_CL)
-  add_definitions(-DPADDLE_WITH_ASCEND_CL)
-endif()
-
-if(WITH_ASCEND_INT64)
-  add_definitions(-DPADDLE_WITH_ASCEND_INT64)
-endif()
-
 if(WITH_XPU)
   message(STATUS "Compile with XPU!")
   add_definitions(-DPADDLE_WITH_XPU)
@@ -120,11 +108,6 @@ if(WITH_IPU)
   add_definitions(-DPADDLE_WITH_IPU)
 endif()
 
-if(WITH_MLU)
-  message(STATUS "Compile with MLU!")
-  add_definitions(-DPADDLE_WITH_MLU)
-endif()
-
 if(WITH_GPU)
   add_definitions(-DPADDLE_WITH_CUDA)
   add_definitions(-DEIGEN_USE_GPU)
@@ -222,6 +205,10 @@ if(WITH_PSCORE)
   add_definitions(-DPADDLE_WITH_PSCORE)
 endif()
 
+if(WITH_RPC)
+  add_definitions(-DPADDLE_WITH_RPC)
+endif()
+
 if(WITH_HETERPS)
   add_definitions(-DPADDLE_WITH_HETERPS)
 endif()
@@ -244,3 +231,11 @@ endif()
 if(WITH_GPU_GRAPH)
   add_definitions(-DPADDLE_WITH_GPU_GRAPH)
 endif()
+
+if(WITH_CUDNN_FRONTEND)
+  add_definitions(-DPADDLE_WITH_CUDNN_FRONTEND)
+endif()
+
+if(WITH_SHARED_PHI)
+  add_definitions(-DPHI_SHARED)
+endif()

cmake/copyfile.py

@@ -12,32 +12,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import glob
 import os
-import sys
 import shutil
-import glob
+import sys
 
 
 def main():
     src = sys.argv[1]
     dst = sys.argv[2]
-    if os.path.isdir(src):  #copy directory
+    if os.path.isdir(src):  # copy directory
         pathList = os.path.split(src)
         dst = os.path.join(dst, pathList[-1])
         if not os.path.exists(dst):
             shutil.copytree(src, dst)
-            print("first copy directory: {0} --->>> {1}".format(src, dst))
+            print(f"first copy directory: {src} --->>> {dst}")
         else:
             shutil.rmtree(dst)
             shutil.copytree(src, dst)
-            print("overwritten copy directory: {0} --->>> {1}".format(src, dst))
-    else:  #copy file, wildcard
+            print(f"overwritten copy directory: {src} --->>> {dst}")
+    else:  # copy file, wildcard
         if not os.path.exists(dst):
             os.makedirs(dst)
         srcFiles = glob.glob(src)
         for srcFile in srcFiles:
             shutil.copy(srcFile, dst)
-            print("copy file: {0} --->>> {1}".format(srcFile, dst))
+            print(f"copy file: {srcFile} --->>> {dst}")
 
 
 if __name__ == "__main__":

cmake/cuda.cmake

@@ -2,33 +2,41 @@ if(NOT WITH_GPU)
   return()
 endif()
 
+#(risemeup1) note: CMake 3.18 needs to specify the value of CMAKE_CUDA_ARCHITECTURES，otherwise a large number of warnings may appear in cmake
+set(CMAKE_CUDA_ARCHITECTURES OFF)
+
 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")
   set(paddle_known_gpu_archs11 "53 62 72 87")
+  set(paddle_known_gpu_archs12 "53 62 72 87 90")
 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_archs "50 52 60 61 70 75 80 86 90")
+  set(paddle_known_gpu_archs10 "50 52 60 61 70 75")
   set(paddle_known_gpu_archs11 "50 60 61 70 75 80")
+  set(paddle_known_gpu_archs12 "50 60 61 70 75 80 90")
 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_archs "50 52 60 61 70 75 80 86 90")
   set(paddle_known_gpu_archs10 "")
-  set(paddle_known_gpu_archs11 "60 61 70 75 80")
+  set(paddle_known_gpu_archs11 "61 70 75 80")
+  set(paddle_known_gpu_archs12 "61 70 75 80 90")
 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")
+  set(paddle_known_gpu_archs "50 52 60 61 70 75 80 86 90")
+  set(paddle_known_gpu_archs10 "50 60 70 75")
+  set(paddle_known_gpu_archs11 "50 60 70 75 80")
+  set(paddle_known_gpu_archs12 "50 60 70 75 80 90")
 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_archs "50 52 60 61 70 75 80 90")
+  set(paddle_known_gpu_archs10 "50 52 60 61 70 75")
   set(paddle_known_gpu_archs11 "52 60 61 70 75 80")
+  set(paddle_known_gpu_archs12 "52 60 61 70 75 80 90")
 endif()
 
 ######################################################################################
@@ -58,7 +66,8 @@ function(detect_installed_gpus out_variable)
       "}\n")
 
     execute_process(
-      COMMAND "${CUDA_NVCC_EXECUTABLE}" "--run" "${cufile}"
+      COMMAND "${CUDA_NVCC_EXECUTABLE}" "-ccbin=${CMAKE_C_COMPILER}" "--run"
+              "${cufile}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/CMakeFiles/"
       RESULT_VARIABLE nvcc_res
       OUTPUT_VARIABLE nvcc_out
@@ -96,15 +105,15 @@ 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)
+function(select_nvcc_arch_flags out_variable out_arch_bin)
   # List of arch names
   set(archs_names
-      "Kepler"
       "Maxwell"
       "Pascal"
       "Volta"
       "Turing"
       "Ampere"
+      "Hopper"
       "All"
       "Manual")
   set(archs_name_default "Auto")
@@ -143,9 +152,7 @@ function(select_nvcc_arch_flags out_variable)
     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(${CUDA_ARCH_NAME} STREQUAL "Maxwell")
     if(WITH_NV_JETSON)
       set(cuda_arch_bin "53")
     else()
@@ -171,10 +178,12 @@ function(select_nvcc_arch_flags out_variable)
     else()
       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+
+      else()
         set(cuda_arch_bin "80 86")
       endif()
     endif()
+  elseif(${CUDA_ARCH_NAME} STREQUAL "Hopper")
+    set(cuda_arch_bin "90")
   elseif(${CUDA_ARCH_NAME} STREQUAL "All")
     set(cuda_arch_bin ${paddle_known_gpu_archs})
   elseif(${CUDA_ARCH_NAME} STREQUAL "Auto")
@@ -207,6 +216,7 @@ function(select_nvcc_arch_flags out_variable)
 
   set(nvcc_flags "")
   set(nvcc_archs_readable "")
+  set(nvcc_archs_bin_list "")
 
   # Tell NVCC to add binaries for the specified GPUs
   foreach(arch ${cuda_arch_bin})
@@ -215,10 +225,12 @@ function(select_nvcc_arch_flags out_variable)
       string(APPEND nvcc_flags
              " -gencode arch=compute_${CMAKE_MATCH_2},code=sm_${CMAKE_MATCH_1}")
       string(APPEND nvcc_archs_readable " sm_${CMAKE_MATCH_1}")
+      string(APPEND nvcc_archs_bin_list " ${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}")
+      string(APPEND nvcc_archs_bin_list " ${arch}")
     endif()
   endforeach()
 
@@ -230,12 +242,20 @@ function(select_nvcc_arch_flags out_variable)
   endforeach()
 
   string(REPLACE ";" " " nvcc_archs_readable "${nvcc_archs_readable}")
+  string(REGEX MATCHALL "[0-9()]+" nvcc_archs_bin_list "${nvcc_archs_bin_list}")
+  string(JOIN "," nvcc_real_archs ${nvcc_archs_bin_list})
   set(${out_variable}
       ${nvcc_flags}
       PARENT_SCOPE)
   set(${out_variable}_readable
       ${nvcc_archs_readable}
       PARENT_SCOPE)
+  set(${out_variable}_real_archs
+      ${nvcc_real_archs}
+      PARENT_SCOPE)
+  set(${out_arch_bin}
+      ${cuda_arch_bin}
+      PARENT_SCOPE)
 endfunction()
 
 message(STATUS "CUDA detected: " ${CMAKE_CUDA_COMPILER_VERSION})
@@ -254,6 +274,11 @@ elseif(${CMAKE_CUDA_COMPILER_VERSION} LESS 12.0) # CUDA 11.2+
   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 13.0) # CUDA 12.0+
+  set(paddle_known_gpu_archs "${paddle_known_gpu_archs12} 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)
@@ -265,7 +290,7 @@ 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)
+select_nvcc_arch_flags(NVCC_FLAGS_EXTRA NVCC_ARCH_BIN)
 set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${NVCC_FLAGS_EXTRA}")
 message(STATUS "NVCC_FLAGS_EXTRA: ${NVCC_FLAGS_EXTRA}")
 
@@ -273,7 +298,7 @@ message(STATUS "NVCC_FLAGS_EXTRA: ${NVCC_FLAGS_EXTRA}")
 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)
+set(CMAKE_CUDA_STANDARD 17)
 
 # (Note) For windows, if delete /W[1-4], /W1 will be added defaultly and conflic with -w
 # So replace /W[1-4] with /W0

cmake/cudnn.cmake

@@ -29,11 +29,13 @@ list(
   ${CUDNN_ROOT}
   ${CUDNN_ROOT}/lib64
   ${CUDNN_ROOT}/lib
+  ${CUDNN_ROOT}/lib/x64
   ${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
+  $ENV{CUDNN_ROOT}/lib/x64
   /usr/lib
   ${CUDA_TOOLKIT_ROOT_DIR}
   ${CUDA_TOOLKIT_ROOT_DIR}/lib/x64)

cmake/cupti.cmake

@@ -2,9 +2,15 @@ if(NOT WITH_GPU AND NOT WITH_ROCM)
   return()
 endif()
 
-set(CUPTI_ROOT
+if(WITH_ROCM)
+  set(CUPTI_ROOT
+      "${ROCM_PATH}/cuda/extras/CUPTI"
+      CACHE PATH "CUPTI ROOT")
+else()
+  set(CUPTI_ROOT
       "/usr"
       CACHE PATH "CUPTI ROOT")
+endif()
 find_path(
   CUPTI_INCLUDE_DIR cupti.h
   PATHS ${CUPTI_ROOT}
@@ -46,6 +52,10 @@ find_library(
 get_filename_component(CUPTI_LIBRARY_PATH ${CUPTI_LIBRARY} DIRECTORY)
 if(CUPTI_INCLUDE_DIR AND CUPTI_LIBRARY)
   set(CUPTI_FOUND ON)
+  if(WITH_ROCM)
+    include_directories(${ROCM_PATH}/cuda/include)
+    add_definitions(-D__CUDA_HIP_PLATFORM_AMD__)
+  endif()
 else()
   set(CUPTI_FOUND OFF)
 endif()

cmake/experiments/cuda_module_loading_lazy.cmake

@@ -45,6 +45,9 @@ if(LINUX)
       CACHE BOOL "" FORCE)
   set(CMAKE_CUDA_FLAGS "--cudart shared")
   enable_language(CUDA)
+  set(CMAKE_CUDA_COMPILER
+      "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy"
+      CACHE FILEPATH "" FORCE)
   execute_process(
     COMMAND "rm" "-rf" "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy"
     COMMAND "chmod" "755" "${CMAKE_SOURCE_DIR}/tools/nvcc_lazy.sh"
@@ -54,7 +57,4 @@ if(LINUX)
   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.
+# Copyright (c) 2023 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.
@@ -32,12 +32,15 @@ if((NOT DEFINED ARM_BRPC_NAME) OR (NOT DEFINED ARM_BRPC_URL))
   set(ARM_BRPC_NAME
       "arm_brpc"
       CACHE STRING "" FORCE)
+  set(ARM_BRPC_URL
+      "https://paddlerec.bj.bcebos.com/online_infer/arm_brpc_ubuntu18/output.tar.gz"
+      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_DOWNLOAD_DIR "${PADDLE_SOURCE_DIR}/third_party/arm_brpc")
 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)
@@ -49,32 +52,32 @@ set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH}" "${ARM_BRPC_ROOT}/lib")
 
 include_directories(${ARM_BRPC_INSTALL_ROOT}/${ARM_BRPC_NAME}/output/include)
 
+file(
+  DOWNLOAD ${ARM_BRPC_URL} ${ARM_BRPC_DOWNLOAD_DIR}
+  TLS_VERIFY OFF
+  STATUS ERR)
+
 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
+  SOURCE_DIR ${ARM_BRPC_INSTALL_DIR}
   UPDATE_COMMAND ""
+  COMMAND ${CMAKE_COMMAND} -E copy ${ARM_BRPC_DOWNLOAD_DIR}/CMakeLists.txt
+          ${ARM_BRPC_INSTALL_DIR}
   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) # 直接导入已经生成的库
+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.
+# Copyright (c) 2023 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.
@@ -23,13 +23,17 @@ if((NOT DEFINED BOX_PS_VER) OR (NOT DEFINED BOX_PS_URL))
   set(BOX_PS_NAME
       "box_ps"
       CACHE STRING "" FORCE)
+  set(BOX_PS_DOWNLOAD_FILE
+      ${BOX_PS_NAME}.tar.gz
+      CACHE STRING "" FORCE)
   set(BOX_PS_URL
-      "http://box-ps.gz.bcebos.com/box_ps.tar.gz"
+      "http://box-ps.gz.bcebos.com/${BOX_PS_DOWNLOAD_FILE}"
       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_DOWNLOAD_DIR
+    "${PADDLE_SOURCE_DIR}/third_party/box_ps/${CMAKE_SYSTEM_NAME}")
 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})
@@ -40,20 +44,27 @@ 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(
+  DOWNLOAD ${BOX_PS_URL} ${BOX_PS_DOWNLOAD_DIR}/${BOX_PS_DOWNLOAD_FILE}
+  TLS_VERIFY OFF
+  STATUS ERR)
+
 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"
+  "install(DIRECTORY ./include ./lib \n"
   "        DESTINATION ${BOX_PS_DST_DIR})\n")
 ExternalProject_Add(
   ${BOX_PS_PROJECT}
   ${EXTERNAL_PROJECT_LOG_ARGS}
+  URL ${BOX_PS_DOWNLOAD_DIR}/${BOX_PS_DOWNLOAD_FILE}
   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
+  SOURCE_DIR ${BOX_PS_INSTALL_DIR}
   UPDATE_COMMAND ""
+  COMMAND ${CMAKE_COMMAND} -E copy ${BOX_PS_DOWNLOAD_DIR}/CMakeLists.txt
+          ${BOX_PS_INSTALL_DIR}
   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}