tensor.h 6.6 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 23 24
#include "paddle/framework/ddim.h"
#include "paddle/framework/enforce.h"
#include "paddle/memory/memory.h"
#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 40 41 42 43 44 45 46 47 48
  template <bool less, size_t i, typename... args>
  friend struct paddle::pybind::details::CastToPyBufferImpl;

  template <typename T, size_t D, typename IndexType = Eigen::DenseIndex>
  friend struct EigenTensor;

  template <typename T, typename IndexType = Eigen::DenseIndex>
  friend struct EigenVector;

  template <typename T, typename IndexType = Eigen::DenseIndex>
  friend struct EigenMatrix;

Y
Yi Wang 已提交
49
 public:
50
  Tensor() : offset_(0) {}
51

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

Q
qijun 已提交
59 60 61 62
  template <typename T>
  T* raw_data() const {
    CheckDims<T>();
    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
Q
qijun 已提交
63
                                offset_);
Q
init  
qijun 已提交
64 65
  }

F
fengjiayi 已提交
66
  template <typename T>
F
fengjiayi 已提交
67
  T* mutable_data(DDim dims, platform::Place place) {
F
fengjiayi 已提交
68
    set_dims(dims);
69 70 71
    return mutable_data<T>(place);
  }

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

F
fengjiayi 已提交
100
  template <typename T>
101
  void ShareDataFrom(const Tensor& src) {
F
fengjiayi 已提交
102
    src.CheckDims<T>();
103
    holder_ = src.holder_;
F
fengjiayi 已提交
104
    set_dims(src.dims());
105
    offset_ = src.offset_;
Y
Yi Wang 已提交
106 107
  }

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

F
fengjiayi 已提交
121
  template <typename T>
F
fengjiayi 已提交
122
  Tensor Slice(const int& begin_idx, const int& end_idx) const {
F
fengjiayi 已提交
123
    CheckDims<T>();
124 125 126 127 128 129 130 131 132 133 134 135
    PADDLE_ENFORCE(begin_idx >= 0 && end_idx <= dims_[0],
                   "Slice index is less than zero or out of bound.");
    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.");
    std::vector<int> d = vectorize(dims_);
    int base = 1;
    for (size_t i = 1; i < d.size(); ++i) {
      base *= d[i];
    }
    Tensor dst;
    dst.holder_ = holder_;
F
fengjiayi 已提交
136 137 138
    DDim dst_dims = dims_;
    dst_dims[0] = end_idx - begin_idx;
    dst.set_dims(dst_dims);
F
fengjiayi 已提交
139
    dst.offset_ = offset_ + begin_idx * base * sizeof(T);
140 141 142
    return dst;
  }

F
fengjiayi 已提交
143 144 145 146 147 148 149
  void set_dims(const DDim& dims) {
    if (dims == dims_) {
      return;
    }
    dims_ = dims;
  }

150 151
  DDim dims() const { return dims_; }

Y
Yi Wang 已提交
152 153 154 155 156
 private:
  // Placeholder hides type T, so it doesn't appear as a template
  // parameter of Variable.
  struct Placeholder {
    virtual ~Placeholder() {}
F
fengjiayi 已提交
157
    virtual void* ptr() const = 0;
F
fengjiayi 已提交
158
    virtual platform::Place place() const = 0;
F
fengjiayi 已提交
159
    virtual size_t size() const = 0;
Y
Yu Yang 已提交
160
    virtual std::type_index type() const = 0;
Y
Yi Wang 已提交
161 162
  };

F
fengjiayi 已提交
163
  template <typename T, typename PlaceType>
Y
Yi Wang 已提交
164
  struct PlaceholderImpl : public Placeholder {
165
   private:
F
fengjiayi 已提交
166
    template <typename PType>
167 168
    class Deleter {
     public:
F
fengjiayi 已提交
169 170
      Deleter(PType place) : place_(place) {}
      void operator()(T* ptr) { memory::Free(place_, static_cast<void*>(ptr)); }
171 172

     private:
F
fengjiayi 已提交
173
      PType place_;
174 175 176
    };

   public:
F
fengjiayi 已提交
177 178 179
    PlaceholderImpl(PlaceType place, size_t size)
        : ptr_(static_cast<T*>(memory::Alloc(place, size)),
               Deleter<PlaceType>(place)),
180
          place_(place),
Y
Yi Wang 已提交
181 182
          size_(size) {}

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

F
fengjiayi 已提交
188 189 190
    std::unique_ptr<T, Deleter<PlaceType>> ptr_;
    platform::Place place_;  // record the place of ptr_.
    size_t size_;            // size of the memory block.
Y
Yi Wang 已提交
191 192
  };

F
fengjiayi 已提交
193
  template <typename T>
F
fengjiayi 已提交
194
  inline void CheckDims() const {
F
fengjiayi 已提交
195 196
    PADDLE_ENFORCE(holder_ != nullptr,
                   "Tenosr holds no memory. Call Tensor::mutable_data first.");
197
    PADDLE_ENFORCE(holder_->size() >= product(dims_) * sizeof(T) + offset_,
F
fengjiayi 已提交
198 199 200 201
                   "Tensor's dims_ is out of bound. Call Tensor::mutable_data "
                   "first to re-allocate memory.");
  }

202
  std::shared_ptr<Placeholder> holder_;  // holds the memory block if allocated.
203 204
  DDim dims_;
  size_t offset_;  // marks the begin of tensor data area.
205
};
Y
Yi Wang 已提交
206 207 208

}  // namespace framework
}  // namespace paddle