MOAB  4.9.3pre
Classes | Namespaces | Defines | Functions | Variables
GeneralBlockPanelKernel.h File Reference

Go to the source code of this file.

Classes

struct  Eigen::internal::CacheSizes
struct  Eigen::internal::gebp_madd_selector< CJ, A, B, C, T >
struct  Eigen::internal::gebp_madd_selector< CJ, T, T, T, T >
class  Eigen::internal::gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs >
class  Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >
struct  Eigen::internal::DoublePacket< Packet >
struct  Eigen::internal::unpacket_traits< DoublePacket< Packet > >
class  Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >
class  Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >
struct  Eigen::internal::PossiblyRotatingKernelHelper< GebpKernel, UseRotatingKernel >
struct  Eigen::internal::PossiblyRotatingKernelHelper< GebpKernel, true >
struct  Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs >
struct  Eigen::internal::gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, ColMajor, Conjugate, PanelMode >
struct  Eigen::internal::gemm_pack_lhs< Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode >
struct  Eigen::internal::gemm_pack_rhs< Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode >
struct  Eigen::internal::gemm_pack_rhs< Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode >

Namespaces

namespace  Eigen
namespace  Eigen::internal

Defines

#define CJMADD(CJ, A, B, C, T)   gebp_madd(CJ,A,B,C,T);
#define EIGEN_GEBP_ONESTEP(K)
#define EIGEN_GEBGP_ONESTEP(K)
#define EIGEN_GEBGP_ONESTEP(K)
#define EIGEN_GEBGP_ONESTEP(K)
#define EIGEN_GEBGP_ONESTEP(K)
#define EIGEN_GEBGP_ONESTEP(K)

Functions

std::ptrdiff_t Eigen::internal::manage_caching_sizes_helper (std::ptrdiff_t a, std::ptrdiff_t b)
void Eigen::internal::manage_caching_sizes (Action action, std::ptrdiff_t *l1, std::ptrdiff_t *l2, std::ptrdiff_t *l3)
template<typename LhsScalar , typename RhsScalar , int KcFactor>
void Eigen::internal::evaluateProductBlockingSizesHeuristic (Index &k, Index &m, Index &n, Index num_threads=1)
bool Eigen::internal::useSpecificBlockingSizes (Index &k, Index &m, Index &n)
template<typename LhsScalar , typename RhsScalar , int KcFactor>
void Eigen::internal::computeProductBlockingSizes (Index &k, Index &m, Index &n, Index num_threads=1)
 Computes the blocking parameters for a m x k times k x n matrix product.
template<typename LhsScalar , typename RhsScalar >
void Eigen::internal::computeProductBlockingSizes (Index &k, Index &m, Index &n, Index num_threads=1)
template<typename CJ , typename A , typename B , typename C , typename T >
EIGEN_STRONG_INLINE void Eigen::internal::gebp_madd (const CJ &cj, A &a, B &b, C &c, T &t)
template<typename Packet >
DoublePacket< Packet > Eigen::internal::padd (const DoublePacket< Packet > &a, const DoublePacket< Packet > &b)
template<typename Packet >
const DoublePacket< Packet > & Eigen::internal::predux4 (const DoublePacket< Packet > &a)
std::ptrdiff_t Eigen::l1CacheSize ()
std::ptrdiff_t Eigen::l2CacheSize ()
void Eigen::setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)

Variables

const std::ptrdiff_t Eigen::internal::defaultL1CacheSize = 16*1024
const std::ptrdiff_t Eigen::internal::defaultL2CacheSize = 512*1024
const std::ptrdiff_t Eigen::internal::defaultL3CacheSize = 512*1024

Define Documentation

#define CJMADD (   CJ,
  A,
  B,
  C,
  T 
)    gebp_madd(CJ,A,B,C,T);

Definition at line 349 of file GeneralBlockPanelKernel.h.

#define EIGEN_GEBGP_ONESTEP (   K)
Value:
do { \
              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX1"); \
              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
              traits.loadLhs(&blA[(0+3*K)*LhsProgress], A0);  \
              traits.loadLhs(&blA[(1+3*K)*LhsProgress], A1);  \
              traits.loadLhs(&blA[(2+3*K)*LhsProgress], A2);  \
              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);   \
              traits.madd(A0, B_0, C0, B_0); \
              traits.madd(A1, B_0, C4, B_0); \
              traits.madd(A2, B_0, C8, B_0); \
              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX1"); \
            } while(false)
#define EIGEN_GEBGP_ONESTEP (   K)
Value:
do {                                                                \
              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX4");        \
              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
              traits.loadLhs(&blA[(0+2*K)*LhsProgress], A0);                    \
              traits.loadLhs(&blA[(1+2*K)*LhsProgress], A1);                    \
              traits.broadcastRhs(&blB[(0+4*K)*RhsProgress], B_0, B1, B2, B3);  \
              traits.madd(A0, B_0, C0, T0);                                     \
              traits.madd(A1, B_0, C4, B_0);                                    \
              traits.madd(A0, B1,  C1, T0);                                     \
              traits.madd(A1, B1,  C5, B1);                                     \
              traits.madd(A0, B2,  C2, T0);                                     \
              traits.madd(A1, B2,  C6, B2);                                     \
              traits.madd(A0, B3,  C3, T0);                                     \
              traits.madd(A1, B3,  C7, B3);                                     \
              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX4");          \
            } while(false)
#define EIGEN_GEBGP_ONESTEP (   K)
Value:
do {                                                                  \
              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX1");          \
              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
              traits.loadLhs(&blA[(0+2*K)*LhsProgress], A0);                      \
              traits.loadLhs(&blA[(1+2*K)*LhsProgress], A1);                      \
              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);                       \
              traits.madd(A0, B_0, C0, B1);                                       \
              traits.madd(A1, B_0, C4, B_0);                                      \
              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX1");            \
            } while(false)
#define EIGEN_GEBGP_ONESTEP (   K)
Value:
do {                                                                \
              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1pX4");        \
              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
              traits.loadLhs(&blA[(0+1*K)*LhsProgress], A0);                    \
              traits.broadcastRhs(&blB[(0+4*K)*RhsProgress], B_0, B1, B2, B3);  \
              traits.madd(A0, B_0, C0, B_0);                                    \
              traits.madd(A0, B1,  C1, B1);                                     \
              traits.madd(A0, B2,  C2, B2);                                     \
              traits.madd(A0, B3,  C3, B3);                                     \
              EIGEN_ASM_COMMENT("end step of gebp micro kernel 1pX4");          \
            } while(false)
#define EIGEN_GEBGP_ONESTEP (   K)
Value:
do {                                                                \
              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1pX1");        \
              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
              traits.loadLhs(&blA[(0+1*K)*LhsProgress], A0);                    \
              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);                     \
              traits.madd(A0, B_0, C0, B_0);                                    \
              EIGEN_ASM_COMMENT("end step of gebp micro kernel 1pX1");          \
            } while(false);
#define EIGEN_GEBP_ONESTEP (   K)
Value:
do { \
              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX4"); \
              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
              internal::prefetch(blA+(3*K+16)*LhsProgress); \
              if (EIGEN_ARCH_ARM) internal::prefetch(blB+(4*K+16)*RhsProgress); /* Bug 953 */ \
              traits.loadLhs(&blA[(0+3*K)*LhsProgress], A0);  \
              traits.loadLhs(&blA[(1+3*K)*LhsProgress], A1);  \
              traits.loadLhs(&blA[(2+3*K)*LhsProgress], A2);  \
              possiblyRotatingKernelHelper.template loadOrRotateRhs<K, 0>(B_0, blB); \
              traits.madd(A0, B_0, C0, T0); \
              traits.madd(A1, B_0, C4, T0); \
              traits.madd(A2, B_0, C8, B_0); \
              possiblyRotatingKernelHelper.template loadOrRotateRhs<K, 1>(B_0, blB); \
              traits.madd(A0, B_0, C1, T0); \
              traits.madd(A1, B_0, C5, T0); \
              traits.madd(A2, B_0, C9, B_0); \
              possiblyRotatingKernelHelper.template loadOrRotateRhs<K, 2>(B_0, blB); \
              traits.madd(A0, B_0, C2,  T0); \
              traits.madd(A1, B_0, C6,  T0); \
              traits.madd(A2, B_0, C10, B_0); \
              possiblyRotatingKernelHelper.template loadOrRotateRhs<K, 3>(B_0, blB); \
              traits.madd(A0, B_0, C3 , T0); \
              traits.madd(A1, B_0, C7,  T0); \
              traits.madd(A2, B_0, C11, B_0); \
              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX4"); \
            } while(false)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines