Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc, MaxPacketSize > Struct Template Reference

#include <AssignEvaluator.h>

Public Types
enum	{ DstFlags = DstEvaluator::Flags , SrcFlags = SrcEvaluator::Flags }
enum	{ DstAlignment = DstEvaluator::Alignment , SrcAlignment = SrcEvaluator::Alignment , DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit , JointAlignment = plain_enum_min(DstAlignment, SrcAlignment) }
enum	{ LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment , InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment }
enum	{ Traversal , Vectorized }
enum	{ Unrolling }
typedef DstEvaluator::XprType	Dst
typedef Dst::Scalar	DstScalar
typedef std::conditional_t< int(Traversal)==LinearVectorizedTraversal, LinearPacketType, InnerPacketType >	PacketType

Private Types
enum	{   InnerSize , InnerMaxSize , RestrictedInnerSize = min_size_prefer_fixed(InnerSize, MaxPacketSize) , RestrictedLinearSize = min_size_prefer_fixed(Dst::SizeAtCompileTime, MaxPacketSize) ,   OuterStride = int(outer_stride_at_compile_time<Dst>::ret) , MaxSizeAtCompileTime = Dst::SizeAtCompileTime }
enum	{ LinearPacketSize = unpacket_traits<LinearPacketType>::size , InnerPacketSize = unpacket_traits<InnerPacketType>::size }
enum	{   DstIsRowMajor = DstFlags & RowMajorBit , SrcIsRowMajor = SrcFlags & RowMajorBit , StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)) , MightVectorize ,   MayInnerVectorize , MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit) , MayLinearVectorize , MaySliceVectorize }
enum	{ ActualPacketSize , UnrollingLimit = EIGEN_UNROLLING_LIMIT * ActualPacketSize }
typedef find_best_packet< DstScalar, RestrictedLinearSize >::type	LinearPacketType
typedef find_best_packet< DstScalar, RestrictedInnerSize >::type	InnerPacketType

Member Typedef Documentation

Dst

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

typedef DstEvaluator::XprType Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc, MaxPacketSize >::Dst

DstScalar

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

typedef Dst::Scalar Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc, MaxPacketSize >::DstScalar

InnerPacketType

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

typedef find_best_packet<DstScalar, RestrictedInnerSize>::type Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc, MaxPacketSize >::InnerPacketType

private

LinearPacketType

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

typedef find_best_packet<DstScalar, RestrictedLinearSize>::type Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc, MaxPacketSize >::LinearPacketType

private

PacketType

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

typedef std::conditional_t<int(Traversal) == LinearVectorizedTraversal, LinearPacketType, InnerPacketType> Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc, MaxPacketSize >::PacketType

Member Enumeration Documentation

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

Enumerator
DstFlags
SrcFlags

{ DstFlags = DstEvaluator::Flags, SrcFlags = SrcEvaluator::Flags };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

Enumerator
DstAlignment
SrcAlignment
DstHasDirectAccess
JointAlignment

       {
    DstAlignment = DstEvaluator::Alignment,
    SrcAlignment = SrcEvaluator::Alignment,
    DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit,
    JointAlignment = plain_enum_min(DstAlignment, SrcAlignment)
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

private

Enumerator
InnerSize
InnerMaxSize
RestrictedInnerSize
RestrictedLinearSize
OuterStride
MaxSizeAtCompileTime

       {
    InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
                : int(DstFlags) & RowMajorBit   ? int(Dst::ColsAtCompileTime)
                                                : int(Dst::RowsAtCompileTime),
    InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
                   : int(DstFlags) & RowMajorBit   ? int(Dst::MaxColsAtCompileTime)
                                                   : int(Dst::MaxRowsAtCompileTime),
    RestrictedInnerSize = min_size_prefer_fixed(InnerSize, MaxPacketSize),
    RestrictedLinearSize = min_size_prefer_fixed(Dst::SizeAtCompileTime, MaxPacketSize),
    OuterStride = int(outer_stride_at_compile_time<Dst>::ret),
    MaxSizeAtCompileTime = Dst::SizeAtCompileTime
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

private

Enumerator
LinearPacketSize
InnerPacketSize

       {
    LinearPacketSize = unpacket_traits<LinearPacketType>::size,
    InnerPacketSize = unpacket_traits<InnerPacketType>::size
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

Enumerator
LinearRequiredAlignment
InnerRequiredAlignment

       {
    LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment,
    InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

private

Enumerator
DstIsRowMajor
SrcIsRowMajor
StorageOrdersAgree
MightVectorize
MayInnerVectorize
MayLinearize
MayLinearVectorize
MaySliceVectorize

       {
    DstIsRowMajor = DstFlags & RowMajorBit,
    SrcIsRowMajor = SrcFlags & RowMajorBit,
    StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
    MightVectorize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit) &&
                     bool(functor_traits<AssignFunc>::PacketAccess),
    MayInnerVectorize = MightVectorize && int(InnerSize) != Dynamic && int(InnerSize) % int(InnerPacketSize) == 0 &&
                        int(OuterStride) != Dynamic && int(OuterStride) % int(InnerPacketSize) == 0 &&
                        (EIGEN_UNALIGNED_VECTORIZE || int(JointAlignment) >= int(InnerRequiredAlignment)),
    MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
    MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess) &&
                         (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment) >= int(LinearRequiredAlignment)) ||
                          MaxSizeAtCompileTime == Dynamic),
    /* If the destination isn't aligned, we have to do runtime checks and we don't unroll,
       so it's only good for large enough sizes. */
    MaySliceVectorize = bool(MightVectorize) && bool(DstHasDirectAccess) &&
                        (int(InnerMaxSize) == Dynamic ||
                         int(InnerMaxSize) >= (EIGEN_UNALIGNED_VECTORIZE ? InnerPacketSize : (3 * InnerPacketSize)))
    /* slice vectorization can be slow, so we only want it if the slices are big, which is
       indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block
       in a fixed-size matrix
       However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

Enumerator
Traversal
Vectorized

       {
    Traversal = int(Dst::SizeAtCompileTime) == 0
                    ? int(AllAtOnceTraversal)  // If compile-size is zero, traversing will fail at compile-time.
                : (int(MayLinearVectorize) && (LinearPacketSize > InnerPacketSize)) ? int(LinearVectorizedTraversal)
                : int(MayInnerVectorize)                                            ? int(InnerVectorizedTraversal)
                : int(MayLinearVectorize)                                           ? int(LinearVectorizedTraversal)
                : int(MaySliceVectorize)                                            ? int(SliceVectorizedTraversal)
                : int(MayLinearize)                                                 ? int(LinearTraversal)
                                                                                    : int(DefaultTraversal),
    Vectorized = int(Traversal) == InnerVectorizedTraversal || int(Traversal) == LinearVectorizedTraversal ||
                 int(Traversal) == SliceVectorizedTraversal
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

private

Enumerator
ActualPacketSize
UnrollingLimit

       {
    ActualPacketSize = int(Traversal) == LinearVectorizedTraversal ? LinearPacketSize
                       : Vectorized                                ? InnerPacketSize
                                                                   : 1,
    UnrollingLimit = EIGEN_UNROLLING_LIMIT * ActualPacketSize,
    MayUnrollCompletely =
        int(Dst::SizeAtCompileTime) != Dynamic &&
        int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost) + int(SrcEvaluator::CoeffReadCost)) <=
            int(UnrollingLimit),
    MayUnrollInner =
        int(InnerSize) != Dynamic &&
        int(InnerSize) * (int(DstEvaluator::CoeffReadCost) + int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit)
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc , int MaxPacketSize = -1>

anonymous enum

Enumerator
Unrolling

       {
    Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal))
                    ? (int(MayUnrollCompletely) ? int(CompleteUnrolling)
                       : int(MayUnrollInner)    ? int(InnerUnrolling)
                                                : int(NoUnrolling))
                : int(Traversal) == int(LinearVectorizedTraversal)
                    ? (bool(MayUnrollCompletely) &&
                               (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment) >= int(LinearRequiredAlignment)))
                           ? int(CompleteUnrolling)
                           : int(NoUnrolling))
                : int(Traversal) == int(LinearTraversal)
                    ? (bool(MayUnrollCompletely) ? int(CompleteUnrolling) : int(NoUnrolling))
#if EIGEN_UNALIGNED_VECTORIZE
                : int(Traversal) == int(SliceVectorizedTraversal)
                    ? (bool(MayUnrollInner) ? int(InnerUnrolling) : int(NoUnrolling))
#endif
                    : int(NoUnrolling)
  };

---

The documentation for this struct was generated from the following file:

• AssignEvaluator.h