Merge branch 'op2func_refactor' of https://github.com/chenwhql/Paddle …

…into op2func_refactor

paddle/pten/common/data_type.h

@@ -75,17 +75,20 @@ inline size_t SizeOf(DataType data_type) {
       PADDLE_THROW(platform::errors::Unimplemented(
           "Data type %d is not supported by tensor.",
           static_cast<int>(data_type)));
-      return 0;
   }
+  return 0;
 }
 
 #define PT_FOR_EACH_DATA_TYPE(_)    \
   _(bool, DataType::BOOL)           \
   _(int8_t, DataType::INT8)         \
   _(uint8_t, DataType::UINT8)       \
   _(int16_t, DataType::INT16)       \
-  _(int, DataType::INT32)           \
+  _(uint16_t, DataType::UINT16)     \
+  _(int32_t, DataType::INT32)       \
+  _(uint32_t, DataType::UINT32)     \
   _(int64_t, DataType::INT64)       \
+  _(uint64_t, DataType::UINT64)     \
   _(bfloat16, DataType::BFLOAT16)   \
   _(float16, DataType::FLOAT16)     \
   _(float, DataType::FLOAT32)       \

paddle/pten/core/CMakeLists.txt

@@ -1,3 +1,5 @@
+add_subdirectory(candidate)
+
 IF(WITH_MKLDNN)
     set(MKLDNN_CTX_DEPS mkldnn)
 ELSE()
@@ -15,3 +17,5 @@ cc_library(dense_tensor SRCS dense_tensor.cc DEPS enforce data_type ddim allocat
 
 cc_library(kernel_factory SRCS kernel_factory.cc DEPS enforce)
 cc_library(kernel_context SRCS kernel_context.cc DEPS enforce device_context)
+
+cc_library(tensor_base SRCS tensor_base.cc allocator.cc storage.cc DEPS enforce)

paddle/pten/core/allocator.h

@@ -23,6 +23,8 @@ namespace pten {
 /// deallocation and construction/destruction of objects.
 class RawAllocator {
  public:
+  using Place = paddle::platform::Place;
+
   /// \brief Default destructor.
   virtual ~RawAllocator() = default;
 
@@ -43,7 +45,7 @@ class RawAllocator {
 
   /// \brief Get the place value of the allocator and the allocation.
   /// \return The place value of the allocator and the allocation.
-  virtual const paddle::platform::Place& place() const = 0;
+  virtual const Place& place() const = 0;
 };
 
 /// \brief Fancy pointer with context. The use of this data type
@@ -52,24 +54,24 @@ class RawAllocator {
 /// support being inherited.
 class Allocation final {
  public:
+  using Place = paddle::platform::Place;
   using DeleterFnPtr = void (*)(void*);
 
   Allocation() = default;
   Allocation(Allocation&&) = default;
   Allocation& operator=(Allocation&&) = default;
 
-  Allocation(void* data, const paddle::platform::Place& place)
-      : data_(data), place_(place) {}
+  Allocation(void* data, const Place& place) : data_(data), place_(place) {}
 
   Allocation(void* data,
              void* ctx,
              DeleterFnPtr ctx_deleter,
-             const paddle::platform::Place& place)
+             const Place& place)
       : data_(data), ctx_(ctx, ctx_deleter), place_(place) {}
 
   void* operator->() const noexcept { return data_; }
   operator bool() const noexcept { return data_ || ctx_.Get(); }
-  const paddle::platform::Place& place() const noexcept { return place_; }
+  const Place& place() const noexcept { return place_; }
 
   void Clear() noexcept {
     data_ = nullptr;
@@ -132,7 +134,7 @@ class Allocation final {
   Context ctx_;
   // TODO(Shixiaowei02): Enum needs to be used instead to reduce
   // the construction overhead by more than 50%.
-  paddle::platform::Place place_;
+  Place place_;
 };
 
 inline void swap(Allocation::Context& a, Allocation::Context& b) noexcept {

paddle/pten/core/candidate/CMakeLists.txt

@@ -0,0 +1 @@
+cc_library(pten_dense_tensor SRCS dense_tensor.cc DEPS tensor_base)

paddle/pten/core/candidate/dense_tensor.cc

@@ -0,0 +1,145 @@
+/* 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. */
+
+#include "paddle/pten/core/candidate/dense_tensor.h"
+
+namespace pten {
+namespace candidate {
+
+DenseTensorMeta::DenseTensorMeta(DataType type, const DDim& dims)
+    : dims(dims), type(type) {}
+DenseTensorMeta::DenseTensorMeta(DataType type,
+                                 const DDim& dims,
+                                 DataLayout layout)
+    : dims(dims), type(type), layout(layout) {}
+DenseTensorMeta::DenseTensorMeta(DataType type,
+                                 const DDim& dims,
+                                 DataLayout layout,
+                                 const std::vector<std::vector<size_t>>& lod)
+    : dims(dims), type(type), layout(layout), lod(lod) {}
+
+bool DenseTensorMeta::valid() const noexcept {
+  bool valid{true};
+  valid = valid && (type != DataType::UNDEFINED);
+  valid = valid && (layout != DataLayout::UNDEFINED);
+  valid = valid && (is_scalar || product(dims));
+  return valid;
+}
+
+DenseTensor::DenseTensor(const std::shared_ptr<Allocator>& a,
+                         const DenseTensorMeta& meta)
+    : meta_(meta),
+      storage_(
+          make_intrusive<TensorStorage>(a, SizeOf(data_type()) * numel())) {}
+
+DenseTensor::DenseTensor(const std::shared_ptr<Allocator>& a,
+                         DenseTensorMeta&& meta)
+    : meta_(std::move(meta)),
+      storage_(
+          make_intrusive<TensorStorage>(a, SizeOf(data_type()) * numel())) {}
+
+DenseTensor::DenseTensor(intrusive_ptr<Storage> storage,
+                         const DenseTensorMeta& meta)
+    : meta_(meta), storage_(std::move(storage)) {}
+
+DenseTensor::DenseTensor(intrusive_ptr<Storage> storage, DenseTensorMeta&& meta)
+    : meta_(std::move(meta)), storage_(std::move(storage)) {}
+
+int64_t DenseTensor::numel() const {
+  if (meta_.is_scalar) {
+    return 1;
+  }
+  return product(meta_.dims);
+}
+
+bool DenseTensor::SharesStorageWith(const DenseTensor& b) const {
+  return storage_.get() == b.storage_.get() && storage_.get() != nullptr;
+}
+
+template <typename T>
+T* DenseTensor::mutable_data(size_t request_bytes) {
+  PADDLE_ENFORCE(
+      valid(),
+      paddle::platform::errors::PreconditionNotMet(
+          "The meta data must be valid when call the mutable data function."));
+  PADDLE_ENFORCE_NOT_NULL(
+      storage_,
+      paddle::platform::errors::PreconditionNotMet(
+          "The storage must be valid when call the mutable data function."));
+  PADDLE_ENFORCE(
+      (data_type() == paddle::experimental::CppTypeToDataType<T>::Type()),
+      paddle::platform::errors::PreconditionNotMet(
+          "The type of data we are trying to retrieve does not match the "
+          "type of data currently contained in the container."));
+  size_t bytes = numel() * SizeOf(data_type());
+  if (request_bytes) {
+    PADDLE_ENFORCE_GE(request_bytes,
+                      bytes,
+                      paddle::platform::errors::InvalidArgument(
+                          "The reserved size %d should be enough to meet the "
+                          "volume required by metadata %d.",
+                          request_bytes,
+                          bytes));
+    bytes = request_bytes;
+  }
+  if (storage_->size() < bytes) {
+    storage_->Realloc(bytes);
+  }
+  return static_cast<T*>(storage_->data());
+}
+
+template <typename T>
+const T* DenseTensor::data() const {
+  PADDLE_ENFORCE_NOT_NULL(
+      storage_,
+      paddle::platform::errors::PreconditionNotMet(
+          "The storage must be valid when call the mutable data function."));
+  PADDLE_ENFORCE(
+      (data_type() == paddle::experimental::CppTypeToDataType<T>::Type()),
+      paddle::platform::errors::PreconditionNotMet(
+          "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*>(storage_->data());
+}
+
+void DenseTensor::check_memory_size() const {
+  size_t bytes = numel() * SizeOf(data_type());
+  PADDLE_ENFORCE_GE(memory_size(),
+                    bytes,
+                    paddle::platform::errors::InvalidArgument(
+                        "The memory size %d should be enough to meet the "
+                        "volume required by metadata %d.",
+                        memory_size(),
+                        bytes));
+}
+
+#define DATA_MEMBER_FUNC_INSTANTIATION(dtype)                      \
+  template dtype* DenseTensor::mutable_data(size_t request_bytes); \
+  template const dtype* DenseTensor::data() const;
+
+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);
+DATA_MEMBER_FUNC_INSTANTIATION(float);
+DATA_MEMBER_FUNC_INSTANTIATION(double);
+
+#undef DATA_MEMBER_FUNC_INSTANTIATION
+
+}  // namespace candidate
+}  // namespace pten