tensor.h 6.7 KB
Newer Older
Y
Yi Wang 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.

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. */

Y
Yi Wang 已提交
15 16
#pragma once

17
#include <cstdint>
18
#include <cstring>
F
fengjiayi 已提交
19
#include <memory>
Y
Yu Yang 已提交
20
#include <typeindex>
F
fengjiayi 已提交
21 22
#include "paddle/framework/ddim.h"
#include "paddle/memory/memory.h"
L
liaogang 已提交
23
#include "paddle/platform/enforce.h"
F
fengjiayi 已提交
24
#include "paddle/platform/place.h"
Q
init  
qijun 已提交
25
#include "unsupported/Eigen/CXX11/Tensor"
F
fengjiayi 已提交
26

Y
Yi Wang 已提交
27
namespace paddle {
28 29 30 31 32 33
namespace pybind {
namespace details {  // forward declare
template <bool less, size_t i, typename... args>
struct CastToPyBufferImpl;
}  // namespace details
}  // namespace pybind
Y
Yi Wang 已提交
34 35 36
namespace framework {

class Tensor {
Y
Yi Wang 已提交
37 38 39
  template <bool less, size_t i, typename... args>
  friend struct paddle::pybind::details::CastToPyBufferImpl;

40
  template <typename T, size_t D, int MajorType, typename IndexType>
Y
Yi Wang 已提交
41 42
  friend struct EigenTensor;

43
  template <typename T, int MajorType, typename IndexType>
Y
Yi Wang 已提交
44 45
  friend struct EigenVector;

Y
Yi Wang 已提交
46
 public:
47
  Tensor() : offset_(0) {}
48

Y
Yi Wang 已提交
49 50
  template <typename T>
  const T* data() const {
F
fengjiayi 已提交
51
    EnforceSufficientMemory<T>();
52
    return reinterpret_cast<const T*>(
F
fengjiayi 已提交
53
        reinterpret_cast<uintptr_t>(holder_->ptr()) + offset_);
Y
Yi Wang 已提交
54 55
  }

Q
qijun 已提交
56
  template <typename T>
Y
Yi Wang 已提交
57
  T* data() {
F
fengjiayi 已提交
58
    EnforceSufficientMemory<T>();
Q
qijun 已提交
59
    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
Q
qijun 已提交
60
                                offset_);
Q
init  
qijun 已提交
61 62
  }

63 64
  template <typename T,  // must be POD types
            typename std::enable_if<std::is_pod<T>::value>::type* = nullptr>
F
fengjiayi 已提交
65
  T* mutable_data(DDim dims, platform::Place place) {
F
fengjiayi 已提交
66
    Resize(dims);
67 68 69
    return mutable_data<T>(place);
  }

70 71
  template <typename T,  // must be POD types
            typename std::enable_if<std::is_pod<T>::value>::type* = nullptr>
F
fengjiayi 已提交
72
  T* mutable_data(platform::Place place) {
73 74
    PADDLE_ENFORCE(product(dims_) > 0,
                   "Tensor's numel must be larger than zero to call "
F
fengjiayi 已提交
75
                   "Tensor::mutable_data. Call Tensor::set_dim first.");
F
fengjiayi 已提交
76
    if (holder_ == nullptr ||
F
fengjiayi 已提交
77
        !(holder_->place() ==
F
fengjiayi 已提交
78
          place) /* some versions of boost::variant don't have operator!= */
79 80 81 82 83
        || holder_->size() < product(dims_) * sizeof(T) + offset_) {
      if (platform::is_cpu_place(place)) {
        holder_.reset(new PlaceholderImpl<T, platform::CPUPlace>(
            boost::get<platform::CPUPlace>(place), product(dims_) * sizeof(T)));
      } else if (platform::is_gpu_place(place)) {
84 85 86
#ifdef PADDLE_ONLY_CPU
        PADDLE_THROW("'GPUPlace' is not supported in CPU only device.");
#else
87 88
        holder_.reset(new PlaceholderImpl<T, platform::GPUPlace>(
            boost::get<platform::GPUPlace>(place), product(dims_) * sizeof(T)));
89
#endif
90
      } else {
91
        PADDLE_THROW("Unknown 'place'.");
92
      }
93
      offset_ = 0;
Y
Yi Wang 已提交
94
    }
F
fengjiayi 已提交
95
    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
96
                                offset_);
Y
Yi Wang 已提交
97 98
  }

F
fengjiayi 已提交
99
  template <typename T>
F
fengjiayi 已提交
100 101 102
  void ShareDataWith(const Tensor& src) {
    src.EnforceSufficientMemory<T>();
    *this = src;
Y
Yi Wang 已提交
103 104
  }

F
fengjiayi 已提交
105
  template <typename T>
F
fengjiayi 已提交
106
  void CopyFrom(const Tensor& src, platform::Place dst_place) {
F
fengjiayi 已提交
107 108 109
    PADDLE_ENFORCE(platform::is_cpu_place(src.holder_->place()) &&
                       platform::is_cpu_place(dst_place),
                   "Tensor::CopyFrom only support CPU now.");
F
fengjiayi 已提交
110
    src.EnforceSufficientMemory<T>();
111
    size_t size = product(src.dims_) * sizeof(T);
F
fengjiayi 已提交
112
    Resize(src.dims());
F
fengjiayi 已提交
113
    const void* src_ptr = static_cast<const void*>(src.data<T>());
F
fengjiayi 已提交
114 115
    void* dst_ptr = static_cast<void*>(mutable_data<T>(dst_place));
    memcpy(dst_ptr, src_ptr, size);
116 117
  }

F
fengjiayi 已提交
118
  template <typename T>
F
fengjiayi 已提交
119
  Tensor Slice(const int& begin_idx, const int& end_idx) const {
F
fengjiayi 已提交
120 121 122
    EnforceSufficientMemory<T>();
    PADDLE_ENFORCE(begin_idx >= 0, "Slice begin index is less than zero.");
    PADDLE_ENFORCE(end_idx <= dims_[0], "Slice end index is out of bound.");
123 124 125
    PADDLE_ENFORCE(begin_idx < end_idx,
                   "Begin index must be less than end index.");
    PADDLE_ENFORCE(dims_[0] != 1, "Can not slice a tensor with dims_[0] = 1.");
F
fengjiayi 已提交
126
    int base = product(dims_) / dims_[0];
127 128
    Tensor dst;
    dst.holder_ = holder_;
F
fengjiayi 已提交
129 130
    DDim dst_dims = dims_;
    dst_dims[0] = end_idx - begin_idx;
F
fengjiayi 已提交
131
    dst.Resize(dst_dims);
F
fengjiayi 已提交
132
    dst.offset_ = offset_ + begin_idx * base * sizeof(T);
133 134 135
    return dst;
  }

F
fengjiayi 已提交
136
  void Resize(const DDim& dims) { dims_ = dims; }
F
fengjiayi 已提交
137

F
fengjiayi 已提交
138
  const DDim& dims() const { return dims_; }
139

Q
qijun 已提交
140 141
  paddle::platform::Place place() const { return holder_->place(); }

Y
Yi Wang 已提交
142 143 144 145 146
 private:
  // Placeholder hides type T, so it doesn't appear as a template
  // parameter of Variable.
  struct Placeholder {
    virtual ~Placeholder() {}
F
fengjiayi 已提交
147
    virtual void* ptr() const = 0;
F
fengjiayi 已提交
148
    virtual platform::Place place() const = 0;
F
fengjiayi 已提交
149
    virtual size_t size() const = 0;
Y
Yu Yang 已提交
150
    virtual std::type_index type() const = 0;
Y
Yi Wang 已提交
151 152
  };

F
fengjiayi 已提交
153
  template <typename T, typename PlaceType>
Y
Yi Wang 已提交
154
  struct PlaceholderImpl : public Placeholder {
F
fengjiayi 已提交
155 156
    PlaceholderImpl(PlaceType place, size_t size)
        : ptr_(static_cast<T*>(memory::Alloc(place, size)),
157
               memory::PODDeleter<T, PlaceType>(place)),
158
          place_(place),
Y
Yi Wang 已提交
159 160
          size_(size) {}

F
fengjiayi 已提交
161 162
    virtual void* ptr() const { return static_cast<void*>(ptr_.get()); }
    virtual size_t size() const { return size_; }
Y
Yu Yang 已提交
163 164
    virtual paddle::platform::Place place() const { return place_; }
    virtual std::type_index type() const { return std::type_index(typeid(T)); }
Y
Yi Wang 已提交
165

166
    std::unique_ptr<T, memory::PODDeleter<T, PlaceType>> ptr_;
F
fengjiayi 已提交
167 168
    platform::Place place_;  // record the place of ptr_.
    size_t size_;            // size of the memory block.
Y
Yi Wang 已提交
169 170
  };

F
fengjiayi 已提交
171
  template <typename T>
F
fengjiayi 已提交
172
  inline void EnforceSufficientMemory() const {
F
fengjiayi 已提交
173 174
    PADDLE_ENFORCE(holder_ != nullptr,
                   "Tenosr holds no memory. Call Tensor::mutable_data first.");
175
    PADDLE_ENFORCE(holder_->size() >= product(dims_) * sizeof(T) + offset_,
F
fengjiayi 已提交
176 177 178 179
                   "Tensor's dims_ is out of bound. Call Tensor::mutable_data "
                   "first to re-allocate memory.");
  }

180
  std::shared_ptr<Placeholder> holder_;  // holds the memory block if allocated.
181
  DDim dims_;
F
fengjiayi 已提交
182 183 184 185 186
  // A PlaceHolder may be shared by more than one tensor. Some of them may be
  // slices of the others. So the offset_ is introduced here to indicate the
  // byte offset between PlaceHolder::ptr_ and where tensor's data really
  // begins.
  size_t offset_;
187
};
Y
Yi Wang 已提交
188 189 190

}  // namespace framework
}  // namespace paddle