Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ > Class Template Reference

#include <GeneralBlockPanelKernel.h>

Public Types
enum	{   ConjLhs = ConjLhs_ , ConjRhs = ConjRhs_ , Vectorizable = unpacket_traits<LhsPacket_>::vectorizable && unpacket_traits<RhsPacket_>::vectorizable , LhsPacketSize = Vectorizable ? unpacket_traits<LhsPacket_>::size : 1 ,   RhsPacketSize = Vectorizable ? unpacket_traits<RhsPacket_>::size : 1 , ResPacketSize = Vectorizable ? unpacket_traits<ResPacket_>::size : 1 , NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS , nr = 4 ,   default_mr = (plain_enum_min(16, NumberOfRegisters) / 2 / nr) * LhsPacketSize , mr = default_mr , LhsProgress = LhsPacketSize , RhsProgress = 1 }
typedef LhsScalar_	LhsScalar
typedef RhsScalar_	RhsScalar
typedef ScalarBinaryOpTraits< LhsScalar, RhsScalar >::ReturnType	ResScalar
typedef std::conditional_t< Vectorizable, LhsPacket_, LhsScalar >	LhsPacket
typedef std::conditional_t< Vectorizable, RhsPacket_, RhsScalar >	RhsPacket
typedef std::conditional_t< Vectorizable, ResPacket_, ResScalar >	ResPacket
typedef LhsPacket	LhsPacket4Packing
typedef QuadPacket< RhsPacket >	RhsPacketx4
typedef ResPacket	AccPacket

Public Member Functions
	PACKET_DECL_COND_POSTFIX (_, Lhs, PacketSize_)
	PACKET_DECL_COND_POSTFIX (_, Rhs, PacketSize_)
	PACKET_DECL_COND_POSTFIX (_, Res, PacketSize_)
EIGEN_STRONG_INLINE void	initAcc (AccPacket &p)
template<typename RhsPacketType >
EIGEN_STRONG_INLINE void	loadRhs (const RhsScalar *b, RhsPacketType &dest) const
EIGEN_STRONG_INLINE void	loadRhs (const RhsScalar *b, RhsPacketx4 &dest) const
template<typename RhsPacketType >
EIGEN_STRONG_INLINE void	updateRhs (const RhsScalar *b, RhsPacketType &dest) const
EIGEN_STRONG_INLINE void	updateRhs (const RhsScalar *, RhsPacketx4 &) const
EIGEN_STRONG_INLINE void	loadRhsQuad (const RhsScalar *b, RhsPacket &dest) const
template<typename LhsPacketType >
EIGEN_STRONG_INLINE void	loadLhs (const LhsScalar *a, LhsPacketType &dest) const
template<typename LhsPacketType >
EIGEN_STRONG_INLINE void	loadLhsUnaligned (const LhsScalar *a, LhsPacketType &dest) const
template<typename LhsPacketType , typename RhsPacketType , typename AccPacketType , typename LaneIdType >
EIGEN_STRONG_INLINE void	madd (const LhsPacketType &a, const RhsPacketType &b, AccPacketType &c, RhsPacketType &tmp, const LaneIdType &) const
template<typename LhsPacketType , typename AccPacketType , typename LaneIdType >
EIGEN_STRONG_INLINE void	madd (const LhsPacketType &a, const RhsPacketx4 &b, AccPacketType &c, RhsPacket &tmp, const LaneIdType &lane) const
EIGEN_STRONG_INLINE void	acc (const AccPacket &c, const ResPacket &alpha, ResPacket &r) const
template<typename ResPacketHalf >
EIGEN_STRONG_INLINE void	acc (const ResPacketHalf &c, const ResPacketHalf &alpha, ResPacketHalf &r) const

Member Typedef Documentation

AccPacket

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef ResPacket Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::AccPacket

LhsPacket

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef std::conditional_t<Vectorizable, LhsPacket_, LhsScalar> Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::LhsPacket

LhsPacket4Packing

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef LhsPacket Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::LhsPacket4Packing

LhsScalar

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef LhsScalar_ Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::LhsScalar

ResPacket

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef std::conditional_t<Vectorizable, ResPacket_, ResScalar> Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::ResPacket

ResScalar

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::ResScalar

RhsPacket

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef std::conditional_t<Vectorizable, RhsPacket_, RhsScalar> Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::RhsPacket

RhsPacketx4

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef QuadPacket<RhsPacket> Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::RhsPacketx4

RhsScalar

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

typedef RhsScalar_ Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::RhsScalar

Member Enumeration Documentation

anonymous enum

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

anonymous enum

Enumerator
ConjLhs
ConjRhs
Vectorizable
LhsPacketSize
RhsPacketSize
ResPacketSize
NumberOfRegisters
nr
default_mr
mr
LhsProgress
RhsProgress

       {
    ConjLhs = ConjLhs_,
    ConjRhs = ConjRhs_,
    Vectorizable = unpacket_traits<LhsPacket_>::vectorizable && unpacket_traits<RhsPacket_>::vectorizable,
    LhsPacketSize = Vectorizable ? unpacket_traits<LhsPacket_>::size : 1,
    RhsPacketSize = Vectorizable ? unpacket_traits<RhsPacket_>::size : 1,
    ResPacketSize = Vectorizable ? unpacket_traits<ResPacket_>::size : 1,
 
    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
 
    // register block size along the N direction must be 1 or 4
    nr = 4,
 
    // register block size along the M direction (currently, this one cannot be modified)
    default_mr = (plain_enum_min(16, NumberOfRegisters) / 2 / nr) * LhsPacketSize,
#if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && \
    !defined(EIGEN_VECTORIZE_VSX) && ((!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC >= 1914))
    // we assume 16 registers or more
    // See bug 992, if the scalar type is not vectorizable but that EIGEN_HAS_SINGLE_INSTRUCTION_MADD is defined,
    // then using 3*LhsPacketSize triggers non-implemented paths in syrk.
    // Bug 1515: MSVC prior to v19.14 yields to register spilling.
    mr = Vectorizable ? 3 * LhsPacketSize : default_mr,
#else
    mr = default_mr,
#endif
 
    LhsProgress = LhsPacketSize,
    RhsProgress = 1
  };

Member Function Documentation

acc() [1/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::acc ( const AccPacket &  c, const ResPacket &  alpha, ResPacket &  r  ) const

inline

                                                                                               {
    r = pmadd(c, alpha, r);
  }

References alpha, calibrate::c, Eigen::internal::pmadd(), and UniformPSDSelfTest::r.

Referenced by Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()(), and Eigen::internal::last_row_process_16_packets< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs, 16 >::operator()().

acc() [2/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

template<typename ResPacketHalf >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::acc ( const ResPacketHalf &  c, const ResPacketHalf &  alpha, ResPacketHalf &  r  ) const

inline

                                                                                                           {
    r = pmadd(c, alpha, r);
  }

References alpha, calibrate::c, Eigen::internal::pmadd(), and UniformPSDSelfTest::r.

initAcc()

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::initAcc ( AccPacket &  p )

inline

{ p = pset1<ResPacket>(ResScalar(0)); }

References p.

Referenced by Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()().

loadLhs()

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

template<typename LhsPacketType >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadLhs ( const LhsScalar *  a, LhsPacketType &  dest  ) const

inline

                                                                                  {
    dest = pload<LhsPacketType>(a);
  }

References a.

loadLhsUnaligned()

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

template<typename LhsPacketType >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadLhsUnaligned ( const LhsScalar *  a, LhsPacketType &  dest  ) const

inline

                                                                                           {
    dest = ploadu<LhsPacketType>(a);
  }

References a.

Referenced by Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()(), and Eigen::internal::last_row_process_16_packets< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs, 16 >::operator()().

loadRhs() [1/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

template<typename RhsPacketType >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadRhs ( const RhsScalar *  b, RhsPacketType &  dest  ) const

inline

                                                                                  {
    dest = pset1<RhsPacketType>(*b);
  }

References b.

Referenced by Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadRhs(), Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadRhsQuad(), Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()(), Eigen::internal::last_row_process_16_packets< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs, 16 >::operator()(), Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::updateRhs(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, ConjLhs_, false, Arch, PacketSize_ >::updateRhs(), Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, ConjRhs_, Arch, PacketSize_ >::updateRhs(), and Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::updateRhs().

loadRhs() [2/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadRhs ( const RhsScalar *  b, RhsPacketx4 &  dest  ) const

inline

                                                                                {
    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
  }

References b, Eigen::internal::QuadPacket< Packet >::B1, Eigen::internal::QuadPacket< Packet >::B2, Eigen::internal::QuadPacket< Packet >::B3, Eigen::internal::QuadPacket< Packet >::B_0, and Eigen::internal::pbroadcast4().

loadRhsQuad()

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadRhsQuad ( const RhsScalar *  b, RhsPacket &  dest  ) const

inline

{ dest = ploadquad<RhsPacket>(b); }

References b.

Referenced by Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()().

madd() [1/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

template<typename LhsPacketType , typename RhsPacketType , typename AccPacketType , typename LaneIdType >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::madd ( const LhsPacketType &  a, const RhsPacketType &  b, AccPacketType &  c, RhsPacketType &  tmp, const LaneIdType &    ) const

inline

                                                         {
    conj_helper<LhsPacketType, RhsPacketType, ConjLhs, ConjRhs> cj;
    // It would be a lot cleaner to call pmadd all the time. Unfortunately if we
    // let gcc allocate the register in which to store the result of the pmul
    // (in the case where there is no FMA) gcc fails to figure out how to avoid
    // spilling register.
#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
    EIGEN_UNUSED_VARIABLE(tmp);
    c = cj.pmadd(a, b, c);
#else
    tmp = b;
    tmp = cj.pmul(a, tmp);
    c = padd(c, tmp);
#endif
  }

References a, b, calibrate::c, EIGEN_UNUSED_VARIABLE, Eigen::internal::padd(), Eigen::internal::conj_helper< LhsType, RhsType, ConjLhs, ConjRhs >::pmadd(), Eigen::internal::conj_helper< LhsType, RhsType, ConjLhs, ConjRhs >::pmul(), and tmp.

Referenced by Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, ConjLhs_, false, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, ConjRhs_, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >::operator()(), and Eigen::internal::last_row_process_16_packets< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs, 16 >::operator()().

madd() [2/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

template<typename LhsPacketType , typename AccPacketType , typename LaneIdType >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::madd ( const LhsPacketType &  a, const RhsPacketx4 &  b, AccPacketType &  c, RhsPacket &  tmp, const LaneIdType &  lane  ) const

inline

                                                              {
    madd(a, b.get(lane), c, tmp, lane);
  }

References a, b, calibrate::c, Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::madd(), and tmp.

PACKET_DECL_COND_POSTFIX() [1/3]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::PACKET_DECL_COND_POSTFIX	(	_	,
		Lhs	,
		PacketSize_
	)

PACKET_DECL_COND_POSTFIX() [2/3]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::PACKET_DECL_COND_POSTFIX	(	_	,
		Res	,
		PacketSize_
	)

PACKET_DECL_COND_POSTFIX() [3/3]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::PACKET_DECL_COND_POSTFIX	(	_	,
		Rhs	,
		PacketSize_
	)

updateRhs() [1/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::updateRhs ( const RhsScalar *  , RhsPacketx4 &    ) const

inline

{}

updateRhs() [2/2]

template<typename LhsScalar_ , typename RhsScalar_ , bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>

template<typename RhsPacketType >

EIGEN_STRONG_INLINE void Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::updateRhs ( const RhsScalar *  b, RhsPacketType &  dest  ) const

inline

                                                                                    {
    loadRhs(b, dest);
  }

References b, and Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::loadRhs().

---

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

• products/GeneralBlockPanelKernel.h