/* 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 "paddle/phi/backends/dynload/dynamic_loader.h"
#include <dirent.h>

#include <codecvt>
#include <cstdlib>
#include <locale>
#include <string>
#include <vector>
#include "paddle/phi/backends/dynload/cupti_lib_path.h"
#include "paddle/phi/common/port.h"
#include "paddle/phi/core/enforce.h"

#if defined(_WIN32)
#include <windows.h>
#endif

// TODO(wilber): The phi computing library requires a component to manage flags
// (maybe not use gflags).
#include "glog/logging.h"

#include "paddle/common/flags.h"

COMMON_DECLARE_string(cudnn_dir);
COMMON_DECLARE_string(cuda_dir);
COMMON_DECLARE_string(cublas_dir);
COMMON_DECLARE_string(nccl_dir);
COMMON_DECLARE_string(cupti_dir);
COMMON_DECLARE_string(tensorrt_dir);
COMMON_DECLARE_string(mklml_dir);
COMMON_DECLARE_string(hml_dir);
COMMON_DECLARE_string(lapack_dir);
COMMON_DECLARE_string(mkl_dir);
COMMON_DECLARE_string(op_dir);
COMMON_DECLARE_string(cusparselt_dir);
COMMON_DECLARE_string(curand_dir);
COMMON_DECLARE_string(cusolver_dir);
COMMON_DECLARE_string(cusparse_dir);
COMMON_DECLARE_string(win_cuda_bin_dir);
#ifdef PADDLE_WITH_MAGMA
COMMON_DECLARE_string(magma_dir);
#endif

#ifndef CUDA_LIB_NAME
#define CUDA_LIB_NAME "libcuda.so"
#endif

#ifndef BLAS_LIB_NAME
#define BLAS_LIB_NAME "libcublas.so"
#endif

#ifndef BLASLT_LIB_NAME
#define BLASLT_LIB_NAME "libcublasLt.so"
#endif

#ifndef DNN_LIB_NAME
#define DNN_LIB_NAME "libcudnn.so"
#endif

#ifndef PTI_LIB_NAME
#define PTI_LIB_NAME "libcupti.so"
#endif

#ifndef RAND_LIB_NAME
#define RAND_LIB_NAME "libcurand.so"
#endif

#ifndef JPEG_LIB_NAME
#define JPEG_LIB_NAME "libnvjpeg.so"
#endif

#ifndef SOLVER_LIB_NAME
#define SOLVER_LIB_NAME "libcusolver.so"
#endif

#ifndef SPARSE_LIB_NAME
#define SPARSE_LIB_NAME "libcusparse.so"
#endif

#ifndef RTC_LIB_NAME
#define RTC_LIB_NAME "libnvrtc.so"
#endif

#ifndef FLASHATTN_LIB_NAME
#define FLASHATTN_LIB_NAME "libflashattn.so"
#endif

#ifndef FLASHATTNV3_LIB_NAME
#define FLASHATTNV3_LIB_NAME "libflashattnv3.so"
#endif

#ifndef CCL_LIB_NAME
#define CCL_LIB_NAME "libnccl.so"
#endif

#ifndef FFT_LIB_NAME
#define FFT_LIB_NAME "libcufft.so"
#endif

#ifndef SPARSELT_LIB_NAME
#define SPARSELT_LIB_NAME "libcusparseLt.so"
#endif

#ifdef PADDLE_WITH_HIP

PHI_DEFINE_string(miopen_dir,
                  "",
                  "Specify path for loading libMIOpen.so. For instance, "
                  "/opt/rocm/miopen/lib. If empty [default], dlopen "
                  "will search miopen from LD_LIBRARY_PATH");

PHI_DEFINE_string(rocm_dir,
                  "",
                  "Specify path for loading rocm library, such as librocblas, "
                  "libmiopen, libhipsparse. For instance, /opt/rocm/lib. "
                  "If default, dlopen will search rocm from LD_LIBRARY_PATH");

PHI_DEFINE_string(rccl_dir,
                  "",
                  "Specify path for loading rccl library, such as librccl.so. "
                  "For instance, /opt/rocm/rccl/lib. If default, "
                  "dlopen will search rccl from LD_LIBRARY_PATH");
#endif

#ifdef PADDLE_WITH_FLAGCX
COMMON_DECLARE_string(flagcx_dir);

PHI_DEFINE_EXPORTED_string(
    flagcx_dir,  // NOLINT
    "",
    "Specify path for loading libflagcx.so. For instance, "
    "For instance, /usr/local/flagcx/lib. If default, "
    "dlopen will search flagcx from LD_LIBRARY_PATH");
#endif

#ifdef PADDLE_WITH_XPU
PD_DEFINE_string(xpti_dir, "", "Specify path for loading libxpti.so.");
PD_DEFINE_string(xputx_dir, "", "Specify path for loading llibxpuToolsExt.so.");
#endif

namespace phi::dynload {

struct PathNode {
  PathNode() = default;
  std::string path = "";
};

static constexpr char cupti_lib_path[] = CUPTI_LIB_PATH;  // NOLINT

// NOTE: In order to adapt to the default installation path of cuda
#if defined(_WIN32) && defined(PADDLE_WITH_CUDA)
static constexpr char cuda_lib_path[] = CUDA_TOOLKIT_ROOT_DIR "/bin";
#else
static constexpr char cuda_lib_path[] = "/usr/local/cuda/lib64";  // NOLINT
#endif

static PathNode s_py_site_pkg_path;

#if defined(_WIN32) && defined(PADDLE_WITH_CUDA)
static constexpr const char* win_cudnn_lib =
    "cudnn64_" CUDNN_MAJOR_VERSION ".dll";
static constexpr const char* win_cublas_lib =
    "cublas64_" CUDA_VERSION_MAJOR CUDA_VERSION_MINOR
    ".dll;cublas64_" CUDA_VERSION_MAJOR ".dll";
static constexpr const char* win_cublaslt_lib =
    "cublasLt64_" CUDA_VERSION_MAJOR CUDA_VERSION_MINOR
    ".dll;cublasLt64_" CUDA_VERSION_MAJOR ".dll";
static constexpr const char* win_curand_lib =
    "curand64_" CUDA_VERSION_MAJOR CUDA_VERSION_MINOR
    ".dll;curand64_" CUDA_VERSION_MAJOR ".dll;curand64_10.dll";
static constexpr const char* win_nvjpeg_lib =
    "nvjpeg64_" CUDA_VERSION_MAJOR CUDA_VERSION_MINOR
    ".dll;nvjpeg64_" CUDA_VERSION_MAJOR ".dll;nvjpeg64_10.dll";
static constexpr const char* win_cusolver_lib =
    "cusolver64_" CUDA_VERSION_MAJOR CUDA_VERSION_MINOR
    ".dll;cusolver64_" CUDA_VERSION_MAJOR
    ".dll;cusolver64_11.dll;cusolver64_10.dll";
static constexpr const char* win_cusparse_lib =
    "cusparse64_" CUDA_VERSION_MAJOR CUDA_VERSION_MINOR
    ".dll;cusparse64_" CUDA_VERSION_MAJOR ".dll;cusparse64_10.dll";
static constexpr const char* win_cufft_lib =
    "cufft64_" CUDA_VERSION_MAJOR CUDA_VERSION_MINOR
    ".dll;cufft64_" CUDA_VERSION_MAJOR ".dll;cufft64_11.dll;cufft64_10.dll";
#endif

static inline std::string join(const std::string& part1,
                               const std::string& part2) {
// directory separator
#if defined(_WIN32)
  const char sep = '\\';
#else
  const char sep = '/';
#endif
  if (!part2.empty() && part2.front() == sep) {
    return part2;
  }
  std::string ret;
  ret.reserve(part1.size() + part2.size() + 1);
  ret = part1;
  if (!ret.empty() && ret.back() != sep) {
    ret += sep;
  }
  ret += part2;
  return ret;
}

static inline std::vector<std::string> split(
    const std::string& str, const std::string separator = " ") {
  std::vector<std::string> str_list;
  std::string::size_type firstPos = 0;
  firstPos = str.find_first_not_of(separator, 0);
  std::string::size_type lastPos = 0;
  lastPos = str.find_first_of(separator, firstPos);
  while (std::string::npos != firstPos && std::string::npos != lastPos) {
    str_list.push_back(str.substr(firstPos, lastPos - firstPos));
    firstPos = str.find_first_not_of(separator, lastPos);
    lastPos = str.find_first_of(separator, firstPos);
  }
  if (std::string::npos == lastPos) {
    str_list.push_back(str.substr(firstPos, lastPos - firstPos));
  }
  return str_list;
}

void SetPaddleLibPath(const std::string& py_site_pkg_path) {
  s_py_site_pkg_path.path = py_site_pkg_path;
  VLOG(6) << "Set paddle lib path : " << py_site_pkg_path;
}

#if defined(_WIN32) || defined(_WIN64)
static inline void* LoadLibraryHandleFromUtf8Path(const std::string& dso_path) {
  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
  std::wstring dso_path_w = converter.from_bytes(dso_path);
  HMODULE handle = LoadLibraryW(dso_path_w.c_str());
  return reinterpret_cast<void*>(handle);
}
#endif

static inline void* GetDsoHandleFromSpecificPath(const std::string& spec_path,
                                                 const std::string& dso_name,
                                                 int dynload_flags) {
  void* dso_handle = nullptr;
  if (!spec_path.empty() || !dso_name.empty()) {
    // search xxx.so from custom path
    VLOG(6) << "Try to find library: " << dso_name
            << " from specific path: " << spec_path;
    std::string dso_path = join(spec_path, dso_name);
#if defined(_WIN32) || defined(_WIN64)
    dso_handle = LoadLibraryHandleFromUtf8Path(dso_path);
#else
    dso_handle = dlopen(dso_path.c_str(), dynload_flags);
#endif
  }
  return dso_handle;
}

static inline std::string FindLibAbsolutePath(const std::string& directory,
                                              const std::string& filename) {
  DIR* dir = opendir(directory.c_str());
  struct dirent* ent;

  if (dir != nullptr) {
    while ((ent = readdir(dir)) != nullptr) {
      if (ent->d_type == DT_REG || ent->d_type == DT_LNK) {
        if (filename == std::string(ent->d_name)) {
          closedir(dir);
          return join(directory, ent->d_name);
        }
      } else if (ent->d_type == DT_DIR) {
        if (strcmp(ent->d_name, ".") != 0 && strcmp(ent->d_name, "..") != 0) {
          std::string res =
              FindLibAbsolutePath(join(directory, ent->d_name) + "/", filename);
          if (!res.empty()) {
            closedir(dir);
            return res;
          }
        }
      }
    }
    closedir(dir);
  }
  return "";
}

static inline void* GetDsoHandleFromDefaultPath(const std::string& dso_path,
                                                int dynload_flags) {
#if defined(_WIN32) || defined(_WIN64)
  return LoadLibraryHandleFromUtf8Path(dso_path);
#else
  // default search from LD_LIBRARY_PATH/DYLD_LIBRARY_PATH
  // and /usr/local/lib path
  void* dso_handle = dlopen(dso_path.c_str(), dynload_flags);
  VLOG(3) << "Try to find library: " << dso_path
          << " from default system path.";

// TODO(chenweihang): This path is used to search which libs?
// DYLD_LIBRARY_PATH is disabled after Mac OS 10.11 to
// bring System Integrity Projection (SIP), if dso_handle
// is null, search from default package path in Mac OS.
#if defined(__APPLE__) || defined(__OSX__)
#if defined(__arm__) || defined(__aarch64__)
  if (nullptr == dso_handle) {
    dso_handle =
        dlopen(FindLibAbsolutePath("/opt/homebrew/Cellar/", dso_path).c_str(),
               dynload_flags);
  }
#else
  if (nullptr == dso_handle) {
    dso_handle =
        dlopen(FindLibAbsolutePath("/usr/local/cuda/lib/", dso_path).c_str(),
               dynload_flags);
  }
#endif
#endif

  return dso_handle;
#endif
}

/*
 * We define three priorities for dynamic library search:
 *
 * First: Search for  path specified by the user
 * Second: Search the stheystem default path
 * Third: Search for a special path corresponding to
 *        a specific library to adapt to changes and easy to expand.
 */

static inline void* GetDsoHandleFromSearchPath(
    const std::string& config_path,
    const std::string& dso_name,
    bool throw_on_error = true,
    const std::vector<std::string>& extra_paths = std::vector<std::string>(),
    const std::string& warning_msg = std::string()) {
#if !defined(_WIN32)
  int dynload_flags = RTLD_LAZY | RTLD_LOCAL;
#else
  int dynload_flags = 0;
#endif  // !_WIN32
#if defined(_WIN32)
  std::vector<std::wstring> cuda_bin_search_path = {
      L"cublas",
      L"cuda_nvrtc",
      L"cuda_runtime",
      L"cudnn",
      L"cufft",
      L"curand",
      L"cusolver",
      L"cusparse",
      L"nvjitlink",
  };
  for (auto search_path : cuda_bin_search_path) {
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
    std::wstring win_path_wstring =
        converter.from_bytes(FLAGS_win_cuda_bin_dir);
    search_path = win_path_wstring + L"\\" + search_path + L"\\bin";
#ifdef PADDLE_WITH_CUDA
    AddDllDirectory(search_path.c_str());
#endif
  }
#endif
  std::vector<std::string> dso_names = split(dso_name, ";");
  void* dso_handle = nullptr;
  for (auto const& dso : dso_names) {
    // 1. search in user config path by FLAGS
    dso_handle = GetDsoHandleFromSpecificPath(config_path, dso, dynload_flags);
    // 2. search in system default path
    if (nullptr == dso_handle) {
      dso_handle = GetDsoHandleFromDefaultPath(dso, dynload_flags);
    }
    // 3. search in extra paths
    if (nullptr == dso_handle) {
      for (auto const& path : extra_paths) {
        VLOG(3) << "extra_paths: " << path;
        dso_handle = GetDsoHandleFromSpecificPath(path, dso, dynload_flags);
      }
    }
    if (nullptr != dso_handle) break;
  }

  // 4. [If Failed for All dso_names] logging warning if exists
  if (nullptr == dso_handle && !warning_msg.empty()) {
    LOG(WARNING) << warning_msg;
  }

  // 5. [If Failed for All dso_names] logging or throw error info
  if (nullptr == dso_handle) {
    auto error_msg =
        "The third-party dynamic library (%s) that Paddle depends on is not "
        "configured correctly. (error code is %s)\n"
        "  Suggestions:\n"
        "  1. Check if the third-party dynamic library (e.g. CUDA, CUDNN) "
        "is installed correctly and its version is matched with paddlepaddle "
        "you installed.\n"
        "  2. Configure third-party dynamic library environment variables as "
        "follows:\n"
        "  - Linux: set LD_LIBRARY_PATH by `export LD_LIBRARY_PATH=...`\n"
        "  - Windows: set PATH by `set PATH=XXX;%%PATH%%`\n"
        "  - Mac: set  DYLD_LIBRARY_PATH by `export DYLD_LIBRARY_PATH=...` "
        "[Note: After Mac OS 10.11, using the DYLD_LIBRARY_PATH is "
        "impossible unless System Integrity Protection (SIP) is disabled.]";
#if !defined(_WIN32)
    auto errorno = dlerror();
#else
    auto errorno = GetLastError();
#endif  // !_WIN32
    if (throw_on_error) {
      // NOTE: Special error report case, no need to change its format
      PADDLE_THROW(
          common::errors::PreconditionNotMet(error_msg, dso_name, errorno));
    } else {
      LOG(WARNING) << paddle::string::Sprintf(error_msg, dso_name, errorno);
    }
  }

  return dso_handle;
}

void* GetCublasDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcublas.dylib");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, BLAS_LIB_NAME);
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cublas64_11.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cublas_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cublas64_12.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cublas_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cublas64_13.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cublas_lib, true, {cuda_lib_path});
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 13, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#elif defined(__linux__) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublas.so.11");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublas.so");
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublas.so.12");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublas.so");
#endif
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublas.so.13");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublas.so");
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 14, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "librocblas.so");
#else
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcublas.so");
#endif
}

void* GetCublasLtDsoHandle() {
// APIs available after CUDA 10.1
#if defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, BLASLT_LIB_NAME);
#elif defined(__linux__) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublasLt.so.11");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublasLt.so");
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublasLt.so.12");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublasLt.so");
#endif
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublasLt.so.13");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cublas_dir, "libcublasLt.so");
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 14, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cublasLt64_11.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cublaslt_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cublasLt64_12.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cublaslt_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cublasLt64_13.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cublaslt_lib, true, {cuda_lib_path});
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 14, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#elif !defined(__linux__) && defined(PADDLE_WITH_CUDA)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcublasLt.so");
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "libhipblaslt.so");
#else
  std::string warning_msg(
      "Your CUDA_VERSION less 11, not support CublasLt. "
      "If you want to use CublasLt, please upgrade CUDA and rebuild "
      "PaddlePaddle.");
  return nullptr;
#endif
}

void* GetCUDNNDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  std::string mac_warn_meg(
      "Note: [Recommend] copy cudnn into /usr/local/cuda/ \n "
      "For instance, sudo tar -xzf "
      "cudnn-7.5-osx-x64-v5.0-ga.tgz -C /usr/local \n sudo "
      "chmod a+r /usr/local/cuda/include/cudnn.h "
      "/usr/local/cuda/lib/libcudnn*");
  return GetDsoHandleFromSearchPath(
      FLAGS_cudnn_dir, "libcudnn.dylib", false, {}, mac_warn_meg);
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(
      FLAGS_cudnn_dir, DNN_LIB_NAME, false, {cuda_lib_path});
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
  std::string win_warn_meg(
      "Note: [Recommend] copy cudnn into CUDA installation directory. \n "
      "For instance, download cudnn-10.0-windows10-x64-v7.6.5.32.zip from "
      "NVIDIA's official website, \n"
      "then, unzip it and copy it into C:\\Program Files\\NVIDIA GPU Computing "
      "Toolkit\\CUDA\\v10.0\n"
      "You should do this according to your CUDA installation directory and "
      "CUDNN version.");
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12030) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, "cudnn64_8.dll", true, {cuda_lib_path}, win_warn_meg);
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cudnn_lib, true, {cuda_lib_path}, win_warn_meg);
#endif
  } else if (CUDA_VERSION >= 12030) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, "cudnn64_9.dll", true, {cuda_lib_path}, win_warn_meg);
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cudnn_lib, true, {cuda_lib_path}, win_warn_meg);
#endif
  }
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_miopen_dir, "libMIOpen.so", false);
#else
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
  if (CUDA_VERSION >= 12030) {
    return GetDsoHandleFromSearchPath(
        FLAGS_cudnn_dir, "libcudnn.so.9", false, {cuda_lib_path});
  } else {
    return GetDsoHandleFromSearchPath(
        FLAGS_cudnn_dir, "libcudnn.so.8", false, {cuda_lib_path});
  }
#else
  return GetDsoHandleFromSearchPath(
      FLAGS_cudnn_dir, "libcudnn.so", false, {cuda_lib_path});
#endif
#endif
}

void* GetCUPTIDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(
      FLAGS_cupti_dir, "libcupti.dylib", false, {cupti_lib_path});
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(
      FLAGS_cupti_dir, PTI_LIB_NAME, false, {cupti_lib_path});
#elif defined(PADDLE_WITH_XPU)
  return GetDsoHandleFromSearchPath(
      FLAGS_cupti_dir, "libcupti.so", false, {cupti_lib_path});
#elif defined(__linux__) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(
        FLAGS_cupti_dir, "libcupti.so.11.8", false, {cupti_lib_path});
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cupti_dir, "libcupti.so", false, {cupti_lib_path});
#endif

  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(
        FLAGS_cupti_dir, "libcupti.so.12", false, {cupti_lib_path});
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cupti_dir, "libcupti.so", false, {cupti_lib_path});
#endif
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(
        FLAGS_cupti_dir, "libcupti.so.13", false, {cupti_lib_path});
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cupti_dir, "libcupti.so", false, {cupti_lib_path});
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 14, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#else
  return GetDsoHandleFromSearchPath(
      FLAGS_cupti_dir, "libcupti.so", false, {cupti_lib_path});
#endif
}

void* GetCurandDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcurand.dylib");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, RAND_LIB_NAME);
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
  return GetDsoHandleFromSearchPath(
      FLAGS_cuda_dir, "curand64_10.dll", true, {cuda_lib_path});
#else
  return GetDsoHandleFromSearchPath(
      FLAGS_cuda_dir, win_curand_lib, true, {cuda_lib_path});
#endif
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "libhiprand.so");
#else
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
  return GetDsoHandleFromSearchPath(FLAGS_curand_dir, "libcurand.so.10");
#else
  return GetDsoHandleFromSearchPath(FLAGS_curand_dir, "libcurand.so");
#endif

#endif
}

#ifdef PADDLE_WITH_HIP
void* GetROCFFTDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "librocfft.dylib");
#else
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "libhipfft.so");
#endif
}
#endif

void* GetNvjpegDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libnvjpeg.dylib");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, JPEG_LIB_NAME);
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
  return GetDsoHandleFromSearchPath(
      FLAGS_cuda_dir, win_nvjpeg_lib, true, {cuda_lib_path});
#else
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libnvjpeg.so");
#endif
}

void* GetCusolverDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusolver.dylib");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, SOLVER_LIB_NAME);
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, "cusolver64_11.dll", true, {cuda_lib_path});
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cusolver_lib, true, {cuda_lib_path});
#endif
  } else {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, "cusolver64_12.dll", true, {cuda_lib_path});
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cusolver_lib, true, {cuda_lib_path});
#endif
  }
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "librocsolver.so");
#elif defined(__linux__) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusolver.so.11");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusolver.so");
#endif
  } else {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusolver.so.12");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusolver.so");
#endif
  }
#else
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusolver.so.11");
#endif
}

void* GetCusparseDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusparse.dylib");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cusparse_dir, SPARSE_LIB_NAME);
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cusparse64_11.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cusparse_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cusparse64_12.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cusparse_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cusparse64_12.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cusparse_lib, true, {cuda_lib_path});
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 13, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#elif defined(__linux__) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cusparse_dir, "libcusparse.so.11");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cusparse_dir, "libcusparse.so");
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cusparse_dir, "libcusparse.so.12");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cusparse_dir, "libcusparse.so");
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 14, paddle "
        "temporarily no longer.");
    return nullptr;
  }
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "librocsparse.so");
#else
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcusparse.so");
#endif
}

void* GetNVRTCDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libnvrtc.dylib", false);
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, RTC_LIB_NAME);
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "libamdhip64.so", false);
#else
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libnvrtc.so", false);
#endif
}

void* GetCUDADsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcuda.dylib", false);
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, CUDA_LIB_NAME, false);
#elif defined(PADDLE_WITH_HIP)
  return GetDsoHandleFromSearchPath(FLAGS_rocm_dir, "libamdhip64.so", false);
#elif defined(_WIN32)
  char system32_dir[MAX_PATH];
  GetSystemDirectory(system32_dir, MAX_PATH);
  return GetDsoHandleFromSearchPath(system32_dir, "nvcuda.dll");
#else
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcuda.so", false);
#endif
}

void* GetWarpCTCDsoHandle() {
  std::string warpctc_dir = "";
  if (!s_py_site_pkg_path.path.empty()) {
    warpctc_dir = s_py_site_pkg_path.path;
  }
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(warpctc_dir, "libwarpctc.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(warpctc_dir, "warpctc.dll");
#else
  return GetDsoHandleFromSearchPath(warpctc_dir, "libwarpctc.so");
#endif
}

void* GetWarpRNNTDsoHandle() {
  std::string warprnnt_dir = "";
  if (!s_py_site_pkg_path.path.empty()) {
    warprnnt_dir = s_py_site_pkg_path.path;
  }
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(warprnnt_dir, "libwarprnnt.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(warprnnt_dir, "warprnnt.dll");
#else
  return GetDsoHandleFromSearchPath(warprnnt_dir, "libwarprnnt.so");
#endif
}

void* GetFlashAttnDsoHandle() {
  std::string flashattn_dir = "";
  if (!s_py_site_pkg_path.path.empty()) {
    flashattn_dir = s_py_site_pkg_path.path;
  }
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(flashattn_dir, "libflashattn.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(flashattn_dir, "flashattn.dll");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(flashattn_dir, FLASHATTN_LIB_NAME);
#else
  return GetDsoHandleFromSearchPath(flashattn_dir, "libflashattn.so");
#endif
}

void* GetFlashAttnV3DsoHandle() {
  std::string flashattn_dir = "";
  if (!s_py_site_pkg_path.path.empty()) {
    flashattn_dir = s_py_site_pkg_path.path;
  }
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(flashattn_dir, "libflashattnv3.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(flashattn_dir, "flashattnv3.dll");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(flashattn_dir, FLASHATTNV3_LIB_NAME);
#else
  return GetDsoHandleFromSearchPath(flashattn_dir, "libflashattnv3.so");
#endif
}

void* GetFlashMaskV2DsoHandle() {
  std::string flashattn_dir = "";
  if (!s_py_site_pkg_path.path.empty()) {
    flashattn_dir = s_py_site_pkg_path.path;
  }
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(flashattn_dir, "libflashmaskv2.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(flashattn_dir, "flashmaskv2.dll");
#else
  return GetDsoHandleFromSearchPath(flashattn_dir, "libflashmaskv2.so");
#endif
}

void* GetAfsApiDsoHandle() {
  std::string afsapi_dir = "";
  if (!s_py_site_pkg_path.path.empty()) {
    afsapi_dir = s_py_site_pkg_path.path;
  }
#if defined(__APPLE__) || defined(__OSX__) || defined(_WIN32)
  return NULL;
#else
  return GetDsoHandleFromSearchPath(afsapi_dir, "libafs-api-so.so");
#endif
}

void* GetNCCLDsoHandle() {
#ifdef PADDLE_WITH_HIP
  std::string warning_msg(
      "You may need to install 'rccl' from ROCM official website: "
      "https://rocmdocs.amd.com/en/latest/Installation_Guide/"
      "Installation-Guide.html before install PaddlePaddle.");
#else
  std::string warning_msg(
      "You may need to install 'nccl2' from NVIDIA official website: "
      "https://developer.nvidia.com/nccl/nccl-download "
      "before install PaddlePaddle.");
#endif

#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(
      FLAGS_nccl_dir, "libnccl.dylib", true, {}, warning_msg);
#elif defined(PADDLE_WITH_HIP) && defined(PADDLE_WITH_RCCL)
  return GetDsoHandleFromSearchPath(
      FLAGS_rccl_dir, "librccl.so", true, {}, warning_msg);
#else
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
  return GetDsoHandleFromSearchPath(
      FLAGS_nccl_dir, "libnccl.so.2;libnccl.so", true, {}, warning_msg);
#else
#if defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(
      FLAGS_nccl_dir, CCL_LIB_NAME, true, {}, warning_msg);
#else
  return GetDsoHandleFromSearchPath(
      FLAGS_nccl_dir, "libnccl.so", true, {}, warning_msg);
#endif
#endif

#endif
}

void* GetFLAGCXDsoHandle() {
#ifdef PADDLE_WITH_FLAGCX
  return GetDsoHandleFromSearchPath(FLAGS_flagcx_dir, "libflagcx.so");
#else
  return nullptr;
#endif
}

void* GetTensorRtDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_tensorrt_dir, "libnvinfer.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(FLAGS_mklml_dir, "nvinfer.dll");
#else
  return GetDsoHandleFromSearchPath(FLAGS_tensorrt_dir, "libnvinfer.so");
#endif
}

void* GetMKLMLDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_mklml_dir, "libmklml_intel.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(FLAGS_mklml_dir, "mklml.dll");
#else
  return GetDsoHandleFromSearchPath(FLAGS_mklml_dir, "libmklml_intel.so");
#endif
}

void* GetHMLDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return nullptr;
#elif defined(_WIN32)
  return nullptr;
#else
  return GetDsoHandleFromSearchPath(FLAGS_hml_dir, "libhml_rt.so");
#endif
}

void* GetLAPACKDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
#if defined(__arm__) || defined(__aarch64__)
  return GetDsoHandleFromSearchPath(FLAGS_lapack_dir, "liblapack.dylib");
#else
  return GetDsoHandleFromSearchPath(FLAGS_lapack_dir, "liblapack.3.dylib");
#endif
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(FLAGS_lapack_dir, "liblapack.dll");
#else
  return GetDsoHandleFromSearchPath(FLAGS_lapack_dir, "liblapack.so.3");
#endif
}

void* GetMAGMADsoHandle() {
#if defined(PADDLE_WITH_MAGMA)
  return GetDsoHandleFromSearchPath(FLAGS_magma_dir, "libmagma.so");
#endif
  return nullptr;
}

void* GetOpDsoHandle(const std::string& dso_name) {
  return GetDsoHandleFromSearchPath(FLAGS_op_dir, dso_name);
}

void* GetNvtxDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  PADDLE_THROW(common::errors::Unimplemented("Nvtx do not support Apple."));
#elif defined(_WIN32)
  PADDLE_THROW(common::errors::Unimplemented("Nvtx do not support Windows."));
#elif !defined(PADDLE_WITH_CUDA) && !defined(PADDLE_WITH_XPU)
  PADDLE_THROW(common::errors::Unimplemented(
      "Nvtx do not support without CUDA or XPU."));
#elif defined(PADDLE_WITH_XPU)
  return GetDsoHandleFromSearchPath("FLAGS_xputx_dir", "libxpuToolsExt.so");
#else
  if (CUDA_VERSION >= 12090) {
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libnvtx3interop.so.1");
  }
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libnvToolsExt.so");
#endif
}

void* GetCUFFTDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcufft.dylib");
#elif defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, FFT_LIB_NAME);
#elif defined(__linux__) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcufft.so.10");
#else
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcufft.so");
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcufft.so.11");
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcufft.so.12");
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 14, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#elif defined(_WIN32) && defined(PADDLE_WITH_CUDA)
  if (CUDA_VERSION >= 11000 && CUDA_VERSION < 12000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cufft64_10.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cufft_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 12000 && CUDA_VERSION < 13000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cufft64_11.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cufft_lib, true, {cuda_lib_path});
#endif
  } else if (CUDA_VERSION >= 13000 && CUDA_VERSION < 14000) {
#ifdef PADDLE_WITH_PIP_CUDA_LIBRARIES
    return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "cufft64_12.dll");
#else
    return GetDsoHandleFromSearchPath(
        FLAGS_cuda_dir, win_cufft_lib, true, {cuda_lib_path});
#endif
  } else {
    std::string warning_msg(
        "Your CUDA_VERSION is less than 11 or greater than 13, paddle "
        "temporarily no longer supports");
    return nullptr;
  }
#else
  return GetDsoHandleFromSearchPath(FLAGS_cuda_dir, "libcufft.so");
#endif
}

void* GetMKLRTDsoHandle() {
#if defined(__APPLE__) || defined(__OSX__)
  return GetDsoHandleFromSearchPath(FLAGS_mkl_dir, "libmkl_rt.dylib");
#elif defined(_WIN32)
  return GetDsoHandleFromSearchPath(FLAGS_mkl_dir, "mkl_rt.dll");
#else
  return GetDsoHandleFromSearchPath(FLAGS_mkl_dir, "libmkl_rt.so");
#endif
}

void* GetCusparseLtDsoHandle() {
#if defined(PADDLE_WITH_CUSTOM_DEVICE)
  return GetDsoHandleFromSearchPath(FLAGS_cusparselt_dir, SPARSELT_LIB_NAME);
#elif defined(PADDLE_WITH_CUDA)
  return GetDsoHandleFromSearchPath(FLAGS_cusparselt_dir, "libcusparseLt.so");
#else
  std::string warning_msg(
      "Your CUDA_VERSION less 11.2, not support cusparseLt. "
      "If you want to use cusparseLt, please upgrade CUDA and rebuild "
      "PaddlePaddle.");
  return nullptr;
#endif
}

void* GetXPTIDsoHandle() {
#ifdef PADDLE_WITH_XPTI
  return GetDsoHandleFromSearchPath(FLAGS_xpti_dir, "libxpti.so");
#else
  return nullptr;
#endif
}
}  // namespace phi::dynload