Public Types
enum	{ IsAligned , PacketAccess , BlockAccess , PreferBlockAccess , CoordAccess , RawAccess }

typedef XprType::CoeffReturnType	CoeffReturnType

typedef array< Index, ContractDims >	contract_t

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

typedef DSizes< Index, NumDims >	Dimensions

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 Storage::Type	EvaluatorPointerType

typedef XprType::Index	Index

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

typedef array< Index, LDims - ContractDims >	left_nocontract_t

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

typedef TensorEvaluator< EvalLeftArgType, Device >	LeftEvaluatorType

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

typedef PacketType< CoeffReturnType, Device >::type	PacketReturnType

typedef array< Index, RDims - ContractDims >	right_nocontract_t

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

typedef TensorEvaluator< EvalRightArgType, Device >	RightEvaluatorType

typedef std::remove_const_t< typename XprType::Scalar >	Scalar

typedef StorageMemory< Scalar, Device >	Storage

typedef internal::TensorBlockNotImplemented	TensorBlock

typedef TensorContractionOp< Indices, LeftArgType, RightArgType, OutputKernelType >	XprType

Public Member Functions
void	cleanup ()

CoeffReturnType	coeff (Index index) const

TensorOpCost	costPerCoeff (bool) const

EvaluatorPointerType	data () const

const Dimensions &	dimensions () const

template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
void	evalGemm (Scalar *buffer) const

template<bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment, bool use_output_kernel>
void	evalGemmPartial (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>
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>
void	evalGemv (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

bool	evalSubExprsIfNeeded (EvaluatorPointerType data)

void	evalTo (Scalar *buffer) const

template<int LoadMode>
PacketReturnType	packet (Index index) const

	TensorContractionEvaluatorBase (const XprType &op, const Device &device)

Static Public Attributes
static constexpr int	ContractDims

static constexpr int	Layout

static constexpr int	LDims

static constexpr int	NumDims

static constexpr int	RDims

Detailed Description

template<typename Derived>
struct Eigen::TensorContractionEvaluatorBase< Derived >

Definition at line 365 of file TensorContraction.h.

Member Typedef Documentation

◆ CoeffReturnType

template<typename Derived >

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

Definition at line 375 of file TensorContraction.h.

◆ contract_t

template<typename Derived >

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

Definition at line 413 of file TensorContraction.h.

◆ Device

template<typename Derived >

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

Definition at line 370 of file TensorContraction.h.

◆ Dimensions

template<typename Derived >

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

Definition at line 417 of file TensorContraction.h.

◆ EvalLeftArgType

template<typename Derived >

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

Definition at line 399 of file TensorContraction.h.

◆ EvalRightArgType

template<typename Derived >

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

Definition at line 401 of file TensorContraction.h.

◆ EvaluatorPointerType

template<typename Derived >

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

Definition at line 378 of file TensorContraction.h.

◆ Index

template<typename Derived >

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

Definition at line 374 of file TensorContraction.h.

◆ Indices

template<typename Derived >

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

Definition at line 366 of file TensorContraction.h.

◆ left_nocontract_t

template<typename Derived >

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

Definition at line 414 of file TensorContraction.h.

◆ LeftArgType

template<typename Derived >

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

Definition at line 367 of file TensorContraction.h.

◆ LeftEvaluatorType

template<typename Derived >

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

Definition at line 403 of file TensorContraction.h.

◆ OutputKernelType

template<typename Derived >

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

Definition at line 369 of file TensorContraction.h.

◆ PacketReturnType

template<typename Derived >

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

Definition at line 376 of file TensorContraction.h.

◆ right_nocontract_t

template<typename Derived >

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

Definition at line 415 of file TensorContraction.h.

◆ RightArgType

template<typename Derived >

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

Definition at line 368 of file TensorContraction.h.

◆ RightEvaluatorType

template<typename Derived >

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

Definition at line 404 of file TensorContraction.h.

◆ Scalar

template<typename Derived >

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

Definition at line 373 of file TensorContraction.h.

◆ Storage

template<typename Derived >

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

Definition at line 377 of file TensorContraction.h.

◆ TensorBlock

template<typename Derived >

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

Definition at line 391 of file TensorContraction.h.

◆ XprType

template<typename Derived >

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

Definition at line 372 of file TensorContraction.h.

Member Enumeration Documentation

◆ anonymous enum

template<typename Derived >

anonymous enum

Enumerator
IsAligned
PacketAccess
BlockAccess
PreferBlockAccess
CoordAccess
RawAccess

Definition at line 381 of file TensorContraction.h.

        {
     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::TensorContractionEvaluatorBase< Derived >::TensorContractionEvaluatorBase	(	const XprType &	op,
		const Device &	device
	)

inline

Definition at line 420 of file TensorContraction.h.

       : 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;
   }

Member Function Documentation

◆ cleanup()

template<typename Derived >

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

inline

Definition at line 914 of file TensorContraction.h.

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

◆ coeff()

template<typename Derived >

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

inline

Definition at line 924 of file TensorContraction.h.

                                                                                  {
     return m_result[index];
   }

◆ costPerCoeff()

template<typename Derived >

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

inline

Definition at line 928 of file TensorContraction.h.

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

◆ data()

template<typename Derived >

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

inline

Definition at line 937 of file TensorContraction.h.

937 { return m_result; }

◆ dimensions()

template<typename Derived >

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

inline

Definition at line 602 of file TensorContraction.h.

602 { return m_dimensions; }

◆ evalGemm()

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 >::evalGemm ( Scalar * buffer ) const

inline

Definition at line 780 of file TensorContraction.h.

                                       {
     // 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);
   }

◆ 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>

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

inline

Definition at line 800 of file TensorContraction.h.

                                                                                                             {
     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);
   }

◆ evalGemmPartialWithoutOutputKernel()

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 >::evalGemmPartialWithoutOutputKernel	(	Scalar *	buffer,
		Index	k_start,
		Index	k_end,
		int	num_threads
	)		const

inline

Definition at line 791 of file TensorContraction.h.

                                                                          {
     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);
   }

◆ evalGemv()

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 >::evalGemv ( Scalar * buffer ) const

inline

Definition at line 731 of file TensorContraction.h.

                                       {
     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));
   }

◆ 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

Definition at line 716 of file TensorContraction.h.

                                                    {
     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);
     }
   }

◆ evalSubExprsIfNeeded()

template<typename Derived >

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

inline

Definition at line 604 of file TensorContraction.h.

                                                                            {
     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;
     }
   }

◆ evalTo()

template<typename Derived >

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

inline

Definition at line 701 of file TensorContraction.h.

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

◆ packet()

template<typename Derived >

template<int LoadMode>

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

inline

Definition at line 933 of file TensorContraction.h.

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

Member Data Documentation

◆ ContractDims

template<typename Derived >

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

staticconstexpr

Definition at line 410 of file TensorContraction.h.

◆ Layout

template<typename Derived >

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

staticconstexpr

Definition at line 380 of file TensorContraction.h.

◆ LDims

template<typename Derived >

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

staticconstexpr

Definition at line 406 of file TensorContraction.h.

◆ m_device

template<typename Derived >

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

protected

Definition at line 963 of file TensorContraction.h.

◆ m_dimensions

template<typename Derived >

Dimensions Eigen::TensorContractionEvaluatorBase< Derived >::m_dimensions

protected

Definition at line 940 of file TensorContraction.h.

◆ m_i_size

template<typename Derived >

Index Eigen::TensorContractionEvaluatorBase< Derived >::m_i_size

protected

Definition at line 955 of file TensorContraction.h.

◆ m_i_strides

template<typename Derived >

left_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_i_strides

protected

Definition at line 950 of file TensorContraction.h.

◆ m_j_size

template<typename Derived >

Index Eigen::TensorContractionEvaluatorBase< Derived >::m_j_size

protected

Definition at line 956 of file TensorContraction.h.

◆ m_j_strides

template<typename Derived >

right_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_j_strides

protected

Definition at line 951 of file TensorContraction.h.

◆ m_k_size

template<typename Derived >

Index Eigen::TensorContractionEvaluatorBase< Derived >::m_k_size

protected

Definition at line 957 of file TensorContraction.h.

◆ m_k_strides

template<typename Derived >

contract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_k_strides

protected

Definition at line 942 of file TensorContraction.h.

◆ m_left_contracting_strides

template<typename Derived >

contract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_left_contracting_strides

protected

Definition at line 943 of file TensorContraction.h.

◆ m_left_nocontract_strides

template<typename Derived >

left_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_left_nocontract_strides

protected

Definition at line 952 of file TensorContraction.h.

◆ m_leftImpl

template<typename Derived >

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

protected

Definition at line 961 of file TensorContraction.h.

◆ m_lhs_inner_dim_contiguous

template<typename Derived >

bool Eigen::TensorContractionEvaluatorBase< Derived >::m_lhs_inner_dim_contiguous

protected

Definition at line 946 of file TensorContraction.h.

◆ m_output_kernel

template<typename Derived >

OutputKernelType Eigen::TensorContractionEvaluatorBase< Derived >::m_output_kernel

protected

Definition at line 964 of file TensorContraction.h.

◆ m_result

template<typename Derived >

EvaluatorPointerType Eigen::TensorContractionEvaluatorBase< Derived >::m_result

protected

Definition at line 965 of file TensorContraction.h.

◆ m_rhs_inner_dim_contiguous

template<typename Derived >

bool Eigen::TensorContractionEvaluatorBase< Derived >::m_rhs_inner_dim_contiguous

protected

Definition at line 947 of file TensorContraction.h.

◆ m_rhs_inner_dim_reordered

template<typename Derived >

bool Eigen::TensorContractionEvaluatorBase< Derived >::m_rhs_inner_dim_reordered

protected

Definition at line 948 of file TensorContraction.h.

◆ m_right_contracting_strides

template<typename Derived >

contract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_right_contracting_strides

protected

Definition at line 944 of file TensorContraction.h.

◆ m_right_nocontract_strides

template<typename Derived >

right_nocontract_t Eigen::TensorContractionEvaluatorBase< Derived >::m_right_nocontract_strides

protected

Definition at line 953 of file TensorContraction.h.

◆ m_rightImpl

template<typename Derived >

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

protected

Definition at line 962 of file TensorContraction.h.

◆ m_tensor_contraction_params

template<typename Derived >

TensorContractionParams Eigen::TensorContractionEvaluatorBase< Derived >::m_tensor_contraction_params

protected

Definition at line 959 of file TensorContraction.h.

◆ NumDims

template<typename Derived >

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

staticconstexpr

Definition at line 411 of file TensorContraction.h.

◆ RDims

template<typename Derived >

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

staticconstexpr

Definition at line 408 of file TensorContraction.h.

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

TensorContraction.h

Protected Attributes
const Device EIGEN_DEVICE_REF	m_device

Dimensions	m_dimensions

Index	m_i_size

left_nocontract_t	m_i_strides

Index	m_j_size

right_nocontract_t	m_j_strides

Index	m_k_size

contract_t	m_k_strides

contract_t	m_left_contracting_strides

left_nocontract_t	m_left_nocontract_strides

TensorEvaluator< EvalLeftArgType, Device >	m_leftImpl

bool	m_lhs_inner_dim_contiguous

OutputKernelType	m_output_kernel

EvaluatorPointerType	m_result

bool	m_rhs_inner_dim_contiguous

bool	m_rhs_inner_dim_reordered

contract_t	m_right_contracting_strides

right_nocontract_t	m_right_nocontract_strides

TensorEvaluator< EvalRightArgType, Device >	m_rightImpl

TensorContractionParams	m_tensor_contraction_params

Public Types

Public Member Functions

Static Public Attributes

Protected Attributes

Detailed Description

template<typename Derived> struct Eigen::TensorContractionEvaluatorBase< Derived >

Member Typedef Documentation

◆ CoeffReturnType

◆ contract_t

◆ Device

◆ Dimensions

◆ EvalLeftArgType

◆ EvalRightArgType

◆ EvaluatorPointerType

◆ Index

◆ Indices

◆ left_nocontract_t

◆ LeftArgType

◆ LeftEvaluatorType

◆ OutputKernelType

◆ PacketReturnType

◆ right_nocontract_t

◆ RightArgType

◆ RightEvaluatorType

◆ Scalar

◆ Storage

◆ TensorBlock

◆ XprType

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ TensorContractionEvaluatorBase()

Member Function Documentation

◆ cleanup()

◆ coeff()

◆ costPerCoeff()

◆ data()

◆ dimensions()

◆ evalGemm()

◆ evalGemmPartial()

◆ evalGemmPartialWithoutOutputKernel()

◆ evalGemv()

◆ evalProductSequential()

◆ evalSubExprsIfNeeded()

◆ evalTo()

◆ packet()

Member Data Documentation

◆ ContractDims

◆ Layout

◆ LDims

◆ m_device

◆ m_dimensions

◆ m_i_size

◆ m_i_strides

◆ m_j_size

◆ m_j_strides

◆ m_k_size

◆ m_k_strides

◆ m_left_contracting_strides

◆ m_left_nocontract_strides

◆ m_leftImpl

◆ m_lhs_inner_dim_contiguous

◆ m_output_kernel

◆ m_result

◆ m_rhs_inner_dim_contiguous

◆ m_rhs_inner_dim_reordered

◆ m_right_contracting_strides

◆ m_right_nocontract_strides

◆ m_rightImpl

◆ m_tensor_contraction_params

◆ NumDims

◆ RDims

template<typename Derived>
struct Eigen::TensorContractionEvaluatorBase< Derived >