Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar > Struct Template Reference

#include <TensorContraction.h>

Classes
struct	BlockSizes

Public Types
typedef void *	BlockMemHandle

Static Public Member Functions
template<typename Device >
static EIGEN_DEVICE_FUNC BlockMemHandle	allocate (Device &d, const Index bm, const Index bk, const Index bn, LhsScalar **lhs_block, RhsScalar **rhs_block)
template<typename Device >
static EIGEN_DEVICE_FUNC BlockMemHandle	allocateSlices (Device &d, const Index bm, const Index bk, const Index bn, const Index num_lhs, const Index num_rhs, const Index num_slices, std::vector< LhsScalar * > *lhs_blocks, std::vector< RhsScalar * > *rhs_blocks)
template<typename Device >
static EIGEN_DEVICE_FUNC void	deallocate (Device &d, BlockMemHandle handle)

Static Private Member Functions
static EIGEN_DEVICE_FUNC BlockSizes	ComputeLhsRhsBlockSizes (const Index bm, const Index bk, const Index bn)

Member Typedef Documentation

BlockMemHandle

template<typename LhsScalar , typename RhsScalar >

typedef void* Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::BlockMemHandle

Member Function Documentation

allocate()

template<typename LhsScalar , typename RhsScalar >

template<typename Device >

static EIGEN_DEVICE_FUNC BlockMemHandle Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::allocate ( Device &  d, const Index  bm, const Index  bk, const Index  bn, LhsScalar **  lhs_block, RhsScalar **  rhs_block  )

inlinestatic

                                                                                                 {
    eigen_assert(lhs_block);
    eigen_assert(rhs_block);
    BlockSizes sz = ComputeLhsRhsBlockSizes(bm, bk, bn);
    char* block_mem = static_cast<char*>(d.allocate(sz.lhs_size + sz.rhs_size));
    *lhs_block = static_cast<LhsScalar*>(static_cast<void*>(block_mem));
    *rhs_block = static_cast<RhsScalar*>(static_cast<void*>(block_mem + sz.lhs_size));
    return block_mem;
  }

References Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::ComputeLhsRhsBlockSizes(), eigen_assert, Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::BlockSizes::lhs_size, and Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::BlockSizes::rhs_size.

Referenced by Eigen::internal::TensorContractionKernel< ResScalar, LhsScalar, RhsScalar, StorageIndex, OutputMapper, LhsMapper, RhsMapper >::allocate().

allocateSlices()

template<typename LhsScalar , typename RhsScalar >

template<typename Device >

static EIGEN_DEVICE_FUNC BlockMemHandle Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::allocateSlices ( Device &  d, const Index  bm, const Index  bk, const Index  bn, const Index  num_lhs, const Index  num_rhs, const Index  num_slices, std::vector< LhsScalar * > *  lhs_blocks, std::vector< RhsScalar * > *  rhs_blocks  )

inlinestatic

                                                                                            {
    eigen_assert(num_slices > 0);
    eigen_assert(num_lhs >= 0 && num_rhs >= 0);
    eigen_assert(num_lhs == 0 || lhs_blocks);
    eigen_assert(num_rhs == 0 || rhs_blocks);
    BlockSizes sz = ComputeLhsRhsBlockSizes(bm, bk, bn);
    void* block_mem = d.allocate((num_lhs * sz.lhs_size + num_rhs * sz.rhs_size) * num_slices);
    eigen_assert(block_mem);
    char* mem = static_cast<char*>(block_mem);
 
    for (Index x = 0; x < num_slices; x++) {
      if (num_lhs > 0) lhs_blocks[x].resize(num_lhs);
      for (Index m = 0; m < num_lhs; m++) {
        lhs_blocks[x][m] = static_cast<LhsScalar*>(static_cast<void*>(mem));
        mem += sz.lhs_size;
      }
      if (num_rhs > 0) rhs_blocks[x].resize(num_rhs);
      for (Index n = 0; n < num_rhs; n++) {
        rhs_blocks[x][n] = static_cast<RhsScalar*>(static_cast<void*>(mem));
        mem += sz.rhs_size;
      }
    }
 
    return block_mem;
  }

References Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::ComputeLhsRhsBlockSizes(), eigen_assert, Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::BlockSizes::lhs_size, m, n, Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::BlockSizes::rhs_size, and plotDoE::x.

Referenced by Eigen::internal::TensorContractionKernel< ResScalar, LhsScalar, RhsScalar, StorageIndex, OutputMapper, LhsMapper, RhsMapper >::allocateSlices().

ComputeLhsRhsBlockSizes()

template<typename LhsScalar , typename RhsScalar >

static EIGEN_DEVICE_FUNC BlockSizes Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::ComputeLhsRhsBlockSizes ( const Index  bm, const Index  bk, const Index  bn  )

inlinestaticprivate

                                                                                                              {
    Index align = numext::maxi(EIGEN_MAX_ALIGN_BYTES, 1);
    BlockSizes sz;
    sz.lhs_size = numext::div_ceil<Index>(bm * bk * sizeof(LhsScalar), align) * align;
    sz.rhs_size = numext::div_ceil<Index>(bn * bk * sizeof(RhsScalar), align) * align;
    return sz;
  }

References EIGEN_MAX_ALIGN_BYTES, Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::BlockSizes::lhs_size, Eigen::numext::maxi(), and Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::BlockSizes::rhs_size.

Referenced by Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::allocate(), and Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::allocateSlices().

deallocate()

template<typename LhsScalar , typename RhsScalar >

template<typename Device >

static EIGEN_DEVICE_FUNC void Eigen::internal::TensorContractionBlockMemAllocator< LhsScalar, RhsScalar >::deallocate ( Device &  d, BlockMemHandle  handle  )

inlinestatic

                                                                             {
    d.deallocate(handle);
  }

Referenced by Eigen::internal::TensorContractionKernel< ResScalar, LhsScalar, RhsScalar, StorageIndex, OutputMapper, LhsMapper, RhsMapper >::deallocate().

---

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

• TensorContraction.h