tensor.cc 14.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */

15
// clang-format off
16
#include "paddle/phi/api/include/tensor.h"
17 18 19 20 21 22

#include <memory>
#include <utility>
#include <vector>

#include "glog/logging.h"
23

24
#include "paddle/phi/api/lib/utils/allocator.h"
25 26
#include "paddle/phi/backends/gpu/gpu_info.h"
#include "paddle/phi/core/ddim.h"
27
#include "paddle/phi/core/dense_tensor.h"
28
#include "paddle/phi/core/enforce.h"
29
#include "paddle/phi/core/selected_rows.h"
30 31
#include "paddle/phi/core/sparse_coo_tensor.h"
#include "paddle/phi/core/sparse_csr_tensor.h"
J
Jack Zhou 已提交
32
#include "paddle/phi/core/string_tensor.h"
33 34 35
#include "paddle/phi/core/tensor_base.h"
#include "paddle/phi/core/tensor_meta.h"
#include "paddle/phi/core/tensor_utils.h"
36

37
#include "paddle/fluid/platform/stream/cuda_stream.h"
38
// clang-format off
39 40 41

namespace paddle {
namespace experimental {
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
namespace detail {
static Place GetCorrectPlaceByPlaceType(const Place &place_type) {
  auto alloc_type = place_type.GetType();
  switch (alloc_type) {
    case AllocationType::CPU:
      return place_type;
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
    case AllocationType::GPU:
      return phi::Place(AllocationType::GPU,
                        phi::backends::gpu::GetCurrentDeviceId());
#endif
    default:
      PADDLE_THROW(phi::errors::Unavailable(
          "The PlaceType is a legacy design, only supports CPU and GPU, "
          "and will not support other place types in the future."));
  }
}
}  // namespace detail
60 61 62 63 64

/////// Tensor Methods ////////

/* Part 1: Construction and destruction methods */

65
Tensor::Tensor(std::shared_ptr<phi::TensorBase> tensor_impl)
66
    : impl_(std::move(tensor_impl)) {
67 68 69
  PADDLE_ENFORCE_NOT_NULL(
      impl_,
      phi::errors::InvalidArgument("TensorImpl with nullptr is not supported"));
70 71
}

72
Tensor::Tensor(const Place &place) {
73 74 75 76 77 78 79 80
  LOG_FIRST_N(WARNING, 1)
      << "The Tensor(place) constructor is deprecated since version "
         "2.3, and will be removed in version 2.4! Please use "
         "`paddle::empty/full` method to create a new "
         "Tensor instead. "
         "Reason: A legal tensor cannot be constructed only based on "
         "the `place`, and datatype, shape, layout, etc. is also "
         "required.";
81 82 83 84 85 86 87 88
  DefaultAllocator alloc(detail::GetCorrectPlaceByPlaceType(place));
  impl_ = std::move(std::make_shared<phi::DenseTensor>(
      &alloc,
      std::move(phi::DenseTensorMeta(
          phi::DataType::FLOAT32, phi::make_ddim({}), phi::DataLayout::NCHW))));
}

Tensor::Tensor(const Place &place, const std::vector<int64_t> &shape) {
89 90 91 92 93 94 95 96
  LOG_FIRST_N(WARNING, 1)
      << "The Tensor(place, shape) constructor is deprecated since "
         "version 2.3, and will be removed in version 2.4! Please use "
         "`paddle::empty/full` method to create a new "
         "Tensor instead. "
         "Reason: A legal tensor cannot be constructed only based on "
         "the `place` and `shape`, and datatype, layout, etc. is also "
         "required.";
97 98 99 100 101 102 103
  DefaultAllocator alloc(detail::GetCorrectPlaceByPlaceType(place));
  impl_ = std::move(std::make_shared<phi::DenseTensor>(
      &alloc,
      std::move(phi::DenseTensorMeta(phi::DataType::FLOAT32,
                                     phi::make_ddim({shape}),
                                     phi::DataLayout::NCHW))));
}
104

105
Tensor::Tensor(std::shared_ptr<phi::TensorBase> tensor_impl,
106 107
               const std::string &name)
    : impl_(std::move(tensor_impl)), name_(std::move(name)) {}
108

109 110 111 112 113 114
/* Part 2: Dimension, DataType and DataLayout methods */

int64_t Tensor::numel() const { return impl_->numel(); }

int64_t Tensor::size() const { return impl_->numel(); }

115
const phi::DDim &Tensor::dims() const { return impl_->dims(); }
116 117

std::vector<int64_t> Tensor::shape() const {
118 119
  auto dims = impl_->dims();
  return phi::vectorize<int64_t>(dims);
120 121 122
}

void Tensor::reshape(const std::vector<int64_t> &shape) {
123 124 125 126 127 128 129 130 131
  LOG_FIRST_N(WARNING, 1)
      << "The function of resetting the shape of the uninitialized "
         "Tensor of the `reshape` method is deprecated since version "
         "2.3, and will be removed in version 2.4, please use "
         "`paddle::empty/full` method to create a new Tensor "
         "instead. "
         "reason: `reshape` means changing the tensor shape without "
         "touching underlying data, this requires the total size of "
         "the tensor to remain constant.";
C
Chen Weihang 已提交
132
  if (is_dense_tensor()) {
133
    static_cast<phi::DenseTensor *>(impl_.get())->Resize(phi::make_ddim(shape));
134
  } else {
135
    PADDLE_THROW(phi::errors::Unimplemented(
136 137
        "Only support reshape operation on DenseTensor now."));
  }
138 139
}

140
DataType Tensor::dtype() const { return impl_->dtype(); }
141

142
DataType Tensor::type() const { return impl_->dtype(); }
143 144 145

DataLayout Tensor::layout() const { return impl_->layout(); }

C
Chen Weihang 已提交
146
bool Tensor::is_dense_tensor() const {
147
  return phi::DenseTensor::classof(impl_.get());
C
Chen Weihang 已提交
148
}
149
bool Tensor::is_selected_rows() const {
150
  return phi::SelectedRows::classof(impl_.get());
151
}
152 153 154 155 156 157
bool Tensor::is_sparse_coo_tensor() const {
  return phi::SparseCooTensor::classof(impl_.get());
}
bool Tensor::is_sparse_csr_tensor() const {
  return phi::SparseCsrTensor::classof(impl_.get());
}
J
Jack Zhou 已提交
158 159 160
bool Tensor::is_string_tensor() const {
  return phi::StringTensor::classof(impl_.get());
}
161 162
/* Part 3: Device and Backend methods */

163
const Place &Tensor::place() const {
164 165 166 167 168 169
  PADDLE_ENFORCE_NOT_NULL(
      impl_,
      phi::errors::PermissionDenied(
          "Null pointer error, the impl_ of Tensor should not be "
          "Null when calling Tensor::place()."));
  return impl_->place();
170 171
}

C
Chen Weihang 已提交
172
bool Tensor::is_cpu() const { return paddle::platform::is_cpu_place(place()); }
173

C
Chen Weihang 已提交
174
bool Tensor::is_gpu() const { return paddle::platform::is_gpu_place(place()); }
175

176
bool Tensor::is_gpu_pinned() const {
C
Chen Weihang 已提交
177
  return paddle::platform::is_cuda_pinned_place(place());
178 179
}

180 181 182 183
/* Part 4: Data Access methods */

template <typename T>
T *Tensor::mutable_data() {
184 185 186 187 188 189 190 191 192 193
  LOG_FIRST_N(WARNING, 1)
      << "Allocating memory through `mutable_data` method is "
         "deprecated since version 2.3, and `mutable_data` method "
         "will be removed in version 2.4! Please use "
         "`paddle::empty/full` method to create a new "
         "Tensor with allocated memory, and use data<T>() method "
         "to get the memory pointer of tensor instead. "
         "Reason: When calling `mutable_data` to allocate memory, "
         "the place, datatype, and data layout of tensor may be in "
         "an illegal state.";
C
Chen Weihang 已提交
194
  if (is_dense_tensor()) {
195 196
    return static_cast<phi::DenseTensor *>(impl_.get())
        ->mutable_data<T>(place());
197 198 199 200
  }
  return nullptr;
}

201 202 203 204 205 206 207 208
template PADDLE_API float *Tensor::mutable_data<float>();
template PADDLE_API double *Tensor::mutable_data<double>();
template PADDLE_API int64_t *Tensor::mutable_data<int64_t>();
template PADDLE_API int32_t *Tensor::mutable_data<int32_t>();
template PADDLE_API uint8_t *Tensor::mutable_data<uint8_t>();
template PADDLE_API int8_t *Tensor::mutable_data<int8_t>();
template PADDLE_API int16_t *Tensor::mutable_data<int16_t>();
template PADDLE_API bool *Tensor::mutable_data<bool>();
209 210 211 212 213 214
template PADDLE_API phi::dtype::complex<float>
    *Tensor::mutable_data<phi::dtype::complex<float>>();
template PADDLE_API phi::dtype::complex<double>
    *Tensor::mutable_data<phi::dtype::complex<double>>();
template PADDLE_API phi::dtype::float16 *
Tensor::mutable_data<phi::dtype::float16>();
215 216

template <typename T>
217
T *Tensor::mutable_data(const Place &place) {
218 219 220 221 222 223 224 225 226 227
  LOG_FIRST_N(WARNING, 1)
      << "Allocating memory through `mutable_data` method is "
         "deprecated since version 2.3, and `mutable_data` method "
         "will be removed in version 2.4! Please use "
         "`paddle::empty/full` method to create a new "
         "Tensor with allocated memory, and use data<T>() method "
         "to get the memory pointer of tensor instead. "
         "Reason: When calling `mutable_data` to allocate memory, "
         "the datatype, and data layout of tensor may be in "
         "an illegal state.";
228
  if (is_dense_tensor()) {
229
    return static_cast<phi::DenseTensor *>(impl_.get())->mutable_data<T>(place);
230 231
  }
  return nullptr;
232 233
}

234 235 236 237 238 239 240 241
template PADDLE_API float *Tensor::mutable_data<float>(const Place &place);
template PADDLE_API double *Tensor::mutable_data<double>(const Place &place);
template PADDLE_API int64_t *Tensor::mutable_data<int64_t>(const Place &place);
template PADDLE_API int32_t *Tensor::mutable_data<int32_t>(const Place &place);
template PADDLE_API uint8_t *Tensor::mutable_data<uint8_t>(const Place &place);
template PADDLE_API int8_t *Tensor::mutable_data<int8_t>(const Place &place);
template PADDLE_API int16_t *Tensor::mutable_data<int16_t>(const Place &place);
template PADDLE_API bool *Tensor::mutable_data<bool>(const Place &place);
242
template PADDLE_API phi::dtype::complex<float>
243
    *Tensor::mutable_data<phi::dtype::complex<float>>(const Place &place);
244
template PADDLE_API phi::dtype::complex<double>
245
    *Tensor::mutable_data<phi::dtype::complex<double>>(const Place &place);
246
template PADDLE_API phi::dtype::float16 *
247
Tensor::mutable_data<phi::dtype::float16>(const Place &place);
248 249 250

template <typename T>
const T *Tensor::data() const {
C
Chen Weihang 已提交
251
  if (is_dense_tensor()) {
252 253 254
    return static_cast<phi::DenseTensor *>(impl_.get())->data<T>();
  } else if (is_selected_rows()) {
    return static_cast<phi::SelectedRows *>(impl_.get())->value().data<T>();
255 256 257 258
  }
  return nullptr;
}

259 260 261 262 263 264 265 266
template PADDLE_API const float *Tensor::data<float>() const;
template PADDLE_API const double *Tensor::data<double>() const;
template PADDLE_API const int64_t *Tensor::data<int64_t>() const;
template PADDLE_API const int32_t *Tensor::data<int32_t>() const;
template PADDLE_API const uint8_t *Tensor::data<uint8_t>() const;
template PADDLE_API const int8_t *Tensor::data<int8_t>() const;
template PADDLE_API const int16_t *Tensor::data<int16_t>() const;
template PADDLE_API const bool *Tensor::data<bool>() const;
267 268 269 270 271 272 273 274
template PADDLE_API const phi::dtype::complex<float>
    *Tensor::data<phi::dtype::complex<float>>() const;
template PADDLE_API const phi::dtype::complex<double>
    *Tensor::data<phi::dtype::complex<double>>() const;
template PADDLE_API const phi::dtype::float16 *
Tensor::data<phi::dtype::float16>() const;
template PADDLE_API const phi::dtype::bfloat16 *
Tensor::data<phi::dtype::bfloat16>() const;
275 276 277

template <typename T>
T *Tensor::data() {
278
  if (is_dense_tensor()) {
279 280 281
    return static_cast<phi::DenseTensor *>(impl_.get())->data<T>();
  } else if (is_selected_rows()) {
    return static_cast<phi::SelectedRows *>(impl_.get())
282 283 284
        ->mutable_value()
        ->data<T>();
  }
285 286 287
  return nullptr;
}

288 289 290 291 292 293 294 295
template PADDLE_API float *Tensor::data<float>();
template PADDLE_API double *Tensor::data<double>();
template PADDLE_API int64_t *Tensor::data<int64_t>();
template PADDLE_API int32_t *Tensor::data<int32_t>();
template PADDLE_API uint8_t *Tensor::data<uint8_t>();
template PADDLE_API int8_t *Tensor::data<int8_t>();
template PADDLE_API int16_t *Tensor::data<int16_t>();
template PADDLE_API bool *Tensor::data<bool>();
296 297 298 299 300
template PADDLE_API phi::dtype::complex<float>
    *Tensor::data<phi::dtype::complex<float>>();
template PADDLE_API phi::dtype::complex<double>
    *Tensor::data<phi::dtype::complex<double>>();
template PADDLE_API phi::dtype::float16 *Tensor::data<phi::dtype::float16>();
301

302
// TODO(chenweihang): replace slice impl by API
303
Tensor Tensor::slice(int64_t begin_idx, int64_t end_idx) const {
C
Chen Weihang 已提交
304
  if (is_dense_tensor()) {
305 306
    return Tensor(std::make_shared<phi::DenseTensor>(
        std::move(phi::DenseTensorUtils::Slice(
307
            *(static_cast<phi::DenseTensor *>(impl_.get())),
308 309 310
            begin_idx,
            end_idx))));
  } else {
311
    PADDLE_THROW(phi::errors::Unimplemented(
312
        "Only support slice operation on DenseTensor now."));
313
  }
314 315
}

316
const std::shared_ptr<phi::TensorBase> &Tensor::impl() const { return impl_; }
317

318
void Tensor::set_impl(const std::shared_ptr<phi::TensorBase> &impl) {
319 320 321
  impl_ = impl;
}

322 323 324 325
void Tensor::set_impl(std::shared_ptr<phi::TensorBase> &&impl) {
  impl_ = std::move(impl);
}

326 327 328 329 330 331
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
gpuStream_t Tensor::stream() const {
  return platform::stream::get_current_stream(-1)->raw_stream();
}
#endif

332
/* Part 5: Status utils methods */
333 334 335

bool Tensor::defined() const { return impl_ != nullptr; }

336
bool Tensor::initialized() const { return defined() && impl_->initialized(); }
337 338

bool Tensor::is_initialized() const {
339 340 341 342
  LOG_FIRST_N(WARNING, 1)
      << "The `is_initialized` method is deprecated since version "
         "2.3, and will be removed in version 2.4! "
         "Please use `initialized` method instead.";
343
  return defined() && impl_->initialized();
344 345
}

346 347 348 349 350
void Tensor::reset() {
  impl_.reset();
  autograd_meta_.reset();
  name_ = "";
}
351

352
/* Part 6: Operator overloading */
353 354 355 356

Tensor &Tensor::operator=(const Tensor &x) & {
  impl_ = x.impl_;
  autograd_meta_ = x.autograd_meta_;
357
  name_ = x.name_;
358 359 360 361 362 363
  return *this;
}

Tensor &Tensor::operator=(Tensor &&x) & {
  impl_ = std::move(x.impl_);
  autograd_meta_ = std::move(x.autograd_meta_);
364
  name_ = std::move(x.name_);
365 366 367 368 369 370 371
  return *this;
}

AbstractAutogradMeta *Tensor::get_autograd_meta() const {
  return autograd_meta_.get();
}

372 373 374 375 376
const std::shared_ptr<AbstractAutogradMeta> &Tensor::mutable_autograd_meta()
    const {
  return autograd_meta_;
}

377 378 379 380 381
void Tensor::set_autograd_meta(
    std::shared_ptr<AbstractAutogradMeta> autograd_meta) {
  autograd_meta_ = std::move(autograd_meta);
}

382 383 384
void Tensor::bump_inplace_version() {
  if (is_dense_tensor()) {
    auto &inplace_version_counter =
385
        static_cast<phi::DenseTensor *>(impl_.get())->InplaceVersionCounter();
386 387 388 389 390 391 392 393 394 395
    inplace_version_counter.Bump();
  } else {
    PADDLE_THROW(phi::errors::Unimplemented(
        "bump_inplace_version is only supported on DenseTensor now."));
  }
}

uint32_t Tensor::current_inplace_version() {
  if (is_dense_tensor()) {
    auto &inplace_version_counter =
396
        static_cast<phi::DenseTensor *>(impl_.get())->InplaceVersionCounter();
397 398
    return inplace_version_counter.CurrentVersion();
  } else {
399 400
    LOG_FIRST_N(WARNING, 1)
        << "current_inplace_version is only supported on DenseTensor now.";
401 402 403 404
  }
  return 0;
}

405 406 407 408
void Tensor::reset_inplace_version(bool set_to_zero) {
  if (set_to_zero) {
    if (is_dense_tensor()) {
      auto &inplace_version_counter =
409
          static_cast<phi::DenseTensor *>(impl_.get())->InplaceVersionCounter();
410 411 412 413 414
      inplace_version_counter.SetInplaceVersionToZero();
    }
  }
}

415 416
}  // namespace experimental
}  // namespace paddle