update op lower

CMakeLists.txt

@@ -65,7 +65,8 @@ option(WITH_SETUP_INSTALL "Compile PaddlePaddle with setup.py" OFF)
 option(WITH_SHARED_PHI "Compile PaddlePaddle with SHARED LIB of PHI" ON)
 option(CINN_ONLY "Compile CINN only in Paddle" OFF)
 option(CINN_WITH_CUDNN "Compile CINN with CUDNN support" ON)
-
+option(WITH_PIP_CUDA_LIBRARIES
+       "Paddle uses the CUDA library provided by NVIDIA" OFF)
 find_package(Git REQUIRED)
 
 # config GIT_URL with github mirrors to speed up dependent repos clone
@@ -97,11 +98,16 @@ endif()
 
 if(WITH_GPU AND NOT APPLE)
   #(Note risemeup1): The cudart dynamic library libcudart.so is used by set CUDA_USE_STATIC_CUDA_RUNTIME and CMAKE_CUDA_FLAGS
-  if(LINUX)
+  if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL
+                                            "x86_64")
     set(CUDA_USE_STATIC_CUDA_RUNTIME
         OFF
         CACHE BOOL "" FORCE)
     set(CMAKE_CUDA_FLAGS "--cudart shared")
+    if(WITH_PIP_CUDA_LIBRARIES)
+      #(Note risemeup1): Flag 'WITH_PIP_CUDA_LIBRARIES' will be used in dynamic_loader.cc to search for CUDA-related .so files through the Python libraries provided by NVIDIA.
+      add_definitions(-DWITH_PIP_CUDA_LIBRARIES)
+    endif()
   endif()
   enable_language(CUDA)
   message(STATUS "CUDA compiler: ${CMAKE_CUDA_COMPILER}, version: "

cmake/external/eigen.cmake

@@ -39,27 +39,19 @@ elseif(LINUX)
   endif()
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCC)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
   file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/eigen/TensorRandom.h.patch
        tensor_random_header)
   # See: [Why calling some `git` commands before `patch`?]
   set(EIGEN_PATCH_COMMAND
       git checkout -- . && git checkout ${EIGEN_TAG} && patch -Nd
       ${SOURCE_DIR}/unsupported/Eigen/CXX11/src/Tensor <
       ${tensor_random_header})
-  execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpfullversion -dumpversion
-                  OUTPUT_VARIABLE GCC_VERSION)
-  string(REGEX MATCHALL "[0-9]+" GCC_VERSION_COMPONENTS ${GCC_VERSION})
-  list(GET GCC_VERSION_COMPONENTS 0 GCC_MAJOR)
-  list(GET GCC_VERSION_COMPONENTS 1 GCC_MINOR)
-  set(GCC_VERSION "${GCC_MAJOR}.${GCC_MINOR}")
-  if(GCC_VERSION GREATER_EQUAL 12.0)
-    file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/eigen/Complex.h.patch
-         complex_header)
-    set(EIGEN_PATCH_COMMAND
-        ${EIGEN_PATCH_COMMAND} && patch -Nd
-        ${SOURCE_DIR}/Eigen/src/Core/arch/SSE/ < ${complex_header})
-  endif()
+  file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/eigen/Complex.h.patch
+       complex_header)
+  set(EIGEN_PATCH_COMMAND
+      ${EIGEN_PATCH_COMMAND} && patch -Nd
+      ${SOURCE_DIR}/Eigen/src/Core/arch/SSE/ < ${complex_header})
 endif()
 
 set(EIGEN_INCLUDE_DIR ${SOURCE_DIR})

cmake/external/gloo.cmake

@@ -42,24 +42,16 @@ if(WITH_GPU)
   endif()
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCC)
-  execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpfullversion -dumpversion
-                  OUTPUT_VARIABLE GCC_VERSION)
-  string(REGEX MATCHALL "[0-9]+" GCC_VERSION_COMPONENTS ${GCC_VERSION})
-  list(GET GCC_VERSION_COMPONENTS 0 GCC_MAJOR)
-  list(GET GCC_VERSION_COMPONENTS 1 GCC_MINOR)
-  set(GCC_VERSION "${GCC_MAJOR}.${GCC_MINOR}")
-  if(GCC_VERSION GREATER_EQUAL "12.0")
-    file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/gloo/device.cc.patch
-         native_dst)
-    file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/gloo/types.h.patch
-         types_header)
-    # See: [Why calling some `git` commands before `patch`?]
-    set(GLOO_PATCH_COMMAND
-        git checkout -- . && git checkout ${GLOO_TAG} && patch -Nd
-        ${SOURCE_DIR}/gloo/transport/tcp < ${native_dst} && patch -Nd
-        ${SOURCE_DIR}/gloo/ < ${types_header})
-  endif()
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+  file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/gloo/device.cc.patch
+       native_dst)
+  file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/gloo/types.h.patch
+       types_header)
+  # See: [Why calling some `git` commands before `patch`?]
+  set(GLOO_PATCH_COMMAND
+      git checkout -- . && git checkout ${GLOO_TAG} && patch -Nd
+      ${SOURCE_DIR}/gloo/transport/tcp < ${native_dst} && patch -Nd
+      ${SOURCE_DIR}/gloo/ < ${types_header})
 endif()
 
 file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/gloo/linux.cc.patch

cmake/simd.cmake

@@ -4,9 +4,7 @@
 include(CheckCXXSourceRuns)
 include(CheckCXXSourceCompiles)
 
-if(CMAKE_COMPILER_IS_GNUCC
-   OR CMAKE_COMPILER_IS_GNUCXX
-   OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
   set(MMX_FLAG "-mmmx")
   set(SSE2_FLAG "-msse2")
   set(SSE3_FLAG "-msse3")

cmake/third_party.cmake

@@ -15,6 +15,11 @@
 include(ExternalProject)
 # Create a target named "third_party", which can compile external dependencies on all platform(windows/linux/mac)
 
+# Avoid warning about DOWNLOAD_EXTRACT_TIMESTAMP in CMake 3.24
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
+  cmake_policy(SET CMP0135 NEW)
+endif()
+
 set(THIRD_PARTY_PATH
     "${CMAKE_BINARY_DIR}/third_party"
     CACHE STRING

paddle/cinn/backends/codegen_cuda_dev.cc

@@ -21,6 +21,7 @@
 #include <set>
 #include <unordered_set>
 
+#include "paddle/cinn/common/cas.h"
 #include "paddle/cinn/common/ir_util.h"
 #include "paddle/cinn/ir/op/ir_operators.h"
 #include "paddle/cinn/ir/utils/ir_verify.h"
@@ -124,6 +125,7 @@ std::vector<Expr> FilterDeallocTempBuffers(const std::vector<Expr> &frees) {
     bool has_symbolic_constant = false;
     const ir::_Buffer_ *buffer = op->destination.As<ir::_Buffer_>();
     for (Expr shape : buffer->shape) {
+      shape = common::AutoSimplify(shape);
       ir::ir_utils::CollectIRNodes(shape, [&](const Expr *x) {
         if (x->as_var()) {
           CHECK(x->as_var()->is_symbolic_constant)

paddle/cinn/common/integer_set.cc

@@ -44,6 +44,9 @@ cas_intervals_t CollectVarIntervalsOfExprs(const std::vector<ir::Expr>& exprs,
         if (var->upper_bound.defined()) {
           upper_bound = var->upper_bound;
         }
+        if (var->is_symbolic_constant) {
+          lower_bound = ir::Expr(1);
+        }
         var_intervals.insert(
             {var->name, CasInterval(lower_bound, upper_bound)});
       }
@@ -118,32 +121,32 @@ std::optional<bool> SymbolicExprAnalyzer::ProveGE(const ir::Expr& lhs,
   if (lhs == rhs) {
     return true;
   }
-  if (lhs == SymbolicExprLimit::positive_inf ||
-      rhs == SymbolicExprLimit::negative_inf) {
-    return true;
-  }
   if (rhs == SymbolicExprLimit::positive_inf ||
       lhs == SymbolicExprLimit::negative_inf) {
     return false;
   }
-  ir::Expr diff = AutoSimplify(ir::Sub::Make(lhs, rhs), var_intervals_);
-  VLOG(6) << "diff of " << ir::Sub::Make(lhs, rhs) << " = " << diff;
-  if (diff.is_constant() && diff.get_constant() >= 0) {
+  if (lhs == SymbolicExprLimit::positive_inf ||
+      rhs == SymbolicExprLimit::negative_inf) {
     return true;
   }
+  ir::Expr diff = AutoSimplify(ir::Sub::Make(lhs, rhs), var_intervals_);
+  VLOG(6) << "diff of " << ir::Sub::Make(lhs, rhs) << " = " << diff;
   if (diff.is_constant() && diff.get_constant() < 0) {
     return false;
   }
-  ir::Expr diff_lower_bound = LowerBound(diff);
-  VLOG(6) << "lower bound of " << diff << " = " << diff_lower_bound;
-  if (diff_lower_bound.is_constant() && diff_lower_bound.get_constant() >= 0) {
+  if (diff.is_constant() && diff.get_constant() >= 0) {
     return true;
   }
   ir::Expr diff_upper_bound = UpperBound(diff);
   VLOG(6) << "upper bound of " << diff << " = " << diff_upper_bound;
   if (diff_upper_bound.is_constant() && diff_upper_bound.get_constant() < 0) {
     return false;
   }
+  ir::Expr diff_lower_bound = LowerBound(diff);
+  VLOG(6) << "lower bound of " << diff << " = " << diff_lower_bound;
+  if (diff_lower_bound.is_constant() && diff_lower_bound.get_constant() >= 0) {
+    return true;
+  }
   return std::nullopt;
 }
 
@@ -157,32 +160,33 @@ std::optional<bool> SymbolicExprAnalyzer::ProveGT(const ir::Expr& lhs,
   if (lhs == rhs) {
     return false;
   }
-  if (lhs == SymbolicExprLimit::positive_inf ||
-      rhs == SymbolicExprLimit::negative_inf) {
-    return true;
-  }
   if (rhs == SymbolicExprLimit::positive_inf ||
       lhs == SymbolicExprLimit::negative_inf) {
     return false;
   }
-  ir::Expr diff = AutoSimplify(ir::Sub::Make(lhs, rhs), var_intervals_);
-  VLOG(6) << "diff of " << ir::Sub::Make(lhs, rhs) << " = " << diff;
-  if (diff.is_constant() && diff.get_constant() > 0) {
+  if (lhs == SymbolicExprLimit::positive_inf ||
+      rhs == SymbolicExprLimit::negative_inf) {
     return true;
   }
+  ir::Expr diff = AutoSimplify(ir::Sub::Make(lhs, rhs), var_intervals_);
+  VLOG(6) << "diff of " << ir::Sub::Make(lhs, rhs) << " = " << diff;
   if (diff.is_constant() && diff.get_constant() <= 0) {
     return false;
   }
-  ir::Expr diff_lower_bound = LowerBound(diff);
-  VLOG(6) << "lower bound of " << diff << " = " << diff_lower_bound;
-  if (diff_lower_bound.is_constant() && diff_lower_bound.get_constant() > 0) {
+  if (diff.is_constant() && diff.get_constant() > 0) {
     return true;
   }
   ir::Expr diff_upper_bound = UpperBound(diff);
   VLOG(6) << "upper bound of " << diff << " = " << diff_upper_bound;
   if (diff_upper_bound.is_constant() && diff_upper_bound.get_constant() <= 0) {
     return false;
   }
+  ir::Expr diff_lower_bound = LowerBound(diff);
+  VLOG(6) << "lower bound of " << diff << " = " << diff_lower_bound;
+  if (diff_lower_bound.is_constant() && diff_lower_bound.get_constant() > 0) {
+    return true;
+  }
+
   return std::nullopt;
 }