11#ifndef EIGEN_CXX11_TENSOR_TENSOR_REVERSE_H
12#define EIGEN_CXX11_TENSOR_TENSOR_REVERSE_H
22template<
typename ReverseDimensions,
typename XprType>
23struct traits<TensorReverseOp<ReverseDimensions,
24 XprType> > :
public traits<XprType>
26 typedef typename XprType::Scalar Scalar;
27 typedef traits<XprType> XprTraits;
28 typedef typename XprTraits::StorageKind StorageKind;
29 typedef typename XprTraits::Index
Index;
30 typedef typename XprType::Nested Nested;
31 typedef typename remove_reference<Nested>::type _Nested;
32 static const int NumDimensions = XprTraits::NumDimensions;
33 static const int Layout = XprTraits::Layout;
34 typedef typename XprTraits::PointerType PointerType;
37template<
typename ReverseDimensions,
typename XprType>
38struct eval<TensorReverseOp<ReverseDimensions, XprType>,
Eigen::Dense>
40 typedef const TensorReverseOp<ReverseDimensions, XprType>& type;
43template<
typename ReverseDimensions,
typename XprType>
44struct nested<TensorReverseOp<ReverseDimensions, XprType>, 1,
45 typename eval<TensorReverseOp<ReverseDimensions, XprType> >::type>
47 typedef TensorReverseOp<ReverseDimensions, XprType> type;
52template<
typename ReverseDimensions,
typename XprType>
53class TensorReverseOp :
public TensorBase<TensorReverseOp<ReverseDimensions,
54 XprType>, WriteAccessors>
57 typedef TensorBase<TensorReverseOp<ReverseDimensions, XprType>,
WriteAccessors>Base;
58 typedef typename Eigen::internal::traits<TensorReverseOp>::Scalar Scalar;
60 typedef typename XprType::CoeffReturnType CoeffReturnType;
61 typedef typename Eigen::internal::nested<TensorReverseOp>::type Nested;
62 typedef typename Eigen::internal::traits<TensorReverseOp>::StorageKind
64 typedef typename Eigen::internal::traits<TensorReverseOp>::Index
Index;
66 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReverseOp(
67 const XprType& expr,
const ReverseDimensions& reverse_dims)
68 : m_xpr(expr), m_reverse_dims(reverse_dims) { }
71 const ReverseDimensions& reverse()
const {
return m_reverse_dims; }
74 const typename internal::remove_all<typename XprType::Nested>::type&
75 expression()
const {
return m_xpr; }
77 EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorReverseOp)
81 typename XprType::Nested m_xpr;
82 const ReverseDimensions m_reverse_dims;
86template<
typename ReverseDimensions,
typename ArgType,
typename Device>
87struct TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>, Device>
89 typedef TensorReverseOp<ReverseDimensions, ArgType> XprType;
90 typedef typename XprType::Index Index;
91 static const int NumDims = internal::array_size<ReverseDimensions>::value;
92 typedef DSizes<Index, NumDims> Dimensions;
93 typedef typename XprType::Scalar Scalar;
94 typedef typename XprType::CoeffReturnType CoeffReturnType;
95 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
96 static const int PacketSize = PacketType<CoeffReturnType, Device>::size;
97 typedef StorageMemory<CoeffReturnType, Device> Storage;
98 typedef typename Storage::Type EvaluatorPointerType;
102 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
103 BlockAccess = NumDims > 0,
104 PreferBlockAccess =
true,
105 Layout = TensorEvaluator<ArgType, Device>::Layout,
110 typedef internal::TensorIntDivisor<Index> IndexDivisor;
113 typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
114 typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
116 typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock
119 typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims,
124 EIGEN_STRONG_INLINE TensorEvaluator(
const XprType& op,
const Device& device)
125 : m_impl(op.expression(), device),
126 m_reverse(op.reverse()),
130 EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
133 m_dimensions = m_impl.dimensions();
134 if (
static_cast<int>(Layout) ==
static_cast<int>(
ColMajor)) {
136 for (
int i = 1; i < NumDims; ++i) {
137 m_strides[i] = m_strides[i-1] * m_dimensions[i-1];
138 if (m_strides[i] > 0) m_fastStrides[i] = IndexDivisor(m_strides[i]);
141 m_strides[NumDims-1] = 1;
142 for (
int i = NumDims - 2; i >= 0; --i) {
143 m_strides[i] = m_strides[i+1] * m_dimensions[i+1];
144 if (m_strides[i] > 0) m_fastStrides[i] = IndexDivisor(m_strides[i]);
149 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
150 const Dimensions& dimensions()
const {
return m_dimensions; }
152 EIGEN_STRONG_INLINE
bool evalSubExprsIfNeeded(EvaluatorPointerType) {
153 m_impl.evalSubExprsIfNeeded(NULL);
157#ifdef EIGEN_USE_THREADS
158 template <
typename EvalSubExprsCallback>
159 EIGEN_STRONG_INLINE
void evalSubExprsIfNeededAsync(
160 EvaluatorPointerType, EvalSubExprsCallback done) {
161 m_impl.evalSubExprsIfNeededAsync(
nullptr, [done](
bool) { done(
true); });
165 EIGEN_STRONG_INLINE
void cleanup() {
169 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Index reverseIndex(
171 eigen_assert(index < dimensions().TotalSize());
172 Index inputIndex = 0;
173 if (
static_cast<int>(Layout) ==
static_cast<int>(
ColMajor)) {
175 for (
int i = NumDims - 1; i > 0; --i) {
176 Index idx = index / m_fastStrides[i];
177 index -= idx * m_strides[i];
179 idx = m_dimensions[i] - idx - 1;
181 inputIndex += idx * m_strides[i] ;
184 inputIndex += (m_dimensions[0] - index - 1);
190 for (
int i = 0; i < NumDims - 1; ++i) {
191 Index idx = index / m_fastStrides[i];
192 index -= idx * m_strides[i];
194 idx = m_dimensions[i] - idx - 1;
196 inputIndex += idx * m_strides[i] ;
198 if (m_reverse[NumDims-1]) {
199 inputIndex += (m_dimensions[NumDims-1] - index - 1);
207 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(
209 return m_impl.coeff(reverseIndex(index));
212 template<
int LoadMode>
213 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
214 PacketReturnType packet(Index index)
const
216 EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
217 eigen_assert(index+PacketSize-1 < dimensions().TotalSize());
221 EIGEN_ALIGN_MAX
typename internal::remove_const<CoeffReturnType>::type
224 for (
int i = 0; i < PacketSize; ++i) {
225 values[i] = coeff(index+i);
227 PacketReturnType rslt = internal::pload<PacketReturnType>(values);
231 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
232 internal::TensorBlockResourceRequirements getResourceRequirements()
const {
233 const size_t target_size = m_device.lastLevelCacheSize();
236 return internal::TensorBlockResourceRequirements::skewed<Scalar>(
238 .addCostPerCoeff({0, 0, 24});
241 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock
242 block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
243 bool =
false)
const {
251 static const bool isColMajor =
252 static_cast<int>(Layout) ==
static_cast<int>(
ColMajor);
254 static const Index inner_dim_idx = isColMajor ? 0 : NumDims - 1;
255 const bool inner_dim_reversed = m_reverse[inner_dim_idx];
258 Index block_offset = 0;
261 Index input_offset = reverseIndex(desc.offset());
265 array<BlockIteratorState, NumDims> it;
266 for (
int i = 0; i < NumDims; ++i) {
267 const int dim = isColMajor ? i : NumDims - 1 - i;
268 it[i].size = desc.dimension(dim);
270 it[i].reverse = m_reverse[dim];
273 i == 0 ? 1 : (it[i - 1].size * it[i - 1].block_stride);
274 it[i].block_span = it[i].block_stride * (it[i].size - 1);
276 it[i].input_stride = m_strides[dim];
277 it[i].input_span = it[i].input_stride * (it[i].size - 1);
280 it[i].input_stride = -1 * it[i].input_stride;
281 it[i].input_span = -1 * it[i].input_span;
287 int effective_inner_dim = 0;
288 for (
int i = 1; i < NumDims; ++i) {
289 if (it[i].reverse != it[effective_inner_dim].reverse)
break;
290 if (it[i].block_stride != it[effective_inner_dim].size)
break;
291 if (it[i].block_stride != numext::abs(it[i].input_stride))
break;
293 it[i].size = it[effective_inner_dim].size * it[i].size;
295 it[i].block_stride = 1;
296 it[i].input_stride = (inner_dim_reversed ? -1 : 1);
298 it[i].block_span = it[i].block_stride * (it[i].size - 1);
299 it[i].input_span = it[i].input_stride * (it[i].size - 1);
301 effective_inner_dim = i;
304 eigen_assert(it[effective_inner_dim].block_stride == 1);
305 eigen_assert(it[effective_inner_dim].input_stride ==
306 (inner_dim_reversed ? -1 : 1));
308 const Index inner_dim_size = it[effective_inner_dim].size;
311 const typename TensorBlock::Storage block_storage =
312 TensorBlock::prepareStorage(desc, scratch);
313 CoeffReturnType* block_buffer = block_storage.data();
315 while (it[NumDims - 1].count < it[NumDims - 1].size) {
317 Index dst = block_offset;
318 Index src = input_offset;
322 if (inner_dim_reversed) {
323 for (Index i = 0; i < inner_dim_size; ++i) {
324 block_buffer[dst] = m_impl.coeff(src);
329 for (Index i = 0; i < inner_dim_size; ++i) {
330 block_buffer[dst] = m_impl.coeff(src);
337 if ((NumDims - effective_inner_dim) == 1)
break;
340 for (Index i = effective_inner_dim + 1; i < NumDims; ++i) {
341 if (++it[i].count < it[i].size) {
342 block_offset += it[i].block_stride;
343 input_offset += it[i].input_stride;
346 if (i != NumDims - 1) it[i].count = 0;
347 block_offset -= it[i].block_span;
348 input_offset -= it[i].input_span;
352 return block_storage.AsTensorMaterializedBlock();
355 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(
bool vectorized)
const {
356 double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() +
357 2 * TensorOpCost::MulCost<Index>() +
358 TensorOpCost::DivCost<Index>());
359 for (
int i = 0; i < NumDims; ++i) {
361 compute_cost += 2 * TensorOpCost::AddCost<Index>();
364 return m_impl.costPerCoeff(vectorized) +
365 TensorOpCost(0, 0, compute_cost,
false , PacketSize);
368 EIGEN_DEVICE_FUNC
typename Storage::Type data()
const {
return NULL; }
372 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void bind(cl::sycl::handler &cgh)
const {
378 Dimensions m_dimensions;
379 array<Index, NumDims> m_strides;
380 array<IndexDivisor, NumDims> m_fastStrides;
381 TensorEvaluator<ArgType, Device> m_impl;
382 ReverseDimensions m_reverse;
383 const Device EIGEN_DEVICE_REF m_device;
386 struct BlockIteratorState {
408template <
typename ReverseDimensions,
typename ArgType,
typename Device>
409struct TensorEvaluator<TensorReverseOp<ReverseDimensions, ArgType>, Device>
410 :
public TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>,
412 typedef TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>,
414 typedef TensorReverseOp<ReverseDimensions, ArgType> XprType;
415 typedef typename XprType::Index
Index;
416 static const int NumDims = internal::array_size<ReverseDimensions>::value;
417 typedef DSizes<Index, NumDims> Dimensions;
421 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
423 PreferBlockAccess =
false,
424 Layout = TensorEvaluator<ArgType, Device>::Layout,
428 EIGEN_STRONG_INLINE TensorEvaluator(
const XprType& op,
const Device& device)
429 : Base(op, device) {}
431 typedef typename XprType::Scalar Scalar;
432 typedef typename XprType::CoeffReturnType CoeffReturnType;
433 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
434 static const int PacketSize = PacketType<CoeffReturnType, Device>::size;
437 typedef internal::TensorBlockNotImplemented TensorBlock;
440 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
441 const Dimensions& dimensions()
const {
return this->m_dimensions; }
443 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) {
444 return this->m_impl.coeffRef(this->reverseIndex(index));
447 template <
int StoreMode> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
448 void writePacket(Index index,
const PacketReturnType& x) {
449 EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
450 eigen_assert(index+PacketSize-1 < dimensions().TotalSize());
453 EIGEN_ALIGN_MAX CoeffReturnType values[PacketSize];
454 internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
456 for (
int i = 0; i < PacketSize; ++i) {
457 this->coeffRef(index+i) = values[i];
Namespace containing all symbols from the Eigen library.
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index