Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType > Class Template Reference

#include <TensorBlock.h>

Classes
class	Storage

Public Types
typedef DSizes< IndexType, NumDims >	Dimensions
typedef TensorMap< const Tensor< Scalar, NumDims, Layout > >	XprType
typedef internal::TensorBlockDescriptor< NumDims, IndexType >	TensorBlockDesc

Public Member Functions
	TensorMaterializedBlock (TensorBlockKind kind, const Scalar *data, const Dimensions &dimensions, bool valid_expr=true)
TensorBlockKind	kind () const
const XprType &	expr () const
const Scalar *	data () const
void	cleanup ()

Static Public Member Functions
template<typename TensorBlockScratch >
static EIGEN_STRONG_INLINE Storage	prepareStorage (TensorBlockDesc &desc, TensorBlockScratch &scratch, bool allow_strided_storage=false)
template<typename DataDimensions , typename TensorBlockScratch >
static EIGEN_STRONG_INLINE TensorMaterializedBlock	materialize (const Scalar *data, const DataDimensions &data_dims, TensorBlockDesc &desc, TensorBlockScratch &scratch)

Private Attributes
TensorBlockKind	m_kind
const Scalar *	m_data
Dimensions	m_dimensions
XprType	m_expr
bool	m_valid_expr

Member Typedef Documentation

Dimensions

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

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

TensorBlockDesc

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

typedef internal::TensorBlockDescriptor<NumDims, IndexType> Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::TensorBlockDesc

XprType

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

typedef TensorMap<const Tensor<Scalar, NumDims, Layout> > Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::XprType

Constructor & Destructor Documentation

TensorMaterializedBlock()

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

Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::TensorMaterializedBlock ( TensorBlockKind  kind, const Scalar *  data, const Dimensions &  dimensions, bool  valid_expr = true  )

inline

      : m_kind(kind), m_data(data), m_dimensions(dimensions), m_expr(m_data, m_dimensions), m_valid_expr(valid_expr) {
    eigen_assert(m_kind == internal::TensorBlockKind::kView ||
                 m_kind == internal::TensorBlockKind::kMaterializedInScratch ||
                 m_kind == internal::TensorBlockKind::kMaterializedInOutput);
  }

References eigen_assert, Eigen::internal::kMaterializedInOutput, Eigen::internal::kMaterializedInScratch, Eigen::internal::kView, and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_kind.

Referenced by Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::Storage::AsTensorMaterializedBlock(), and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::materialize().

Member Function Documentation

cleanup()

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

void Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::cleanup ( )

inline

{}

Referenced by framework.Frame::__init__(), Eigen::TensorEvaluator< const TensorAssignOp< LeftArgType, RightArgType >, Device >::evalBlock(), and Eigen::TensorEvaluator< const TensorEvalToOp< ArgType, MakePointer_ >, Device >::evalBlock().

data()

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

const Scalar* Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::data ( ) const

inline

{ return m_data; }

References Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_data.

Referenced by Eigen::TensorEvaluator< const TensorChippingOp< DimId, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorBroadcastingOp< Broadcast, ArgType >, Device >::BroadcastBlock(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::materialize(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), gdb.printers.EigenQuaternionPrinter::to_string(), and Eigen::TensorEvaluator< TensorShufflingOp< Shuffle, ArgType >, Device >::writeBlock().

expr()

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

const XprType& Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::expr ( ) const

inline

                              {
    eigen_assert(m_valid_expr);
    return m_expr;
  }

References eigen_assert, Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_expr, and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_valid_expr.

Referenced by Eigen::TensorEvaluator< const TensorChippingOp< DimId, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorBroadcastingOp< Broadcast, ArgType >, Device >::BroadcastBlock(), Eigen::TensorEvaluator< const TensorEvalToOp< ArgType, MakePointer_ >, Device >::evalBlock(), Eigen::TensorEvaluator< TensorChippingOp< DimId, ArgType >, Device >::writeBlock(), Eigen::TensorEvaluator< Derived, Device >::writeBlock(), Eigen::TensorEvaluator< TensorReshapingOp< NewDimensions, ArgType >, Device >::writeBlock(), and Eigen::TensorEvaluator< TensorShufflingOp< Shuffle, ArgType >, Device >::writeBlock().

kind()

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

TensorBlockKind Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::kind ( ) const

inline

{ return m_kind; }

References Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_kind.

Referenced by Eigen::TensorEvaluator< const TensorChippingOp< DimId, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorAssignOp< LeftArgType, RightArgType >, Device >::evalBlock(), and Eigen::TensorEvaluator< const TensorEvalToOp< ArgType, MakePointer_ >, Device >::evalBlock().

materialize()

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

template<typename DataDimensions , typename TensorBlockScratch >

static EIGEN_STRONG_INLINE TensorMaterializedBlock Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::materialize ( const Scalar *  data, const DataDimensions &  data_dims, TensorBlockDesc &  desc, TensorBlockScratch &  scratch  )

inlinestatic

                                                                                                                     {
    eigen_assert(array_size<DataDimensions>::value == desc.dimensions().size());
 
    // If a tensor block dimensions covers a contiguous block of the underlying
    // memory, we can skip block buffer memory allocation, and construct a block
    // from existing `data` memory buffer.
    //
    // Example: (RowMajor layout)
    //   data_dims:          [11, 12, 13, 14]
    //   desc.dimensions():  [1,   1,  3, 14]
    //
    // In this case we can construct a TensorBlock starting at
    // `data + desc.offset()`, with a `desc.dimensions()` block sizes.
    static const bool is_col_major = Layout == ColMajor;
 
    // Find out how many inner dimensions have a matching size.
    int num_matching_inner_dims = 0;
    for (int i = 0; i < NumDims; ++i) {
      int dim = is_col_major ? i : NumDims - i - 1;
      if (data_dims[dim] != desc.dimensions()[dim]) break;
      ++num_matching_inner_dims;
    }
 
    // All the outer dimensions must be of size `1`, except a single dimension
    // before the matching inner dimension (`3` in the example above).
    bool can_use_direct_access = true;
    for (int i = num_matching_inner_dims + 1; i < NumDims; ++i) {
      int dim = is_col_major ? i : NumDims - i - 1;
      if (desc.dimension(dim) != 1) {
        can_use_direct_access = false;
        break;
      }
    }
 
    if (can_use_direct_access) {
      const Scalar* block_start = data + desc.offset();
      return TensorMaterializedBlock(internal::TensorBlockKind::kView, block_start, desc.dimensions());
 
    } else {
      // Reuse destination buffer or allocate new buffer with scratch allocator.
      const Storage storage = prepareStorage(desc, scratch);
 
      typedef internal::TensorBlockIO<Scalar, IndexType, NumDims, Layout> TensorBlockIO;
      typedef typename TensorBlockIO::Dst TensorBlockIODst;
      typedef typename TensorBlockIO::Src TensorBlockIOSrc;
 
      TensorBlockIOSrc src(internal::strides<Layout>(Dimensions(data_dims)), data, desc.offset());
      TensorBlockIODst dst(storage.dimensions(), storage.strides(), storage.data());
 
      TensorBlockIO::Copy(dst, src);
      return storage.AsTensorMaterializedBlock();
    }
  }

References Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::Storage::AsTensorMaterializedBlock(), Eigen::ColMajor, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Copy(), Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::data(), Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::Storage::data(), Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::dimension(), Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::dimensions(), Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::Storage::dimensions(), eigen_assert, i, Eigen::internal::kView, Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::offset(), Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::prepareStorage(), Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::Storage::strides(), and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::TensorMaterializedBlock().

Referenced by Eigen::TensorEvaluator< Derived, Device >::block(), Eigen::TensorEvaluator< const Derived, Device >::block(), Eigen::TensorEvaluator< const TensorForcedEvalOp< ArgType_ >, Device >::block(), and Eigen::TensorEvaluator< const TensorReshapingOp< NewDimensions, ArgType >, Device >::block().

prepareStorage()

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

template<typename TensorBlockScratch >

static EIGEN_STRONG_INLINE Storage Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::prepareStorage ( TensorBlockDesc &  desc, TensorBlockScratch &  scratch, bool  allow_strided_storage = false  )

inlinestatic

                                                                                        {
    // Try to reuse destination as an output block buffer.
    typedef typename TensorBlockDesc::DestinationBuffer DestinationBuffer;
 
    if (desc.destination().kind() == DestinationBuffer::kContiguous) {
      Scalar* buffer = desc.destination().template data<Scalar>();
      desc.DropDestinationBuffer();
      return Storage(buffer, desc.dimensions(), internal::strides<Layout>(desc.dimensions()),
                     /*materialized_in_output=*/true,
                     /*strided_storage=*/false);
 
    } else if (desc.destination().kind() == DestinationBuffer::kStrided && allow_strided_storage) {
      Scalar* buffer = desc.destination().template data<Scalar>();
      desc.DropDestinationBuffer();
      return Storage(buffer, desc.dimensions(), desc.destination().strides(),
                     /*materialized_in_output=*/true, /*strided_storage=*/true);
 
    } else {
      void* mem = scratch.allocate(desc.size() * sizeof(Scalar));
      return Storage(static_cast<Scalar*>(mem), desc.dimensions(), internal::strides<Layout>(desc.dimensions()),
                     /*materialized_in_output=*/false,
                     /*strided_storage=*/false);
    }
  }

References Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::destination(), Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::dimensions(), Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DropDestinationBuffer(), Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::kind(), Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::size(), and Eigen::internal::TensorBlockDescriptor< NumDims, IndexType >::DestinationBuffer::strides().

Referenced by Eigen::TensorEvaluator< const TensorChippingOp< DimId, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorShufflingOp< Shuffle, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorBroadcastingOp< Broadcast, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorGeneratorOp< Generator, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorPaddingOp< PaddingDimensions, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorReverseOp< ReverseDimensions, ArgType >, Device >::block(), Eigen::TensorEvaluator< const TensorRollOp< RollDimensions, ArgType >, Device >::block(), and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::materialize().

Member Data Documentation

m_data

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

const Scalar* Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_data

private

Referenced by Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::data().

m_dimensions

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

Dimensions Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_dimensions

private

m_expr

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

XprType Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_expr

private

Referenced by Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::expr().

m_kind

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

TensorBlockKind Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_kind

private

Referenced by Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::kind(), and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::TensorMaterializedBlock().

m_valid_expr

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

bool Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::m_valid_expr

private

Referenced by Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::expr().

---

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

• TensorBlock.h