tensor.h 5.4 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 20 21 22 23 24
#include <memory>
#include "paddle/framework/ddim.h"
#include "paddle/framework/enforce.h"
#include "paddle/memory/memory.h"
#include "paddle/platform/place.h"

Y
Yi Wang 已提交
25 26 27 28 29
namespace paddle {
namespace framework {

class Tensor {
 public:
F
fengjiayi 已提交
30
  Tensor() : numel_(0), offset_(0) {}
31

F
fengjiayi 已提交
32
  Tensor& operator=(const Tensor& src) = delete;
33

Y
Yi Wang 已提交
34 35
  template <typename T>
  const T* data() const {
F
fengjiayi 已提交
36
    CheckDims<T>();
37
    return reinterpret_cast<const T*>(
F
fengjiayi 已提交
38
        reinterpret_cast<uintptr_t>(holder_->ptr()) + offset_);
Y
Yi Wang 已提交
39 40
  }

F
fengjiayi 已提交
41
  template <typename T>
F
fengjiayi 已提交
42
  T* mutable_data(DDim dims, paddle::platform::Place place) {
F
fengjiayi 已提交
43
    set_dims(dims);
44 45 46
    return mutable_data<T>(place);
  }

F
fengjiayi 已提交
47
  template <typename T>
48
  T* mutable_data(paddle::platform::Place place) {
F
fengjiayi 已提交
49 50
    PADDLE_ENFORCE(numel_ > 0,
                   "Tensor::numel_ must be larger than zero to call "
F
fengjiayi 已提交
51
                   "Tensor::mutable_data. Call Tensor::set_dim first.");
F
fengjiayi 已提交
52
    if (holder_ == nullptr ||
F
fengjiayi 已提交
53
        !(holder_->place() ==
F
fengjiayi 已提交
54
          place) /* some versions of boost::variant don't have operator!= */
F
fengjiayi 已提交
55
        || holder_->size() < numel_ * sizeof(T) + offset_) {
F
fengjiayi 已提交
56
      holder_.reset(new PlaceholderImpl<T>(place, numel_ * sizeof(T)));
57
      offset_ = 0;
Y
Yi Wang 已提交
58
    }
F
fengjiayi 已提交
59
    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(holder_->ptr()) +
60
                                offset_);
Y
Yi Wang 已提交
61 62
  }

F
fengjiayi 已提交
63
  template <typename T>
64
  void ShareDataFrom(const Tensor& src) {
F
fengjiayi 已提交
65
    src.CheckDims<T>();
66
    holder_ = src.holder_;
F
fengjiayi 已提交
67
    set_dims(src.dims());
68
    offset_ = src.offset_;
Y
Yi Wang 已提交
69 70
  }

F
fengjiayi 已提交
71
  template <typename T>
72
  void CopyFrom(const Tensor& src, paddle::platform::Place dst_place) {
F
fengjiayi 已提交
73 74 75
    PADDLE_ENFORCE(platform::is_cpu_place(src.holder_->place()) &&
                       platform::is_cpu_place(dst_place),
                   "Tensor::CopyFrom only support CPU now.");
F
fengjiayi 已提交
76
    src.CheckDims<T>();
F
fengjiayi 已提交
77 78
    size_t size = src.numel_ * sizeof(T);
    set_dims(src.dims());
F
fengjiayi 已提交
79
    const void* src_ptr = static_cast<const void*>(src.data<T>());
F
fengjiayi 已提交
80 81
    void* dst_ptr = static_cast<void*>(mutable_data<T>(dst_place));
    memcpy(dst_ptr, src_ptr, size);
82 83
  }

F
fengjiayi 已提交
84
  template <typename T>
F
fengjiayi 已提交
85
  Tensor Slice(const int& begin_idx, const int& end_idx) const {
F
fengjiayi 已提交
86
    CheckDims<T>();
87 88 89 90 91 92 93 94 95 96 97 98
    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 已提交
99 100 101
    DDim dst_dims = dims_;
    dst_dims[0] = end_idx - begin_idx;
    dst.set_dims(dst_dims);
F
fengjiayi 已提交
102
    dst.offset_ = offset_ + begin_idx * base * sizeof(T);
103 104 105
    return dst;
  }

F
fengjiayi 已提交
106 107 108 109 110 111 112 113
  void set_dims(const DDim& dims) {
    if (dims == dims_) {
      return;
    }
    dims_ = dims;
    numel_ = product(dims_);
  }

114 115
  DDim dims() const { return dims_; }

Y
Yi Wang 已提交
116 117 118 119 120
 private:
  // Placeholder hides type T, so it doesn't appear as a template
  // parameter of Variable.
  struct Placeholder {
    virtual ~Placeholder() {}
F
fengjiayi 已提交
121 122 123
    virtual void* ptr() const = 0;
    virtual paddle::platform::Place place() const = 0;
    virtual size_t size() const = 0;
Y
Yi Wang 已提交
124 125 126 127
  };

  template <typename T>
  struct PlaceholderImpl : public Placeholder {
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
   private:
    class Deleter {
     public:
      Deleter(platform::Place place) : place_(place) {}
      void operator()(T* ptr) {
        paddle::memory::Free(place_, static_cast<void*>(ptr));
      }

     private:
      paddle::platform::Place place_;
    };

   public:
    PlaceholderImpl(paddle::platform::Place place, size_t size)
        : ptr_(static_cast<T*>(paddle::memory::Alloc(place, size)),
               Deleter(place)),
          place_(place),
Y
Yi Wang 已提交
145 146
          size_(size) {}

F
fengjiayi 已提交
147 148 149
    virtual void* ptr() const { return static_cast<void*>(ptr_.get()); }
    virtual size_t size() const { return size_; }
    virtual paddle::platform::Place place() const { return place_; }
Y
Yi Wang 已提交
150

151
    std::unique_ptr<T, Deleter> ptr_;
F
fengjiayi 已提交
152 153
    paddle::platform::Place place_;  // record the place of ptr_.
    size_t size_;                    // size of the memory block.
Y
Yi Wang 已提交
154 155
  };

F
fengjiayi 已提交
156
  template <typename T>
F
fengjiayi 已提交
157
  inline void CheckDims() const {
F
fengjiayi 已提交
158 159
    PADDLE_ENFORCE(holder_ != nullptr,
                   "Tenosr holds no memory. Call Tensor::mutable_data first.");
F
fengjiayi 已提交
160
    PADDLE_ENFORCE(holder_->size() >= numel_ * sizeof(T) + offset_,
F
fengjiayi 已提交
161 162 163 164
                   "Tensor's dims_ is out of bound. Call Tensor::mutable_data "
                   "first to re-allocate memory.");
  }

165
  std::shared_ptr<Placeholder> holder_;  // holds the memory block if allocated.
166
  DDim dims_;
F
fengjiayi 已提交
167
  size_t numel_;   // cache of `product(dims_)`
168
  size_t offset_;  // marks the begin of tensor data area.
Y
Yi Wang 已提交
169 170 171 172
};

}  // namespace framework
}  // namespace paddle