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

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/core/dense_tensor.h"
16

17 18 19 20
#include "paddle/phi/common/bfloat16.h"
#include "paddle/phi/common/complex.h"
#include "paddle/phi/common/float16.h"
#include "paddle/phi/core/compat/convert_utils.h"
21

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
/**
 * [ Why still include the fluid headers? ]
 *
 * We hope to organize the basic implementation of Tensor and the logic related
 * to Tensor computation into an independent library, which we call
 * [Tensor Operation Library, phi], so we extract or rewrite the original
 * Kernels.
 *
 * In the future, the training library, inference library and custom operators
 * will link to this Tensor Operation library.
 *
 * However, if we directly split the link relation, we need to make too many
 * changes, which will affect the stability of the framework, so here we still
 * rely on the implementation of the framework, which is a intermediate state.
 *
 * In the future, the necessary components will be moved to the this library,
 * or the corresponding components will be re-implemented.
 */
40
#include "paddle/fluid/memory/malloc.h"
41

42
namespace phi {
43

44
DenseTensor::DenseTensor(Allocator* a, const DenseTensorMeta& meta)
45
    : meta_(meta), holder_(a->Allocate(SizeOf(dtype()) * numel())) {}
46

47
DenseTensor::DenseTensor(Allocator* a, DenseTensorMeta&& meta)
48
    : meta_(std::move(meta)), holder_(a->Allocate(SizeOf(dtype()) * numel())) {}
49

50
DenseTensor::DenseTensor(const std::shared_ptr<phi::Allocation>& holder,
51
                         const DenseTensorMeta& meta)
52
    : meta_(meta), holder_(holder) {}
53

54
DenseTensor::DenseTensor(const DenseTensor& other) : meta_(other.meta()) {
55
  holder_ = other.holder_;
56
  inplace_version_counter_ = other.inplace_version_counter_;
57 58

#ifdef PADDLE_WITH_MKLDNN
59
  mem_desc_ = other.mem_desc_;
60 61
#endif
}
62

63 64
DenseTensor& DenseTensor::operator=(const DenseTensor& other) {
  meta_ = other.meta();
65
  holder_ = other.holder_;
66
  inplace_version_counter_ = other.inplace_version_counter_;
67
#ifdef PADDLE_WITH_MKLDNN
68
  mem_desc_ = other.mem_desc_;
69
#endif
70 71 72
  return *this;
}

73 74
DenseTensor& DenseTensor::operator=(DenseTensor&& other) {
  meta_ = std::move(other.meta_);
75
  std::swap(holder_, other.holder_);
76
  std::swap(inplace_version_counter_, other.inplace_version_counter_);
77 78 79
#ifdef PADDLE_WITH_MKLDNN
  mem_desc_ = other.mem_desc_;
#endif
80 81 82
  return *this;
}

83 84 85 86 87 88 89 90
int64_t DenseTensor::numel() const {
  if (meta_.is_scalar) {
    return 1;
  }
  return product(meta_.dims);
}

bool DenseTensor::IsSharedWith(const DenseTensor& b) const {
91
  return holder_ && holder_ == b.Holder();
92 93
}

94 95 96 97 98
void* DenseTensor::AllocateFrom(Allocator* allocator,
                                DataType dtype,
                                size_t requested_size) {
  PADDLE_ENFORCE_NOT_NULL(
      allocator,
99
      phi::errors::InvalidArgument(
100 101 102 103 104 105 106
          "Required allocator shall not be nullptr, but received nullptr."));
  if (this->dtype() != dtype) {
    VLOG(10) << "change data type in mutbale_data, target dtype - " << dtype;
    meta_.dtype = dtype;
  }
  PADDLE_ENFORCE(
      valid(),
107
      phi::errors::PreconditionNotMet(
108 109 110 111 112
          "The meta data must be valid when call the mutable data function."));
  size_t bytes = numel() * SizeOf(this->dtype());
  if (requested_size) {
    PADDLE_ENFORCE_GE(requested_size,
                      bytes,
113
                      phi::errors::InvalidArgument(
114 115 116 117 118 119
                          "The reserved size %d should be enough to meet the "
                          "volume required by metadata %d.",
                          requested_size,
                          bytes));
    bytes = requested_size;
  }
120 121 122
  // NOTE(paddle-dev): In case of the allocator of storage_ is different with
  // the incoming allocator, we will re-alloc data using the incoming
  // allocator. See DeviceContext.Alloc in core/device_context.cc.
123 124 125 126 127 128 129 130 131 132
  if (!holder_ || holder_->size() < bytes + meta_.offset) {
    meta_.offset = 0;
    VLOG(10) << "Allocate data with bytes: " << bytes;
    ResetHolder(allocator->Allocate(bytes));
  }

  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
                                 meta_.offset);
}

133 134
template <typename T>
const T* DenseTensor::data() const {
H
hong 已提交
135 136 137
  PADDLE_ENFORCE_EQ(
      dtype(),
      paddle::experimental::CppTypeToDataType<T>::Type(),
138
      phi::errors::InvalidArgument(
139 140 141 142 143
          "The type of data we are trying to retrieve does not match the "
          "type of data currently contained in the container."));
  return static_cast<const T*>(data());
}

144 145
template <typename T>
T* DenseTensor::data() {
146
  T* ret = static_cast<T*>(data());
147 148
  PADDLE_ENFORCE(
      (dtype() == paddle::experimental::CppTypeToDataType<T>::Type()),
149
      phi::errors::InvalidArgument(
150 151
          "The type of data we are trying to retrieve does not match the "
          "type of data currently contained in the container."));
152
  return ret;
153 154
}

155
void* DenseTensor::data() {
156
  check_memory_size();
157
  PADDLE_ENFORCE_NOT_NULL(
158
      holder_,
159
      phi::errors::PreconditionNotMet(
160 161
          "The storage must be valid when call the data function."));
  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
162
                                 meta_.offset);
163 164
}

165
const void* DenseTensor::data() const {
166
  check_memory_size();
167
  PADDLE_ENFORCE_NOT_NULL(
168
      holder_,
169
      phi::errors::PreconditionNotMet(
170
          "The storage must be valid when call the data function."));
171
  return reinterpret_cast<const void*>(
172
      reinterpret_cast<uintptr_t>(holder_->ptr()) + meta_.offset);
173 174
}

175 176
void DenseTensor::set_meta(DenseTensorMeta&& meta) {
  PADDLE_ENFORCE(!meta_.valid(),
177
                 phi::errors::InvalidArgument(
178 179 180
                     "Only when the original attribute of Tensor is "
                     "incomplete, can it be reset."));
  meta_ = std::move(meta);
石晓伟 已提交
181 182
}

183 184 185
void DenseTensor::set_meta(const DenseTensorMeta& meta) {
  PADDLE_ENFORCE(
      meta.valid(),
186
      phi::errors::InvalidArgument(
187 188 189 190 191 192 193 194 195
          "Input meta is invalid, please check the meta attribute."));
  meta_.dims = meta.dims;
  meta_.dtype = meta.dtype;
  meta_.is_scalar = meta.is_scalar;
  meta_.layout = meta.layout;
  meta_.lod = meta.lod;
  meta_.offset = meta.offset;
}

196 197 198 199 200 201 202 203 204 205
/* @jim19930609: This interface will be further modified util we finalized the
   design for Allocator - Allocation
   For now, we have to temporarily accommodate two independent use cases:
   1. Designed behaviour: DenseTensor constructed with its underlying storage_
   initialized
   2. Legacy behaviour(fluid): DenseTensor constructed using default
   constructor, where
                               storage_ won't be initialized until the first
   call to mutable_data(place)
   */
206
void DenseTensor::ResizeAndAllocate(const DDim& dims) {
石晓伟 已提交
207
  meta_.dims = dims;
208 209
  if (holder_ != nullptr && place().GetType() != AllocationType::UNDEFINED) {
    mutable_data(place());
210
  }
石晓伟 已提交
211 212
}

213 214
void DenseTensor::ResetLoD(const LoD& lod) { meta_.lod = lod; }

215 216 217
#define DATA_MEMBER_FUNC_INSTANTIATION(dtype)      \
  template const dtype* DenseTensor::data() const; \
  template dtype* DenseTensor::data();
218 219 220 221 222 223 224 225 226 227

DATA_MEMBER_FUNC_INSTANTIATION(bool);
DATA_MEMBER_FUNC_INSTANTIATION(int8_t);
DATA_MEMBER_FUNC_INSTANTIATION(uint8_t);
DATA_MEMBER_FUNC_INSTANTIATION(int16_t);
DATA_MEMBER_FUNC_INSTANTIATION(uint16_t);
DATA_MEMBER_FUNC_INSTANTIATION(int32_t);
DATA_MEMBER_FUNC_INSTANTIATION(uint32_t);
DATA_MEMBER_FUNC_INSTANTIATION(int64_t);
DATA_MEMBER_FUNC_INSTANTIATION(uint64_t);
228 229
DATA_MEMBER_FUNC_INSTANTIATION(::phi::dtype::bfloat16);
DATA_MEMBER_FUNC_INSTANTIATION(::phi::dtype::float16);
230 231
DATA_MEMBER_FUNC_INSTANTIATION(float);
DATA_MEMBER_FUNC_INSTANTIATION(double);
232 233
DATA_MEMBER_FUNC_INSTANTIATION(::phi::dtype::complex<float>);
DATA_MEMBER_FUNC_INSTANTIATION(::phi::dtype::complex<double>);
234 235 236

#undef DATA_MEMBER_FUNC_INSTANTIATION

237
}  // namespace phi