# 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(NOT WITH_XPU)
  return()
endif()

include(ExternalProject)
set(XPU_PROJECT "extern_xpu")
set(XPU_API_LIB_NAME "libxpuapi.so")
set(XPU_RT_LIB_NAME "libxpurt.so")
set(XPU_CUDA_LIB_NAME "libxpucuda.so")
set(XPU_CUDA_RT_LIB_NAME "libcudart.so")
set(XPU_ML_LIB_NAME "libxpuml.so")
set(XPU_XFT_LIB_NAME "libxft.so")
set(XPU_XPTI_LIB_NAME "libxpti.so")
set(XPU_XPUTX_LIB_NAME "libxpuToolsExt.so")
set(XPU_CUPTI_LIB_NAME "libcupti.so")
set(XPU_XBLAS_LIB_NAME "libxpu_blas.so")
set(XPU_XBLAS_JITC_LIB_NAME "libxpujitc.so")
set(XPU_XBLAS_LLVM_LIB_NAME "libLLVM-15.so")
set(XPU_XBLAS_CLANG_LIB_NAME "libclang-cpp.so.15")
set(XPU_XBLAS_CLANG_NAME "clang")
set(XPU_XBLAS_LLD_NAME "ld.lld")
set(XPU_XBLAS_CLUSTER_BUILTINS_P800_ENC_NAME "cluster_builtins_p800.enc")
set(XPU_XBLAS_SDNN_BUILTINS_P800_ENC_NAME "sdnn_builtins_p800.enc")
set(XPU_XBLAS_XBFLOAT16_BUILTINS_P800_ENC_NAME "xbfloat16_wrapper.enc")
set(XPU_XBLAS_XCCL_BUILTINS_P800_ENC_NAME "xccl_builtins_p800.enc")
set(XPU_XFA_LIB_NAME "libxpu_flash_attention.so")
set(XPU_XPUDNN_LIB_NAME "libxpu_dnn.so")
set(XPU_XPUDNN_OMP_LIB_NAME "libomp.so")
set(XPU_FFT_LIB_NAME "libcufft.so")
# Avoid deprecated int32 apis:
add_compile_definitions(XPUAPI_NOT_INCLUDE_DEPRECATED)

if(NOT DEFINED XPU_XHPC_BASE_DATE)
  set(XPU_XHPC_BASE_DATE "dev/20260523")
endif()
if(WITH_ARM)
  set(XPU_XCCL_BASE_VERSION "20251104") # For XRE5
else()
  set(XPU_XCCL_BASE_VERSION "3.0.8.0") # For XRE5
endif()
if(NOT DEFINED XPU_XFT_BASE_VERSION)
  set(XPU_XFT_BASE_VERSION "20250507/xpu3")
endif()

if(NOT DEFINED XPU_XRE_BASE_VERSION)
  if(WITH_XPU_XRE5)
    set(XPU_XRE_BASE_VERSION "5.7.0.0")
  else()
    set(XPU_XRE_BASE_VERSION "4.32.0.1")
  endif()
endif()

if(WITH_XPU_XRE5)
  set(XPU_XPTI_BASE_VERSION "0.2.0")
else()
  set(XPU_XPTI_BASE_VERSION "0.0.1")
endif()

if(WITH_XPU_XRE5)
  set(XPU_XPUTX_BASE_VERSION "2.0.2.4")
endif()

if(WITH_XPU_XRE5)
  set(XPU_CUPTI_BASE_VERSION "1.0.1.0")
endif()

if(NOT DEFINED XPU_FFT_BASE_DATE)
  if(WITH_ARM)
    set(XPU_FFT_BASE_DATE "20251017")
  else()
    set(XPU_FFT_BASE_DATE "20251230")
  endif()
endif()

set(XPU_XRE_BASE_URL
    "https://klx-sdk-release-public.su.bcebos.com/xre/release/${XPU_XRE_BASE_VERSION}"
)

set(XPU_XCCL_BASE_URL
    "https://klx-sdk-release-public.su.bcebos.com/xccl/release/2.0.0.1" # 2.0.0.1 is the final version for R200
)

if(NOT XPU_XFT_BASE_URL)
  set(XPU_XFT_BASE_URL
      "https://klx-sdk-release-public.su.bcebos.com/xft_internal/dev/${XPU_XFT_BASE_VERSION}"
  )
endif()

if(WITH_XPTI)
  set(XPU_XPTI_BASE_URL
      "https://klx-sdk-release-public.su.bcebos.com/xpti/dev/${XPU_XPTI_BASE_VERSION}"
  )
  set(XPU_XPTI_DIR_NAME "xpti")
endif()

if(WITH_XPU_XRE5)
  set(XPU_XRE_BASE_URL
      "https://klx-sdk-release-public.su.bcebos.com/xre/kl3-release/${XPU_XRE_BASE_VERSION}"
  )
  set(XPU_XCCL_BASE_URL
      "https://klx-sdk-release-public.su.bcebos.com/xccl/release/${XPU_XCCL_BASE_VERSION}"
  )
  set(XPU_XPUTX_BASE_URL
      "https://klx-sdk-release-public.su.bcebos.com/xre/xprofiler/release")
  set(XPU_XPUTX_DIR_NAME "xprofiler-Linux_x86_64-${XPU_XPUTX_BASE_VERSION}")
  set(XPU_CUPTI_BASE_URL
      "https://klx-sdk-release-public.su.bcebos.com/cupti/paddle-dev/${XPU_CUPTI_BASE_VERSION}"
  )
  set(XPU_CUPTI_DIR_NAME "cupti-11.8-Linux")
endif()

if(WITH_XPU_FFT)
  set(XPU_FFT_BASE_URL "https://klx-sdk-release-public.su.bcebos.com/xpufft")
endif()

if(WITH_ARM)
  if(WITH_XPU_XRE5)
    set(XPU_XRE_DIR_NAME "xre-kylin_v10_server-aarch64-${XPU_XRE_BASE_VERSION}")
    # TODO: xccl has no kylin output now. set default value here.
    set(XPU_XCCL_DIR_NAME "xccl_Linux_aarch64")
    set(XPU_XHPC_DIR_NAME "xhpc-kylinv4_aarch64")
    set(XPU_XFT_DIR_NAME "") # TODO: xft has no kylin output at now.
  else()
    set(XPU_XRE_DIR_NAME "")
    set(XPU_XCCL_DIR_NAME "") # TODO: xccl has no kylin output now.
    set(XPU_XFT_DIR_NAME "") # TODO: xft has no kylin output at now.
  endif()
  if(WITH_XPU_FFT)
    set(XPU_FFT_DIR_NAME
        "kylin_v10_aarch64/${XPU_FFT_BASE_DATE}/xpufft_kylinv10_aarch64")
  endif()
elseif(WITH_SUNWAY)
  set(XPU_XRE_DIR_NAME "xre-deepin_sw6_64")
  set(XPU_XCCL_DIR_NAME "") # TODO: xccl has no deepin output at now.
  set(XPU_XFT_DIR_NAME "") # TODO: xft has no deepin output at now.
elseif(WITH_BDCENTOS)
  set(XPU_XHPC_DIR_NAME "xhpc-bdcentos7_x86_64")
  if(WITH_XPU_XRE5)
    set(XPU_XRE_DIR_NAME "xre-bdcentos-x86_64-${XPU_XRE_BASE_VERSION}")
  else()
    set(XPU_XRE_DIR_NAME "xre-bdcentos_x86_64")
  endif()
  set(XPU_XCCL_DIR_NAME "xccl_bdcentos_x86_64")
  set(XPU_XFT_DIR_NAME "xft_bdcentos6u3_x86_64_gcc82")
elseif(WITH_CENTOS)
  set(XPU_XRE_DIR_NAME "xre-centos7_x86_64")
  set(XPU_XCCL_DIR_NAME "xccl_Linux_x86_64")
  set(XPU_XFT_DIR_NAME "xft_bdcentos6u3_x86_64_gcc82")
else()
  # Ubuntu as default
  if(WITH_XPU_XRE5)
    set(XPU_XRE_DIR_NAME "xre-ubuntu_2004-x86_64-${XPU_XRE_BASE_VERSION}")
    set(XPU_XHPC_DIR_NAME "xhpc-ubuntu2004_x86_64")
  else()
    set(XPU_XRE_DIR_NAME "xre-ubuntu_1604_x86_64")
    set(XPU_XHPC_DIR_NAME "xhpc-ubuntu1604_x86_64")
  endif()
  if(WITH_XPU_FFT)
    set(XPU_FFT_DIR_NAME "kl3/${XPU_FFT_BASE_DATE}/xpufft_ubuntu2004-x86_64")
  endif()
  set(XPU_XCCL_DIR_NAME "xccl_Linux_x86_64")
  set(XPU_XFT_DIR_NAME "xft_internal_ubuntu2004")
endif()

set(XPU_XRE_URL
    "${XPU_XRE_BASE_URL}/${XPU_XRE_DIR_NAME}.tar.gz"
    CACHE STRING "" FORCE)
set(XPU_XCCL_URL
    "${XPU_XCCL_BASE_URL}/${XPU_XCCL_DIR_NAME}.tar.gz"
    CACHE STRING "" FORCE)
set(XPU_XFT_URL "${XPU_XFT_BASE_URL}/${XPU_XFT_DIR_NAME}.tar.gz")
set(XPU_XFT_GET_DEPENCE_URL
    "https://baidu-kunlun-public.su.bcebos.com/paddle_depence/get_xft_dependence.sh"
    CACHE STRING "" FORCE)

if(WITH_XPTI)
  set(XPU_XPTI_URL "${XPU_XPTI_BASE_URL}/${XPU_XPTI_DIR_NAME}.tar.gz")
endif()

if(WITH_XPU_FFT)
  set(XPU_FFT_URL "${XPU_FFT_BASE_URL}/${XPU_FFT_DIR_NAME}.tar.gz")
endif()

set(XPU_XHPC_URL
    "https://klx-sdk-release-public.su.bcebos.com/xhpc/${XPU_XHPC_BASE_DATE}/${XPU_XHPC_DIR_NAME}.tar.gz"
    CACHE STRING "" FORCE)

set(XPU_XPUTX_URL "${XPU_XPUTX_BASE_URL}/${XPU_XPUTX_DIR_NAME}.tar.gz")
set(XPU_CUPTI_URL "${XPU_CUPTI_BASE_URL}/${XPU_CUPTI_DIR_NAME}.tar.gz")

if(DEFINED XPU_BASE_URL)
  set(XPU_XRE_URL "${XPU_BASE_URL}/${XPU_XRE_DIR_NAME}.tar.gz")
  set(XPU_XHPC_URL "${XPU_BASE_URL}/${XPU_XHPC_DIR_NAME}.tar.gz")
  set(XPU_XCCL_URL "${XPU_BASE_URL}/${XPU_XCCL_DIR_NAME}.tar.gz")
endif()

set(SNAPPY_PREFIX_DIR "${THIRD_PARTY_PATH}/xpu")
set(XPU_DOWNLOAD_DIR "${SNAPPY_PREFIX_DIR}/src/${XPU_PROJECT}")
set(XPU_INSTALL_DIR "${THIRD_PARTY_PATH}/install/xpu")
set(XPU_INC_DIR "${THIRD_PARTY_PATH}/install/xpu/include")
set(XPU_LIB_DIR "${THIRD_PARTY_PATH}/install/xpu/lib")

set(XPU_API_LIB "${XPU_LIB_DIR}/${XPU_API_LIB_NAME}")
set(XPU_XBLAS_LIB "${XPU_LIB_DIR}/${XPU_XBLAS_LIB_NAME}")
set(XPU_XBLAS_JITC_LIB "${XPU_LIB_DIR}/${XPU_XBLAS_JITC_LIB_NAME}")
set(XPU_XBLAS_LLVM_LIB "${XPU_LIB_DIR}/${XPU_XBLAS_LLVM_LIB_NAME}")
set(XPU_XBLAS_CLANG_LIB "${XPU_LIB_DIR}/${XPU_XBLAS_CLANG_LIB_NAME}")
set(XPU_XBLAS_CLANG "${XPU_LIB_DIR}/${XPU_XBLAS_CLANG_NAME}")
set(XPU_XBLAS_LLD "${XPU_LIB_DIR}/${XPU_XBLAS_LLD_NAME}")
set(XPU_XBLAS_CLUSTER_BUILTINS_P800_ENC
    "${XPU_LIB_DIR}/${XPU_XBLAS_CLUSTER_BUILTINS_P800_ENC_NAME}")
set(XPU_XBLAS_SDNN_BUILTINS_P800_ENC
    "${XPU_LIB_DIR}/${XPU_XBLAS_SDNN_BUILTINS_P800_ENC_NAME}")
set(XPU_XBLAS_XBFLOAT16_BUILTINS_P800_ENC
    "${XPU_LIB_DIR}/${XPU_XBLAS_XBFLOAT16_BUILTINS_P800_ENC_NAME}")
set(XPU_XBLAS_XCCL_BUILTINS_P800_ENC
    "${XPU_LIB_DIR}/${XPU_XBLAS_XCCL_BUILTINS_P800_ENC_NAME}")
set(XPU_RT_LIB "${XPU_LIB_DIR}/${XPU_RT_LIB_NAME}")
set(XPU_CUDA_LIB "${XPU_LIB_DIR}/${XPU_CUDA_LIB_NAME}")
set(XPU_CUDA_RT_LIB "${XPU_LIB_DIR}/${XPU_CUDA_RT_LIB_NAME}")
set(XPU_ML_LIB "${XPU_LIB_DIR}/${XPU_ML_LIB_NAME}")
set(XPU_XFA_LIB "${XPU_LIB_DIR}/${XPU_XFA_LIB_NAME}")
set(XPU_XPUDNN_LIB "${XPU_LIB_DIR}/${XPU_XPUDNN_LIB_NAME}")
set(XPU_XPUDNN_OMP_LIB "${XPU_LIB_DIR}/${XPU_XPUDNN_OMP_LIB_NAME}")

set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH}" "${XPU_INSTALL_DIR}/lib")

file(
  WRITE ${XPU_DOWNLOAD_DIR}/CMakeLists.txt
  "PROJECT(XPU)\n" "cmake_minimum_required(VERSION 3.5)\n"
  "install(DIRECTORY xpu/include xpu/lib \n"
  "        DESTINATION ${XPU_INSTALL_DIR})\n")

if(WITH_XPU_BKCL)
  message(STATUS "Compile with XPU BKCL!")
  add_definitions(-DPADDLE_WITH_XPU_BKCL)

  set(XPU_BKCL_LIB_NAME "libbkcl.so")
  set(XPU_BKCL_LIB "${XPU_LIB_DIR}/${XPU_BKCL_LIB_NAME}")
  set(XPU_BKCL_INC_DIR "${THIRD_PARTY_PATH}/install/xpu/include")
  include_directories(${XPU_BKCL_INC_DIR})
endif()

set(XFT_COMMAND "get_xft_dependence.sh")
# If the corresponding path exists locally, use it directly; otherwise, download it.
# The current implementation only supports XPU-related libraries being located in the same directory.
if(DEFINED ENV{XPU_LIB_ROOT})
  message(STATUS "Compile with LOCAL XPU LIBS!")
  set(XPU_LIB_ROOT "$ENV{XPU_LIB_ROOT}")

  # XRE
  if(DEFINED ENV{XPU_XRE_DIR_NAME})
    set(XPU_XRE_URL "${XPU_LIB_ROOT}/$ENV{XPU_XRE_DIR_NAME}")
    set(XPU_XRE_DIR_NAME "$ENV{XPU_XRE_DIR_NAME}")
  endif()

  # XCCL
  if(DEFINED ENV{XPU_XCCL_DIR_NAME})
    set(XPU_XCCL_URL "${XPU_LIB_ROOT}/$ENV{XPU_XCCL_DIR_NAME}")
    set(XPU_XCCL_DIR_NAME "$ENV{XPU_XCCL_DIR_NAME}")
  endif()

  # XHPC
  if(DEFINED ENV{XPU_XHPC_DIR_NAME})
    set(XPU_XHPC_URL "${XPU_LIB_ROOT}/$ENV{XPU_XHPC_DIR_NAME}")
    set(XPU_XHPC_DIR_NAME "$ENV{XPU_XHPC_DIR_NAME}")
  endif()

  # XFT
  if(DEFINED ENV{XPU_XFT_DIR_NAME})
    set(XPU_XFT_DIR_NAME "$ENV{XPU_XFT_DIR_NAME}")
    set(XPU_XFT_URL "${XPU_LIB_ROOT}/${XPU_XFT_DIR_NAME}")
    set(XFT_COMMAND
        "${CMAKE_SOURCE_DIR}/tools/xpu/get_xft_dependence_from_custom_path.sh")
  endif()

  # FFT
  if(DEFINED ENV{XPU_FFT_DIR_NAME})
    set(XPU_FFT_URL "${XPU_LIB_ROOT}/$ENV{XPU_FFT_DIR_NAME}")
    set(XPU_FFT_DIR_NAME "$ENV{XPU_FFT_DIR_NAME}")
  endif()
endif()

if(WITH_XPU_XRE5)
  ExternalProject_Add(
    ${XPU_PROJECT}
    ${EXTERNAL_PROJECT_LOG_ARGS}
    PREFIX ${SNAPPY_PREFIX_DIR}
    DOWNLOAD_DIR ${XPU_DOWNLOAD_DIR}
    DOWNLOAD_COMMAND
      bash ${CMAKE_SOURCE_DIR}/tools/xpu/pack_paddle_dependence.sh
      ${XPU_XRE_URL} ${XPU_XRE_DIR_NAME} ${XPU_XHPC_URL} ${XPU_XHPC_DIR_NAME}
      ${XPU_XCCL_URL} ${XPU_XCCL_DIR_NAME} 1 ${WITH_MKL} "${CMAKE_BINARY_DIR}"
      && wget ${XPU_XFT_GET_DEPENCE_URL} && bash ${XFT_COMMAND} ${XPU_XFT_URL}
      ${XPU_XFT_DIR_NAME} && bash
      ${CMAKE_SOURCE_DIR}/tools/xpu/get_xpti_dependence.sh ${XPU_XPTI_URL}
      ${XPU_XPTI_DIR_NAME} && bash
      ${CMAKE_SOURCE_DIR}/tools/xpu/get_cupti_dependence.sh ${XPU_CUPTI_URL}
      ${XPU_CUPTI_DIR_NAME} && bash
      ${CMAKE_SOURCE_DIR}/tools/xpu/get_xputx_dependence.sh ${XPU_XPUTX_URL}
      ${XPU_XPUTX_DIR_NAME} && bash
      ${CMAKE_SOURCE_DIR}/tools/xpu/get_xpufft_dependence.sh ${XPU_FFT_URL}
    DOWNLOAD_NO_PROGRESS 1
    UPDATE_COMMAND ""
    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${XPU_INSTALL_ROOT}
    CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${XPU_INSTALL_ROOT}
    BUILD_BYPRODUCTS ${XPU_API_LIB}
    BUILD_BYPRODUCTS ${XPU_XBLAS_LIB}
    BUILD_BYPRODUCTS ${XPU_XBLAS_JITC_LIB}
    BUILD_BYPRODUCTS ${XPU_XBLAS_LLVM_LIB}
    BUILD_BYPRODUCTS ${XPU_XBLAS_CLANG_LIB}
    BUILD_BYPRODUCTS ${XPU_XPUDNN_LIB}
    BUILD_BYPRODUCTS ${XPU_XPUDNN_OMP_LIB}
    BUILD_BYPRODUCTS ${XPU_XFA_LIB}
    BUILD_BYPRODUCTS ${XPU_RT_LIB}
    BUILD_BYPRODUCTS ${XPU_CUDA_RT_LIB}
    BUILD_BYPRODUCTS ${XPU_ML_LIB}
    BUILD_BYPRODUCTS ${XPU_BKCL_LIB})
else()
  ExternalProject_Add(
    ${XPU_PROJECT}
    ${EXTERNAL_PROJECT_LOG_ARGS}
    PREFIX ${SNAPPY_PREFIX_DIR}
    DOWNLOAD_DIR ${XPU_DOWNLOAD_DIR}
    DOWNLOAD_COMMAND
      bash ${CMAKE_SOURCE_DIR}/tools/xpu/pack_paddle_dependence.sh
      ${XPU_XRE_URL} ${XPU_XRE_DIR_NAME} ${XPU_XHPC_URL} ${XPU_XHPC_DIR_NAME}
      ${XPU_XCCL_URL} ${XPU_XCCL_DIR_NAME} 0 && wget ${XPU_XFT_GET_DEPENCE_URL}
      && bash get_xft_dependence.sh ${XPU_XFT_URL} ${XPU_XFT_DIR_NAME} && bash
      ${CMAKE_SOURCE_DIR}/tools/xpu/get_xpti_dependence.sh ${XPU_XPTI_URL}
      ${XPU_XPTI_DIR_NAME} && bash
      ${CMAKE_SOURCE_DIR}/tools/xpu/get_xpufft_dependence.sh ${XPU_FFT_URL}
    DOWNLOAD_NO_PROGRESS 1
    UPDATE_COMMAND ""
    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${XPU_INSTALL_ROOT}
    CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${XPU_INSTALL_ROOT}
    BUILD_BYPRODUCTS ${XPU_API_LIB}
    BUILD_BYPRODUCTS ${XPU_RT_LIB}
    BUILD_BYPRODUCTS ${XPU_BKCL_LIB})
endif()

include_directories(${XPU_INC_DIR})
add_library(shared_xpuapi SHARED IMPORTED GLOBAL)
set_property(TARGET shared_xpuapi PROPERTY IMPORTED_LOCATION "${XPU_API_LIB}")

# generate a static dummy target to track xpulib dependencies
# for cc_library(xxx SRCS xxx.c DEPS xpulib)
generate_dummy_static_lib(LIB_NAME "xpulib" GENERATOR "xpu.cmake")

if(WITH_XPU_XFT)
  message(STATUS "Compile with XPU XFT!")
  add_definitions(-DPADDLE_WITH_XPU_XFT)

  set(XPU_XFT_INC_DIR "${XPU_INC_DIR}/xft")
  include_directories(${XPU_XFT_INC_DIR})
  set(XPU_XFT_LIB "${XPU_LIB_DIR}/${XPU_XFT_LIB_NAME}")
  target_link_libraries(xpulib ${XPU_XFT_LIB})
endif()

if(WITH_XPU_FFT)
  message(STATUS "Compile with XPU FFT!")
  add_definitions(-DPADDLE_WITH_XPU_FFT)

  set(XPU_FFT_INC_DIR "${XPU_INC_DIR}/fft")
  include_directories(${XPU_FFT_INC_DIR})
  set(XPU_FFT_LIB "${XPU_LIB_DIR}/${XPU_FFT_LIB_NAME}")
  target_link_libraries(xpulib ${XPU_FFT_LIB})
endif()

set(XPU_XHPC_INC_DIR "${XPU_INC_DIR}/xhpc")
include_directories(${XPU_XHPC_INC_DIR})
set(XPU_XRE_INC_DIR "${XPU_INC_DIR}/xre")
include_directories(${XPU_XRE_INC_DIR})

if(WITH_XPU_XRE5)
  add_definitions(-DPADDLE_WITH_XPU_XRE5)
  set(XPU_XBLAS_INC_DIR "${XPU_INC_DIR}/xhpc/xblas")
  include_directories(${XPU_XBLAS_INC_DIR})
  set(XPU_XFA_INC_DIR "${XPU_INC_DIR}/xhpc/xfa")
  include_directories(${XPU_XFA_INC_DIR})
  set(XPU_XPUDNN_INC_DIR "${XPU_INC_DIR}/xhpc/xpudnn")
  include_directories(${XPU_XPUDNN_INC_DIR})
  set(XPU_XPUTX_INC_DIR "${XPU_INC_DIR}/nvtx3")
  include_directories(${XPU_XPUTX_INC_DIR})
  set(XPU_XPUTX_LIB "${XPU_LIB_DIR}/${XPU_XPUTX_LIB_NAME}")
  set(XPU_CUPTI_INC_DIR "${XPU_INC_DIR}/cupti")
  include_directories(${XPU_CUPTI_INC_DIR})
  set(XPU_CUPTI_LIB "${XPU_LIB_DIR}/${XPU_CUPTI_LIB_NAME}")
endif()

if(WITH_XPTI)
  message(STATUS "Compile with XPU XPTI!")
  add_definitions(-DPADDLE_WITH_XPTI)
  set(XPU_XPTI_LIB "${XPU_LIB_DIR}/${XPU_XPTI_LIB_NAME}")
endif()

if(WITH_XPU_XRE5 AND (NOT WITH_XPTI))
  set(CUPTI_FOUND ON)
  set(CUPTI_INCLUDE_DIR "${XPU_CUPTI_INC_DIR}")
  set(CUPTI_LIBRARY_PATH "${XPU_LIB_DIR}")
  message(STATUS "Compile with XPU CUPTI!")
endif()

if(WITH_XPU_PLUGIN)
  message(STATUS "Compile with XPU PLUGIN!")
  add_definitions(-DPADDLE_WITH_XPU_PLUGIN)
  include_directories(${CMAKE_SOURCE_DIR}/paddle/phi/kernels/xpu/plugin/include)
endif()

if(WITH_XPTI)
  target_link_libraries(xpulib ${XPU_XPTI_LIB})
endif()

if(WITH_XPU_XRE5)
  target_link_libraries(
    xpulib
    ${XPU_RT_LIB}
    ${XPU_CUDA_RT_LIB}
    ${XPU_XBLAS_LIB}
    ${XPU_XBLAS_JITC_LIB}
    ${XPU_XBLAS_LLVM_LIB}
    ${XPU_XBLAS_CLANG_LIB}
    ${XPU_API_LIB}
    ${XPU_XFA_LIB}
    ${XPU_XPUDNN_LIB}
    ${XPU_ML_LIB})

  if(NOT WITH_MKL)
    target_link_libraries(xpulib ${XPU_XPUDNN_OMP_LIB})
  endif()
else()
  target_link_libraries(xpulib ${XPU_RT_LIB} ${XPU_API_LIB})
endif()

if(WITH_XPU_BKCL)
  target_link_libraries(xpulib ${XPU_BKCL_LIB})
endif()

if(WITH_XPU_XRE5)
  get_filename_component(XPUTX_DIR "${XPU_XPUTX_LIB}" DIRECTORY)
  if(EXISTS "${XPUTX_DIR}")
    set(ENV{LD_LIBRARY_PATH} "$ENV{LD_LIBRARY_PATH}:${XPUTX_DIR}")
  else()
    message(
      WARNING
        "Directory '${XPUTX_DIR}' does not exist; cannot add it to LD_LIBRARY_PATH"
    )
  endif()
endif()
add_dependencies(xpulib ${XPU_PROJECT})

# Ensure that xpu/api.h can be included without dependency errors.
file(
  GENERATE
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/.xpu_headers_dummy.cc
  CONTENT "")
add_library(xpu_headers_dummy STATIC
            ${CMAKE_CURRENT_BINARY_DIR}/.xpu_headers_dummy.cc)
add_dependencies(xpu_headers_dummy extern_xpu)
link_libraries(xpu_headers_dummy)