Eigen::TensorContractionEvaluatorBase< Derived > Struct Template Reference

#include <TensorContraction.h>

Public Types
enum	{   IsAligned = true , PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1) , BlockAccess = false , PreferBlockAccess = false ,   CoordAccess = false , RawAccess = true }
typedef internal::traits< Derived >::Indices	Indices
typedef internal::traits< Derived >::LeftArgType	LeftArgType
typedef internal::traits< Derived >::RightArgType	RightArgType
typedef internal::traits< Derived >::OutputKernelType	OutputKernelType
typedef internal::traits< Derived >::Device	Device
typedef TensorContractionOp< Indices, LeftArgType, RightArgType, OutputKernelType >	XprType
typedef std::remove_const_t< typename XprType::Scalar >	Scalar
typedef XprType::Index	Index
typedef XprType::CoeffReturnType	CoeffReturnType
typedef PacketType< CoeffReturnType, Device >::type	PacketReturnType
typedef StorageMemory< Scalar, Device >	Storage
typedef Storage::Type	EvaluatorPointerType
typedef internal::TensorBlockNotImplemented	TensorBlock
typedef std::conditional_t< static_cast< int >Layout)==static_cast< int >ColMajor), LeftArgType, RightArgType >	EvalLeftArgType
typedef std::conditional_t< static_cast< int >Layout)==static_cast< int >ColMajor), RightArgType, LeftArgType >	EvalRightArgType
typedef TensorEvaluator< EvalLeftArgType, Device >	LeftEvaluatorType
typedef TensorEvaluator< EvalRightArgType, Device >	RightEvaluatorType
typedef array< Index, ContractDims >	contract_t
typedef array< Index, LDims - ContractDims >	left_nocontract_t
typedef array< Index, RDims - ContractDims >	right_nocontract_t
typedef DSizes< Index, NumDims >	Dimensions

Public Member Functions
EIGEN_STRONG_INLINE	TensorContractionEvaluatorBase (const XprType &op, const Device &device)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions &	dimensions () const
EIGEN_STRONG_INLINE bool	evalSubExprsIfNeeded (EvaluatorPointerType data)
EIGEN_DEVICE_FUNC void	evalTo (Scalar *buffer) const
template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
void	evalProductSequential (Scalar *buffer) const
template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
EIGEN_DEVICE_FUNC void	evalGemv (Scalar *buffer) const
template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
EIGEN_DEVICE_FUNC void	evalGemm (Scalar *buffer) const
template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
EIGEN_DEVICE_FUNC void	evalGemmPartialWithoutOutputKernel (Scalar *buffer, Index k_start, Index k_end, int num_threads) const
template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment, bool use_output_kernel>
EIGEN_DEVICE_FUNC void	evalGemmPartial (Scalar *buffer, Index k_start, Index k_end, int num_threads) const
EIGEN_STRONG_INLINE void	cleanup ()
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType	coeff (Index index) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost	costPerCoeff (bool) const
template<int LoadMode>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType	packet (Index index) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType	data () const

Static Public Attributes
static constexpr int	Layout = TensorEvaluator<LeftArgType, Device>::Layout
static constexpr int	LDims
static constexpr int	RDims
static constexpr int	ContractDims = internal::array_size<Indices>::value
static constexpr int	NumDims = LDims + RDims - 2 * ContractDims

Protected Attributes
Dimensions	m_dimensions
contract_t	m_k_strides
contract_t	m_left_contracting_strides
contract_t	m_right_contracting_strides
bool	m_lhs_inner_dim_contiguous
bool	m_rhs_inner_dim_contiguous
bool	m_rhs_inner_dim_reordered
left_nocontract_t	m_i_strides
right_nocontract_t	m_j_strides
left_nocontract_t	m_left_nocontract_strides
right_nocontract_t	m_right_nocontract_strides
Index	m_i_size
Index	m_j_size
Index	m_k_size
TensorContractionParams	m_tensor_contraction_params
TensorEvaluator< EvalLeftArgType, Device >	m_leftImpl
TensorEvaluator< EvalRightArgType, Device >	m_rightImpl
const Device EIGEN_DEVICE_REF	m_device
OutputKernelType	m_output_kernel
EvaluatorPointerType	m_result

Member Typedef Documentation

CoeffReturnType

template<typename Derived >

typedef XprType::CoeffReturnType Eigen::TensorContractionEvaluatorBase< Derived >::CoeffReturnType

contract_t

template<typename Derived >

typedef array<Index, ContractDims> Eigen::TensorContractionEvaluatorBase< Derived >::contract_t

Device

template<typename Derived >

typedef internal::traits<Derived>::Device Eigen::TensorContractionEvaluatorBase< Derived >::Device

Dimensions

template<typename Derived >

typedef DSizes<Index, NumDims> Eigen::TensorContractionEvaluatorBase< Derived >::Dimensions

EvalLeftArgType

template<typename Derived >

typedef std::conditional_t<static_cast<int>Layout) == static_cast<int>ColMajor), LeftArgType, RightArgType> Eigen::TensorContractionEvaluatorBase< Derived >::EvalLeftArgType

EvalRightArgType

template<typename Derived >

typedef std::conditional_t<static_cast<int>Layout) == static_cast<int>ColMajor), RightArgType, LeftArgType> Eigen::TensorContractionEvaluatorBase< Derived >::EvalRightArgType

EvaluatorPointerType

template<typename Derived >

typedef Storage::Type Eigen::TensorContractionEvaluatorBase< Derived >::EvaluatorPointerType

Index

template<typename Derived >

typedef XprType::Index Eigen::TensorContractionEvaluatorBase< Derived >::Index

Indices

template<typename Derived >

typedef internal::traits<Derived>::Indices Eigen::TensorContractionEvaluatorBase< Derived >::Indices

left_nocontract_t

template<typename Derived >

typedef array<Index, LDims - ContractDims> Eigen::TensorContractionEvaluatorBase< Derived >::left_nocontract_t

LeftArgType

template<typename Derived >

typedef internal::traits<Derived>::LeftArgType Eigen::TensorContractionEvaluatorBase< Derived >::LeftArgType

LeftEvaluatorType

template<typename Derived >

typedef TensorEvaluator<EvalLeftArgType, Device> Eigen::TensorContractionEvaluatorBase< Derived >::LeftEvaluatorType

OutputKernelType

template<typename Derived >

typedef internal::traits<Derived>::OutputKernelType Eigen::TensorContractionEvaluatorBase< Derived >::OutputKernelType

PacketReturnType

template<typename Derived >

typedef PacketType<CoeffReturnType, Device>::type Eigen::TensorContractionEvaluatorBase< Derived >::PacketReturnType

right_nocontract_t

template<typename Derived >

typedef array<Index, RDims - ContractDims> Eigen::TensorContractionEvaluatorBase< Derived >::right_nocontract_t

RightArgType

template<typename Derived >

typedef internal::traits<Derived>::RightArgType Eigen::TensorContractionEvaluatorBase< Derived >::RightArgType

RightEvaluatorType

template<typename Derived >

typedef TensorEvaluator<EvalRightArgType, Device> Eigen::TensorContractionEvaluatorBase< Derived >::RightEvaluatorType

Scalar

template<typename Derived >

typedef std::remove_const_t<typename XprType::Scalar> Eigen::TensorContractionEvaluatorBase< Derived >::Scalar

Storage

template<typename Derived >

typedef StorageMemory<Scalar, Device> Eigen::TensorContractionEvaluatorBase< Derived >::Storage

TensorBlock

template<typename Derived >

typedef internal::TensorBlockNotImplemented Eigen::TensorContractionEvaluatorBase< Derived >::TensorBlock

XprType

template<typename Derived >

typedef TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType> Eigen::TensorContractionEvaluatorBase< Derived >::XprType

Member Enumeration Documentation

anonymous enum

template<typename Derived >

anonymous enum

Enumerator
IsAligned
PacketAccess
BlockAccess
PreferBlockAccess
CoordAccess
RawAccess

       {
    IsAligned = true,
    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
    BlockAccess = false,
    PreferBlockAccess = false,
    CoordAccess = false,  // to be implemented
    RawAccess = true
  };

Constructor & Destructor Documentation

TensorContractionEvaluatorBase()

template<typename Derived >

EIGEN_STRONG_INLINE Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase ( const XprType &  op, const Device &  device  )

inline

      : m_leftImpl(choose(Cond<static_cast<int>(Layout) == static_cast<int>(ColMajor)>(), op.lhsExpression(),
                          op.rhsExpression()),
                   device),
        m_rightImpl(choose(Cond<static_cast<int>(Layout) == static_cast<int>(ColMajor)>(), op.rhsExpression(),
                           op.lhsExpression()),
                    device),
        m_device(device),
        m_output_kernel(op.outputKernel()),
        m_result(NULL) {
    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
                         static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout)),
                        YOU_MADE_A_PROGRAMMING_MISTAKE);
 
    DSizes<Index, LDims> eval_left_dims;
    DSizes<Index, RDims> eval_right_dims;
    array<IndexPair<Index>, ContractDims> eval_op_indices;
    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
      // For ColMajor, we keep using the existing dimensions
      for (int i = 0; i < LDims; i++) {
        eval_left_dims[i] = m_leftImpl.dimensions()[i];
      }
      for (int i = 0; i < RDims; i++) {
        eval_right_dims[i] = m_rightImpl.dimensions()[i];
      }
      // We keep the pairs of contracting indices.
      for (int i = 0; i < ContractDims; i++) {
        eval_op_indices[i].first = op.indices()[i].first;
        eval_op_indices[i].second = op.indices()[i].second;
      }
    } else {
      // For RowMajor, we need to reverse the existing dimensions
      for (int i = 0; i < LDims; i++) {
        eval_left_dims[i] = m_leftImpl.dimensions()[LDims - i - 1];
      }
      for (int i = 0; i < RDims; i++) {
        eval_right_dims[i] = m_rightImpl.dimensions()[RDims - i - 1];
      }
      // We need to flip all the pairs of contracting indices as well as
      // reversing the dimensions.
      for (int i = 0; i < ContractDims; i++) {
        eval_op_indices[i].first = LDims - 1 - op.indices()[ContractDims - 1 - i].second;
        eval_op_indices[i].second = RDims - 1 - op.indices()[ContractDims - 1 - i].first;
      }
    }
 
    // Check for duplicate axes and make sure the first index in eval_op_indices
    // is increasing. Using O(n^2) sorting is OK since ContractDims is small
    for (int i = 0; i < ContractDims; i++) {
      for (int j = i + 1; j < ContractDims; j++) {
        eigen_assert(eval_op_indices[j].first != eval_op_indices[i].first &&
                     eval_op_indices[j].second != eval_op_indices[i].second && "contraction axes should be unique");
        if (eval_op_indices[j].first < eval_op_indices[i].first) {
          numext::swap(eval_op_indices[j], eval_op_indices[i]);
        }
      }
    }
 
    array<Index, LDims> lhs_strides;
    lhs_strides[0] = 1;
    for (int i = 0; i < LDims - 1; ++i) {
      lhs_strides[i + 1] = lhs_strides[i] * eval_left_dims[i];
    }
 
    array<Index, RDims> rhs_strides;
    rhs_strides[0] = 1;
    for (int i = 0; i < RDims - 1; ++i) {
      rhs_strides[i + 1] = rhs_strides[i] * eval_right_dims[i];
    }
 
    if (m_i_strides.size() > 0) m_i_strides[0] = 1;
    if (m_j_strides.size() > 0) m_j_strides[0] = 1;
    if (m_k_strides.size() > 0) m_k_strides[0] = 1;
 
    m_i_size = 1;
    m_j_size = 1;
    m_k_size = 1;
 
    // To compute the dimension, we simply concatenate the non-contracting
    // dimensions of the left and then the right tensor. Additionally, we also
    // compute the strides corresponding to the left non-contracting
    // dimensions and right non-contracting dimensions.
    m_lhs_inner_dim_contiguous = true;
    int dim_idx = 0;
    Index nocontract_idx = 0;
 
    for (int i = 0; i < LDims; i++) {
      // find if we are contracting on index i of left tensor
      bool contracting = false;
      for (int j = 0; j < ContractDims; j++) {
        if (eval_op_indices[j].first == i) {
          contracting = true;
          break;
        }
      }
      if (!contracting) {
        // add dimension size to output dimensions
        m_dimensions[dim_idx] = eval_left_dims[i];
        m_left_nocontract_strides[nocontract_idx] = lhs_strides[i];
        if (dim_idx != i) {
          m_lhs_inner_dim_contiguous = false;
        }
        if (nocontract_idx + 1 < internal::array_size<left_nocontract_t>::value) {
          m_i_strides[nocontract_idx + 1] = m_i_strides[nocontract_idx] * eval_left_dims[i];
        } else {
          m_i_size = m_i_strides[nocontract_idx] * eval_left_dims[i];
        }
        dim_idx++;
        nocontract_idx++;
      }
    }
 
    nocontract_idx = 0;
    for (int i = 0; i < RDims; i++) {
      bool contracting = false;
      // find if we are contracting on index i of right tensor
      for (int j = 0; j < ContractDims; j++) {
        if (eval_op_indices[j].second == i) {
          contracting = true;
          break;
        }
      }
      if (!contracting) {
        m_dimensions[dim_idx] = eval_right_dims[i];
        if (nocontract_idx + 1 < internal::array_size<right_nocontract_t>::value) {
          m_j_strides[nocontract_idx + 1] = m_j_strides[nocontract_idx] * eval_right_dims[i];
        } else {
          m_j_size = m_j_strides[nocontract_idx] * eval_right_dims[i];
        }
        m_right_nocontract_strides[nocontract_idx] = rhs_strides[i];
        dim_idx++;
        nocontract_idx++;
      }
    }
 
    // Now compute the strides corresponding to the contracting dimensions. We
    // assumed above that non-contracting axes are represented in the same order
    // in the matrix as they are in the tensor. This is not the case for
    // contracting axes. As the contracting axes must be of the same size in
    // each tensor, we'll only look at the first tensor here.
    m_rhs_inner_dim_contiguous = true;
    m_rhs_inner_dim_reordered = false;
    for (int i = 0; i < ContractDims; i++) {
      Index left = eval_op_indices[i].first;
      Index right = eval_op_indices[i].second;
 
      Index size = eval_left_dims[left];
      eigen_assert(size == eval_right_dims[right] && "Contraction axes must be same size");
 
      if (i + 1 < static_cast<int>(internal::array_size<contract_t>::value)) {
        m_k_strides[i + 1] = m_k_strides[i] * size;
      } else {
        m_k_size = m_k_strides[i] * size;
      }
      m_left_contracting_strides[i] = lhs_strides[left];
      m_right_contracting_strides[i] = rhs_strides[right];
 
      if (i > 0 && right < eval_op_indices[i - 1].second) {
        m_rhs_inner_dim_reordered = true;
      }
      if (right != i) {
        m_rhs_inner_dim_contiguous = false;
      }
    }
 
    // If the layout is RowMajor, we need to reverse the m_dimensions
    if (static_cast<int>(Layout) == static_cast<int>(RowMajor)) {
      for (int i = 0, j = NumDims - 1; i < j; i++, j--) {
        numext::swap(m_dimensions[i], m_dimensions[j]);
      }
    }
 
    // A set of parameters that will allow output kernel to get from output
    // tensor dimensions (i, j) into the original tensor dimensions.
    // TODO(ezhulenev): Add parameters required to infer output tensor index for
    // more complex contractions than 2x2 on internal dimension.
    m_tensor_contraction_params.swapped_arguments = static_cast<int>(Layout) == RowMajor;
  }

References Eigen::ColMajor, Eigen::TensorContractionEvaluatorBase< Derived >::ContractDims, Eigen::TensorEvaluator< Derived, Device >::dimensions(), eigen_assert, EIGEN_STATIC_ASSERT, i, j, Eigen::TensorContractionEvaluatorBase< Derived >::Layout, Eigen::TensorContractionEvaluatorBase< Derived >::LDims, Eigen::TensorContractionEvaluatorBase< Derived >::m_dimensions, Eigen::TensorContractionEvaluatorBase< Derived >::m_i_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_i_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_j_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_j_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_k_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_k_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_left_contracting_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_left_nocontract_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_leftImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_lhs_inner_dim_contiguous, Eigen::TensorContractionEvaluatorBase< Derived >::m_rhs_inner_dim_contiguous, Eigen::TensorContractionEvaluatorBase< Derived >::m_rhs_inner_dim_reordered, Eigen::TensorContractionEvaluatorBase< Derived >::m_right_contracting_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_right_nocontract_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_rightImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_tensor_contraction_params, Eigen::TensorContractionEvaluatorBase< Derived >::NumDims, op, Eigen::TensorContractionEvaluatorBase< Derived >::RDims, Eigen::RowMajor, size, Eigen::numext::swap(), and Eigen::TensorContractionParams::swapped_arguments.

Member Function Documentation

cleanup()

template<typename Derived >

EIGEN_STRONG_INLINE void Eigen::TensorContractionEvaluatorBase< Derived >::cleanup ( )

inline

                                     {
    m_leftImpl.cleanup();
    m_rightImpl.cleanup();
 
    if (m_result != NULL) {
      m_device.deallocate(m_result);
      m_result = NULL;
    }
  }

References Eigen::TensorEvaluator< Derived, Device >::cleanup(), Eigen::TensorContractionEvaluatorBase< Derived >::m_device, Eigen::TensorContractionEvaluatorBase< Derived >::m_leftImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_result, and Eigen::TensorContractionEvaluatorBase< Derived >::m_rightImpl.

Referenced by framework.Frame::__init__().

coeff()

template<typename Derived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType Eigen::TensorContractionEvaluatorBase< Derived >::coeff ( Index  index ) const

inline

{ return m_result[index]; }

References Eigen::TensorContractionEvaluatorBase< Derived >::m_result.

costPerCoeff()

template<typename Derived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost Eigen::TensorContractionEvaluatorBase< Derived >::costPerCoeff ( bool  ) const

inline

                                                                              {
    return TensorOpCost(sizeof(CoeffReturnType), 0, 0);
  }

data()

template<typename Derived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType Eigen::TensorContractionEvaluatorBase< Derived >::data ( ) const

inline

{ return m_result; }

References Eigen::TensorContractionEvaluatorBase< Derived >::m_result.

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

dimensions()

template<typename Derived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& Eigen::TensorContractionEvaluatorBase< Derived >::dimensions ( ) const

inline

{ return m_dimensions; }

References Eigen::TensorContractionEvaluatorBase< Derived >::m_dimensions.

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded().

evalGemm()

template<typename Derived >

template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>

EIGEN_DEVICE_FUNC void Eigen::TensorContractionEvaluatorBase< Derived >::evalGemm ( Scalar *  buffer ) const

inline

                                     {
    // columns in left side, rows in right side
    const Index k = this->m_k_size;
    this->template evalGemmPartial<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered,
                                   Alignment, true>(buffer, 0, k, 1);
  }

References Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), k, and Eigen::TensorContractionEvaluatorBase< Derived >::m_k_size.

evalGemmPartial()

template<typename Derived >

template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment, bool use_output_kernel>

EIGEN_DEVICE_FUNC void Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial ( Scalar *  buffer, Index  k_start, Index  k_end, int  num_threads  ) const

inline

                                                                                                            {
    eigen_assert(k_end >= k_start && k_start >= 0 && k_end <= this->m_k_size);
    // columns in slice on left side, rows on right side
    const Index k_slice = k_end - k_start;
 
    // rows in left side
    const Index m = this->m_i_size;
 
    // columns in right side
    const Index n = this->m_j_size;
 
    // define data mappers for Lhs and Rhs
    typedef std::remove_const_t<typename EvalLeftArgType::Scalar> LhsScalar;
    typedef std::remove_const_t<typename EvalRightArgType::Scalar> RhsScalar;
 
    typedef TensorEvaluator<EvalLeftArgType, Device> LeftEvaluator;
    typedef TensorEvaluator<EvalRightArgType, Device> RightEvaluator;
 
    const Index lhs_packet_size = internal::unpacket_traits<typename LeftEvaluator::PacketReturnType>::size;
    const Index rhs_packet_size = internal::unpacket_traits<typename RightEvaluator::PacketReturnType>::size;
 
    typedef internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
                                                   contract_t, lhs_packet_size, lhs_inner_dim_contiguous, false,
                                                   Unaligned>
        LhsMapper;
 
    typedef internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
                                                   contract_t, rhs_packet_size, rhs_inner_dim_contiguous,
                                                   rhs_inner_dim_reordered, Unaligned>
        RhsMapper;
 
    typedef internal::blas_data_mapper<Scalar, Index, ColMajor> OutputMapper;
 
    typedef internal::TensorContractionKernel<Scalar, LhsScalar, RhsScalar, Index, OutputMapper, LhsMapper, RhsMapper>
        TensorContractionKernel;
 
    // initialize data mappers
    LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
                  this->m_left_contracting_strides, this->m_k_strides);
 
    RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
                  this->m_right_contracting_strides, this->m_k_strides);
 
    OutputMapper output(buffer, m);
 
    // Sizes of the blocks to load in cache. See the Goto paper for details.
    internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByCol> blocking(
        k_slice, m, n, num_threads);
    const Index kc = blocking.kc();
    const Index mc = numext::mini(m, blocking.mc());
    const Index nc = numext::mini(n, blocking.nc());
 
    typedef typename TensorContractionKernel::LhsBlock LhsBlock;
    typedef typename TensorContractionKernel::RhsBlock RhsBlock;
 
    LhsBlock blockA;
    RhsBlock blockB;
 
    TensorContractionKernel kernel(m, k_slice, n, mc, kc, nc);
 
    typedef typename TensorContractionKernel::BlockMemHandle BlockMemHandle;
    const BlockMemHandle packed_mem = kernel.allocate(this->m_device, &blockA, &blockB);
 
    // If a contraction kernel does not support beta, explicitly initialize
    // output buffer with zeroes.
    if (!TensorContractionKernel::HasBeta) {
      this->m_device.fill(buffer, buffer + m * n, Scalar(0));
    }
 
    for (Index i2 = 0; i2 < m; i2 += mc) {
      const Index actual_mc = numext::mini(i2 + mc, m) - i2;
      for (Index k2 = k_start; k2 < k_end; k2 += kc) {
        // make sure we don't overshoot right edge of left matrix, then pack vertical panel
        const Index actual_kc = numext::mini(k2 + kc, k_end) - k2;
        kernel.packLhs(&blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
 
        // If kernel supports beta, there is no need to initialize output
        // buffer with zeroes.
        const Scalar alpha = Scalar(1);
        const Scalar beta = (TensorContractionKernel::HasBeta && k2 == k_start) ? Scalar(0) : Scalar(1);
 
        // series of horizontal blocks
        for (Index j2 = 0; j2 < n; j2 += nc) {
          // make sure we don't overshoot right edge of right matrix, then pack block
          const Index actual_nc = numext::mini(j2 + nc, n) - j2;
          kernel.packRhs(&blockB, rhs.getSubMapper(k2, j2), actual_kc, actual_nc);
 
          // call gebp (matrix kernel)
          // The parameters here are copied from Eigen's GEMM implementation
          const OutputMapper output_mapper = output.getSubMapper(i2, j2);
          kernel.invoke(output_mapper, blockA, blockB, actual_mc, actual_kc, actual_nc, alpha, beta);
 
          // We are done with this [i2, j2] output block.
          if (use_output_kernel && k2 + kc >= k_end) {
            m_output_kernel(output_mapper, m_tensor_contraction_params, i2, j2, actual_mc, actual_nc);
          }
        }
      }
    }
 
    kernel.deallocate(this->m_device, packed_mem);
  }

References alpha, beta, eigen_assert, Eigen::internal::TensorContractionBlocking< ResScalar, LhsScalar, RhsScalar, StorageIndex, ShardingType >::kc(), Eigen::internal::Lhs, m, Eigen::TensorContractionEvaluatorBase< Derived >::m_device, Eigen::TensorContractionEvaluatorBase< Derived >::m_i_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_i_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_j_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_j_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_k_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_k_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_left_contracting_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_left_nocontract_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_leftImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_output_kernel, Eigen::TensorContractionEvaluatorBase< Derived >::m_right_contracting_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_right_nocontract_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_rightImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_tensor_contraction_params, Eigen::internal::TensorContractionBlocking< ResScalar, LhsScalar, RhsScalar, StorageIndex, ShardingType >::mc(), Eigen::numext::mini(), n, Eigen::internal::TensorContractionBlocking< ResScalar, LhsScalar, RhsScalar, StorageIndex, ShardingType >::nc(), output(), Eigen::internal::Rhs, and Eigen::Unaligned.

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemm(), and Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartialWithoutOutputKernel().

evalGemmPartialWithoutOutputKernel()

template<typename Derived >

template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>

EIGEN_DEVICE_FUNC void Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartialWithoutOutputKernel ( Scalar *  buffer, Index  k_start, Index  k_end, int  num_threads  ) const

inline

                                                                                   {
    evalGemmPartial<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment,
                    /*use_output_kernel*/ false>(buffer, k_start, k_end, num_threads);
  }

References Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial().

evalGemv()

template<typename Derived >

template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>

EIGEN_DEVICE_FUNC void Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv ( Scalar *  buffer ) const

inline

                                     {
    const Index rows = m_i_size;
    const Index cols = m_k_size;
 
    typedef std::remove_const_t<typename EvalLeftArgType::Scalar> LhsScalar;
    typedef std::remove_const_t<typename EvalRightArgType::Scalar> RhsScalar;
    typedef TensorEvaluator<EvalLeftArgType, Device> LeftEvaluator;
    typedef TensorEvaluator<EvalRightArgType, Device> RightEvaluator;
    const Index lhs_packet_size = internal::unpacket_traits<typename LeftEvaluator::PacketReturnType>::size;
    const Index rhs_packet_size = internal::unpacket_traits<typename RightEvaluator::PacketReturnType>::size;
    const int lhs_alignment = LeftEvaluator::IsAligned ? Aligned : Unaligned;
    const int rhs_alignment = RightEvaluator::IsAligned ? Aligned : Unaligned;
    typedef internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
                                                   contract_t, lhs_packet_size, lhs_inner_dim_contiguous, false,
                                                   lhs_alignment>
        LhsMapper;
 
    typedef internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
                                                   contract_t, rhs_packet_size, rhs_inner_dim_contiguous,
                                                   rhs_inner_dim_reordered, rhs_alignment>
        RhsMapper;
 
    LhsMapper lhs(m_leftImpl, m_left_nocontract_strides, m_i_strides, m_left_contracting_strides, m_k_strides);
    RhsMapper rhs(m_rightImpl, m_right_nocontract_strides, m_j_strides, m_right_contracting_strides, m_k_strides);
 
    const Scalar alpha(1);
    const Index resIncr(1);
 
    // zero out the result buffer (which must be of size at least rows * sizeof(Scalar)
    m_device.fill(buffer, buffer + rows, Scalar(0));
 
    internal::general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, false, RhsScalar, RhsMapper,
                                            false>::run(rows, cols, lhs, rhs, buffer, resIncr, alpha);
 
    typedef internal::blas_data_mapper<Scalar, Index, ColMajor> OutputMapper;
    m_output_kernel(OutputMapper(buffer, rows), m_tensor_contraction_params, static_cast<Index>(0),
                    static_cast<Index>(0), rows, static_cast<Index>(1));
  }

References Eigen::Aligned, alpha, Eigen::ColMajor, cols, Eigen::internal::Lhs, Eigen::TensorContractionEvaluatorBase< Derived >::m_device, Eigen::TensorContractionEvaluatorBase< Derived >::m_i_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_i_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_j_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_k_size, Eigen::TensorContractionEvaluatorBase< Derived >::m_k_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_left_contracting_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_left_nocontract_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_leftImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_output_kernel, Eigen::TensorContractionEvaluatorBase< Derived >::m_right_contracting_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_right_nocontract_strides, Eigen::TensorContractionEvaluatorBase< Derived >::m_rightImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_tensor_contraction_params, Eigen::internal::Rhs, rows, Eigen::run(), and Eigen::Unaligned.

evalProductSequential()

template<typename Derived >

template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>

void Eigen::TensorContractionEvaluatorBase< Derived >::evalProductSequential ( Scalar *  buffer ) const

inline

                                                   {
    if (this->m_j_size == 1) {
      this->template evalGemv<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(
          buffer);
    } else {
      this->template evalGemm<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(
          buffer);
    }
  }

References Eigen::TensorContractionEvaluatorBase< Derived >::m_j_size.

evalSubExprsIfNeeded()

template<typename Derived >

EIGEN_STRONG_INLINE bool Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded ( EvaluatorPointerType  data )

inline

                                                                           {
    m_leftImpl.evalSubExprsIfNeeded(NULL);
    m_rightImpl.evalSubExprsIfNeeded(NULL);
    if (data) {
      evalTo(data);
      return false;
    } else {
      m_result = static_cast<EvaluatorPointerType>(m_device.allocate(dimensions().TotalSize() * sizeof(Scalar)));
      evalTo(m_result);
      return true;
    }
  }

References Eigen::TensorContractionEvaluatorBase< Derived >::data(), Eigen::TensorContractionEvaluatorBase< Derived >::dimensions(), Eigen::TensorEvaluator< Derived, Device >::evalSubExprsIfNeeded(), Eigen::TensorContractionEvaluatorBase< Derived >::evalTo(), Eigen::TensorContractionEvaluatorBase< Derived >::m_device, Eigen::TensorContractionEvaluatorBase< Derived >::m_leftImpl, Eigen::TensorContractionEvaluatorBase< Derived >::m_result, and Eigen::TensorContractionEvaluatorBase< Derived >::m_rightImpl.

evalTo()

template<typename Derived >

EIGEN_DEVICE_FUNC void Eigen::TensorContractionEvaluatorBase< Derived >::evalTo ( Scalar *  buffer ) const

inline

                                                      {
    static_cast<const Derived*>(this)->template evalProduct<Unaligned>(buffer);
  }

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded().

packet()

template<typename Derived >

template<int LoadMode>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType Eigen::TensorContractionEvaluatorBase< Derived >::packet ( Index  index ) const

inline

                                                                                   {
    return internal::ploadt<PacketReturnType, LoadMode>(m_result + index);
  }

References Eigen::TensorContractionEvaluatorBase< Derived >::m_result.

Member Data Documentation

ContractDims

template<typename Derived >

constexpr int Eigen::TensorContractionEvaluatorBase< Derived >::ContractDims = internal::array_size<Indices>::value

staticconstexpr

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

Layout

template<typename Derived >

constexpr int Eigen::TensorContractionEvaluatorBase< Derived >::Layout = TensorEvaluator<LeftArgType, Device>::Layout

staticconstexpr

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

LDims

template<typename Derived >

constexpr int Eigen::TensorContractionEvaluatorBase< Derived >::LDims

staticconstexpr

Initial value:

=
      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_device

template<typename Derived >

const Device EIGEN_DEVICE_REF Eigen::TensorContractionEvaluatorBase< Derived >::m_device

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::cleanup(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded().

m_dimensions

template<typename Derived >

Dimensions Eigen::TensorContractionEvaluatorBase< Derived >::m_dimensions

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::dimensions(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_i_size

template<typename Derived >

Index Eigen::TensorContractionEvaluatorBase< Derived >::m_i_size

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_i_strides

template<typename Derived >

left_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_i_strides

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_j_size

template<typename Derived >

Index Eigen::TensorContractionEvaluatorBase< Derived >::m_j_size

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalProductSequential(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_j_strides

template<typename Derived >

right_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_j_strides

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_k_size

template<typename Derived >

Index Eigen::TensorContractionEvaluatorBase< Derived >::m_k_size

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemm(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_k_strides

template<typename Derived >

contract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_k_strides

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_left_contracting_strides

template<typename Derived >

contract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_left_contracting_strides

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_left_nocontract_strides

template<typename Derived >

left_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_left_nocontract_strides

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_leftImpl

template<typename Derived >

TensorEvaluator<EvalLeftArgType, Device> Eigen::TensorContractionEvaluatorBase< Derived >::m_leftImpl

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::cleanup(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_lhs_inner_dim_contiguous

template<typename Derived >

bool Eigen::TensorContractionEvaluatorBase< Derived >::m_lhs_inner_dim_contiguous

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_output_kernel

template<typename Derived >

OutputKernelType Eigen::TensorContractionEvaluatorBase< Derived >::m_output_kernel

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), and Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv().

m_result

template<typename Derived >

EvaluatorPointerType Eigen::TensorContractionEvaluatorBase< Derived >::m_result

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::cleanup(), Eigen::TensorContractionEvaluatorBase< Derived >::coeff(), Eigen::TensorContractionEvaluatorBase< Derived >::data(), Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded(), and Eigen::TensorContractionEvaluatorBase< Derived >::packet().

m_rhs_inner_dim_contiguous

template<typename Derived >

bool Eigen::TensorContractionEvaluatorBase< Derived >::m_rhs_inner_dim_contiguous

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_rhs_inner_dim_reordered

template<typename Derived >

bool Eigen::TensorContractionEvaluatorBase< Derived >::m_rhs_inner_dim_reordered

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_right_contracting_strides

template<typename Derived >

contract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_right_contracting_strides

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_right_nocontract_strides

template<typename Derived >

right_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_right_nocontract_strides

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_rightImpl

template<typename Derived >

TensorEvaluator<EvalRightArgType, Device> Eigen::TensorContractionEvaluatorBase< Derived >::m_rightImpl

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::cleanup(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), Eigen::TensorContractionEvaluatorBase< Derived >::evalSubExprsIfNeeded(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

m_tensor_contraction_params

template<typename Derived >

TensorContractionParams Eigen::TensorContractionEvaluatorBase< Derived >::m_tensor_contraction_params

protected

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), and Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

NumDims

template<typename Derived >

constexpr int Eigen::TensorContractionEvaluatorBase< Derived >::NumDims = LDims + RDims - 2 * ContractDims

staticconstexpr

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

RDims

template<typename Derived >

constexpr int Eigen::TensorContractionEvaluatorBase< Derived >::RDims

staticconstexpr

Initial value:

=
      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value

Referenced by Eigen::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase().

---

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

• TensorContraction.h