Loading...
Searching...
No Matches
TensorConcatenation.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
5//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9
10#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
11#define EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
12
13namespace Eigen {
14
15namespace internal {
16template<typename Axis, typename LhsXprType, typename RhsXprType>
17struct traits<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >
18{
19 // Type promotion to handle the case where the types of the lhs and the rhs are different.
20 typedef typename promote_storage_type<typename LhsXprType::Scalar,
21 typename RhsXprType::Scalar>::ret Scalar;
22 typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
23 typename traits<RhsXprType>::StorageKind>::ret StorageKind;
24 typedef typename promote_index_type<typename traits<LhsXprType>::Index,
25 typename traits<RhsXprType>::Index>::type Index;
26 typedef typename LhsXprType::Nested LhsNested;
27 typedef typename RhsXprType::Nested RhsNested;
28 typedef typename remove_reference<LhsNested>::type _LhsNested;
29 typedef typename remove_reference<RhsNested>::type _RhsNested;
30 static const int NumDimensions = traits<LhsXprType>::NumDimensions;
31 static const int Layout = traits<LhsXprType>::Layout;
32 enum { Flags = 0 };
33};
34
35template<typename Axis, typename LhsXprType, typename RhsXprType>
36struct eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, Eigen::Dense>
37{
38 typedef const TensorConcatenationOp<Axis, LhsXprType, RhsXprType>& type;
39};
40
41template<typename Axis, typename LhsXprType, typename RhsXprType>
42struct nested<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, 1, typename eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >::type>
43{
44 typedef TensorConcatenationOp<Axis, LhsXprType, RhsXprType> type;
45};
46
47} // end namespace internal
48
54template <typename Axis, typename LhsXprType, typename RhsXprType>
55class TensorConcatenationOp : public TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors> {
56 public:
57 typedef typename internal::traits<TensorConcatenationOp>::Scalar Scalar;
58 typedef typename internal::traits<TensorConcatenationOp>::StorageKind StorageKind;
59 typedef typename internal::traits<TensorConcatenationOp>::Index Index;
60 typedef typename internal::nested<TensorConcatenationOp>::type Nested;
61 typedef typename internal::promote_storage_type<typename LhsXprType::CoeffReturnType,
62 typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
63 typedef typename NumTraits<Scalar>::Real RealScalar;
64
65 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConcatenationOp(const LhsXprType& lhs, const RhsXprType& rhs, Axis axis)
66 : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_axis(axis) {}
67
68 EIGEN_DEVICE_FUNC
69 const typename internal::remove_all<typename LhsXprType::Nested>::type&
70 lhsExpression() const { return m_lhs_xpr; }
71
72 EIGEN_DEVICE_FUNC
73 const typename internal::remove_all<typename RhsXprType::Nested>::type&
74 rhsExpression() const { return m_rhs_xpr; }
75
76 EIGEN_DEVICE_FUNC const Axis& axis() const { return m_axis; }
77
78 EIGEN_DEVICE_FUNC
79 EIGEN_STRONG_INLINE TensorConcatenationOp& operator = (const TensorConcatenationOp& other)
80 {
81 typedef TensorAssignOp<TensorConcatenationOp, const TensorConcatenationOp> Assign;
82 Assign assign(*this, other);
83 internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
84 return *this;
85 }
86
87 template<typename OtherDerived>
88 EIGEN_DEVICE_FUNC
89 EIGEN_STRONG_INLINE TensorConcatenationOp& operator = (const OtherDerived& other)
90 {
91 typedef TensorAssignOp<TensorConcatenationOp, const OtherDerived> Assign;
92 Assign assign(*this, other);
93 internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
94 return *this;
95 }
96
97 protected:
98 typename LhsXprType::Nested m_lhs_xpr;
99 typename RhsXprType::Nested m_rhs_xpr;
100 const Axis m_axis;
101};
102
103
104// Eval as rvalue
105template<typename Axis, typename LeftArgType, typename RightArgType, typename Device>
106struct TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
107{
108 typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
109 typedef typename XprType::Index Index;
110 static const int NumDims = internal::array_size<typename TensorEvaluator<LeftArgType, Device>::Dimensions>::value;
111 static const int RightNumDims = internal::array_size<typename TensorEvaluator<RightArgType, Device>::Dimensions>::value;
112 typedef DSizes<Index, NumDims> Dimensions;
113 typedef typename XprType::Scalar Scalar;
114 typedef typename XprType::CoeffReturnType CoeffReturnType;
115 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
116 enum {
117 IsAligned = false,
118 PacketAccess = TensorEvaluator<LeftArgType, Device>::PacketAccess & TensorEvaluator<RightArgType, Device>::PacketAccess,
119 Layout = TensorEvaluator<LeftArgType, Device>::Layout,
120 RawAccess = false
121 };
122
123 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
124 : m_leftImpl(op.lhsExpression(), device), m_rightImpl(op.rhsExpression(), device), m_axis(op.axis())
125 {
126 EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) == static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) || NumDims == 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
127 EIGEN_STATIC_ASSERT((NumDims == RightNumDims), YOU_MADE_A_PROGRAMMING_MISTAKE);
128 EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
129
130 eigen_assert(0 <= m_axis && m_axis < NumDims);
131 const Dimensions& lhs_dims = m_leftImpl.dimensions();
132 const Dimensions& rhs_dims = m_rightImpl.dimensions();
133 {
134 int i = 0;
135 for (; i < m_axis; ++i) {
136 eigen_assert(lhs_dims[i] > 0);
137 eigen_assert(lhs_dims[i] == rhs_dims[i]);
138 m_dimensions[i] = lhs_dims[i];
139 }
140 eigen_assert(lhs_dims[i] > 0); // Now i == m_axis.
141 eigen_assert(rhs_dims[i] > 0);
142 m_dimensions[i] = lhs_dims[i] + rhs_dims[i];
143 for (++i; i < NumDims; ++i) {
144 eigen_assert(lhs_dims[i] > 0);
145 eigen_assert(lhs_dims[i] == rhs_dims[i]);
146 m_dimensions[i] = lhs_dims[i];
147 }
148 }
149
150 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
151 m_leftStrides[0] = 1;
152 m_rightStrides[0] = 1;
153 m_outputStrides[0] = 1;
154
155 for (int j = 1; j < NumDims; ++j) {
156 m_leftStrides[j] = m_leftStrides[j-1] * lhs_dims[j-1];
157 m_rightStrides[j] = m_rightStrides[j-1] * rhs_dims[j-1];
158 m_outputStrides[j] = m_outputStrides[j-1] * m_dimensions[j-1];
159 }
160 } else {
161 m_leftStrides[NumDims - 1] = 1;
162 m_rightStrides[NumDims - 1] = 1;
163 m_outputStrides[NumDims - 1] = 1;
164
165 for (int j = NumDims - 2; j >= 0; --j) {
166 m_leftStrides[j] = m_leftStrides[j+1] * lhs_dims[j+1];
167 m_rightStrides[j] = m_rightStrides[j+1] * rhs_dims[j+1];
168 m_outputStrides[j] = m_outputStrides[j+1] * m_dimensions[j+1];
169 }
170 }
171 }
172
173 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
174
175 // TODO(phli): Add short-circuit memcpy evaluation if underlying data are linear?
176 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* /*data*/)
177 {
178 m_leftImpl.evalSubExprsIfNeeded(NULL);
179 m_rightImpl.evalSubExprsIfNeeded(NULL);
180 return true;
181 }
182
183 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void cleanup()
184 {
185 m_leftImpl.cleanup();
186 m_rightImpl.cleanup();
187 }
188
189 // TODO(phli): attempt to speed this up. The integer divisions and modulo are slow.
190 // See CL/76180724 comments for more ideas.
191 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
192 {
193 // Collect dimension-wise indices (subs).
194 array<Index, NumDims> subs;
195 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
196 for (int i = NumDims - 1; i > 0; --i) {
197 subs[i] = index / m_outputStrides[i];
198 index -= subs[i] * m_outputStrides[i];
199 }
200 subs[0] = index;
201 } else {
202 for (int i = 0; i < NumDims - 1; ++i) {
203 subs[i] = index / m_outputStrides[i];
204 index -= subs[i] * m_outputStrides[i];
205 }
206 subs[NumDims - 1] = index;
207 }
208
209 const Dimensions& left_dims = m_leftImpl.dimensions();
210 if (subs[m_axis] < left_dims[m_axis]) {
211 Index left_index;
212 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
213 left_index = subs[0];
214 for (int i = 1; i < NumDims; ++i) {
215 left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
216 }
217 } else {
218 left_index = subs[NumDims - 1];
219 for (int i = NumDims - 2; i >= 0; --i) {
220 left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
221 }
222 }
223 return m_leftImpl.coeff(left_index);
224 } else {
225 subs[m_axis] -= left_dims[m_axis];
226 const Dimensions& right_dims = m_rightImpl.dimensions();
227 Index right_index;
228 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
229 right_index = subs[0];
230 for (int i = 1; i < NumDims; ++i) {
231 right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
232 }
233 } else {
234 right_index = subs[NumDims - 1];
235 for (int i = NumDims - 2; i >= 0; --i) {
236 right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
237 }
238 }
239 return m_rightImpl.coeff(right_index);
240 }
241 }
242
243 // TODO(phli): Add a real vectorization.
244 template<int LoadMode>
245 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
246 {
247 const int packetSize = internal::unpacket_traits<PacketReturnType>::size;
248 EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
249 eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
250
251 EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
252 for (int i = 0; i < packetSize; ++i) {
253 values[i] = coeff(index+i);
254 }
255 PacketReturnType rslt = internal::pload<PacketReturnType>(values);
256 return rslt;
257 }
258
259 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost
260 costPerCoeff(bool vectorized) const {
261 const double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() +
262 2 * TensorOpCost::MulCost<Index>() +
263 TensorOpCost::DivCost<Index>() +
264 TensorOpCost::ModCost<Index>());
265 const double lhs_size = m_leftImpl.dimensions().TotalSize();
266 const double rhs_size = m_rightImpl.dimensions().TotalSize();
267 return (lhs_size / (lhs_size + rhs_size)) *
268 m_leftImpl.costPerCoeff(vectorized) +
269 (rhs_size / (lhs_size + rhs_size)) *
270 m_rightImpl.costPerCoeff(vectorized) +
271 TensorOpCost(0, 0, compute_cost);
272 }
273
274 EIGEN_DEVICE_FUNC Scalar* data() const { return NULL; }
275
276 protected:
277 Dimensions m_dimensions;
278 array<Index, NumDims> m_outputStrides;
279 array<Index, NumDims> m_leftStrides;
280 array<Index, NumDims> m_rightStrides;
281 TensorEvaluator<LeftArgType, Device> m_leftImpl;
282 TensorEvaluator<RightArgType, Device> m_rightImpl;
283 const Axis m_axis;
284};
285
286// Eval as lvalue
287template<typename Axis, typename LeftArgType, typename RightArgType, typename Device>
288 struct TensorEvaluator<TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
289 : public TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
290{
291 typedef TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> Base;
292 typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
293 typedef typename Base::Dimensions Dimensions;
294 enum {
295 IsAligned = false,
296 PacketAccess = TensorEvaluator<LeftArgType, Device>::PacketAccess & TensorEvaluator<RightArgType, Device>::PacketAccess,
297 Layout = TensorEvaluator<LeftArgType, Device>::Layout,
298 RawAccess = false
299 };
300
301 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(XprType& op, const Device& device)
302 : Base(op, device)
303 {
304 EIGEN_STATIC_ASSERT((static_cast<int>(Layout) == static_cast<int>(ColMajor)), YOU_MADE_A_PROGRAMMING_MISTAKE);
305 }
306
307 typedef typename XprType::Index Index;
308 typedef typename XprType::Scalar Scalar;
309 typedef typename XprType::CoeffReturnType CoeffReturnType;
310 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
311
312 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index)
313 {
314 // Collect dimension-wise indices (subs).
315 array<Index, Base::NumDims> subs;
316 for (int i = Base::NumDims - 1; i > 0; --i) {
317 subs[i] = index / this->m_outputStrides[i];
318 index -= subs[i] * this->m_outputStrides[i];
319 }
320 subs[0] = index;
321
322 const Dimensions& left_dims = this->m_leftImpl.dimensions();
323 if (subs[this->m_axis] < left_dims[this->m_axis]) {
324 Index left_index = subs[0];
325 for (int i = 1; i < Base::NumDims; ++i) {
326 left_index += (subs[i] % left_dims[i]) * this->m_leftStrides[i];
327 }
328 return this->m_leftImpl.coeffRef(left_index);
329 } else {
330 subs[this->m_axis] -= left_dims[this->m_axis];
331 const Dimensions& right_dims = this->m_rightImpl.dimensions();
332 Index right_index = subs[0];
333 for (int i = 1; i < Base::NumDims; ++i) {
334 right_index += (subs[i] % right_dims[i]) * this->m_rightStrides[i];
335 }
336 return this->m_rightImpl.coeffRef(right_index);
337 }
338 }
339
340 template <int StoreMode> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
341 void writePacket(Index index, const PacketReturnType& x)
342 {
343 const int packetSize = internal::unpacket_traits<PacketReturnType>::size;
344 EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
345 eigen_assert(index + packetSize - 1 < this->dimensions().TotalSize());
346
347 EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
348 internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
349 for (int i = 0; i < packetSize; ++i) {
350 coeffRef(index+i) = values[i];
351 }
352 }
353};
354
355} // end namespace Eigen
356
357#endif // EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
Eigen::TensorAssignOp
Definition TensorAssign.h:56
Eigen::TensorBase
The tensor base class.
Definition TensorForwardDeclarations.h:29
Eigen::TensorConcatenationOp
Tensor concatenation class.
Definition TensorConcatenation.h:55
Eigen::ColMajor
ColMajor
Eigen
Namespace containing all symbols from the Eigen library.
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
Eigen::TensorEvaluator
The tensor evaluator class.
Definition TensorEvaluator.h:27
Eigen::TensorEvaluator::device
const Device & device() const
required by sycl in order to construct sycl buffer from raw pointer
Definition TensorEvaluator.h:112