Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle into transpose_conv1d

test=develop

Author: wanghaoshuang

CMakeLists.txt

@@ -28,7 +28,10 @@ include(generic) # simplify cmake module
 # TODO(Shibo Tao): remove find_package(CUDA) completely.
 find_package(CUDA QUIET)
 option(WITH_GPU "Compile PaddlePaddle with NVIDIA GPU" ${CUDA_FOUND})
-
+option(WITH_XPU "Compile PaddlePaddle with BAIDU KUNLUN" OFF)
+if (WITH_GPU AND WITH_XPU)
+ message(FATAL_ERROR "Error when compile GPU and XPU at the same time")
+endif()
 # cmake 3.12, 3.13, 3.14 will append gcc link options to nvcc, and nvcc doesn't recognize them.
 if(WITH_GPU AND (${CMAKE_VERSION} VERSION_GREATER_EQUAL 3.12) AND (${CMAKE_VERSION} VERSION_LESS 3.15))
  message(FATAL_ERROR "cmake ${CMAKE_VERSION} is not supported when WITH_GPU=ON because of bug https://cmake.org/pipermail/cmake/2018-September/068195.html. "

cmake/configure.cmake

@@ -63,6 +63,11 @@ if(WITH_BOX_PS)
  add_definitions(-DPADDLE_WITH_BOX_PS)
 endif()
 
+if(WITH_XPU)
+ message(STATUS "Compile with XPU!")
+ add_definitions(-DPADDLE_WITH_XPU)
+endif()
+
 if(WITH_GPU)
  add_definitions(-DPADDLE_WITH_CUDA)
  add_definitions(-DEIGEN_USE_GPU)

cmake/external/cub.cmake

@@ -17,7 +17,7 @@ include(ExternalProject)
 set(CUB_PREFIX_DIR ${THIRD_PARTY_PATH}/cub)
 set(CUB_SOURCE_DIR ${THIRD_PARTY_PATH}/cub/src/extern_cub)
 set(CUB_REPOSITORY https://github.com/NVlabs/cub.git)
-set(CUB_TAG 1.9.8)
+set(CUB_TAG 1.8.0)
 
 cache_third_party(extern_cub
  REPOSITORY ${CUB_REPOSITORY}

cmake/external/xpu.cmake

@@ -0,0 +1,54 @@
+if (NOT WITH_XPU)
+ return()
+endif()
+
+INCLUDE(ExternalProject)
+SET(XPU_PROJECT "extern_xpu")
+SET(XPU_URL "https://kunlun1.su.bcebos.com/xpu.tar.gz" CACHE STRING "" FORCE)
+SET(XPU_SOURCE_DIR "${THIRD_PARTY_PATH}/xpu")
+SET(XPU_DOWNLOAD_DIR "${XPU_SOURCE_DIR}/src/${XPU_PROJECT}")
+SET(XPU_INSTALL_DIR "${THIRD_PARTY_PATH}/install/xpu")
+SET(XPU_API_INC_DIR "${THIRD_PARTY_PATH}/install/xpu/api/include")
+SET(XPU_RUNTIME_INC_DIR "${THIRD_PARTY_PATH}/install/xpu/runtime/include")
+SET(XPU_LIB_DIR "${THIRD_PARTY_PATH}/install/xpu/lib")
+
+SET(XPU_API_LIB_NAME "libxpuapi.so")
+SET(XPU_RT_LIB_NAME "libxpurt.so")
+SET(XPU_SIM_LIB_NAME "libxpusim.so")
+SET(XPU_API_LIB "${XPU_LIB_DIR}/${XPU_API_LIB_NAME}")
+SET(XPU_RT_LIB "${XPU_LIB_DIR}/${XPU_RT_LIB_NAME}")
+SET(XPU_SIM_LIB "${XPU_LIB_DIR}/${XPU_SIM_LIB_NAME}")
+
+SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH}" "${XPU_INSTALL_DIR}/lib")
+
+INCLUDE_DIRECTORIES(${XPU_API_INC_DIR})
+INCLUDE_DIRECTORIES(${XPU_RUNTIME_INC_DIR})
+
+FILE(WRITE ${XPU_DOWNLOAD_DIR}/CMakeLists.txt
+ "PROJECT(XPU)\n"
+ "cmake_minimum_required(VERSION 3.0)\n"
+ "install(DIRECTORY xpu/api xpu/runtime xpu/lib \n"
+ " DESTINATION ${XPU_INSTALL_DIR})\n")
+
+ExternalProject_Add(
+ ${XPU_PROJECT}
+ ${EXTERNAL_PROJECT_LOG_ARGS}
+ PREFIX ${XPU_SOURCE_DIR}
+ DOWNLOAD_DIR ${XPU_DOWNLOAD_DIR}
+ DOWNLOAD_COMMAND wget --no-check-certificate ${XPU_URL} -c -q -O xpu.tar.gz
+ && tar xvf xpu.tar.gz
+ DOWNLOAD_NO_PROGRESS 1
+ UPDATE_COMMAND ""
+ CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${XPU_INSTALL_ROOT}
+ CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${XPU_INSTALL_ROOT}
+)
+
+ADD_LIBRARY(shared_xpuapi SHARED IMPORTED GLOBAL)
+set_property(TARGET shared_xpuapi PROPERTY IMPORTED_LOCATION "${XPU_API_LIB}")
+
+# generate a static dummy target to track xpulib dependencies
+# for cc_library(xxx SRCS xxx.c DEPS xpulib)
+generate_dummy_static_lib(LIB_NAME "xpulib" GENERATOR "xpu.cmake")
+
+TARGET_LINK_LIBRARIES(xpulib ${XPU_API_LIB} ${XPU_RT_LIB} ${XPU_SIM_LIB})
+ADD_DEPENDENCIES(xpulib ${XPU_PROJECT})

cmake/operators.cmake

@@ -8,6 +8,7 @@ function(op_library TARGET)
  set(hip_cu_srcs)
  set(miopen_hip_cc_srcs)
  set(cu_cc_srcs)
+ set(xpu_cc_srcs)
  set(cudnn_cu_cc_srcs)
  set(cudnn_cu_srcs)
  set(CUDNN_FILE)
@@ -60,6 +61,12 @@ function(op_library TARGET)
  list(APPEND mkldnn_cc_srcs mkldnn/${MKLDNN_FILE}.cc)
  endif()
  endif()
+ if(WITH_XPU)
+ string(REPLACE "_op" "_xpu_op" XPU_FILE "${TARGET}")
+ if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/xpu/${XPU_FILE}.cc)
+ list(APPEND xpu_cc_srcs xpu/${XPU_FILE}.cc)
+ endif()
+ endif()
  else()
  foreach(src ${op_library_SRCS})
  if (${src} MATCHES ".*\\.hip.cu$")
@@ -76,6 +83,8 @@ function(op_library TARGET)
  list(APPEND mkldnn_cc_srcs ${src})
  elseif(${src} MATCHES ".*\\.cu.cc$")
  list(APPEND cu_cc_srcs ${src})
+ elseif(WITH_XPU AND ${src} MATCHES ".*_xpu_op.cc$")
+ list(APPEND xpu_cc_srcs ${src})
  elseif(${src} MATCHES ".*\\.cc$")
  list(APPEND cc_srcs ${src})
  else()
@@ -109,7 +118,7 @@ function(op_library TARGET)
  hip_library(${TARGET} SRCS ${cc_srcs} ${hip_cu_srcs} ${miopen_hip_cc_srcs} ${mkldnn_cc_srcs} DEPS ${op_library_DEPS}
  ${op_common_deps})
  else()
- cc_library(${TARGET} SRCS ${cc_srcs} ${mkldnn_cc_srcs} DEPS ${op_library_DEPS}
+ cc_library(${TARGET} SRCS ${cc_srcs} ${mkldnn_cc_srcs} ${xpu_cc_srcs} DEPS ${op_library_DEPS}
  ${op_common_deps})
  endif()
 
@@ -150,10 +159,11 @@ function(op_library TARGET)
  list(LENGTH cu_srcs cu_srcs_len)
  list(LENGTH cu_cc_srcs cu_cc_srcs_len)
  list(LENGTH mkldnn_cc_srcs mkldnn_cc_srcs_len)
+ list(LENGTH xpu_cc_srcs xpu_cc_srcs_len)
  list(LENGTH hip_cu_srcs hip_cu_srcs_len)
  list(LENGTH miopen_hip_cc_srcs miopen_hip_cc_srcs_len)
  if (${pybind_flag} EQUAL 0 AND ${mkldnn_cc_srcs_len} EQUAL 0 AND ${cu_srcs_len} EQUAL 0 AND ${cu_cc_srcs_len} EQUAL 0 AND
- ${hip_cu_srcs_len} EQUAL 0 AND ${miopen_hip_cc_srcs_len} EQUAL 0)
+ ${hip_cu_srcs_len} EQUAL 0 AND ${miopen_hip_cc_srcs_len} EQUAL 0 AND ${xpu_cc_srcs_len} EQUAL 0)
  file(APPEND ${pybind_file} "USE_CPU_ONLY_OP(${TARGET});\n")
  set(pybind_flag 1)
  endif()
@@ -179,6 +189,9 @@ function(op_library TARGET)
  file(APPEND ${pybind_file} "USE_OP_DEVICE_KERNEL(${TARGET}, MIOPEN);\n")
  endif()
 
+ if (WITH_XPU AND ${xpu_cc_srcs_len} GREATER 0)
+ file(APPEND ${pybind_file} "USE_OP_DEVICE_KERNEL(${TARGET}, XPU);\n")
+ endif()
  # pybind USE_OP_DEVICE_KERNEL for MKLDNN
  if (WITH_MKLDNN AND ${mkldnn_cc_srcs_len} GREATER 0)
  # Append first implemented MKLDNN activation operator
@@ -228,6 +241,7 @@ function(register_operators)
 
  file(GLOB OPS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "*_op.cc")
  string(REPLACE "_mkldnn" "" OPS "${OPS}")
+ string(REPLACE "_xpu" "" OPS "${OPS}")
  string(REPLACE ".cc" "" OPS "${OPS}")
  list(REMOVE_DUPLICATES OPS)
  list(LENGTH register_operators_DEPS register_operators_DEPS_len)

cmake/third_party.cmake

@@ -250,6 +250,11 @@ if(WITH_GPU)
  file_download_and_uncompress(${CUDAERROR_URL} "cudaerror") # download file cudaErrorMessage
 endif(WITH_GPU)
 
+if(WITH_XPU)
+ include(external/xpu) # download, build, install xpu
+ list(APPEND third_party_deps extern_xpu)
+endif(WITH_XPU)
+
 if(WITH_PSLIB)
  include(external/pslib) # download, build, install pslib
  list(APPEND third_party_deps extern_pslib)

paddle/fluid/framework/dlpack_tensor.cc

@@ -70,6 +70,11 @@ struct DLContextVisitor : public boost::static_visitor<::DLContext> {
  return ctx;
  }
 
+ inline ::DLContext operator()(const platform::XPUPlace &place) const {
+ PADDLE_THROW(
+ platform::errors::Unimplemented("platform::XPUPlace is not supported"));
+ }
+
  inline ::DLContext operator()(const platform::CUDAPlace &place) const {
 #ifdef PADDLE_WITH_CUDA
  ::DLContext ctx;

paddle/fluid/framework/executor.cc

@@ -444,22 +444,31 @@ void Executor::RunPartialPreparedContext(ExecutorPrepareContext* ctx,
  int64_t max_memory_size = GetEagerDeletionThreshold();
  std::unique_ptr<GarbageCollector> gc;
  if (!ctx->force_disable_gc_ && max_memory_size >= 0) {
-#ifdef PADDLE_WITH_CUDA
  if (platform::is_gpu_place(place_)) {
+#ifdef PADDLE_WITH_CUDA
  if (IsFastEagerDeletionModeEnabled()) {
  gc.reset(new UnsafeFastGPUGarbageCollector(
  BOOST_GET_CONST(platform::CUDAPlace, place_), max_memory_size));
  } else {
  gc.reset(new DefaultStreamGarbageCollector(
  BOOST_GET_CONST(platform::CUDAPlace, place_), max_memory_size));
  }
- } else if (platform::is_cpu_place(place_)) {
+#else
+ PADDLE_THROW(
+ platform::errors::Unimplemented("No GPU gc found in CPU/XPU paddle"));
 #endif
+ } else if (platform::is_cpu_place(place_)) {
  gc.reset(new CPUGarbageCollector(
  BOOST_GET_CONST(platform::CPUPlace, place_), max_memory_size));
-#ifdef PADDLE_WITH_CUDA
- }
+ } else if (platform::is_xpu_place(place_)) {
+#ifdef PADDLE_WITH_XPU
+ gc.reset(new XPUGarbageCollector(
+ BOOST_GET_CONST(platform::XPUPlace, place_), max_memory_size));
+#else
+ PADDLE_THROW(
+ platform::errors::Unimplemented("No XPU gc found in CPU/GPU paddle"));
 #endif
+ }
  }
 
  for (int64_t i = start_op_index; i < end_op_index; ++i) {

paddle/fluid/framework/garbage_collector.cc

@@ -50,6 +50,15 @@ void CPUGarbageCollector::ClearCallback(const std::function<void()> &callback) {
  callback();
 }
 
+#ifdef PADDLE_WITH_XPU
+XPUGarbageCollector::XPUGarbageCollector(const platform::XPUPlace &place,
+ size_t max_memory_size)
+ : GarbageCollector(place, max_memory_size) {}
+void XPUGarbageCollector::ClearCallback(const std::function<void()> &callback) {
+ callback();
+}
+#endif
+
 #ifdef PADDLE_WITH_CUDA
 UnsafeFastGPUGarbageCollector::UnsafeFastGPUGarbageCollector(
  const platform::CUDAPlace &place, size_t max_memory_size)

paddle/fluid/framework/garbage_collector.h

@@ -59,6 +59,16 @@ class CPUGarbageCollector : public GarbageCollector {
  void ClearCallback(const std::function<void()> &callback) override;
 };
 
+#ifdef PADDLE_WITH_XPU
+class XPUGarbageCollector : public GarbageCollector {
+ public:
+ XPUGarbageCollector(const platform::XPUPlace &place, size_t max_memory_size);
+
+ protected:
+ void ClearCallback(const std::function<void()> &callback) override;
+};
+#endif
+
 #ifdef PADDLE_WITH_CUDA
 class UnsafeFastGPUGarbageCollector : public GarbageCollector {
  public: