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
#include "paddle/phi/api/include/tensor.h"
16 17 18 19 20 21

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

#include "glog/logging.h"
22

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

36 37 38 39
#include "paddle/fluid/platform/stream/cuda_stream.h"

namespace paddle {
namespace experimental {
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
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
58 59 60 61 62

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

/* Part 1: Construction and destruction methods */

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

70
Tensor::Tensor(const Place &place) {
71 72 73 74 75 76 77 78
  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.";
79 80 81 82 83 84 85 86
  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) {
87 88 89 90 91 92 93 94
  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.";
95 96 97 98 99 100 101
  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))));
}
102

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

107 108 109 110 111 112
/* Part 2: Dimension, DataType and DataLayout methods */

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

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

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

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

void Tensor::reshape(const std::vector<int64_t> &shape) {
121 122 123 124 125 126 127 128 129
  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 已提交
130
  if (is_dense_tensor()) {
131
    static_cast<phi::DenseTensor *>(impl_.get())->Resize(phi::make_ddim(shape));
132
  } else {
133
    PADDLE_THROW(phi::errors::Unimplemented(
134 135
        "Only support reshape operation on DenseTensor now."));
  }
136 137
}

138
DataType Tensor::dtype() const { return impl_->dtype(); }
139

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

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

C
Chen Weihang 已提交
144
bool Tensor::is_dense_tensor() const {
145
  return phi::DenseTensor::classof(impl_.get());
C
Chen Weihang 已提交
146
}
147
bool Tensor::is_selected_rows() const {
148
  return phi::SelectedRows::classof(impl_.get());
149
}
150 151 152 153 154 155
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 已提交
156 157 158
bool Tensor::is_string_tensor() const {
  return phi::StringTensor::classof(impl_.get());
}
159 160
/* Part 3: Device and Backend methods */

161
const Place &Tensor::place() const {
162 163 164 165 166 167
  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();
168 169
}

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

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

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

178 179 180 181
/* Part 4: Data Access methods */

template <typename T>
T *Tensor::mutable_data() {
182 183 184 185 186 187 188 189 190 191
  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 已提交
192
  if (is_dense_tensor()) {
193 194
    return static_cast<phi::DenseTensor *>(impl_.get())
        ->mutable_data<T>(place());
195 196 197 198
  }
  return nullptr;
}

199 200 201 202 203 204 205 206
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>();
207 208 209 210 211 212
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>();
213 214

template <typename T>
215
T *Tensor::mutable_data(const Place &place) {
216 217 218 219 220 221 222 223 224 225
  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.";
226
  if (is_dense_tensor()) {
227
    return static_cast<phi::DenseTensor *>(impl_.get())->mutable_data<T>(place);
228 229
  }
  return nullptr;
230 231
}

232 233 234 235 236 237 238 239
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);
240
template PADDLE_API phi::dtype::complex<float>
241
    *Tensor::mutable_data<phi::dtype::complex<float>>(const Place &place);
242
template PADDLE_API phi::dtype::complex<double>
243
    *Tensor::mutable_data<phi::dtype::complex<double>>(const Place &place);
244
template PADDLE_API phi::dtype::float16 *
245
Tensor::mutable_data<phi::dtype::float16>(const Place &place);
246 247 248

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

257 258 259 260 261 262 263 264
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;
265 266 267 268 269 270 271 272
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;
273 274 275

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

286 287 288 289 290 291 292 293
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>();
294 295 296 297 298
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>();
299

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

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

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

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

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

330
/* Part 5: Status utils methods */
331 332 333

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

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

bool Tensor::is_initialized() const {
337 338 339 340
  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.";
341
  return defined() && impl_->initialized();
342 343 344 345
}

void Tensor::reset() { impl_.reset(); }

346
/* Part 6: Operator overloading */
347 348 349 350

Tensor &Tensor::operator=(const Tensor &x) & {
  impl_ = x.impl_;
  autograd_meta_ = x.autograd_meta_;
351
  name_ = x.name_;
352 353 354 355 356 357
  return *this;
}

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

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

366 367 368 369 370
const std::shared_ptr<AbstractAutogradMeta> &Tensor::mutable_autograd_meta()
    const {
  return autograd_meta_;
}

371 372 373 374 375
void Tensor::set_autograd_meta(
    std::shared_ptr<AbstractAutogradMeta> autograd_meta) {
  autograd_meta_ = std::move(autograd_meta);
}

376 377 378
void Tensor::bump_inplace_version() {
  if (is_dense_tensor()) {
    auto &inplace_version_counter =
379
        static_cast<phi::DenseTensor *>(impl_.get())->InplaceVersionCounter();
380 381 382 383 384 385 386 387 388 389
    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 =
390
        static_cast<phi::DenseTensor *>(impl_.get())->InplaceVersionCounter();
391 392 393 394 395 396 397 398
    return inplace_version_counter.CurrentVersion();
  } else {
    PADDLE_THROW(phi::errors::Unimplemented(
        "current_inplace_version is only supported on DenseTensor now."));
  }
  return 0;
}

399 400 401 402
void Tensor::reset_inplace_version(bool set_to_zero) {
  if (set_to_zero) {
    if (is_dense_tensor()) {
      auto &inplace_version_counter =
403
          static_cast<phi::DenseTensor *>(impl_.get())->InplaceVersionCounter();
404 405 406 407 408
      inplace_version_counter.SetInplaceVersionToZero();
    }
  }
}

409 410
}  // namespace experimental
}  // namespace paddle