11#ifndef EIGEN_TENSOR_TENSOR_LAYOUT_SWAP_H
12#define EIGEN_TENSOR_TENSOR_LAYOUT_SWAP_H
15#include "./InternalHeaderCheck.h"
20template <
typename XprType>
21struct traits<TensorLayoutSwapOp<XprType> > :
public traits<XprType> {
22 using Scalar =
typename XprType::Scalar;
23 using XprTraits = traits<XprType>;
24 using StorageKind =
typename XprTraits::StorageKind;
25 using Index =
typename XprTraits::Index;
26 static constexpr int NumDimensions = traits<XprType>::NumDimensions;
27 static constexpr int Layout = (traits<XprType>::Layout ==
ColMajor) ? RowMajor :
ColMajor;
28 using PointerType =
typename XprTraits::PointerType;
31template <
typename XprType>
32struct eval<TensorLayoutSwapOp<XprType>, Eigen::Dense> {
33 using type =
const TensorLayoutSwapOp<XprType>&;
60template <
typename XprType>
61class TensorLayoutSwapOp :
public TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors> {
63 using Base = TensorBase<TensorLayoutSwapOp<XprType>,
WriteAccessors>;
64 using Scalar =
typename Eigen::internal::traits<TensorLayoutSwapOp>::Scalar;
65 using RealScalar =
typename Eigen::NumTraits<Scalar>::Real;
66 using CoeffReturnType = std::remove_const_t<typename XprType::CoeffReturnType>;
67 using Nested =
typename Eigen::internal::ref_selector<TensorLayoutSwapOp>::type;
68 using StorageKind =
typename Eigen::internal::traits<TensorLayoutSwapOp>::StorageKind;
69 using Index =
typename Eigen::internal::traits<TensorLayoutSwapOp>::Index;
71 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorLayoutSwapOp(
const XprType& expr) : m_xpr(expr) {}
73 EIGEN_DEVICE_FUNC
const internal::remove_all_t<typename XprType::Nested>& expression()
const {
return m_xpr; }
75 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorLayoutSwapOp)
77 typename XprType::Nested m_xpr;
81template <
typename ArgType,
typename Device>
83 using XprType = TensorLayoutSwapOp<ArgType>;
84 using Index =
typename XprType::Index;
85 static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
86 using Dimensions = DSizes<Index, NumDims>;
88 static constexpr int Layout =
91 IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
92 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
97 (TensorEvaluator<ArgType, Device>::RawAccess || TensorEvaluator<ArgType, Device>::BlockAccess) && NumDims > 0,
98 PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
100 RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
105 static constexpr bool ForwardBlocksToArg =
106 TensorEvaluator<ArgType, Device>::BlockAccess && !TensorEvaluator<ArgType, Device>::RawAccess;
107 static constexpr int ArgLayout = TensorEvaluator<ArgType, Device>::Layout;
109 using Scalar =
typename XprType::Scalar;
110 using CoeffReturnType =
typename XprType::CoeffReturnType;
111 using PacketReturnType =
typename PacketType<CoeffReturnType, Device>::type;
112 using Storage = StorageMemory<CoeffReturnType, Device>;
113 using EvaluatorPointerType =
typename Storage::Type;
115 using ScalarNoConst = std::remove_const_t<Scalar>;
118 using TensorBlockDesc = internal::TensorBlockDescriptor<NumDims, Index>;
119 using TensorBlockScratch = internal::TensorBlockScratchAllocator<Device>;
120 using TensorBlock =
typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index>;
121 using ArgTensorBlock =
typename TensorEvaluator<ArgType, Device>::TensorBlock;
124 EIGEN_STRONG_INLINE TensorEvaluator(
const XprType& op,
const Device& device) : m_impl(op.expression(), device) {
125 for (
int i = 0; i < NumDims; ++i) {
126 m_dimensions[i] = m_impl.dimensions()[NumDims - 1 - i];
130 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const Dimensions& dimensions()
const {
return m_dimensions; }
132 EIGEN_STRONG_INLINE
bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
return m_impl.evalSubExprsIfNeeded(data); }
133 EIGEN_STRONG_INLINE
void cleanup() { m_impl.cleanup(); }
135 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index)
const {
return m_impl.coeff(index); }
137 template <
int LoadMode>
138 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index)
const {
139 return m_impl.template packet<LoadMode>(index);
142 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(
bool vectorized)
const {
143 return m_impl.costPerCoeff(vectorized);
146 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements()
const {
147 return getResourceRequirementsImpl(std::integral_constant<bool, ForwardBlocksToArg>());
150 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
151 bool root_of_expr_ast =
false)
const {
152 return blockImpl(desc, scratch, root_of_expr_ast, std::integral_constant<bool, ForwardBlocksToArg>());
155 EIGEN_DEVICE_FUNC
typename Storage::Type data()
const {
return constCast(m_impl.data()); }
157 const TensorEvaluator<ArgType, Device>& impl()
const {
return m_impl; }
161 EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE DSizes<Index, NumDims> reversed(
const DSizes<Index, NumDims>& sizes) {
162 DSizes<Index, NumDims> result;
163 for (
int i = 0; i < NumDims; ++i) result[i] = sizes[NumDims - 1 - i];
167 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirementsImpl(
168 std::true_type )
const {
169 return m_impl.getResourceRequirements();
172 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirementsImpl(
173 std::false_type )
const {
174 return internal::TensorBlockResourceRequirements::any();
178 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock blockImpl(TensorBlockDesc& desc, TensorBlockScratch& scratch,
180 std::false_type )
const {
181 eigen_assert(m_impl.data() !=
nullptr);
182 return TensorBlock::materialize(m_impl.data(), m_dimensions, desc, scratch);
188 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock blockImpl(TensorBlockDesc& desc, TensorBlockScratch& scratch,
189 bool root_of_expr_ast,
190 std::true_type )
const {
191 const DSizes<Index, NumDims> arg_dims = reversed(desc.dimensions());
192 TensorBlockDesc arg_desc(desc.offset(), arg_dims);
199 using DestinationBuffer =
typename TensorBlockDesc::DestinationBuffer;
200 const bool strided_destination = desc.destination().kind() == DestinationBuffer::kStrided;
201 if (desc.destination().kind() == DestinationBuffer::kContiguous || (strided_destination && root_of_expr_ast)) {
202 arg_desc.template AddDestinationBuffer<ArgLayout>(desc.destination().template data<ScalarNoConst>(),
203 reversed(desc.destination().strides()));
206 ArgTensorBlock arg_block = m_impl.block(arg_desc, scratch, root_of_expr_ast);
208 if (arg_block.data() != NULL) {
211 const bool materialized_in_output = arg_block.kind() == internal::TensorBlockKind::kMaterializedInOutput;
212 if (materialized_in_output) desc.DropDestinationBuffer();
213 return TensorBlock(arg_block.kind(), arg_block.data(), desc.dimensions(),
214 !(materialized_in_output && strided_destination));
220 using ArgBlockAssign =
221 internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename ArgTensorBlock::XprType, Index>;
222 typename TensorBlock::Storage storage =
223 TensorBlock::prepareStorage(desc, scratch, root_of_expr_ast);
224 ArgBlockAssign::Run(ArgBlockAssign::target(arg_dims, reversed(storage.strides()), storage.data()),
227 return storage.AsTensorMaterializedBlock();
230 TensorEvaluator<ArgType, Device> m_impl;
231 Dimensions m_dimensions;
235template <
typename ArgType,
typename Device>
238 using Base = TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device>;
239 using XprType = TensorLayoutSwapOp<ArgType>;
241 static constexpr int NumDims = Base::NumDims;
242 static constexpr int Layout = Base::Layout;
244 IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
245 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
251 BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess && NumDims > 0,
252 PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
256 using Index =
typename XprType::Index;
257 using Scalar =
typename XprType::Scalar;
258 using CoeffReturnType =
typename XprType::CoeffReturnType;
259 using PacketReturnType =
typename PacketType<CoeffReturnType, Device>::type;
262 using TensorBlockDesc =
typename Base::TensorBlockDesc;
265 EIGEN_STRONG_INLINE TensorEvaluator(
const XprType& op,
const Device& device) : Base(op, device) {}
267 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index)
const {
268 return this->m_impl.coeffRef(index);
270 template <
int StoreMode>
271 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void writePacket(Index index,
const PacketReturnType& x)
const {
272 this->m_impl.template writePacket<StoreMode>(index, x);
275 template <
typename TensorBlock>
276 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void writeBlock(
const TensorBlockDesc& desc,
const TensorBlock& block) {
277 eigen_assert(this->m_impl.data() != NULL);
282 using TensorBlockExpr =
typename TensorBlock::XprType;
283 using TensorBlockAssign = internal::TensorBlockAssignment<Scalar, NumDims, TensorBlockExpr, Index>;
285 TensorBlockAssign::Run(TensorBlockAssign::target(desc.dimensions(), internal::strides<Layout>(this->dimensions()),
286 this->m_impl.data(), desc.offset()),
The tensor base class.
Definition TensorForwardDeclarations.h:69
Namespace containing all symbols from the Eigen library.
The tensor evaluator class.
Definition TensorEvaluator.h:47