Function ContiguousKernel

paddle/phi/kernels/cpu/contiguous_kernel.cc:127–280

template <typename T, typename Context>
void ContiguousKernel(const Context& dev_ctx,
                      const DenseTensor& input,
                      DenseTensor* out) {
  DenseTensorMeta meta = input.meta();
  meta.strides = meta.calc_strides(meta.dims);
  meta.offset = 0;
  out->set_meta(meta);

  const T* input_data = input.data<T>();
  T* output_data = dev_ctx.template Alloc<T>(out);
  auto numel = input.numel();

  if (numel == 0) {
    return;
  }

  if (IsComplexType(input.dtype())) {
    FallbackContiguous<T>(
        input.dims(), input.strides(), numel, input_data, output_data);
    return;
  }

#if defined(_WIN32)
  FallbackContiguous<T>(
      input.dims(), input.strides(), numel, input_data, output_data);
  return;
#else
  if (FastTransposeCopyValid(*out, input)) {
    constexpr int64_t TRANS_NUMEL = 60;
    void* trans_buffer =
        malloc(SizeOf(input.dtype()) * TRANS_NUMEL * TRANS_NUMEL);

    const T* tmp_src_ptr = input_data;
    T* tmp_out_ptr = output_data;
    T* tmp_buf_ptr = reinterpret_cast<T*>(trans_buffer);

    int64_t dim0 = out->dims()[0];
    int64_t dim1 = out->dims()[1];

    for (int64_t d0 = 0; d0 < dim0; d0 += TRANS_NUMEL) {
      for (int64_t d1 = 0; d1 < dim1; d1 += TRANS_NUMEL) {
        const T* src_ptr_inter = tmp_src_ptr + d0 + d1 * dim0;
        T* out_ptr_inter = tmp_out_ptr + d1 + d0 * dim1;

        int nr = std::min(dim0 - d0, TRANS_NUMEL);
        int nc = std::min(dim1 - d1, TRANS_NUMEL);

        for (int c = 0; c < nc; c++) {
          memcpy(tmp_buf_ptr + c * TRANS_NUMEL,
                 src_ptr_inter + c * dim0,
                 nr * sizeof(T));
        }

        int rc_max = std::max(nr, nc);
        int rc_min = std::min(nr, nc);
        for (int r = 0; r < rc_max; r++) {
          int end = std::min(r, rc_min);
          for (int c = 0; c < end; c++) {