unstack 大tensor问题

Author: cszdrg

paddle/phi/infermeta/backward.cc

@@ -16,6 +16,7 @@ limitations under the License. */
 #include "paddle/phi/common/type_traits.h"
 #include "paddle/phi/core/utils/data_type.h"
 #include "paddle/phi/kernels/funcs/axis_utils.h"
+#include <glog/logging.h>
 
 namespace phi {
 
@@ -1747,8 +1748,10 @@ void UnStackGradInferMeta(const std::vector<const MetaTensor*>& out_grad,
                         rank));
   if (axis < 0) axis += (rank + 1);
 
-  auto vec = common::vectorize<int>(input_dims[0]);
-  vec.insert(vec.begin() + axis, static_cast<int>(input_dims.size()));
+  auto vec = common::vectorize<int64_t>(input_dims[0]);
+  vec.insert(vec.begin() + axis, static_cast<int64_t>(input_dims.size()));
+  for (size_t i =0;i<vec.size();i++)
+    VLOG(1) << "!!!!!!" << vec[i];
   x_grad->set_dims(common::make_ddim(vec));
   x_grad->set_dtype(out_grad[0]->dtype());
 }

paddle/phi/infermeta/unary.cc

@@ -32,6 +32,8 @@ limitations under the License. */
 #include "paddle/phi/kernels/funcs/unsqueeze.h"
 #include "paddle/phi/kernels/impl/einsum_impl.h"
 
+#include <glog/logging.h>
+
 namespace phi {
 
 namespace detail {
@@ -5962,7 +5964,7 @@ void UnStackInferMeta(const MetaTensor& x,
             x_dim[axis],
             num));
   }
-  auto vec = common::vectorize<int>(x_dim);
+  auto vec = common::vectorize<int64_t>(x_dim);
   vec.erase(vec.begin() + axis);
   for (size_t i = 0; i < output_count; i++) {
     outs[i]->set_dims(common::make_ddim(vec));

paddle/phi/kernels/funcs/stack_and_unstack.h

@@ -210,7 +210,7 @@ void LaunchUnStackKernel(const Context& ctx,
     constexpr int kWarpSize = 32;
     constexpr int kMaxOut = 16;
 
-    int tid_x = 0, tid_y = 0, bid_x = 0, bid_y = 1;
+    int64_t tid_x = 0, tid_y = 0, bid_x = 0, bid_y = 1;
     if (split_dim < kMaxOut) {
       tid_y = split_dim;
       tid_x =
@@ -219,10 +219,13 @@ void LaunchUnStackKernel(const Context& ctx,
     } else {
       tid_y = kMaxOut;
       tid_x = kWarpSize;
-      bid_y = backends::gpu::DivUp<int>(split_dim, kMaxOut);
+      bid_y = backends::gpu::DivUp<int64_t>(split_dim, kMaxOut);
     }
-    int tile_x_num = backends::gpu::DivUp<int>(out_row, tid_x);
-    bid_x = std::min(tile_x_num, backends::gpu::kMultiDimslimit);
+    int64_t tile_x_num = backends::gpu::DivUp<int64_t>(out_row, tid_x);
+    if (tile_x_num < static_cast<int64_t>(backends::gpu::kMultiDimslimit))
+      bid_x = tile_x_num;
+    else
+      bid_x = backends::gpu::kMultiDimslimit;
     dim3 blocks(tid_x, tid_y, 1);
     dim3 grids(bid_x, bid_y, 1);
 

paddle/phi/kernels/impl/unstack_grad_kernel_impl.h

@@ -26,15 +26,16 @@ void UnStackGradKernel(const Context &dev_ctx,
                        const std::vector<const DenseTensor *> &x,
                        int axis,
                        DenseTensor *x_grad) {
+  VLOG(1) << "in";
   if (axis < 0) axis += (x[0]->dims().size() + 1);
 
-  int n = static_cast<int>(x.size());
+  int64_t n = static_cast<int64_t>(x.size());
   auto *x_grad_data = dev_ctx.template Alloc<T>(x_grad);
   std::vector<const T *> x_datas(n);
-  for (int i = 0; i < n; i++) x_datas[i] = x[i]->data<T>();
+  for (int64_t i = 0; i < n; i++) x_datas[i] = x[i]->data<T>();
 
-  int pre = 1;
-  int post = 1;
+  int64_t pre = 1;
+  int64_t post = 1;
   auto &dim = x[0]->dims();
   for (auto i = 0; i < axis; ++i) pre *= dim[i];
   for (auto i = axis; i < dim.size(); ++i) post *= dim[i];
@@ -56,8 +57,8 @@ void UnStackGradKernel(const Context &dev_ctx,
 
   size_t x_offset = 0;
   size_t y_offset = 0;
-  for (int i = 0; i < pre; i++) {
-    for (int j = 0; j < n; j++) {
+  for (int64_t i = 0; i < pre; i++) {
+    for (int64_t j = 0; j < n; j++) {
       std::memcpy(
           x_grad_data + y_offset, x_data_arr[j] + x_offset, post * sizeof(T));
       y_offset += post;