[Cpp API Compatibility] Align SymInt with PyTorch (#78807)

Author: youge325

paddle/phi/api/include/compat/ATen/TensorIndexing.h

@@ -91,6 +91,7 @@ struct TensorIndex final {
 
   TensorIndex(c10::SymInt integer)
       : integer_(std::move(integer)), type_(TensorIndexType::SymInt) {}
+  TensorIndex(int64_t integer) : TensorIndex(c10::SymInt(integer)) {}
   TensorIndex(int integer) : TensorIndex(c10::SymInt(integer)) {}
 
   template <class T, class = std::enable_if_t<std::is_same_v<bool, T>>>

paddle/phi/api/include/compat/ATen/core/TensorBase.h

@@ -155,7 +155,9 @@ class PADDLE_API TensorBase {
   }
 
   c10::SymIntArrayRef sym_strides() const {
-    return c10::SymIntArrayRef(strides());
+    return c10::SymIntArrayRef(
+        reinterpret_cast<const c10::SymInt*>(strides().data()),
+        strides().size());
   }
 
   int64_t size(int64_t dim) const {
@@ -173,7 +175,10 @@ class PADDLE_API TensorBase {
     return compat::_PD_PhiDDimToIntArrayRef(tensor_.dims());
   }
 
-  c10::SymIntArrayRef sym_sizes() const { return c10::SymIntArrayRef(sizes()); }
+  c10::SymIntArrayRef sym_sizes() const {
+    return c10::SymIntArrayRef(
+        reinterpret_cast<const c10::SymInt*>(sizes().data()), sizes().size());
+  }
 
   int64_t numel() const { return tensor_.numel(); }
 

paddle/phi/api/include/compat/ATen/ops/split.h

@@ -59,10 +59,11 @@ inline std::vector<at::Tensor> split(const at::Tensor& self,
 inline std::vector<at::Tensor> split_symint(const at::Tensor& self,
                                             c10::SymIntArrayRef split_sizes,
                                             int64_t dim = 0) {
-  return split(self,
-               at::IntArrayRef(static_cast<const int64_t*>(split_sizes.data()),
-                               split_sizes.size()),
-               dim);
+  return split(
+      self,
+      at::IntArrayRef(reinterpret_cast<const int64_t*>(split_sizes.data()),
+                      split_sizes.size()),
+      dim);
 }
 
 }  // namespace at

paddle/phi/api/include/compat/ATen/ops/tensor_split.h

@@ -119,7 +119,7 @@ inline std::vector<at::Tensor> tensor_split_symint(const at::Tensor& self,
                                                    int64_t dim = 0) {
   return tensor_split(
       self,
-      at::IntArrayRef(static_cast<const int64_t*>(indices.data()),
+      at::IntArrayRef(reinterpret_cast<const int64_t*>(indices.data()),
                       indices.size()),
       dim);
 }

paddle/phi/api/include/compat/ATen/ops/unflatten.h

@@ -40,8 +40,11 @@ inline at::Tensor unflatten(const at::Tensor& self,
 inline at::Tensor unflatten_symint(const at::Tensor& self,
                                    const int64_t dim,
                                    c10::SymIntArrayRef sizes) {
-  // SymIntArrayRef is the same as IntArrayRef in this implementation
-  return unflatten(self, dim, sizes);
+  return unflatten(
+      self,
+      dim,
+      at::IntArrayRef(reinterpret_cast<const int64_t*>(sizes.data()),
+                      sizes.size()));
 }
 
 }  // namespace at

paddle/phi/api/include/compat/c10/core/SymInt.h

@@ -15,8 +15,26 @@
 #pragma once
 #include <c10/util/accumulate.h>
 #include <cstdint>
+#include <optional>
 
 namespace c10 {
-using SymInt = int64_t;
+
+class SymInt {
+ public:
+  SymInt() : data_(0) {}
+  /*implicit*/ SymInt(int64_t d) : data_(d) {}  // NOLINT
+  /*implicit*/ operator int64_t() const { return data_; }
+
+  int64_t guard_int(const char* file, int64_t line) const {
+    (void)file;
+    (void)line;
+    return data_;
+  }
+
+  std::optional<int64_t> maybe_as_int() const { return data_; }
+
+ private:
+  int64_t data_;
+};
 
 }  // namespace c10

paddle/phi/api/include/compat/c10/core/SymIntArrayRef.h

@@ -18,7 +18,7 @@
 #include <c10/util/ArrayRef.h>
 
 namespace c10 {
-using SymIntArrayRef = IntArrayRef;  // SymIntArrayRef is same as ArrayRef
+using SymIntArrayRef = ArrayRef<SymInt>;
 }  // namespace c10
 
 namespace at {

paddle/phi/api/include/compat/c10/util/ArrayRef.h

@@ -152,7 +152,8 @@ class ArrayRef {
   std::vector<T> vec() const { return std::vector<T>(Data, Data + Length); }
 
   const paddle::experimental::IntArray _PD_ToPaddleIntArray() const {
-    return paddle::experimental::IntArray(Data, Length);
+    return paddle::experimental::IntArray(
+        reinterpret_cast<const int64_t*>(Data), Length);
   }
 };
 

test/cpp/compat/ATen_flatten_test.cc

@@ -146,7 +146,7 @@ TEST(TestUnflatten, UnflattenSymInt) {
 
   // Unflatten dimension 1 using symint version
   // Note: Must keep the underlying data alive
-  std::vector<int64_t> sizes_vec = {2, 3};
+  std::vector<c10::SymInt> sizes_vec = {2, 3};
   c10::SymIntArrayRef sizes(sizes_vec);
   at::Tensor unflattened = tensor.unflatten_symint(1, sizes);
   ASSERT_EQ(unflattened.sizes(), c10::IntArrayRef({4, 2, 3, 8}));