#include <TensorBlock.h>

Public Types
typedef DSizes< IndexType, NumDims >	Dimensions

Public Member Functions
	TensorBlockMapper ()=default

	TensorBlockMapper (const DSizes< IndexType, NumDims > &dimensions, const TensorBlockResourceRequirements &requirements)

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType	blockCount () const

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType	blockTotalSize () const

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const DSizes< IndexType, NumDims > &	blockDimensions () const

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockDescriptor	blockDescriptor (IndexType block_index) const

Private Types
typedef TensorBlockDescriptor< NumDims, IndexType >	BlockDescriptor

Private Member Functions
void	InitializeBlockDimensions ()

Private Attributes
DSizes< IndexType, NumDims >	m_tensor_dimensions

TensorBlockResourceRequirements	m_requirements

DSizes< IndexType, NumDims >	m_block_dimensions

IndexType	m_total_block_count

DSizes< IndexType, NumDims >	m_tensor_strides

DSizes< IndexType, NumDims >	m_block_strides

Member Typedef Documentation

◆ BlockDescriptor

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

typedef TensorBlockDescriptor<NumDims, IndexType> Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::BlockDescriptor

private

◆ Dimensions

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

typedef DSizes<IndexType, NumDims> Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::Dimensions

Constructor & Destructor Documentation

◆ TensorBlockMapper() [1/2]

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::TensorBlockMapper ( )

default

◆ TensorBlockMapper() [2/2]

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::TensorBlockMapper	(	const DSizes< IndexType, NumDims > &	dimensions,
		const TensorBlockResourceRequirements &	requirements
	)

inline

       : m_tensor_dimensions(dimensions), m_requirements(requirements) {
     // Compute block dimensions and the total number of blocks.
     InitializeBlockDimensions();
   }

References Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::InitializeBlockDimensions().

Member Function Documentation

◆ blockCount()

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::blockCount ( ) const

inline

327 { return m_total_block_count; }

Eigen::internal::TensorBlockMapper::m_total_block_count

IndexType m_total_block_count

Definition: TensorBlock.h:459

References Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::m_total_block_count.

Referenced by Eigen::internal::TensorExecutor< Expression, DefaultDevice, Vectorizable, TiledEvaluation::On >::run().

◆ blockDescriptor()

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockDescriptor Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::blockDescriptor ( IndexType block_index ) const

inline

                                                                                                      {
     static const bool isColMajor = Layout == static_cast<int>(ColMajor);
  
     IndexType offset = 0;
     DSizes<IndexType, NumDims> dimensions;
  
     if (NumDims == 0) return BlockDescriptor(offset, dimensions);
  
     // Iterate outer -> inner dimensions.
     for (int i = NumDims - 1; i >= 0; --i) {
       const int dim = isColMajor ? i : NumDims - i - 1;
  
       const IndexType idx = block_index / m_block_strides[dim];
       block_index -= idx * m_block_strides[dim];
  
       const IndexType coord = idx * m_block_dimensions[dim];
       dimensions[dim] = numext::mini(m_tensor_dimensions[dim] - coord, m_block_dimensions[dim]);
       offset += coord * m_tensor_strides[dim];
     }
  
     return {offset, dimensions};
   }

References Eigen::ColMajor, i, Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::m_block_dimensions, Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::m_block_strides, Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::m_tensor_dimensions, Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::m_tensor_strides, and Eigen::numext::mini().

Referenced by Eigen::internal::TensorExecutor< Expression, DefaultDevice, Vectorizable, TiledEvaluation::On >::run().

◆ blockDimensions()

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const DSizes<IndexType, NumDims>& Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::blockDimensions ( ) const

inline

                                                                                                   {
     return m_block_dimensions;
   }

References Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::m_block_dimensions.

◆ blockTotalSize()

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::blockTotalSize ( ) const

inline

329 { return m_block_dimensions.TotalSize(); }

Eigen::DSizes::TotalSize

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex TotalSize() const

Definition: TensorDimensions.h:167

References Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::m_block_dimensions, and Eigen::DSizes< DenseIndex, NumDims >::TotalSize().

◆ InitializeBlockDimensions()

template<int NumDims, int Layout, typename IndexType = Eigen::Index>

void Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::InitializeBlockDimensions ( )

inlineprivate

                                    {
     // Requested block shape and size.
     const TensorBlockShapeType shape_type = m_requirements.shape_type;
     IndexType target_block_size = numext::maxi<IndexType>(1, static_cast<IndexType>(m_requirements.size));
  
     IndexType tensor_size = m_tensor_dimensions.TotalSize();
  
     // Corner case: one of the dimensions is zero. Logic below is too complex
     // to handle this case on a general basis, just use unit block size.
     // Note: we must not yield blocks with zero dimensions (recipe for
     // overflows/underflows, divisions by zero and NaNs later).
     if (tensor_size == 0) {
       for (int i = 0; i < NumDims; ++i) {
         m_block_dimensions[i] = 1;
       }
       m_total_block_count = 0;
       return;
     }
  
     // If tensor fits into a target block size, evaluate it as a single block.
     if (tensor_size <= target_block_size) {
       m_block_dimensions = m_tensor_dimensions;
       m_total_block_count = 1;
       // The only valid block index is `0`, and in this case we do not need
       // to compute real strides for tensor or blocks (see blockDescriptor).
       for (int i = 0; i < NumDims; ++i) {
         m_tensor_strides[i] = 0;
         m_block_strides[i] = 1;
       }
       return;
     }
  
     static const bool isColMajor = Layout == static_cast<int>(ColMajor);
  
     // Block shape skewed towards inner dimension.
     if (shape_type == TensorBlockShapeType::kSkewedInnerDims) {
       IndexType coeff_to_allocate = target_block_size;
  
       for (int i = 0; i < NumDims; ++i) {
         const int dim = isColMajor ? i : NumDims - i - 1;
         m_block_dimensions[dim] = numext::mini(coeff_to_allocate, m_tensor_dimensions[dim]);
         coeff_to_allocate =
             numext::div_ceil(coeff_to_allocate, numext::maxi(static_cast<IndexType>(1), m_block_dimensions[dim]));
       }
       eigen_assert(coeff_to_allocate == 1);
  
     } else if (shape_type == TensorBlockShapeType::kUniformAllDims) {
       // Tensor will not fit within 'target_block_size' budget: calculate tensor
       // block dimension sizes based on "square" dimension size target.
       const IndexType dim_size_target = convert_index<IndexType>(
           std::pow(static_cast<float>(target_block_size), 1.0f / static_cast<float>(m_block_dimensions.rank())));
  
       for (int i = 0; i < NumDims; ++i) {
         // TODO(andydavis) Adjust the inner most 'block_dim_size' to make it
         // a multiple of the packet size. Note that reducing
         // 'block_dim_size' in this manner can increase the number of
         // blocks, and so will amplify any per-block overhead.
         m_block_dimensions[i] = numext::mini(dim_size_target, m_tensor_dimensions[i]);
       }
  
       // Add any un-allocated coefficients to inner dimension(s).
       IndexType total_size = m_block_dimensions.TotalSize();
       for (int i = 0; i < NumDims; ++i) {
         const int dim = isColMajor ? i : NumDims - i - 1;
  
         if (m_block_dimensions[dim] < m_tensor_dimensions[dim]) {
           const IndexType total_size_other_dims = total_size / m_block_dimensions[dim];
           const IndexType alloc_avail = numext::div_ceil<IndexType>(target_block_size, total_size_other_dims);
           if (alloc_avail == m_block_dimensions[dim]) {
             // Insufficient excess coefficients to allocate.
             break;
           }
           m_block_dimensions[dim] = numext::mini(m_tensor_dimensions[dim], alloc_avail);
           total_size = total_size_other_dims * m_block_dimensions[dim];
         }
       }
  
     } else {
       eigen_assert(false);  // unknown block shape
     }
  
     eigen_assert(m_block_dimensions.TotalSize() >=
                  numext::mini<IndexType>(target_block_size, m_tensor_dimensions.TotalSize()));
  
     // Calculate block counts by dimension and total block count.
     DSizes<IndexType, NumDims> block_count;
     for (int i = 0; i < NumDims; ++i) {
       block_count[i] = numext::div_ceil(m_tensor_dimensions[i], m_block_dimensions[i]);
     }
     m_total_block_count = array_prod(block_count);
  
     // Calculate block strides (used for enumerating blocks).
     m_tensor_strides = strides<Layout>(m_tensor_dimensions);
     m_block_strides = strides<Layout>(block_count);
   }